com.segment.analytics.android.integrations.adobeanalytics.AdobeIntegration Maven / Gradle / Ivy

Go to download
package com.segment.analytics.android.integrations.adobeanalytics;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;

import com.segment.analytics.Properties;
import com.segment.analytics.ValueMap;
import com.segment.analytics.integrations.BasePayload;
import com.segment.analytics.integrations.GroupPayload;
import com.segment.analytics.integrations.IdentifyPayload;
import com.segment.analytics.integrations.Integration;
import com.segment.analytics.integrations.Logger;
import com.segment.analytics.integrations.ScreenPayload;
import com.segment.analytics.integrations.TrackPayload;

import java.util.HashMap;
import java.util.Map;

import static com.segment.analytics.internal.Utils.isNullOrEmpty;

/**
 * Adobe Analytics is an analytics tracking tool and dashboard that helps you understand your
 * customer segments via activity and video tracking.
 *
 * @see Adobe Analytics
 * @see Adobe Integration
 * @see Adobe
 *     Android SDK
 */
public class AdobeIntegration extends Integration {

  public static final Factory FACTORY =
      new Factory() {
        @Override
        public Integration create(ValueMap settings, com.segment.analytics.Analytics analytics) {
          Logger logger = analytics.logger(ADOBE_KEY);
          return new AdobeIntegration(settings, analytics, logger);
        }

        @Override
        public String key() {
          return ADOBE_KEY;
        }
      };

  private static final String ADOBE_KEY = "Adobe Analytics";

  private Logger logger;
  private AdobeAnalyticsClient adobeAnalytics;
  private VideoAnalytics video;
  private EcommerceAnalytics ecommerce;
  private Map eventsMapping;
  private ContextDataConfiguration contextDataConfiguration;

  AdobeIntegration(ValueMap settings, com.segment.analytics.Analytics analytics, Logger logger) {

    String serverUrl = settings.getString("heartbeatTrackingServerUrl");
    String productIdentifier = settings.getString("productIdentifier");
    boolean ssl = settings.getBoolean("ssl", false);

    eventsMapping = getSetting("eventsV2", settings);
    contextDataConfiguration = new ContextDataConfiguration(settings);

    this.logger = logger;

    video =
        new VideoAnalytics(
            analytics.getApplication(), serverUrl, contextDataConfiguration, ssl, logger);
    adobeAnalytics = new AdobeAnalyticsClient.DefaultClient();
    ecommerce =
        new EcommerceAnalytics(adobeAnalytics, productIdentifier, contextDataConfiguration, logger);

    if (logger.logLevel.equals(com.segment.analytics.Analytics.LogLevel.VERBOSE)) {
      logger.verbose("Enabled debugging");
      video.setDebugLogging(true);
      adobeAnalytics.setDebugLogging(true);
    }

    Context context = analytics.getApplication();
    // This is the same as adding it to onCreate in the main application class.
    adobeAnalytics.setContext(context);
    logger.verbose("Config.setContext();");
  }

  AdobeIntegration(
      ValueMap settings,
      com.segment.analytics.Analytics analytics,
      VideoAnalytics video,
      EcommerceAnalytics ecommerce,
      AdobeAnalyticsClient adobeAnalytics,
      Logger logger) {

    this.adobeAnalytics = adobeAnalytics;
    this.logger = logger;
    this.video = video;
    this.ecommerce = ecommerce;
    this.eventsMapping = getSetting("eventsV2", settings);
    contextDataConfiguration = new ContextDataConfiguration(settings);

    Context context = analytics.getApplication();
    // This is the same as adding it to onCreate in the main application class.
    this.adobeAnalytics.setContext(context);
    logger.verbose("Config.setContext();");
  }

  @Override
  public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
    super.onActivityCreated(activity, savedInstanceState);

