@snowplow/react-native-tracker 0.2.0 → 1.1.0

package/android/src/main/java/com/snowplowanalytics/react/tracker/RNSnowplowTrackerModule.java

@@ -1,4 +1,3 @@
-
 package com.snowplowanalytics.react.tracker;
 
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -8,21 +7,44 @@ import com.facebook.react.bridge.Promise;
 
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+
+import com.snowplowanalytics.snowplow.Snowplow;
+import com.snowplowanalytics.snowplow.configuration.Configuration;
+import com.snowplowanalytics.snowplow.configuration.EmitterConfiguration;
+import com.snowplowanalytics.snowplow.configuration.GdprConfiguration;
+import com.snowplowanalytics.snowplow.configuration.NetworkConfiguration;
+import com.snowplowanalytics.snowplow.configuration.RemoteConfiguration;
+import com.snowplowanalytics.snowplow.configuration.SessionConfiguration;
+import com.snowplowanalytics.snowplow.configuration.TrackerConfiguration;
+import com.snowplowanalytics.snowplow.configuration.SubjectConfiguration;
+import com.snowplowanalytics.snowplow.configuration.GlobalContextsConfiguration;
+import com.snowplowanalytics.snowplow.event.DeepLinkReceived;
+import com.snowplowanalytics.snowplow.event.MessageNotification;
+import com.snowplowanalytics.snowplow.globalcontexts.GlobalContext;
+import com.snowplowanalytics.snowplow.controller.TrackerController;
+import com.snowplowanalytics.snowplow.payload.SelfDescribingJson;
+import com.snowplowanalytics.snowplow.event.SelfDescribing;
+import com.snowplowanalytics.snowplow.event.ScreenView;
+import com.snowplowanalytics.snowplow.event.Structured;
+import com.snowplowanalytics.snowplow.event.PageView;
+import com.snowplowanalytics.snowplow.event.Timing;
+import com.snowplowanalytics.snowplow.event.ConsentGranted;
+import com.snowplowanalytics.snowplow.event.ConsentWithdrawn;
+import com.snowplowanalytics.snowplow.event.EcommerceTransactionItem;
+import com.snowplowanalytics.snowplow.event.EcommerceTransaction;
+import com.snowplowanalytics.snowplow.network.HttpMethod;
+import com.snowplowanalytics.snowplow.internal.utils.Util;
+import com.snowplowanalytics.snowplow.util.Size;
+
+import java.util.List;
+import java.util.ArrayList;
+
 import com.snowplowanalytics.react.util.EventUtil;
