plotline-engage 3.2.3 → 4.0.1

package/android/build.gradle

@@ -39,6 +39,6 @@ repositories {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+'
-    implementation 'com.gitlab.plotline:plotline-android-sdk:2.9.7'
+    implementation 'com.gitlab.plotline:plotline-android-sdk:3.0.0'
 }
   

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

@@ -9,16 +9,25 @@ import android.view.accessibility.AccessibilityNodeInfo;
 
 import androidx.annotation.NonNull;
 
+import com.facebook.react.bridge.Arguments;
 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.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import org.json.JSONObject;
 import org.json.JSONException;
 
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import so.plotline.insights.Listeners.PlotlineEventsListener;
+import so.plotline.insights.Listeners.PlotlineRedirectListener;
 import so.plotline.insights.Plotline;
 
 public class RNPlotline extends ReactContextBaseJavaModule {
@@ -40,6 +49,56 @@ public class RNPlotline extends ReactContextBaseJavaModule {
       final Activity activity = getCurrentActivity();
       Plotline.init(activity, apiKey, userId, endpoint);
       Plotline.setFramework("REACT_NATIVE");
+      Plotline.setPlotlineEventsListener((eventName, eventProperties) -> {
+          try {
+              WritableMap writableMap = Arguments.createMap();
+              Iterator<String> iterator = eventProperties.keys();
+
+              while (iterator.hasNext()) {
+                  String key = iterator.next();
+                  Object value = eventProperties.get(key);
+
+                  if (value instanceof String) {
+                      writableMap.putString(key, (String) value);
+                  } else if (value instanceof Integer) {
+                      writableMap.putInt(key, (Integer) value);
+                  } else if (value instanceof Double) {
+                      writableMap.putDouble(key, (Double) value);
+                  } else if (value instanceof Boolean) {
+                      writableMap.putBoolean(key, (Boolean) value);
+                  } else {
+                      writableMap.putString(key, value.toString());
+                  }
+              }
+
+              WritableMap event = Arguments.createMap();
+              event.putString("eventName", eventName);
+              event.putMap("properties", writableMap);
+
+              getReactApplicationContext()
+                      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                      .emit("PlotlineEvents", event);
+
+          } catch (Exception e) {
+              e.printStackTrace();
+          }
+      });
+
+      Plotline.setPlotlineRedirectListener(redirectKeyValues -> {
+          try {
+              WritableMap writableMap = Arguments.createMap();
+
+              for (Map.Entry<String, String> entry : redirectKeyValues.entrySet()) {
+                  writableMap.putString(entry.getKey(), entry.getValue());
+              }
+
+              getReactApplicationContext()
+                      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                      .emit("PlotlineRedirect", writableMap);
+          } catch (Exception e) {
+              e.printStackTrace();
+          }
+      });
   }
   
   @ReactMethod

package/index.d.ts

@@ -12,6 +12,8 @@ declare class plotline {
     trackPage(pageId: string): void;
     debug(): void;
     notifyScroll(): void;
+    setPlotlineEventsListener(listener: (eventName: string, properties: {[key: string]: any}) => void): void;
+    setPlotlineRedirectListener(listener: (keyValuePairs: {[key: string]: any}) => void): void;
     logout(): void;
 }
 declare class ScrollView extends React.Component<ScrollViewProps> {

package/index.js

@@ -1,5 +1,5 @@
 
-import { NativeModules } from 'react-native';
+import { NativeModules, DeviceEventEmitter, Platform, NativeEventEmitter } from 'react-native';
 import { ScrollView as RNScrollView, FlatList as RNFlatList} from 'react-native';
 import React from 'react';
 const { RNPlotline } = NativeModules;
@@ -7,6 +7,25 @@ const { RNPlotline } = NativeModules;
 class plotline {
     constructor() {
         this.throttledNotifyScroll = this.throttle(this.handleScroll, 250);
+        this.plotlineEventsListener = null;
+        this.plotlineRedirectListener = null;
+
+        if (Platform.OS === 'android') {
+            this.plotlineEventsSubscription = DeviceEventEmitter.addListener('PlotlineEvents', (event) => {
+                this._notifyEvent(event.eventName, event.properties);
+            });
+            this.plotlineRedirectSubscription = DeviceEventEmitter.addListener('PlotlineRedirect', (keyValuePairs) => {
+                this._notifyRedirect(keyValuePairs);
+            });
+        } else if (Platform.OS === 'ios') {
+            const myNativeEventEmitterModule = new NativeEventEmitter(NativeModules.RNPlotline);
+            this.plotlineEventsSubscription = myNativeEventEmitterModule.addListener('PlotlineEvents', (event) => {
+                this._notifyEvent(event.eventName, event.properties);
+            });
+            this.plotlineRedirectSubscription = myNativeEventEmitterModule.addListener('PlotlineRedirect', (keyValuePairs) => {
+                this._notifyRedirect(keyValuePairs);
+            });
+        }
     }
 
     throttle(func, limit) {
@@ -65,7 +84,35 @@ class plotline {
         this.throttledNotifyScroll();
     }
 
+    setPlotlineEventsListener(plotlineEventsListener) {
+        this.plotlineEventsListener = plotlineEventsListener;
+    }
+
+    setPlotlineRedirectListener(plotlineRedirectListener) {
+        this.plotlineRedirectListener = plotlineRedirectListener;
+    }
+
+    _notifyEvent(eventName, properties) {
+        if (this.plotlineEventsListener) {
+            this.plotlineEventsListener(eventName, properties);
+        }
+    }
+
+    _notifyRedirect(keyValuePairs) {
+        if (this.plotlineRedirectListener) {
+            this.plotlineRedirectListener(keyValuePairs);
+        }
+    }
+
     logout() {
+        if (this.plotlineEventsSubscription) {
+            this.plotlineEventsSubscription.remove();
+            this.plotlineEventsSubscription = null;
+        }
+        if (this.plotlineRedirectSubscription) {
+            this.plotlineRedirectSubscription.remove();
+            this.plotlineRedirectSubscription = null;
+        }
         RNPlotline.logout();
     }
 }

package/ios/RNPlotline.h

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

package/ios/RNPlotline.m

@@ -1,9 +1,14 @@
 
 #import "RNPlotline.h"
 #import <Plotline/Plotline-Swift.h>
+#import <React/RCTEventEmitter.h>
 
 @implementation RNPlotline
 
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"PlotlineEvents",@"PlotlineRedirect"];
+}
+
 RCT_EXPORT_METHOD(init:(NSString *)apiKey userId:(NSString *)userId endpoint:(NSString *)endpoint)
 {
  if (endpoint != nil) {
@@ -12,6 +17,16 @@ RCT_EXPORT_METHOD(init:(NSString *)apiKey userId:(NSString *)userId endpoint:(NS
     [Plotline initializeWithApiKey:apiKey userId:userId];
  }
  [Plotline setPlotlineFrameworkWithFramework:@"REACT_NATIVE"];
+ [Plotline setPlotlineEventsListenerWithListener:^(NSString *eventName, NSDictionary *eventProperties) {
+    NSDictionary *event = @{
+      @"eventName": eventName,
+      @"properties": eventProperties
+    };
+    [self sendEventWithName:@"PlotlineEvents" body:event];
+  }];
+ [Plotline setPlotlineRedirectListenerWithListener:^(NSDictionary<NSString *, NSString *> * redirectKeyValues) {
+    [self sendEventWithName:@"PlotlineRedirect" body:redirectKeyValues];
+ }];
 }
 
 RCT_EXPORT_METHOD(track:(NSString *)eventName properties: (NSDictionary *) properties)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plotline-engage",
-  "version": "3.2.3",
+  "version": "4.0.1",
   "description": "React Native plugin for Plotline",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"