klaritics-react-native-sdk 1.0.0

package/android/src/main/java/com/deeptaai/reactnativesdk/KlariticsModule.java

@@ -0,0 +1,324 @@
+package com.deeptaai.reactnativesdk;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+import com.deeptaai.klaritics.Klaritics;
+import com.deeptaai.klaritics.KlariticsConfig;
+import com.deeptaai.klaritics.Attributes;
+import com.deeptaai.klaritics.EventListener;
+import com.deeptaai.klaritics.SDKController;
+import com.deeptaai.klaritics.models.BaseAnthraEvent;
+import com.deeptaai.klaritics.models.NavigationEvent;
+import com.deeptaai.klaritics.utils.Logger;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Arguments;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.deeptaai.klaritics.Constants.BACKGROUND;
+import static com.deeptaai.klaritics.Constants.FOREGROUND;
+import static com.deeptaai.klaritics.Constants.SYSTEM_EVENTS;
+
+@ReactModule(name = KlariticsModule.NAME)
+public class KlariticsModule extends ReactContextBaseJavaModule implements EventListener {
+    public static final String NAME = "Klaritics";
+    private static final String TAG = "Klaritics";
+
+    private NavigationEvent navigationEvent;
+    private String prevScreenName;
+
+    public KlariticsModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+
+        SDKController controller = SDKController.getInstance();
+
+        controller.markAsReactNative();
+        controller.registerToEvent(SYSTEM_EVENTS, this);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void setup(String appId, String host) {
+        if (appId == null || appId.trim().equals("")) {
+            Logger.e(TAG, "App ID cannot be empty or null", null);
+            return;
+        }
+        if (host == null || host.trim().equals("")) {
+            Logger.e(TAG, "Host cannot be empty or null", null);
+            return;
+        }
+        KlariticsConfig config = new KlariticsConfig(appId, host);
+        Klaritics.setup(getReactApplicationContext().getApplicationContext(), config);
+    }
+
+    @ReactMethod
+    public void setUserIdentifier(String user) {
+        Klaritics.setUserIdentifier(user);
+    }
+
+    @ReactMethod
+    public void setUserCustomInfo(ReadableMap info) {
+        if (info == null) {
+            return;
+        }
+
+        Klaritics.setUserCustomInfo(attributesFromReadableMap(info));
+    }
+
+    @ReactMethod
+    public void logAppEvent(String event, ReadableMap additionalInfo, boolean isAggregate) {
+        if (event == null || event.trim().equals("")) {
+            Logger.e(TAG, "Name cannot be empty or null", null);
+            return;
+        }
+        Klaritics.logAppEvent(event, attributesFromReadableMap(additionalInfo), isAggregate);
+    }
+
+    @ReactMethod
+    public void logMetaEvent(String category, String event, ReadableMap attributes) {
+        if (event == null || event.trim().equals("")) {
+            Logger.e(TAG, "Name cannot be empty or null", null);
+            return;
+        }
+        Klaritics.logMetaEvent(category, event, attributesFromReadableMap(attributes));
+    }
+
+    @ReactMethod
+    public void logClientEvent(String eventName, ReadableMap attributes) {
+        if (eventName == null || eventName.trim().equals("")) {
+            Logger.e(TAG, "Name cannot be empty or null", null);
+            return;
+        }
+
+        Klaritics.logClientEvent(eventName, attributesFromReadableMap(attributes));
+    }
+
+    @ReactMethod
+    public void setSessionCustomInfo(ReadableMap info) {
+        if (info == null) {
+            return;
+        }
+        Klaritics.setSessionCustomInfo(attributesFromReadableMap(info));
+    }
+
+    @ReactMethod
+    public void handlePushNotification(ReadableMap map) {
+      if (map == null) {
+        return;
+      }
+
+      ReadableMapKeySetIterator iterator = map.keySetIterator();
+
+      Map<String, String> data = new HashMap<>();
+      while (iterator.hasNextKey()) {
+        String key = iterator.nextKey();
+        data.put(key, map.getString(key));
+      }
+
+      try {
+        Class<?> pushAPIClass = Class.forName("com.anthra.androidsdk.plugins.push.v2.anthraPushAPI");
+        Method handleMethod = pushAPIClass.getDeclaredMethod("handleNotification", Map.class, Context.class);
+        handleMethod.invoke(null, data, getReactApplicationContext());
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to handle push notification: " + e.getMessage(), null);
+      }
+    }
+
+    @ReactMethod
+    public void logNavigationEvent(String screenName) {
+        double currentTime = SDKController.getInstance().getCurrentTime();
+        if (navigationEvent != null) {
+            // Update the duration for already logged navigation event and save it
+            navigationEvent.setDuration(currentTime - navigationEvent.getJSONData().optDouble("transition_time"));
+            SDKController.getInstance().saveEvent(navigationEvent);
+        }
+
+        // Create new navigation event with given Screen name
+        navigationEvent = new NavigationEvent(screenName, currentTime);
+        navigationEvent.setScreenName(screenName);
+    }
+
+    @ReactMethod
+    public void trackScreen(String screenName) {
+        Klaritics.trackScreen(screenName);
+    }
+
+    @ReactMethod 
+    public void registerSimpleNotification(String notification, String key) {
+    if ((null != notification) && (null != key)) {
+        Klaritics.registerSimpleNotification(notification, key, arg -> {
+            WritableMap params = Arguments.createMap();
+            params.putString("key", arg);
+            params.putString("notification",notification);
+            this.getReactApplicationContext().getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(notification,params);
+        });
+    } else {
+        Logger.e(TAG, "Invalid Arguments", null);
+    }
+    }
+
+//    @ReactMethod
+//    public void registerSimpleNotification(String notification, Callback callback) {
+//        if ((null != notification) && (null != callback)) {
+//            Runnable task = () -> { callback.invoke(); };
+//            anthraSDK.registerSimpleNotification(notification, task);
+//        } else {
+//            Logger.e(TAG, "Invalid Arguments", null);
+//        }
+//    }
+//
+//    @ReactMethod
+//    public void unregisterSimpleNotification(String notification) {
+//        if (null != notification) {
+//            anthraSDK.unregisterSimpleNotification(notification);
+//        } else {
+//            Logger.e(TAG, "Invalid Arguments", null);
+//        }
+//    }
+//
+//    @ReactMethod
+//    public void registerSimpleNotification(String notification, String key, Callback callback) {
+//        if ((null != notification) && (null != callback) && (null != key)) {
+//            anthraSDK.registerSimpleNotification(notification, key, arg -> callback.invoke(arg));
+//        } else {
+//            Logger.e(TAG, "Invalid Arguments", null);
+//        }
+//    }
+
+    @ReactMethod
+    public void unregisterSimpleNotification(String notification, String key) {
+        if ((null != notification) && (null != key)) {
+            Klaritics.unregisterSimpleNotification(notification,key);
+        } else {
+            Logger.e(TAG, "Invalid Arguments", null);
+        }
+    }
+
+    @ReactMethod
+    public void setAnthraDynamicConfig(String key, String value) {
+        if ((null != key) && (null != value)) {
+            Klaritics.setAnthraDynamicConfig(key,value);
+        } else {
+            Logger.e(TAG, "Invalid Arguments", null);
+        }
+    }
+
+    @Override
+    public void onEvent(BaseAnthraEvent event) {
+        if (event.getEventType().equals(SYSTEM_EVENTS)) {
+            String eventName = event.getEventName();
+            if (eventName.equals(FOREGROUND)) {
+                onBecameForeground();
+            } else if (eventName.equals(BACKGROUND)) {
+                onBecameBackground();
+            } else {
+                Logger.e(TAG, "Unknown event");
+            }
+        }
+    }
+
+    private void onBecameForeground() {
+        // This property is null when the app is opened first time in this session
+        // This property will be set, if application moves to background at least once
+
+        // Create new navigation item
+        if (prevScreenName != null) {
+            navigationEvent = new NavigationEvent(prevScreenName, SDKController.getInstance().getCurrentTime());
+            navigationEvent.setScreenName(prevScreenName);
+        }
+    }
+
+    private void onBecameBackground() {
+        if (navigationEvent != null) {
+            // save the last navigation event held in memory
+            navigationEvent.setDuration(SDKController.getInstance().getCurrentTime() - navigationEvent.getJSONData().optDouble("transition_time"));
+            SDKController.getInstance().saveEvent(navigationEvent);
+
+            // Store the current saved navigation ID to log navigationEvent when app comes to foreground
+            prevScreenName = navigationEvent.getEventName();
+        }
+    }
+
+    // Helper method
+    private Attributes attributesFromReadableMap(ReadableMap infoMap) {
+        if (infoMap == null) return null;
+
+        Attributes attributes = new Attributes();
+
+        ReadableMapKeySetIterator iterator = infoMap.keySetIterator();
+
+        while (iterator.hasNextKey()) {
+            try {
+                String key = iterator.nextKey();
+                ReadableType readableType = infoMap.getType(key);
+
+                switch (readableType) {
+                    case String:
+                        attributes.putAttribute(key, infoMap.getString(key));
+                        break;
+                    case Number:
+                        attributes.putAttribute(key, infoMap.getDouble(key));
+                        break;
+                    case Array:
+                        convertArray(attributes, key, infoMap.getArray(key));
+                        break;
+                    case Boolean:
+                        attributes.putAttribute(key, infoMap.getBoolean(key));
+                        break;
+                    default:
+                        Logger.e(TAG, "Unknown type " + readableType, null);
+                        break;
+                }
+            } catch (Throwable t) {
+                String message = t.getMessage();
+                Logger.e(TAG, message == null ? "" : message);
+            }
+        }
+        return attributes;
+    }
+
+    private void convertArray(Attributes attributes, String key, ReadableArray jsonArray) {
+        if (jsonArray == null) {
+            return;
+        }
+
+        int length = jsonArray.size();
+        switch (jsonArray.getType(0)) {
+            case Number:
+                double[] array = new double[length];
+                for (int index = 0; index < length; index++) {
+                    array[index] = jsonArray.getDouble(index);
+                }
+                attributes.putAttribute(key, array);
+                break;
+            case String:
+                String[] strArray = new String[length];
+                for (int index = 0; index < length; index++) {
+                    strArray[index] = jsonArray.getString(index);
+                }
+                attributes.putAttribute(key, strArray);
+                break;
+            default:
+                Logger.e(TAG, "Unknown type", null);
+                break;
+        }
+    }
+}