-import com.snowplowanalytics.snowplow.tracker.Emitter;
-import com.snowplowanalytics.snowplow.tracker.Tracker;
-import com.snowplowanalytics.snowplow.tracker.emitter.HttpMethod;
-import com.snowplowanalytics.snowplow.tracker.emitter.RequestSecurity;
-import com.snowplowanalytics.snowplow.tracker.events.SelfDescribing;
-import com.snowplowanalytics.snowplow.tracker.events.Structured;
-import com.snowplowanalytics.snowplow.tracker.events.ScreenView;
-import com.snowplowanalytics.snowplow.tracker.events.PageView;
+import com.snowplowanalytics.react.util.ConfigUtil;
 
 public class RNSnowplowTrackerModule extends ReactContextBaseJavaModule {
 
     private final ReactApplicationContext reactContext;
-    private Tracker tracker;
-    private Emitter emitter;
 
     public RNSnowplowTrackerModule(ReactApplicationContext reactContext) {
         super(reactContext);
@@ -35,163 +57,663 @@ public class RNSnowplowTrackerModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void initialize(ReadableMap options,
-                          Promise promise) {
+    public void createTracker(ReadableMap argmap,
+                              Promise promise) {
+        try {
+            String trackerNs = argmap.getString("namespace");
+            ReadableMap networkConfig = argmap.getMap("networkConfig");
+
+            // NetworkConfiguration
+            NetworkConfiguration networkConfiguration;
+            if (networkConfig.hasKey("method") && !networkConfig.isNull("method")) {
+                String method = networkConfig.getString("method");
+                networkConfiguration = new NetworkConfiguration(
+                    networkConfig.getString("endpoint"),
+                    ("get".equalsIgnoreCase(method) ? HttpMethod.GET : HttpMethod.POST));
+            } else {
+                networkConfiguration = new NetworkConfiguration(networkConfig.getString("endpoint"));
+            }
+
+            // Configurations
+            List<Configuration> controllers = new ArrayList<Configuration>();
+
+            // TrackerConfiguration
+            if (argmap.hasKey("trackerConfig")) {
+                ReadableMap trackerConfig = argmap.getMap("trackerConfig");
+                TrackerConfiguration trackerConfiguration = ConfigUtil.mkTrackerConfiguration(trackerConfig, this.reactContext);
+                controllers.add(trackerConfiguration);
+            }
+
+            // SessionConfiguration
+            if (argmap.hasKey("sessionConfig")) {
+                ReadableMap sessionConfig = argmap.getMap("sessionConfig");
+                SessionConfiguration sessionConfiguration = ConfigUtil.mkSessionConfiguration(sessionConfig);
+                controllers.add(sessionConfiguration);
+            }
+
+            // EmitterConfiguration
+            if (argmap.hasKey("emitterConfig")) {
+                ReadableMap emitterConfig = argmap.getMap("emitterConfig");
+                EmitterConfiguration emitterConfiguration = ConfigUtil.mkEmitterConfiguration(emitterConfig);
+                controllers.add(emitterConfiguration);
+            }
 
-        // throw if index.js has failed to pass a complete options object
-        if (!(options.hasKey("endpoint") &&
-            options.hasKey("namespace") &&
-            options.hasKey("appId") &&
-            options.hasKey("method") &&
-            options.hasKey("protocol") &&
-            options.hasKey("base64Encoded") &&
-            options.hasKey("platformContext") &&
-            options.hasKey("applicationContext") &&
-            options.hasKey("lifecycleEvents") &&
-            options.hasKey("screenContext") &&
-            options.hasKey("sessionContext") &&
-            options.hasKey("foregroundTimeout") &&
-            options.hasKey("backgroundTimeout") &&
-            options.hasKey("checkInterval") &&
-            options.hasKey("installTracking"))) {
-
-            promise.reject("ERROR", "SnowplowTracker: initialize() method - missing parameter with no default found");
-            return;
-        }
-
-        this.emitter = new Emitter.EmitterBuilder(options.getString("endpoint"), this.reactContext)
-            .method(options.getString("method").equalsIgnoreCase("post") ? HttpMethod.POST : HttpMethod.GET)
-            .security(options.getString("protocol").equalsIgnoreCase("https") ? RequestSecurity.HTTPS : RequestSecurity.HTTP)
-            .build();
-
-        com.snowplowanalytics.snowplow.tracker.Subject subject = new com.snowplowanalytics.snowplow.tracker.Subject.SubjectBuilder()
-            .build();
-
-        this.tracker = Tracker.init(new Tracker
-            .TrackerBuilder(this.emitter, options.getString("namespace"), options.getString("appId"), this.reactContext)
-            .subject(subject)
-            .base64(options.getBoolean("base64Encoded"))
-            .mobileContext(options.getBoolean("platformContext"))
-            .applicationContext(options.getBoolean("applicationContext"))
-            .sessionContext(options.getBoolean("sessionContext"))
-            .sessionCheckInterval(options.getInt("checkInterval"))
-            .foregroundTimeout(options.getInt("foregroundTimeout"))
-            .backgroundTimeout(options.getInt("backgroundTimeout"))
-            .lifecycleEvents(options.getBoolean("lifecycleEvents"))
-            .screenContext(options.getBoolean("screenContext"))
-            .installTracking(options.getBoolean("installTracking"))
-            .build()
-        );
-
-        if (this.tracker != null) {
-            promise.resolve(true);
-        } else {
-            promise.reject("ERROR", "SnowplowTracker: initialize() method - tracker initialisation failed");
-            return;
-        }
-    }
-
-    @ReactMethod
-    public void setSubjectData(ReadableMap options,
+            // SubjectConfiguration
+            if (argmap.hasKey("subjectConfig")) {
+                ReadableMap subjectConfig = argmap.getMap("subjectConfig");
+                SubjectConfiguration subjectConfiguration = ConfigUtil.mkSubjectConfiguration(subjectConfig);
+                controllers.add(subjectConfiguration);
+            }
+
+            // GdprConfiguration
+            if (argmap.hasKey("gdprConfig")) {
+                ReadableMap gdprConfig = argmap.getMap("gdprConfig");
+                GdprConfiguration gdprConfiguration = ConfigUtil.mkGdprConfiguration(gdprConfig);
+                controllers.add(gdprConfiguration);
+            }
+
+            // GCConfiguration
+            if (argmap.hasKey("gcConfig")) {
+                ReadableArray gcConfig = argmap.getArray("gcConfig");
+                GlobalContextsConfiguration gcConfiguration = ConfigUtil.mkGCConfiguration(gcConfig);
+                controllers.add(gcConfiguration);
+            }
+
+            // create the tracker
+            Snowplow.createTracker(this.reactContext,
+                                   trackerNs,
+                                   networkConfiguration,
+                                   controllers.toArray(new Configuration[controllers.size()]));
+
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void removeTracker(ReadableMap details,
                               Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            promise.resolve(Snowplow.removeTracker(trackerController));
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void removeAllTrackers(Promise promise) {
+        try {
+            Snowplow.removeAllTrackers();
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackSelfDescribingEvent(ReadableMap details,
+                                         Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            SelfDescribingJson sdj = EventUtil.createSelfDescribingJson(argmap);
+            SelfDescribing event = new SelfDescribing(sdj);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackStructuredEvent(ReadableMap details,
+                                     Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            Structured event = EventUtil.createStructuredEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackScreenViewEvent(ReadableMap details,
+                                     Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            ScreenView event = EventUtil.createScreenViewEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackPageViewEvent(ReadableMap details,
+                                   Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            PageView event = EventUtil.createPageViewEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackTimingEvent(ReadableMap details,
+                                 Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            Timing event = EventUtil.createTimingEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackConsentGrantedEvent(ReadableMap details,
+                                         Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            ConsentGranted event = EventUtil.createConsentGrantedEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackConsentWithdrawnEvent(ReadableMap details,
+                                           Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            ConsentWithdrawn event = EventUtil.createConsentWithdrawnEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackEcommerceTransactionEvent(ReadableMap details,
+                                               Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
 
-        if (options.hasKey("userId")) {
-            tracker.instance().getSubject().setUserId(options.getString("userId"));
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            EcommerceTransaction event = EventUtil.createEcommerceTransactionEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackDeepLinkReceivedEvent(ReadableMap details,
+                                           Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            DeepLinkReceived event = EventUtil.createDeepLinkReceivedEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void trackMessageNotificationEvent(ReadableMap details,
+                                              Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap argmap = details.getMap("eventData");
+            ReadableArray contexts = details.getArray("contexts");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            MessageNotification event = EventUtil.createMessageNotificationEvent(argmap);
+
+            List<SelfDescribingJson> evCtxts = EventUtil.createContexts(contexts);
+            event.customContexts.addAll(evCtxts);
+
+            trackerController.track(event);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void removeGlobalContexts(ReadableMap details,
+                                     Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            String tag = details.getString("removeTag");
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            trackerController.getGlobalContexts().remove(tag);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void addGlobalContexts(ReadableMap details,
+                                  Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            ReadableMap gcArg = details.getMap("addGlobalContext");
+
+            String tag = gcArg.getString("tag");
+            ReadableArray globalContexts = gcArg.getArray("globalContexts") ;
+
+            List<SelfDescribingJson> staticContexts = new ArrayList<>();
+            for (int i = 0; i < globalContexts.size(); i++) {
+                SelfDescribingJson gContext = EventUtil.createSelfDescribingJson(globalContexts.getMap(i));
+                staticContexts.add(gContext);
+            }
+            GlobalContext gcStatic = new GlobalContext(staticContexts);
+
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            trackerController.getGlobalContexts().add(tag, gcStatic);
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
+
+    @ReactMethod
+    public void setUserId(ReadableMap details,
+                          Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("userId")) {
+                trackerController.getSubject().setUserId(null);
+            } else {
+                trackerController.getSubject().setUserId(details.getString("userId"));
+            }
+            promise.resolve(true);
 
-        if (options.hasKey("timezone")) {
-            tracker.instance().getSubject().setTimezone(options.getString("timezone"));
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
+
+    @ReactMethod
+    public void setNetworkUserId(ReadableMap details,
+                                 Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("networkUserId")) {
+                trackerController.getSubject().setNetworkUserId(null);
+            } else {
+                trackerController.getSubject().setNetworkUserId(details.getString("networkUserId"));
+            }
+            promise.resolve(true);
 
-        if (options.hasKey("language")) {
-            tracker.instance().getSubject().setLanguage(options.getString("language"));
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
 
-        if (options.hasKey("ipAddress")) {
-            tracker.instance().getSubject().setIpAddress(options.getString("ipAddress"));
+    @ReactMethod
+    public void setDomainUserId(ReadableMap details,
+                                Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("domainUserId")) {
+                trackerController.getSubject().setDomainUserId(null);
+            } else {
+                trackerController.getSubject().setDomainUserId(details.getString("domainUserId"));
+            }
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
 
-        if (options.hasKey("useragent")) {
-            tracker.instance().getSubject().setUseragent(options.getString("useragent"));
+    @ReactMethod
+    public void setIpAddress(ReadableMap details,
+                             Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("ipAddress")) {
+                trackerController.getSubject().setIpAddress(null);
+            } else {
+                trackerController.getSubject().setIpAddress(details.getString("ipAddress"));
+            }
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
+
+    @ReactMethod
+    public void setUseragent(ReadableMap details,
+                             Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("useragent")) {
+                trackerController.getSubject().setUseragent(null);
+            } else {
+                trackerController.getSubject().setUseragent(details.getString("useragent"));
+            }
+            promise.resolve(true);
 
-        if (options.hasKey("networkUserId")) {
-            tracker.instance().getSubject().setNetworkUserId(options.getString("networkUserId"));
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
+
+    @ReactMethod
+    public void setTimezone(ReadableMap details,
+                            Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("timezone")) {
+                trackerController.getSubject().setTimezone(null);
+            } else {
+                trackerController.getSubject().setTimezone(details.getString("timezone"));
+            }
+            promise.resolve(true);
 
-        if (options.hasKey("domainUserId")) {
-            tracker.instance().getSubject().setDomainUserId(options.getString("domainUserId"));
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
 
-        // integer values will throw an exception if set to null explicitly
-        if (options.hasKey("viewportWidth") && options.hasKey("viewportHeight")) {
-            if (options.isNull("viewportWidth") || options.isNull("viewportHeight")) {
-                promise.reject("ERROR", "SnowplowTracker: setSubjectData() method - viewportWidth and viewportHeight cannot be null");
+    @ReactMethod
+    public void setLanguage(ReadableMap details,
+                            Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("language")) {
+                trackerController.getSubject().setLanguage(null);
             } else {
-                tracker.instance().getSubject().setViewPort(options.getInt("viewportWidth"), options.getInt("viewportHeight"));
+                trackerController.getSubject().setLanguage(details.getString("language"));
             }
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
 
-        if (options.hasKey("screenWidth") && options.hasKey("screenHeight")) {
-            if (options.isNull("screenWidth") || options.isNull("screenHeight")) {
-                promise.reject("ERROR", "SnowplowTracker: setSubjectData() method - screenWidth and screenHeight cannot be null");
+    @ReactMethod
+    public void setScreenResolution(ReadableMap details,
+                                    Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("screenResolution")) {
+                trackerController.getSubject().setScreenResolution(null);
             } else {
-                tracker.instance().getSubject().setScreenResolution(options.getInt("screenWidth"), options.getInt("screenHeight"));
+                ReadableArray screenRes = details.getArray("screenResolution");
+                int width = screenRes.getInt(0);
+                int height = screenRes.getInt(1);
+                Size screenR = new Size(width, height);
+
+                trackerController.getSubject().setScreenResolution(screenR);
             }
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
+    }
 
-        if (options.hasKey("colorDepth")) {
-            if (options.isNull("colorDepth")) {
-                promise.reject("ERROR", "SnowplowTracker: setSubjectData() method - colorDepth cannot be null");
+    @ReactMethod
+    public void setScreenViewport(ReadableMap details,
+                                  Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("screenViewport")) {
+                trackerController.getSubject().setScreenViewPort(null);
             } else {
-                tracker.instance().getSubject().setColorDepth(options.getInt("colorDepth"));
+                ReadableArray screenView = details.getArray("screenViewport");
+                int width = screenView.getInt(0);
+                int height = screenView.getInt(1);
+                Size screenVP = new Size(width, height);
+
+                trackerController.getSubject().setScreenViewPort(screenVP);
             }
+            promise.resolve(true);
+
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
     }
 
     @ReactMethod
-    public void trackSelfDescribingEvent(ReadableMap event,
-                                        ReadableArray contexts) {
+    public void setColorDepth(ReadableMap details,
+                              Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            if (details.isNull("colorDepth")) {
+                trackerController.getSubject().setColorDepth(null);
+            } else {
+                trackerController.getSubject().setColorDepth(details.getInt("colorDepth"));
+            }
+            promise.resolve(true);
 
-        SelfDescribing trackerEvent = EventUtil.getSelfDescribingEvent(event, contexts);
-        if (trackerEvent != null) {
-            tracker.track(trackerEvent);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
     }
 
     @ReactMethod
-    public void trackStructuredEvent(ReadableMap details,
-                                    ReadableArray contexts) {
+    public void getSessionUserId(ReadableMap details,
+                                 Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            String suid = trackerController.getSession().getUserId();
+            promise.resolve(suid);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
 
-        Structured trackerEvent = EventUtil.getStructuredEvent(
-            details,
-            contexts);
-        if (trackerEvent != null) {
-            tracker.track(trackerEvent);
+    @ReactMethod
+    public void getSessionId(ReadableMap details,
+                             Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            String sid = trackerController.getSession().getSessionId();
+            promise.resolve(sid);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
     }
 
     @ReactMethod
-    public void trackScreenViewEvent(ReadableMap details,
-                                    ReadableArray contexts) {
+    public void getSessionIndex(ReadableMap details,
+                                Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            int sidx = trackerController.getSession().getSessionIndex();
+            promise.resolve(sidx);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
 
-        ScreenView trackerEvent = EventUtil.getScreenViewEvent(
-            details,
-            contexts);
-        if (trackerEvent != null) {
-            tracker.track(trackerEvent);
+    @ReactMethod
+    public void getIsInBackground(ReadableMap details,
+                                  Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            boolean isInBg = trackerController.getSession().isInBackground();
+            promise.resolve(isInBg);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
     }
 
     @ReactMethod
-    public void trackPageViewEvent(ReadableMap details,
-                                  ReadableArray contexts) {
+    public void getBackgroundIndex(ReadableMap details,
+                                   Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            int bgIdx = trackerController.getSession().getBackgroundIndex();
+            promise.resolve(bgIdx);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
 
-        PageView trackerEvent = EventUtil.getPageViewEvent(
-            details,
-            contexts);
-        if (trackerEvent != null) {
-            tracker.track(trackerEvent);
+    @ReactMethod
+    public void getForegroundIndex(ReadableMap details,
+                                   Promise promise) {
+        try {
+            String namespace = details.getString("tracker");
+            TrackerController trackerController = Snowplow.getTracker(namespace);
+
+            int fgIdx = trackerController.getSession().getForegroundIndex();
+            promise.resolve(fgIdx);
+        } catch(Throwable t) {
+            promise.reject("ERROR", t.getMessage());
         }
     }
+
 }