@convivainc/conviva-react-native-appanalytics 0.1.0 → 0.1.2

package/android/src/main/java/com/conviva/react/apptracker/RNConvivaTrackerPackage.java

@@ -0,0 +1,29 @@
+package com.conviva.react.apptracker;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class RNConvivaTrackerPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new RNConvivaTrackerModule(reactContext));
+    }
+
+    // Deprecated from RN 0.47
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/com/conviva/react/apptracker/util/ConfigUtil.java

@@ -0,0 +1,346 @@
+package com.conviva.react.apptracker.util;
+
+import com.conviva.apptracker.configuration.EmitterConfiguration;
+import com.conviva.apptracker.configuration.GdprConfiguration;
+import com.conviva.apptracker.configuration.GlobalContextsConfiguration;
+import com.conviva.apptracker.configuration.SessionConfiguration;
+import com.conviva.apptracker.configuration.SubjectConfiguration;
+import com.conviva.apptracker.configuration.TrackerConfiguration;
+import com.conviva.apptracker.emitter.BufferOption;
+import com.conviva.apptracker.globalcontexts.GlobalContext;
+import com.conviva.apptracker.payload.SelfDescribingJson;
+import com.conviva.apptracker.tracker.DevicePlatform;
+import com.conviva.apptracker.tracker.LogLevel;
+import com.conviva.apptracker.util.Basis;
+import com.conviva.apptracker.util.Size;
+import com.conviva.apptracker.util.TimeMeasure;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+public class ConfigUtil {
+
+    public static DevicePlatform mkDevicePlatform(String devPlatform) {
+
+        DevicePlatform devicePlatform = DevicePlatform.Mobile;
+        if (devPlatform.equals("web")) {
+            devicePlatform = DevicePlatform.Web;
+        } else if (devPlatform.equals("srv")) {
+            devicePlatform = DevicePlatform.ServerSideApp;
+        } else if (devPlatform.equals("pc")) {
+            devicePlatform = DevicePlatform.Desktop;
+        } else if (devPlatform.equals("app")) {
+            devicePlatform = DevicePlatform.General;
+        } else if (devPlatform.equals("tv")) {
+            devicePlatform = DevicePlatform.ConnectedTV;
+        } else if (devPlatform.equals("cnsl")) {
+            devicePlatform = DevicePlatform.GameConsole;
+        } else if (devPlatform.equals("iot")) {
+            devicePlatform = DevicePlatform.InternetOfThings;
+        }
+
+        return devicePlatform;
+    }
+
+    public static LogLevel mkLogLevel(String logLvl) {
+
+        LogLevel logLevel = LogLevel.OFF;
+        if (logLvl.equals("error")) {
+            logLevel = LogLevel.ERROR;
+        } else if (logLvl.equals("debug")) {
+            logLevel = LogLevel.DEBUG;
+        } else if (logLvl.equals("verbose")) {
+            logLevel = LogLevel.VERBOSE;
+        }
+
+        return logLevel;
+    }
+
+    public static BufferOption mkBufferOption(String bufferOpt) {
+
+        BufferOption bufferOption = BufferOption.Single;
+        if (bufferOpt.equals("default")) {
+            bufferOption = BufferOption.DefaultGroup;
+        } else if (bufferOpt.equals("heavy")) {
+            bufferOption = BufferOption.HeavyGroup;
+        }
+
+        return bufferOption;
+    }
+
+    public static Basis mkBasis(String basis) {
+
+        Basis basisForProcessing = Basis.CONSENT;
+        if (basis.equals("contract")) {
+            basisForProcessing = Basis.CONTRACT;
+        }
+        if (basis.equals("legal_obligation")) {
+            basisForProcessing = Basis.LEGAL_OBLIGATION;
+        }
+        if (basis.equals("legitimate_interests")) {
+            basisForProcessing = Basis.LEGITIMATE_INTERESTS;
+        }
+        if (basis.equals("public_task")) {
+            basisForProcessing = Basis.PUBLIC_TASK;
+        }
+        if (basis.equals("vital_interests")) {
+            basisForProcessing = Basis.VITAL_INTERESTS;
+        }
+
+        return basisForProcessing;
+    }
+
+    public static TrackerConfiguration mkTrackerConfiguration(ReadableMap trackerConfig, String appName,
+                                                              ReactApplicationContext context) {
+        TrackerConfiguration trackerConfiguration = new TrackerConfiguration(appName)
+                .trackerVersionSuffix(TrackerVersion.RN_CONVIVA_TRACKER_VERSION);
+
+        if (trackerConfig != null) {
+            if (trackerConfig.hasKey("devicePlatform")) {
+                DevicePlatform devicePlatform = mkDevicePlatform(trackerConfig.getString("devicePlatform"));
+                trackerConfiguration.devicePlatform(devicePlatform);
+            }
+            if (trackerConfig.hasKey("logLevel")) {
+                LogLevel logLevel = mkLogLevel(trackerConfig.getString("logLevel"));
+                trackerConfiguration.logLevel(logLevel);
+            }
+            if (trackerConfig.hasKey("base64Encoding")) {
+                trackerConfiguration.base64encoding(trackerConfig.getBoolean("base64Encoding"));
+            }
+            if (trackerConfig.hasKey("applicationContext")) {
+                trackerConfiguration.applicationContext(trackerConfig.getBoolean("applicationContext"));
+            }
+            if (trackerConfig.hasKey("platformContext")) {
+                trackerConfiguration.platformContext(trackerConfig.getBoolean("platformContext"));
+            }
+            if (trackerConfig.hasKey("geoLocationContext")) {
+                trackerConfiguration.geoLocationContext(trackerConfig.getBoolean("geoLocationContext"));
+            }
+            if (trackerConfig.hasKey("sessionContext")) {
+                trackerConfiguration.sessionContext(trackerConfig.getBoolean("sessionContext"));
+            }
+            if (trackerConfig.hasKey("screenContext")) {
+                trackerConfiguration.screenContext(trackerConfig.getBoolean("screenContext"));
+            }
+            if (trackerConfig.hasKey("screenViewAutotracking")) {
+                trackerConfiguration.screenViewAutotracking(trackerConfig.getBoolean("screenViewAutotracking"));
+            }
+            if (trackerConfig.hasKey("lifecycleAutotracking")) {
+                trackerConfiguration.lifecycleAutotracking(trackerConfig.getBoolean("lifecycleAutotracking"));
+            }
+            if (trackerConfig.hasKey("installAutotracking")) {
+                trackerConfiguration.installAutotracking(trackerConfig.getBoolean("installAutotracking"));
+            }
+            if (trackerConfig.hasKey("exceptionAutotracking")) {
+                trackerConfiguration.exceptionAutotracking(trackerConfig.getBoolean("exceptionAutotracking"));
+            }
+            if (trackerConfig.hasKey("diagnosticAutotracking")) {
+                trackerConfiguration.diagnosticAutotracking(trackerConfig.getBoolean("diagnosticAutotracking"));
+            }
+            if (trackerConfig.hasKey("deepLinkContext")) {
+                trackerConfiguration.deepLinkContext(trackerConfig.getBoolean("deepLinkContext"));
+            }
+            if (trackerConfig.hasKey("userAnonymisation")) {
+                trackerConfiguration.userAnonymisation(trackerConfig.getBoolean("userAnonymisation"));
+            }
+            if (trackerConfig.hasKey("bundleInfoAutotracking")) {
+                trackerConfiguration.bundleInfoAutotracking(trackerConfig.getBoolean("bundleInfoAutotracking"));
+            }
+            if (trackerConfig.hasKey("enablePeriodicHeartbeat")) {
+                trackerConfiguration.enablePeriodicHeartbeat(trackerConfig.getBoolean("enablePeriodicHeartbeat"));
+            }
+            if (trackerConfig.hasKey("periodicHeartbeatIntervalInSec")) {
+                trackerConfiguration.periodicHeartbeatIntervalInSec(trackerConfig.getInt("periodicHeartbeatIntervalInSec"));
+            }
+            if (trackerConfig.hasKey("periodicHeartbeatDelayInSec")) {
+                trackerConfiguration.periodicHeartbeatDelayInSec(trackerConfig.getInt("periodicHeartbeatDelayInSec"));
+            }
+            if (trackerConfig.hasKey("userClickAutotracking")) {
+                trackerConfiguration.userClickAutotracking(trackerConfig.getBoolean("userClickAutotracking"));
+            }
+            if (trackerConfig.hasKey("deepLinkAutotracking")) {
+                trackerConfiguration.deepLinkAutotracking(trackerConfig.getBoolean("deepLinkAutotracking"));
+            }
+        }
+
+        return trackerConfiguration;
+    }
+
+    public static SessionConfiguration mkSessionConfiguration(ReadableMap sessionConfig) {
+        long foregroundTimeout = (long) sessionConfig.getDouble("foregroundTimeout");
+
+        long backgroundTimeout = (long) sessionConfig.getDouble("backgroundTimeout");
+
+        SessionConfiguration sessionConfiguration = new SessionConfiguration(
+                new TimeMeasure(foregroundTimeout, TimeUnit.SECONDS),
+                new TimeMeasure(backgroundTimeout, TimeUnit.SECONDS));
+
+        return sessionConfiguration;
+    }
+
+    public static EmitterConfiguration mkEmitterConfiguration(ReadableMap emitterConfig) {
+        EmitterConfiguration emitterConfiguration = new EmitterConfiguration();
+
+        if (emitterConfig.hasKey("bufferOption")) {
+            BufferOption bufferOption = mkBufferOption(emitterConfig.getString("bufferOption"));
+            emitterConfiguration.bufferOption(bufferOption);
+        }
+        if (emitterConfig.hasKey("emitRange")) {
+            int emitRange = (int) emitterConfig.getDouble("emitRange");
+            emitterConfiguration.emitRange(emitRange);
+        }
+        if (emitterConfig.hasKey("threadPoolSize")) {
+            int threadPoolSize = (int) emitterConfig.getDouble("threadPoolSize");
+            emitterConfiguration.threadPoolSize(threadPoolSize);
+        }
+        if (emitterConfig.hasKey("byteLimitPost")) {
+            int byteLimitPost = (int) emitterConfig.getDouble("byteLimitPost");
+            emitterConfiguration.byteLimitPost(byteLimitPost);
+        }
+        if (emitterConfig.hasKey("byteLimitGet")) {
+            int byteLimitGet = (int) emitterConfig.getDouble("byteLimitGet");
+            emitterConfiguration.byteLimitGet(byteLimitGet);
+        }
+        if (emitterConfig.hasKey("serverAnonymisation")) {
+            emitterConfiguration.serverAnonymisation(emitterConfig.getBoolean("serverAnonymisation"));
+        }
+        if (emitterConfig.hasKey("disableEventCaching")) {
+            emitterConfiguration.disableEventCaching(emitterConfig.getBoolean("disableEventCaching"));
+        }
+        return emitterConfiguration;
+    }
+
+    public static SubjectConfiguration mkSubjectConfiguration(ReadableMap subjectConfig) {
+        SubjectConfiguration subjectConfiguration = new SubjectConfiguration();
+
+        if (subjectConfig.hasKey("userId")) {
+            if (subjectConfig.isNull("userId")) {
+                subjectConfiguration.userId(null);
+            } else {
+                subjectConfiguration.userId(subjectConfig.getString("userId"));
+            }
+        }
+        if (subjectConfig.hasKey("networkUserId")) {
+            if (subjectConfig.isNull("networkUserId")) {
+                subjectConfiguration.networkUserId(null);
+            } else {
+                subjectConfiguration.networkUserId(subjectConfig.getString("networkUserId"));
+            }
+        }
+        if (subjectConfig.hasKey("domainUserId")) {
+            if (subjectConfig.isNull("domainUserId")) {
+                subjectConfiguration.domainUserId(null);
+            } else {
+                subjectConfiguration.domainUserId(subjectConfig.getString("domainUserId"));
+            }
+        }
+        if (subjectConfig.hasKey("useragent")) {
+            if (subjectConfig.isNull("useragent")) {
+                subjectConfiguration.useragent(null);
+            } else {
+                subjectConfiguration.useragent(subjectConfig.getString("useragent"));
+            }
+        }
+        if (subjectConfig.hasKey("ipAddress")) {
+            if (subjectConfig.isNull("ipAddress")) {
+                subjectConfiguration.ipAddress(null);
+            } else {
+                subjectConfiguration.ipAddress(subjectConfig.getString("ipAddress"));
+            }
+        }
+        if (subjectConfig.hasKey("timezone")) {
+            if (subjectConfig.isNull("timezone")) {
+                subjectConfiguration.timezone(null);
+            } else {
+                subjectConfiguration.timezone(subjectConfig.getString("timezone"));
+            }
+        }
+        if (subjectConfig.hasKey("language")) {
+            if (subjectConfig.isNull("language")) {
+                subjectConfiguration.language(null);
+            } else {
+                subjectConfiguration.language(subjectConfig.getString("language"));
+            }
+        }
+        if (subjectConfig.hasKey("screenResolution")) {
+            if (subjectConfig.isNull("screenResolution")) {
+                subjectConfiguration.screenResolution(null);
+            } else {
+                ReadableArray screenRes = subjectConfig.getArray("screenResolution");
+                int screenWidth = (int) screenRes.getDouble(0);
+                int screenHeight = (int) screenRes.getDouble(1);
+
+                Size screenResolution = new Size(screenWidth, screenHeight);
+                subjectConfiguration.screenResolution(screenResolution);
+            }
+        }
+        if (subjectConfig.hasKey("screenViewport")) {
+            if (subjectConfig.isNull("screenViewport")) {
+                subjectConfiguration.screenViewPort(null);
+            } else {
+                ReadableArray screenVP = subjectConfig.getArray("screenViewport");
+                int screenVPWidth = (int) screenVP.getDouble(0);
+                int screenVPHeight = (int) screenVP.getDouble(1);
+
+                Size screenViewport = new Size(screenVPWidth, screenVPHeight);
+                subjectConfiguration.screenViewPort(screenViewport);
+            }
+        }
+        if (subjectConfig.hasKey("colorDepth")) {
+            if (subjectConfig.isNull("colorDepth")) {
+                subjectConfiguration.colorDepth(null);
+            } else {
+                int colorDepth = (int) subjectConfig.getDouble("colorDepth");
+                subjectConfiguration.colorDepth(colorDepth);
+            }
+        }
+
+        return subjectConfiguration;
+    }
+
+    public static GdprConfiguration mkGdprConfiguration(ReadableMap gdprConfig) {
+        Basis basis = mkBasis(gdprConfig.getString("basisForProcessing"));
+        String docId = gdprConfig.getString("documentId");
+        String docVer = gdprConfig.getString("documentVersion");
+        String docDesc = gdprConfig.getString("documentDescription");
+
+        GdprConfiguration gdprConfiguration = new GdprConfiguration(basis,
+                docId,
+                docVer,
+                docDesc);
+
+        return gdprConfiguration;
+    }
+
+    public static GlobalContextsConfiguration mkGCConfiguration(ReadableArray gcConfig) {
+
+        HashMap contextGens = new HashMap<>();
+        for (int i = 0; i < gcConfig.size(); i++) {
+            ReadableMap gcMap = gcConfig.getMap(i);
+
+            String itag = gcMap.getString("tag");
+            ReadableArray globalContexts = gcMap.getArray("globalContexts");
+
+            List<SelfDescribingJson> staticContexts = new ArrayList<>();
+            for (int x = 0; x < globalContexts.size(); x++) {
+                SelfDescribingJson gContext = EventUtil.createSelfDescribingJson(globalContexts.getMap(x));
+                staticContexts.add(gContext);
+            }
+
+            GlobalContext gcStatic = new GlobalContext(staticContexts);
+
+            if (!contextGens.containsKey(itag)) {
+                contextGens.put(itag, gcStatic);
+            }
+        }
+
+        GlobalContextsConfiguration gcConfiguration = new GlobalContextsConfiguration(contextGens);
+
+        return gcConfiguration;
+    }
+}