analytics_ios.mm

/*
 * Copyright 2016 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import <Foundation/Foundation.h>

#import "FIRAnalytics+Consent.h"
#import "FIRAnalytics+OnDevice.h"
#import "FIRAnalytics.h"

#include "analytics/src/include/firebase/analytics.h"

#include "analytics/src/analytics_common.h"
#include "app/src/assert.h"
#include "app/src/include/firebase/internal/mutex.h"
#include "app/src/include/firebase/version.h"
#include "app/src/log.h"
#include "app/src/thread.h"
#include "app/src/time.h"
#include "app/src/util.h"
#include "app/src/util_ios.h"

namespace firebase {
namespace analytics {

// Used to workaround b/143656277 and b/110166640
class AnalyticsDataResetter {
 private:
  enum ResetState {
    kResetStateNone = 0,
    kResetStateRequested,
    kResetStateRetry,
  };

 public:
  // Initialize the class.
  AnalyticsDataResetter() : reset_state_(kResetStateNone), reset_timestamp_(0) {}

  // Reset analytics data.
  void Reset() {
    MutexLock lock(mutex_);
    reset_timestamp_ = firebase::internal::GetTimestampEpoch();
    reset_state_ = kResetStateRequested;
    instance_id_ = util::StringFromNSString([FIRAnalytics appInstanceID]);
    [FIRAnalytics resetAnalyticsData];
  }

  // Get the instance ID, returning a non-empty string if it's valid or an empty string if it's
  // still being reset.
  std::string GetInstanceId() {
    MutexLock lock(mutex_);
    std::string current_instance_id = util::StringFromNSString([FIRAnalytics appInstanceID]);
    uint64_t reset_time_elapsed_milliseconds = GetResetTimeElapsedMilliseconds();
    switch (reset_state_) {
      case kResetStateNone:
        break;
      case kResetStateRequested:
        if (reset_time_elapsed_milliseconds >= kResetRetryIntervalMilliseconds) {
          // Firebase Analytics on iOS can take a while to initialize, in this case we try to reset
          // again if the instance ID hasn't changed for a while.
          reset_state_ = kResetStateRetry;
          reset_timestamp_ = firebase::internal::GetTimestampEpoch();
          [FIRAnalytics resetAnalyticsData];
          return std::string();
        }
        FIREBASE_CASE_FALLTHROUGH;

      case kResetStateRetry:
        if ((current_instance_id.empty() || current_instance_id == instance_id_) &&
            reset_time_elapsed_milliseconds < kResetTimeoutMilliseconds) {
          return std::string();
        }
        break;
    }
    instance_id_ = current_instance_id;
    return current_instance_id;
  }

 private:
  // Get the time elapsed in milliseconds since reset was requested.
  uint64_t GetResetTimeElapsedMilliseconds() const {
    return firebase::internal::GetTimestampEpoch() - reset_timestamp_;
  }

 private:
  Mutex mutex_;
  // Reset attempt.
  ResetState reset_state_;
  // When a reset was last requested.
  uint64_t reset_timestamp_;
  // Instance ID before it was reset.
  std::string instance_id_;

  // Time to wait before trying to reset again.
  static const uint64_t kResetRetryIntervalMilliseconds;
  // Time to wait before giving up on resetting the ID.
  static const uint64_t kResetTimeoutMilliseconds;
};

DEFINE_FIREBASE_VERSION_STRING(FirebaseAnalytics);

const uint64_t AnalyticsDataResetter::kResetRetryIntervalMilliseconds = 1000;
const uint64_t AnalyticsDataResetter::kResetTimeoutMilliseconds = 5000;

static const double kMillisecondsPerSecond = 1000.0;
static Mutex g_mutex;  // NOLINT
static bool g_initialized = false;
static AnalyticsDataResetter* g_resetter = nullptr;

// Initialize the API.
void Initialize(const ::firebase::App& app) {
  MutexLock lock(g_mutex);
  g_initialized = true;
  g_resetter = new AnalyticsDataResetter();
  internal::RegisterTerminateOnDefaultAppDestroy();
  internal::FutureData::Create();
}

namespace internal {

// Determine whether the analytics module is initialized.
bool IsInitialized() { return g_initialized; }

}  // namespace internal

// Terminate the API.
void Terminate() {
  MutexLock lock(g_mutex);
  internal::FutureData::Destroy();
  internal::UnregisterTerminateOnDefaultAppDestroy();
  delete g_resetter;
  g_resetter = nullptr;
  g_initialized = false;
}

// Enable / disable measurement and reporting.
void SetAnalyticsCollectionEnabled(bool enabled) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics setAnalyticsCollectionEnabled:enabled];
}

void SetConsent(const std::map<ConsentType, ConsentStatus>& consent_settings) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  NSMutableDictionary* consent_settings_dict =
      [[NSMutableDictionary alloc] initWithCapacity:consent_settings.size()];
  for (auto it = consent_settings.begin(); it != consent_settings.end(); ++it) {
    FIRConsentType consent_type;
    switch (it->first) {
      case kConsentTypeAdStorage:
        consent_type = FIRConsentTypeAdStorage;
        break;
      case kConsentTypeAnalyticsStorage:
        consent_type = FIRConsentTypeAnalyticsStorage;
        break;
      case kConsentTypeAdUserData:
        consent_type = FIRConsentTypeAdUserData;
        break;
      case kConsentTypeAdPersonalization:
        consent_type = FIRConsentTypeAdPersonalization;
        break;
      default:
        LogError("Unknown ConsentType value: %d", it->first);
        return;
    };
    FIRConsentStatus consent_status;
    switch (it->second) {
      case kConsentStatusGranted:
        consent_status = FIRConsentStatusGranted;
        break;
      case kConsentStatusDenied:
        consent_status = FIRConsentStatusDenied;
        break;
      default:
        LogError("Unknown ConsentStatus value: %d", it->second);
        return;
    };
    [consent_settings_dict setObject:consent_status forKey:consent_type];
  }
  [FIRAnalytics setConsent:consent_settings_dict];
}

// Due to overloads of LogEvent(), it's possible for users to call variants that require a
// string with a nullptr.  To prevent a crash and instead yield a warning, pass an empty string
// to logEventWithName: methods instead.  See b/30061553 for the background.
NSString* SafeString(const char* event_name) { return @(event_name ? event_name : ""); }

// Log an event with one string parameter.
void LogEvent(const char* name, const char* parameter_name, const char* parameter_value) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics logEventWithName:@(name)
                      parameters:@{SafeString(parameter_name) : SafeString(parameter_value)}];
}

// Log an event with one double parameter.
void LogEvent(const char* name, const char* parameter_name, const double parameter_value) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics
      logEventWithName:@(name)
            parameters:@{SafeString(parameter_name) : [NSNumber numberWithDouble:parameter_value]}];
}

// Log an event with one 64-bit integer parameter.
void LogEvent(const char* name, const char* parameter_name, const int64_t parameter_value) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics logEventWithName:@(name)
                      parameters:@{
                        SafeString(parameter_name) : [NSNumber numberWithLongLong:parameter_value]
                      }];
}

/// Log an event with one integer parameter (stored as a 64-bit integer).
void LogEvent(const char* name, const char* parameter_name, const int parameter_value) {
  LogEvent(name, parameter_name, static_cast<int64_t>(parameter_value));
}

/// Log an event with no parameters.
void LogEvent(const char* name) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics logEventWithName:@(name) parameters:@{}];
}

// Declared here so that it can be used, defined below.
NSDictionary* MapToDictionary(const std::map<Variant, Variant>& map);

// Converts the given vector of Maps into an ObjC NSArray of ObjC NSDictionaries.
NSArray* VectorOfMapsToArray(const std::vector<Variant>& vector) {
  NSMutableArray* array = [NSMutableArray arrayWithCapacity:vector.size()];
  for (const Variant& element : vector) {
    if (element.is_map()) {
      NSDictionary* dict = MapToDictionary(element.map());
      [array addObject:dict];
    } else {
      LogError("VectorOfMapsToArray: Unsupported type (%s) within vector.",
               Variant::TypeName(element.type()));
    }
  }
  return array;
}

// Converts and adds the Variant to the given Dictionary.
bool AddVariantToDictionary(NSMutableDictionary* dict, NSString* key, const Variant& value) {
  if (value.is_int64()) {
    [dict setObject:[NSNumber numberWithLongLong:value.int64_value()] forKey:key];
  } else if (value.is_double()) {
    [dict setObject:[NSNumber numberWithDouble:value.double_value()] forKey:key];
  } else if (value.is_string()) {
    [dict setObject:SafeString(value.string_value()) forKey:key];
  } else if (value.is_bool()) {
    // Just use integer 0 or 1.
    [dict setObject:[NSNumber numberWithLongLong:value.bool_value() ? 1 : 0] forKey:key];
  } else if (value.is_null()) {
    // Just use integer 0 for null.
    [dict setObject:[NSNumber numberWithLongLong:0] forKey:key];
  } else if (value.is_vector()) {
    NSArray* array = VectorOfMapsToArray(value.vector());
    [dict setObject:array forKey:key];
  } else if (value.is_map()) {
    NSDictionary* inner_dict = MapToDictionary(value.map());
    [dict setObject:inner_dict forKey:key];
  } else {
    // A Variant type that couldn't be handled was passed in.
    return false;
  }
  return true;
}

// Converts the given map into an ObjC dictionary of ObjC objects.
NSDictionary* MapToDictionary(const std::map<Variant, Variant>& map) {
  NSMutableDictionary* dict = [NSMutableDictionary dictionaryWithCapacity:map.size()];
  for (const auto& pair : map) {
    // Only add elements that use a string key
    if (!pair.first.is_string()) {
      continue;
    }
    NSString* key = SafeString(pair.first.string_value());
    const Variant& value = pair.second;
    if (!AddVariantToDictionary(dict, key, value)) {
      LogError("MapToDictionary: Unsupported type (%s) within map with key %s.",
               Variant::TypeName(value.type()), key);
    }
  }
  return dict;
}

// Log an event with associated parameters.
void LogEvent(const char* name, const Parameter* parameters, size_t number_of_parameters) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  NSMutableDictionary* parameters_dict =
      [NSMutableDictionary dictionaryWithCapacity:number_of_parameters];
  for (size_t i = 0; i < number_of_parameters; ++i) {
    const Parameter& parameter = parameters[i];
    NSString* parameter_name = SafeString(parameter.name);
    if (!AddVariantToDictionary(parameters_dict, parameter_name, parameter.value)) {
      // A Variant type that couldn't be handled was passed in.
      LogError("LogEvent(%s): %s is not a valid parameter value type. "
               "No event was logged.",
               parameter.name, Variant::TypeName(parameter.value.type()));
    }
  }
  [FIRAnalytics logEventWithName:@(name) parameters:parameters_dict];
}

void SetDefaultEventParameters(const std::map<std::string, Variant>& default_parameters) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  // Convert the std::map<std::string, Variant> to NSDictionary*
  // The keys must be strings for FIRAnalytics.
  NSMutableDictionary* parameters_dict =
      [NSMutableDictionary dictionaryWithCapacity:default_parameters.size()];
  for (const auto& pair : default_parameters) {
    NSString* key = firebase::util::StringToNSString(pair.first);
    // A null Variant indicates the default parameter for that key should be
    // cleared. In ObjC, setting a key to [NSNull null] in the dictionary
    // achieves this.
    id value = pair.second.is_null() ? [NSNull null] : firebase::util::VariantToId(pair.second);
    if (value) {
      [parameters_dict setObject:value forKey:key];
    } else {
      // VariantToId could return nil if the variant type is unsupported.
      // Log an error but continue, as NSNull case is handled above.
      LogError("SetDefaultEventParameters: Failed to convert value for key %s.",
               pair.first.c_str());
    }
  }

  [FIRAnalytics setDefaultEventParameters:parameters_dict];
}

void ClearDefaultEventParameters() {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  // Passing nil to the underlying SDK method clears all parameters.
  [FIRAnalytics setDefaultEventParameters:nil];
}

/// Initiates on-device conversion measurement given a user email address on iOS (no-op on
/// Android). On iOS, requires dependency GoogleAppMeasurementOnDeviceConversion to be linked
/// in, otherwise it is a no-op.
void InitiateOnDeviceConversionMeasurementWithEmailAddress(const char* email_address) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics initiateOnDeviceConversionMeasurementWithEmailAddress:@(email_address)];
}

/// Initiates on-device conversion measurement given a phone number on iOS (no-op on
/// Android). On iOS, requires dependency GoogleAppMeasurementOnDeviceConversion to be linked
/// in, otherwise it is a no-op.
void InitiateOnDeviceConversionMeasurementWithPhoneNumber(const char* phone_number) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics initiateOnDeviceConversionMeasurementWithPhoneNumber:@(phone_number)];
}

/// Initiates on-device conversion measurement given a hashed user email address
/// on iOS (no-op on Android). On iOS, requires dependency
/// GoogleAppMeasurementOnDeviceConversion to be linked in, otherwise it is a
/// no-op.
void InitiateOnDeviceConversionMeasurementWithHashedEmailAddress(
    std::vector<unsigned char> hashed_email) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  NSData* hashed_email_data =
      firebase::util::BytesToNSData(hashed_email.data(), hashed_email.size());
  [FIRAnalytics initiateOnDeviceConversionMeasurementWithHashedEmailAddress:hashed_email_data];
}

/// Initiates on-device conversion measurement given a hashed phone number on
/// iOS (no-op on Android). On iOS, requires dependency
/// GoogleAppMeasurementOnDeviceConversion to be linked in, otherwise it is a
/// no-op.
void InitiateOnDeviceConversionMeasurementWithHashedPhoneNumber(
    std::vector<unsigned char> hashed_phone) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  NSData* hashed_phone_data =
      firebase::util::BytesToNSData(hashed_phone.data(), hashed_phone.size());
  [FIRAnalytics initiateOnDeviceConversionMeasurementWithHashedPhoneNumber:hashed_phone_data];
}

// Set a user property to the given value.
void SetUserProperty(const char* name, const char* value) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics setUserPropertyString:(value ? @(value) : nil) forName:@(name)];
}

// Sets the user ID property. This feature must be used in accordance with
// <a href="https://www.google.com/policies/privacy">
// Google's Privacy Policy</a>
void SetUserId(const char* user_id) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics setUserID:(user_id ? @(user_id) : nil)];
}

// Sets the duration of inactivity that terminates the current session.
void SetSessionTimeoutDuration(int64_t milliseconds) {
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  [FIRAnalytics
      setSessionTimeoutInterval:static_cast<NSTimeInterval>(milliseconds) / kMillisecondsPerSecond];
}

void ResetAnalyticsData() {
  MutexLock lock(g_mutex);
  FIREBASE_ASSERT_RETURN_VOID(internal::IsInitialized());
  g_resetter->Reset();
}

Future<std::string> GetAnalyticsInstanceId() {
  MutexLock lock(g_mutex);
  FIREBASE_ASSERT_RETURN(Future<std::string>(), internal::IsInitialized());
  auto* api = internal::FutureData::Get()->api();
  const auto future_handle =
      api->SafeAlloc<std::string>(internal::kAnalyticsFnGetAnalyticsInstanceId);
  static int kPollTimeMs = 100;
  Thread get_id_thread(
      [](SafeFutureHandle<std::string>* handle) {
        for (;;) {
          {
            MutexLock lock(g_mutex);
            if (!internal::IsInitialized()) break;
            std::string instance_id = g_resetter->GetInstanceId();
            if (!instance_id.empty()) {
              internal::FutureData::Get()->api()->CompleteWithResult(*handle, 0, "", instance_id);
              break;
            }
          }
          firebase::internal::Sleep(kPollTimeMs);
        }
        delete handle;
      },
      new SafeFutureHandle<std::string>(future_handle));
  get_id_thread.Detach();
  return Future<std::string>(api, future_handle.get());
}

Future<std::string> GetAnalyticsInstanceIdLastResult() {
  MutexLock lock(g_mutex);
  FIREBASE_ASSERT_RETURN(Future<std::string>(), internal::IsInitialized());
  return static_cast<const Future<std::string>&>(
      internal::FutureData::Get()->api()->LastResult(internal::kAnalyticsFnGetAnalyticsInstanceId));
}

Future<int64_t> GetSessionId() {
  MutexLock lock(g_mutex);
  FIREBASE_ASSERT_RETURN(Future<int64_t>(), internal::IsInitialized());
  auto* api = internal::FutureData::Get()->api();
  const auto future_handle = api->SafeAlloc<int64_t>(internal::kAnalyticsFnGetSessionId);
  [FIRAnalytics sessionIDWithCompletion:^(int64_t session_id, NSError* _Nullable error) {
    MutexLock lock(g_mutex);
    if (!internal::IsInitialized()) return;
    if (error) {
      api->Complete(future_handle, -1, util::NSStringToString(error.localizedDescription).c_str());
    } else {
      api->CompleteWithResult(future_handle, 0, "", session_id);
    }
  }];
  return MakeFuture<int64_t>(api, future_handle);
}

Future<int64_t> GetSessionIdLastResult() {
  MutexLock lock(g_mutex);
  FIREBASE_ASSERT_RETURN(Future<int64_t>(), internal::IsInitialized());
  return static_cast<const Future<int64_t>&>(
      internal::FutureData::Get()->api()->LastResult(internal::kAnalyticsFnGetSessionId));
}

}  // namespace analytics
}  // namespace firebase