    adobeAnalytics.setContext(activity.getApplicationContext());
    logger.verbose("Config.setContext();");
  }

  @Override
  public void onActivityPaused(Activity activity) {
    super.onActivityPaused(activity);

    adobeAnalytics.pauseCollectingLifecycleData();
    logger.verbose("Config.pauseCollectingLifecycleData();");
  }

  @Override
  public void onActivityResumed(Activity activity) {
    super.onActivityResumed(activity);

    adobeAnalytics.collectLifecycleData(activity);
    logger.verbose("Config.collectLifecycleData(%s);", activity);
  }

  @Override
  public void identify(IdentifyPayload identify) {
    super.identify(identify);

    String userId = identify.userId();
    if (isNullOrEmpty(userId)) {
      return;
    }
    adobeAnalytics.setUserIdentifier(userId);
    logger.verbose("Config.setUserIdentifier(%s);", userId);
  }

  @Override
  public void screen(ScreenPayload screen) {
    super.screen(screen);

    Properties properties = screen.properties();

    if (isNullOrEmpty(properties)) {
      adobeAnalytics.trackState(screen.name(), null);
      logger.verbose("Analytics.trackState(%s, %s);", screen.name(), null);
      return;
    }

    Map cdata = getContextData(screen);
    adobeAnalytics.trackState(screen.name(), cdata);
    logger.verbose("Analytics.trackState(%s, %s);", screen.name(), cdata);
  }

  @Override
  public void track(TrackPayload payload) {
    super.track(payload);

    String eventName = payload.event();

    if (VideoAnalytics.Event.isVideoEvent(eventName)) {
      video.track(payload);
      return;
    }

    if (EcommerceAnalytics.Event.isEcommerceEvent(eventName)) {
      if (eventsMapping != null && eventsMapping.containsKey(eventName)) {
        logger.verbose(
            "Segment currently does not support mapping specced ecommerce events to "
                + "custom Adobe events.");
        return;
      }

      ecommerce.track(payload);
      return;
    }

    if (eventsMapping == null
        || eventsMapping.size() == 0
        || !eventsMapping.containsKey(eventName)) {
      logger.verbose(
          "Event must be either configured in Adobe and in the Segment EventsV2 setting, "
              + "a reserved Adobe Ecommerce or Video event.");
      return;
    }

    String event = String.valueOf(eventsMapping.get(eventName));
    Map cdata = getContextData(payload);

    adobeAnalytics.trackAction(event, cdata);
    logger.verbose("Analytics.trackAction(%s, %s);", event, cdata);
  }

  private Map getContextData(BasePayload payload) {

    Properties extraProperties = new Properties();
    if (payload.containsKey("properties")) {
      extraProperties.putAll(payload.getValueMap("properties"));
    }

    // Remove products just in case
    extraProperties.remove("products");

    Map contextData = new HashMap<>();

    for (String field : contextDataConfiguration.getEventFieldNames()) {
      Object value = null;
      try {
        value = contextDataConfiguration.searchValue(field, payload);
      } catch (IllegalArgumentException e) {
        // Ignore.
      }

      if (value != null) {
        String variable = contextDataConfiguration.getVariableName(field);
        contextData.put(variable, value);
        extraProperties.remove(field);
      }
    }

    // Add all extra properties
    for (String extraProperty : extraProperties.keySet()) {
      String variable = contextDataConfiguration.getPrefix() + extraProperty;
      contextData.put(variable, extraProperties.get(extraProperty));
    }

    if (contextData.size() == 0) {
      return null;
    }

    return contextData;
  }

  /**
   * Retrieves the setting as a map of strings, or an empty map if it is not defined.
   *
   * @param name Setting name.
   * @return Strings map.
   */
  private static Map getSetting(String name, ValueMap settings) {
    ValueMap setting = settings.getValueMap(name);
    if (setting == null) {
      setting = new ValueMap();
    }

    return setting.toStringMap();
  }

  @Override
  public void group(GroupPayload group) {
    super.group(group);
  }

  @Override
  public void flush() {
    super.flush();

    adobeAnalytics.flushQueue();
    logger.verbose("Analytics.sendQueuedHits();");
  }

  @Override
  public void reset() {
    super.reset();

    adobeAnalytics.setUserIdentifier(null);
    logger.verbose("Config.setUserIdentifier(null);");
  }

  Map getEventsMapping() {
    return eventsMapping;
  }

  /**
   * Allows to redefine the events mapping. Only used for testing.
   *
   * @param eventsMapping Events mapping as {segment event, adobe analytics event}.
   */
  void setEventsMapping(Map eventsMapping) {
    this.eventsMapping = eventsMapping;
  }

  ContextDataConfiguration getContextDataConfiguration() {
    return contextDataConfiguration;
  }

  /**
   * Allows to redefine the context data configuration. Only used for testing.
   *
   * @param contextDataConfiguration New context data configuration.
   */
  void setContextDataConfiguration(ContextDataConfiguration contextDataConfiguration) {
    this.contextDataConfiguration = contextDataConfiguration;
  }
}