plotline-engage 1.0.0

package/android/build/outputs/logs/manifest-merger-debug-report.txt

@@ -0,0 +1,25 @@
+-- Merging decision tree log ---
+manifest
+ADDED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml:2:1-4:12
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml:2:1-4:12
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml:2:1-4:12
+	package
+		ADDED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml:2:70-103
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+	xmlns:android
+		ADDED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml:2:11-69
+uses-sdk
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml reason: use-sdk injection requested
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+	android:targetSdkVersion
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+		ADDED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+	android:minSdkVersion
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+		ADDED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml
+		INJECTED from /Users/adarsh/Documents/Projects/plotline-react-native/DemoApp/node_modules/plotline-insights/android/src/main/AndroidManifest.xml

package/android/build.gradle

@@ -0,0 +1,44 @@
+
+buildscript {
+    repositories {
+        jcenter()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:1.3.1'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 23
+    buildToolsVersion "23.0.1"
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    defaultConfig {
+        minSdkVersion 16
+        targetSdkVersion 22
+        versionCode 1
+        versionName "1.0"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+    maven {
+        url 'https://plotline-android-sdk.s3.amazonaws.com'
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'com.gitlab.plotline:plotline-android-sdk:2.7.2'
+}
+  

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.reactnativeplotline">
+
+</manifest>
+  

package/android/src/main/java/com/reactnativeplotline/RNPlotline.java

@@ -0,0 +1,297 @@
+
+package com.reactnativeplotline;
+
+import android.app.Activity;
+import android.graphics.RectF;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityNodeInfo;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.util.ReactFindViewUtil;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+import so.plotline.insights.FlowViews.PlotlineInternal;
+import so.plotline.insights.FlowViews.PlotlineViewPositionCallback;
+import so.plotline.insights.FlowViews.PlotlineViewPositionCompleteListener;
+import so.plotline.insights.FlowViews.PlotlineScreenshotPositionsCompleteListener;
+import so.plotline.insights.FlowViews.PlotlineViewsPresenceListener;
+import so.plotline.insights.FlowViews.ElementSearchObject;
+
+import so.plotline.insights.Models.ViewPosition;
+import so.plotline.insights.Plotline;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
+
+public class RNPlotline extends ReactContextBaseJavaModule {
+
+  private final ReactApplicationContext reactContext;
+
+  public RNPlotline(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+  }
+
+  @Override
+  public String getName() {
+    return "RNPlotline";
+  }
+
+  public static JSONArray getAllElements(@NonNull Activity activity) {
+      Set<String> includedElements = new HashSet<>();
+      ViewGroup viewGroup = (ViewGroup) activity.findViewById(android.R.id.content);
+      JSONArray elements = new JSONArray();
+      for(int i=0; i < viewGroup.getChildCount(); i++) {
+          ArrayList<View> children = getAllChildren( viewGroup.getChildAt(i));
+          for(int j=0; j<children.size(); j++) {
+              View childElement = children.get(j);
+              String nativeId = getNativeId(childElement);
+              if (includedElements.contains(nativeId))
+                  continue;
+
+              if (nativeId != null) {
+                  includedElements.add(nativeId);
+                  int[] location = new int[2];
+                  childElement.getLocationInWindow(location);
+                  JSONObject element = new JSONObject();
+                  try {
+                      element.put("clientElementId", nativeId);
+                      JSONObject position = new JSONObject();
+                      position.put("x", location[0]);
+                      position.put("y", location[1]);
+                      position.put("width", childElement.getWidth());
+                      position.put("height", childElement.getHeight());
+                      element.put("position", position);
+                      elements.put(element);
+                  } catch (JSONException e) {
+                      e.printStackTrace();
+                  }
+              }
+          }
+      }
+      return elements;
+  }
+
+  public static ArrayList<View> getAllChildren(View v) {
+      if (!(v instanceof ViewGroup)) {
+          ArrayList<View> viewArrayList = new ArrayList<>();
+          viewArrayList.add(v);
+          return viewArrayList;
+      }
+
+      ArrayList<View> result = new ArrayList<>();
+
+      ViewGroup viewGroup = (ViewGroup) v;
+      for (int i = 0; i < viewGroup.getChildCount(); i++) {
+
+          View child = viewGroup.getChildAt(i);
+
+          ArrayList<View> viewArrayList = new ArrayList<>();
+          viewArrayList.add(v);
+          viewArrayList.addAll(getAllChildren(child));
+
+          result.addAll(viewArrayList);
+      }
+      return result;
+  }
+
+  public static RectF calculeRectOnScreen(View view) {
+    int[] location = new int[2];
+    view.getLocationOnScreen(location);
+    return new RectF(location[0], location[1], location[0] + view.getMeasuredWidth(), location[1] + view.getMeasuredHeight());
+  }
+
+  public static RectF calculeRectInWindow(View view) {
+    int[] location = new int[2];
+    view.getLocationInWindow(location);
+    return new RectF(location[0], location[1], location[0] + view.getMeasuredWidth(), location[1] + view.getMeasuredHeight());
+  }
+
+  private static String getNativeId(View view) {
+    Object tag = view.getTag(R.id.view_tag_native_id);
+    return tag instanceof String ? (String) tag : null;
+  }
+
+  @ReactMethod
+  public void init(String apiKey, String userId, String endpoint) {
+      final Activity activity = getCurrentActivity();
+      Plotline.init(activity, apiKey, userId, endpoint);
+      Plotline.setFramework("REACT_NATIVE");
+      PlotlineInternal.setPositionCallback(new PlotlineViewPositionCallback() {
+          @Override
+          public void getAllElements(Activity activity, PlotlineScreenshotPositionsCompleteListener plotlineScreenshotPositionsCompleteListener) {
+              plotlineScreenshotPositionsCompleteListener.onPositionsReady(RNPlotline.getAllElements(activity));
+          }
+
+          @Override
+          public void getViewPosition(Activity activity, String fragmentId, String nativeId, PlotlineViewPositionCompleteListener plotlineViewPositionCompleteListener) {
+              final Activity activityInternal = getCurrentActivity();
+              View view = ReactFindViewUtil.findView(activityInternal.getWindow().getDecorView().getRootView(), nativeId);
+
+              if (view == null) {
+                  plotlineViewPositionCompleteListener.onViewReady(null);
+                  return;
+              }
+
+              view.post(() -> {
+                  boolean isVisible = false;
+                  try {
+                      AccessibilityNodeInfo nodeInfo = AccessibilityNodeInfo.obtain();
+                      view.onInitializeAccessibilityNodeInfo(nodeInfo);
+                      isVisible = nodeInfo.isVisibleToUser();
+                      nodeInfo.recycle();
+                  } catch (Exception e) {
+                      e.printStackTrace();
+                  }
+
+                  if (isVisible) {
+                      ViewPosition viewPosition = new ViewPosition(calculeRectOnScreen(view), calculeRectInWindow(view));
+                      plotlineViewPositionCompleteListener.onViewReady(viewPosition);
+                  } else {
+                      plotlineViewPositionCompleteListener.onViewReady(null);
+                  }
+            });
+          }
+
+          public boolean isViewPresent(Activity activity, String fragmentId, String nativeId) {
+              final Activity activityInternal = getCurrentActivity();
+              View view = ReactFindViewUtil.findView(activityInternal.getWindow().getDecorView().getRootView(), nativeId);
+
+              if (view == null)
+                  return false;
+
+              try {
+                  AccessibilityNodeInfo nodeInfo = AccessibilityNodeInfo.obtain();
+                  view.onInitializeAccessibilityNodeInfo(nodeInfo);
+                  boolean isVisible = nodeInfo.isVisibleToUser();
+                  nodeInfo.recycle();
+                  return (view.getWidth() != 0 && view.getHeight() != 0 && isVisible);
+              } catch (Exception e) {
+                  e.printStackTrace();
+              }
+              return false;
+          }
+
+          @Override
+          public void areViewsPresent(Activity activity, List<ElementSearchObject> elementSearchObjects, PlotlineViewsPresenceListener plotlineViewsPresenceListener) {
+              List<ElementSearchObject> presentElements = new ArrayList<>();
+              if (elementSearchObjects.size() == 0) {
+                  plotlineViewsPresenceListener.onViewsPresent(presentElements);
+                  return;
+              }
+
+              for(ElementSearchObject elementSearchObject: elementSearchObjects) {
+                  if (isViewPresent(activity, elementSearchObject.clientFragmentId, elementSearchObject.clientElementId)) {
+                      presentElements.add(elementSearchObject);
+                  }
+              }
+              plotlineViewsPresenceListener.onViewsPresent(presentElements);
+          }
+
+
+          @Override
+          public View getView(Activity activity, String fragmentId, String nativeId) {
+              final Activity activityInternal = getCurrentActivity();
+              View view = ReactFindViewUtil.findView(activityInternal.getWindow().getDecorView().getRootView(), nativeId);
+              return view;
+          }
+      });
+  }
+
+  @ReactMethod
+  public void track(String eventName) {
+    final Activity activity = getCurrentActivity();
+    Plotline.track(eventName, activity);
+  }
+
+  @ReactMethod
+  public void track(String eventName, ReadableMap object){
+    final Activity activity = getCurrentActivity();
+    JSONObject properties = new JSONObject();
+    if (object != null) {
+      ReadableMapKeySetIterator iterator = object.keySetIterator();
+      while (iterator.hasNextKey()) {
+        String key = iterator.nextKey();
+        ReadableType type = object.getType(key);
+        if (type == ReadableType.String) {
+          try {
+            properties.put((String) key, (String) object.getString(key));
+          } catch (JSONException e) {
+            e.printStackTrace();
+          }
+        }
+      }
+    }
+    Plotline.track(eventName, properties, activity);
+  }
+
+  @ReactMethod
+  public void identify(ReadableMap object) {
+    JSONObject jsonObject = new JSONObject();
+    if (object != null) {
+      ReadableMapKeySetIterator iterator = object.keySetIterator();
+      while (iterator.hasNextKey()) {
+        String key = iterator.nextKey();
+        ReadableType type = object.getType(key);
+        if (type == ReadableType.String) {
+          try {
+            jsonObject.put((String) key, (String) object.getString(key));
+          } catch (JSONException e) {
+            e.printStackTrace();
+          }
+        }
+      }
+    }
+    Plotline.identify(jsonObject);
+  }
+
+  @ReactMethod
+  public void showMockStudy() {
+    final Activity activity = getCurrentActivity();
+    Plotline.showMockStudy(activity);
+  }
+
+  @ReactMethod
+  public void setLocale(String locale) {
+    Plotline.setLocale(locale);
+  }
+
+  @ReactMethod
+  public void setColor(ReadableMap colors) {
+    JSONObject jsonObject = new JSONObject();
+    if (colors != null) {
+      ReadableMapKeySetIterator iterator = colors.keySetIterator();
+      while (iterator.hasNextKey()) {
+        String key = iterator.nextKey();
+        ReadableType type = colors.getType(key);
+        if (type == ReadableType.String) {
+          try {
+            jsonObject.put((String) key, (String) colors.getString(key));
+          } catch (JSONException e) {
+            e.printStackTrace();
+          }
+        }
+      }
+    }
+    Plotline.setColor(jsonObject);
+  }
+
+  @ReactMethod
+  public void trackPage(String pageId) {
+      final Activity activity = getCurrentActivity();
+      Plotline.trackPage(pageId, activity);
+  }
+}

package/android/src/main/java/com/reactnativeplotline/RNPlotlinePackage.java

@@ -0,0 +1,29 @@
+
+package com.reactnativeplotline;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import com.facebook.react.bridge.JavaScriptModule;
+
+public class RNPlotlinePackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new RNPlotline(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/index.d.ts

@@ -0,0 +1,11 @@
+declare class plotline {
+    track(eventName: string, properties: {[key: string]: string}): void;
+    init(apiKey: string, refId: string, endpoint?: string): void;
+    identify(attributes: {[key: string]: string}): void;
+    setLocale(locale: string): void;
+    showMockStudy(): void;
+    setColor(colors: {[key: string]: string}): void;
+    trackPage(pageId: string): void;
+}
+declare const Plotline: plotline;
+export default Plotline;

package/index.js

@@ -0,0 +1,43 @@
+
+import { NativeModules, Platform } from 'react-native';
+
+const { RNPlotline } = NativeModules;
+
+class plotline {
+    track (eventName, properties) {
+        if (properties)
+            RNPlotline.track(eventName, properties);
+        else
+            RNPlotline.track(eventName, null);
+    }
+
+    init (apiKey, refId, endpoint = null) {
+        console.log("[Plotline] init called");
+        RNPlotline.init(apiKey, refId, endpoint);
+    }
+
+    identify (obj) {
+        RNPlotline.identify(obj);
+    }
+
+    setLocale (locale) {
+        RNPlotline.setLocale(locale);
+    }
+
+    showMockStudy () {
+        RNPlotline.showMockStudy();
+    }
+
+    setColor (colors) {
+        RNPlotline.setColor(colors);
+    }
+
+    trackPage (pageId) {
+        console.log("[Plotline] track called");
+        RNPlotline.trackPage(pageId);
+    }
+}
+
+const Plotline = new plotline();
+
+export default Plotline;

package/ios/RNPlotline.h

@@ -0,0 +1,11 @@
+
+#if __has_include("RCTBridgeModule.h")
+#import "RCTBridgeModule.h"
+#else
+#import <React/RCTBridgeModule.h>
+#endif
+
+@interface RNPlotline : NSObject <RCTBridgeModule>
+
+@end
+  

package/ios/RNPlotline.m

@@ -0,0 +1,64 @@
+
+#import "RNPlotline.h"
+#import <Plotline/Plotline-Swift.h>
+
+@implementation RNPlotline
+
+RCT_EXPORT_METHOD(init:(NSString *)apiKey userId:(NSString *)userId endpoint:(NSString *)endpoint)
+{
+    printf("Plotline Init Called");
+ [Plotline debugWithShouldDebug:true];
+ if (endpoint != nil) {
+    [Plotline initializeWithApiKey:apiKey userId:userId endpoint:endpoint];
+ } else {
+    [Plotline initializeWithApiKey:apiKey userId:userId];
+ }
+ [Plotline setPlotlineFrameworkWithFramework:@"REACT_NATIVE"];
+   //  [Plotline trackPageWithPageName:@"MainActivity"];
+}
+
+RCT_EXPORT_METHOD(track:(NSString *)eventName properties: (NSDictionary *) properties)
+{
+ if(properties != nil) {
+  [Plotline trackWithEventName:eventName properties:properties];
+ } else {
+  [Plotline trackWithEventName:eventName];
+ }
+}
+
+RCT_EXPORT_METHOD(setLocale:(NSString *)locale)
+{
+ [Plotline setLocaleWithLocale:locale];
+}
+
+RCT_EXPORT_METHOD(identify:(NSDictionary *)attribute)
+{
+ [Plotline identifyWithAttributes:attribute];
+}
+
+RCT_EXPORT_METHOD(showMockStudy)
+{
+ [Plotline showMockStudy];
+ [Plotline initAlong];
+}
+
+RCT_EXPORT_METHOD(setColor:(NSDictionary *)colors)
+{
+ [Plotline setColorWithColors:colors];
+}
+
+RCT_EXPORT_METHOD(debug)
+{
+ [Plotline debugWithShouldDebug:true];
+}
+
+RCT_EXPORT_METHOD(trackPage:(NSString *)pageName)
+{
+    printf("Plotline Track Page Called");
+ [Plotline trackPageWithPageName:pageName];
+}
+
+RCT_EXPORT_MODULE();
+
+@end
+