package/android/src/main/java/com/deeptaai/reactnativesdk/KlariticsPackage.java

@@ -0,0 +1,28 @@
+package com.deeptaai.reactnativesdk;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class KlariticsPackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new KlariticsModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/ios/Klaritics.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface Klaritics : NSObject <RCTBridgeModule>
+
+@end

package/ios/Klaritics.m

@@ -0,0 +1,176 @@
+#import "Klaritics.h"
+#import <AnthraSDK/AnthraSDK.h>
+#import <AnthraSDK/ANTController.h>
+
+@implementation Klaritics
+
+RCT_EXPORT_MODULE(Klaritics)
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        NSLog(@"Marking as React Native");
+        [[ANTController sharedController] markAsReactNative];
+    }
+    return self;
+}
+
+// this method was added to remove the warn when 'init' method is overridden
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
++ (BOOL)isInvalidString:(NSString*)aString {
+    if (nil == aString || [aString isEqualToString:@""]) {
+        return YES;
+    }
+    return NO;
+}
+
++ (NSDictionary *)validDictionary:(NSDictionary *)aDict {
+    if (nil == aDict) return nil;
+    if (![aDict isKindOfClass:[NSDictionary class]]) {
+        return nil;
+    }
+    NSMutableDictionary *mutableDict = [[NSMutableDictionary alloc] init];
+    [aDict enumerateKeysAndObjectsUsingBlock:^(id  _Nonnull key, id  _Nonnull obj, BOOL * _Nonnull stop) {
+        if ([(NSString *)key hasPrefix:@"@"]) {
+            NSCharacterSet *atRateCharacterSet = [NSCharacterSet characterSetWithCharactersInString:@"@"];
+            NSString *newKey = [(NSString *)key stringByTrimmingCharactersInSet:atRateCharacterSet];
+            [mutableDict setValue:obj forKey:newKey];
+        } else {
+            [mutableDict setValue:obj forKey:key];
+        }
+    }];
+
+    return [NSDictionary dictionaryWithDictionary:mutableDict];
+}
+
+RCT_EXPORT_METHOD(setUserIdentifier:(NSString *)identifier) {
+    if ([Klaritics isInvalidString:identifier]) {
+        NSLog(@"identifier cannot be empty or null");
+        return;
+    }
+    NSLog(@"setUserIdentifier API!");
+    [AnthraSDK setUserIdentifier:identifier];
+}
+
+RCT_EXPORT_METHOD(logNavigationEvent:(NSString *)title) {
+    if ([Klaritics isInvalidString:title]) {
+        NSLog(@"title cannot be empty or null");
+        return;
+    }
+    NSLog(@"logNavigationEvent API!");
+    [AnthraSDK logScreenWithName:title];
+}
+
+RCT_EXPORT_METHOD(setUserCustomInfo:(NSDictionary *)userCustomInfo) {
+    if (nil == userCustomInfo) {
+        NSLog(@"userCustomInfo cannot be null");
+        return;
+    }
+    NSLog(@"setUserCustomInfo API!");
+    [AnthraSDK setUserCustomInfo:[Klaritics validDictionary:userCustomInfo]];
+}
+
+RCT_EXPORT_METHOD(setSessionCustomInfo:(NSDictionary *)sessionCustomInfo) {
+    if (nil == sessionCustomInfo) {
+        NSLog(@"sessionCustomInfo cannot be null");
+        return;
+    }
+    NSLog(@"setSessionCustomInfo API!");
+    [AnthraSDK setSessionCustomInfo:[Klaritics validDictionary:sessionCustomInfo]];
+}
+
+RCT_REMAP_METHOD(logClientEvent,
+                 logClientEventWithName:(NSString *)eventName
+                                   info:(NSDictionary *)info)
+{
+    if ([Klaritics isInvalidString:eventName]) {
+        NSLog(@"eventName cannot be empty or null");
+        return;
+    }
+    NSLog(@"logClientEventWithName API !");
+    [AnthraSDK logClientEventWithName:eventName info:[Klaritics validDictionary:info]];
+}
+
+RCT_REMAP_METHOD(logAppEvent,
+                 logAppEventWithName:(NSString *)eventName
+                                info:(NSDictionary *)info
+                         isAggregate:(BOOL)isAggregate) {
+    if ([Klaritics isInvalidString:eventName]) {
+        NSLog(@"eventName cannot be empty or null");
+        return;
+    }
+    NSLog(@"logAppEventWithName API!");
+    [AnthraSDK logAppEventWithName:eventName info:[Klaritics validDictionary:info] isAggregate:NO];
+}
+
+RCT_REMAP_METHOD(logAggregateEvent,
+                 logAggregateEventWithName:(NSString *)eventName
+                                      info:(NSDictionary *)info) {
+    if ([Klaritics isInvalidString:eventName]) {
+        NSLog(@"eventName cannot be empty or null");
+        return;
+    }
+
+    NSLog(@"logAggregateEvent API!");
+    [[ANTController sharedController] logAppEventWithName:eventName info:[Klaritics validDictionary:info] isAggregate:YES];
+}
+
+RCT_REMAP_METHOD(logMetaEvent,
+                logMetaEventWithCategory:(NSString *)category event:(NSString *)event info:(NSDictionary *)info) {
+    if ([Klaritics isInvalidString:event]) {
+        NSLog(@"event cannot be empty or null");
+        return;
+    }
+    NSLog(@"logMetaEvent stub called!");
+}
+
+RCT_REMAP_METHOD(handlePushNotification,
+                handlePushNotificationWithInfo:(NSDictionary *)info) {
+    if (nil == info) {
+        NSLog(@"screen cannot be empty or null");
+        return;
+    }
+    NSLog(@"handlePushNotification stub called!");
+}
+
+RCT_REMAP_METHOD(trackScreen,
+                trackScreen:(NSString *)screen) {
+    if ([Klaritics isInvalidString:screen]) {
+        NSLog(@"screen cannot be empty or null");
+        return;
+    }
+    NSLog(@"trackScreen API!");
+    [AnthraSDK logScreenWithName:screen];
+}
+
+RCT_REMAP_METHOD(registerSimpleNotification,
+                registerSimpleNotification:(NSString *)notification :(NSString *)key) {
+    if ([Klaritics isInvalidString:notification] || [Klaritics isInvalidString:key]) {
+        NSLog(@"key or notification cannot be empty or null");
+        return;
+    }
+    NSLog(@"registerSimpleNotification stub called!");
+}
+
+RCT_REMAP_METHOD(unregisterSimpleNotification,
+                unregisterSimpleNotification:(NSString *)notification :(NSString *)key) {
+    if ([Klaritics isInvalidString:notification] || [Klaritics isInvalidString:key]) {
+        NSLog(@"key or notification cannot be empty or null");
+        return;
+    }
+    NSLog(@"unregisterSimpleNotification stub called!");
+}
+
+RCT_REMAP_METHOD(setApxorDynamicConfig,
+                setApxorDynamicConfig:(NSString *)key :(NSString *)value) {
+    if ([Klaritics isInvalidString:key] || [Klaritics isInvalidString:value]) {
+        NSLog(@"key or value cannot be empty or null");
+        return;
+    }
+    NSLog(@"setApxorDynamicConfig stub called!");
+}
+
+@end