Proyectos de Subversion Iphone Microlearning

/*

 * Copyright 2018 Google

 *

 * 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 "FirebaseMessaging/Sources/FIRMessagingAnalytics.h"

#import <GoogleUtilities/GULAppDelegateSwizzler.h>

#import <GoogleUtilities/GULAppEnvironmentUtil.h>

#import "Interop/Analytics/Public/FIRInteropEventNames.h"

#import "Interop/Analytics/Public/FIRInteropParameterNames.h"

#import "FirebaseMessaging/Sources/FIRMessagingConstants.h"

#import "FirebaseMessaging/Sources/FIRMessagingLogger.h"

static NSString *const kLogTag = @"FIRMessagingAnalytics";

// aps Key

static NSString *const kApsKey = @"aps";

static NSString *const kApsAlertKey = @"alert";

static NSString *const kApsSoundKey = @"sound";

static NSString *const kApsBadgeKey = @"badge";

static NSString *const kApsContentAvailableKey = @"badge";

// Data Key

static NSString *const kDataKey = @"data";

static NSString *const kFIRParameterLabel = @"label";

static NSString *const kReengagementSource = @"Firebase";

static NSString *const kReengagementMedium = @"notification";

// Analytics

static NSString *const kAnalyticsEnabled = @"google.c.a.e";

static NSString *const kAnalyticsMessageTimestamp = @"google.c.a.ts";

static NSString *const kAnalyticsMessageUseDeviceTime = @"google.c.a.udt";

static NSString *const kAnalyticsTrackConversions = @"google.c.a.tc";

@implementation FIRMessagingAnalytics

+ (BOOL)canLogNotification:(NSDictionary *)notification {

  if (!notification.count) {

    // Payload is empty

    return NO;

  }

  NSString *isAnalyticsLoggingEnabled = notification[kAnalyticsEnabled];

  if (![isAnalyticsLoggingEnabled isKindOfClass:[NSString class]] ||

      ![isAnalyticsLoggingEnabled isEqualToString:@"1"]) {

    // Analytics logging is not enabled

    FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalytics001,

                            @"Analytics logging is disabled. Do not log event.");

    return NO;

  }

  return YES;

}

+ (void)logOpenNotification:(NSDictionary *)notification

                toAnalytics:(id<FIRAnalyticsInterop> _Nullable)analytics {

  [self logUserPropertyForConversionTracking:notification toAnalytics:analytics];

  [self logEvent:kFIRIEventNotificationOpen withNotification:notification toAnalytics:analytics];

}

+ (void)logForegroundNotification:(NSDictionary *)notification

                      toAnalytics:(id<FIRAnalyticsInterop> _Nullable)analytics {

  [self logEvent:kFIRIEventNotificationForeground

      withNotification:notification

           toAnalytics:analytics];

}

+ (void)logEvent:(NSString *)event

    withNotification:(NSDictionary *)notification

         toAnalytics:(id<FIRAnalyticsInterop> _Nullable)analytics {

  if (!event.length) {

    FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalyticsInvalidEvent,

                            @"Can't log analytics with empty event.");

    return;

  }

  NSMutableDictionary *params = [self paramsForEvent:event withNotification:notification];

  [analytics logEventWithOrigin:@"fcm" name:event parameters:params];

  FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalytics005, @"%@: Sending event: %@ params: %@",

                          kLogTag, event, params);

}

+ (NSMutableDictionary *)paramsForEvent:(NSString *)event

                       withNotification:(NSDictionary *)notification {

  NSDictionary *analyticsDataMap = notification;

  if (!analyticsDataMap.count) {

    FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalytics000,

                            @"No data found in notification. Will not log any analytics events.");

    return nil;

  }

  if (![self canLogNotification:analyticsDataMap]) {

    return nil;

  }

  NSMutableDictionary *params = [NSMutableDictionary dictionary];

  NSString *composerIdentifier = analyticsDataMap[kFIRMessagingAnalyticsComposerIdentifier];

  if ([composerIdentifier isKindOfClass:[NSString class]] && composerIdentifier.length) {

    params[kFIRIParameterMessageIdentifier] = [composerIdentifier copy];

  }

  NSString *composerLabel = analyticsDataMap[kFIRMessagingAnalyticsComposerLabel];

  if ([composerLabel isKindOfClass:[NSString class]] && composerLabel.length) {

    params[kFIRIParameterMessageName] = [composerLabel copy];

  }

  NSString *messageLabel = analyticsDataMap[kFIRMessagingAnalyticsMessageLabel];

  if ([messageLabel isKindOfClass:[NSString class]] && messageLabel.length) {

    params[kFIRParameterLabel] = [messageLabel copy];

  }

  NSString *from = analyticsDataMap[kFIRMessagingFromKey];

  if ([from isKindOfClass:[NSString class]] && [from containsString:@"/topics/"]) {

    params[kFIRIParameterTopic] = [from copy];

  }

  id timestamp = analyticsDataMap[kAnalyticsMessageTimestamp];

  if ([timestamp respondsToSelector:@selector(longLongValue)]) {

    int64_t timestampValue = [timestamp longLongValue];

    if (timestampValue != 0) {

      params[kFIRIParameterMessageTime] = @(timestampValue);

    }

  }

  if (analyticsDataMap[kAnalyticsMessageUseDeviceTime]) {

    params[kFIRIParameterMessageDeviceTime] = analyticsDataMap[kAnalyticsMessageUseDeviceTime];

  }

  return params;

}

+ (void)logUserPropertyForConversionTracking:(NSDictionary *)notification

                                 toAnalytics:(id<FIRAnalyticsInterop> _Nullable)analytics {

  NSInteger shouldTrackConversions = [notification[kAnalyticsTrackConversions] integerValue];

  if (shouldTrackConversions != 1) {

    return;

  }

  NSString *composerIdentifier = notification[kFIRMessagingAnalyticsComposerIdentifier];

  if ([composerIdentifier isKindOfClass:[NSString class]] && composerIdentifier.length) {

    // Set user property for event.

    [analytics setUserPropertyWithOrigin:@"fcm"

                                    name:kFIRIUserPropertyLastNotification

                                   value:composerIdentifier];

    // Set the re-engagement attribution properties.

    NSMutableDictionary *params = [NSMutableDictionary dictionaryWithCapacity:3];

    params[kFIRIParameterSource] = kReengagementSource;

    params[kFIRIParameterMedium] = kReengagementMedium;

    params[kFIRIParameterCampaign] = composerIdentifier;

    [analytics logEventWithOrigin:@"fcm" name:kFIRIEventFirebaseCampaign parameters:params];

    FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalytics003,

                            @"%@: Sending event: %@ params: %@", kLogTag,

                            kFIRIEventFirebaseCampaign, params);

  } else {

    FIRMessagingLoggerDebug(kFIRMessagingMessageCodeAnalytics004,

                            @"%@: Failed to set user property: %@ value: %@", kLogTag,

                            kFIRIUserPropertyLastNotification, composerIdentifier);

  }

}

+ (void)logMessage:(NSDictionary *)notification

       toAnalytics:(id<FIRAnalyticsInterop> _Nullable)analytics {

  // iOS only because Analytics doesn't support other platforms.

#if TARGET_OS_IOS

  if (![self canLogNotification:notification]) {

    return;

  }

  UIApplication *application = [GULAppDelegateSwizzler sharedApplication];

  if (!application) {

    return;

  }

  UIApplicationState applicationState = application.applicationState;

  switch (applicationState) {

    case UIApplicationStateInactive:

      // App was in background and in transition to open when user tapped

      // on a display notification.

      // Needs to check notification is displayed.

      if ([[self class] isDisplayNotification:notification]) {

        [self logOpenNotification:notification toAnalytics:analytics];

      }

      break;

    case UIApplicationStateActive:

      // App was in foreground when it received the notification.

      [self logForegroundNotification:notification toAnalytics:analytics];

      break;

    default:

      // App was either in background state or in transition from closed

      // to open.

      // Needs to check notification is displayed.

      if ([[self class] isDisplayNotification:notification]) {

        [self logOpenNotification:notification toAnalytics:analytics];

      }

      break;

  }

#endif

}

+ (BOOL)isDisplayNotification:(NSDictionary *)notification {

  NSDictionary *aps = notification[kApsKey];

  if (!aps || ![aps isKindOfClass:[NSDictionary class]]) {

    return NO;

  }

  NSDictionary *alert = aps[kApsAlertKey];

  if (!alert) {

    return NO;

  }

  if ([alert isKindOfClass:[NSDictionary class]]) {

    return alert.allKeys.count > 0;

  }

  // alert can be string sometimes (if only body is specified)

  if ([alert isKindOfClass:[NSString class]]) {

    return YES;

  }

  return NO;

}

@end