@luciq/react-native 18.0.0

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqReactnativePackage.java

@@ -0,0 +1,41 @@
+package ai.luciq.reactlibrary;
+
+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 RNLuciqReactnativePackage implements ReactPackage {
+
+    private static final String TAG = RNLuciqReactnativePackage.class.getSimpleName();
+
+    public RNLuciqReactnativePackage() {}
+
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RNLuciqReactnativeModule(reactContext));
+        modules.add(new RNLuciqBugReportingModule(reactContext));
+        modules.add(new RNLuciqCrashReportingModule(reactContext));
+        modules.add(new RNLuciqSurveysModule(reactContext));
+        modules.add(new RNLuciqFeatureRequestsModule(reactContext));
+        modules.add(new RNLuciqRepliesModule(reactContext));
+        modules.add(new RNLuciqAPMModule(reactContext));
+        modules.add(new RNLuciqSessionReplayModule(reactContext));
+        modules.add(new RNLuciqNetworkLoggerModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqRepliesModule.java

@@ -0,0 +1,298 @@
+package ai.luciq.reactlibrary;
+
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import ai.luciq.chat.Replies;
+import ai.luciq.library.Feature;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+
+import javax.annotation.Nonnull;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RNLuciqRepliesModule extends EventEmitterModule {
+
+    public RNLuciqRepliesModule(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQReplies";
+    }
+
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
+    @ReactMethod
+    public void setEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        Replies.setState(Feature.State.ENABLED);
+                    } else {
+                        Replies.setState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void hasChats(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean hasChats = Replies.hasChats();
+                promise.resolve(hasChats);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void show() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                Replies.show();
+            }
+        });
+    }
+
+    /**
+     * Set whether new in app notification received will play a small sound notification
+     * or not (Default is {@code false})
+     *
+     * @param shouldPlaySound desired state of conversation sounds
+     * @since 4.1.0
+     */
+    @ReactMethod
+    public void setInAppNotificationSound(final boolean shouldPlaySound) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setInAppNotificationSound(shouldPlaySound);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Get current unread count of messages for this user
+     *
+     * @return number of messages that are unread for this user
+     */
+    @ReactMethod
+    public void getUnreadRepliesCount(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                int unreadMessages = 0;
+                try {
+                    unreadMessages = Replies.getUnreadRepliesCount();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+
+                promise.resolve(unreadMessages);
+            }
+        });
+    }
+
+    /**
+     * Enabled/disable push notifications
+     *
+     * @param isEnabled whether chat push notifications is enabled or not
+     */
+    @ReactMethod
+    public void setPushNotificationsEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        Replies.setPushNotificationState(Feature.State.ENABLED);
+                    } else {
+                        Replies.setPushNotificationState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Enabled/disable chat notification
+     *
+     * @param isChatNotificationEnable whether chat notification is reburied or not
+     */
+    @ReactMethod
+    public void setInAppNotificationEnabled(final boolean isChatNotificationEnable) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setInAppNotificationEnabled(isChatNotificationEnable);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Set the GCM registration token to Luciq
+     *
+     * @param token the GCM registration token
+     */
+    @ReactMethod
+    public void setPushNotificationRegistrationToken(final String token) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setPushNotificationRegistrationToken(token);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Show in-app Messaging's notifications
+     *
+     * @param data the data bundle related to Luciq
+     */
+    @ReactMethod
+    public void showNotification(final ReadableMap data) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Map<String, String> map = new HashMap<>();
+                    ReadableMapKeySetIterator iterator = data.keySetIterator();
+
+                    while (iterator.hasNextKey()) {
+                        String key = iterator.nextKey();
+                        ReadableType type = data.getType(key);
+
+                        switch(type) {
+                            case String:
+                                String value = data.getString(key);
+                                map.put(key, value);
+                                break;
+                        }
+                    }
+                    if (Replies.isLuciqNotification(map)) {
+                        Replies.showNotification(map);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Set the push notification's icon that will be shown with Luciq notifications
+     *
+     * @param notificationIcon the notification icon resource ID
+     */
+    @ReactMethod
+    public void setNotificationIcon(final int notificationIcon) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setNotificationIcon(notificationIcon);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+
+    /**
+    * Set a notification channel id to a notification channel that notifications
+    * can be posted to.
+    *
+    * @param pushNotificationChannelId an id to a notification channel that notifications
+    */
+    @ReactMethod
+    public void setPushNotificationChannelId(final String pushNotificationChannelId) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setPushNotificationChannelId(pushNotificationChannelId);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Set whether new system notification received will play the default sound from
+     * RingtoneManager or not (Default is {@code false})
+     *
+     * @param shouldPlaySound desired state of conversation sounds
+     */
+    @ReactMethod
+    public void setSystemReplyNotificationSoundEnabled(final boolean shouldPlaySound) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Replies.setSystemReplyNotificationSoundEnabled(shouldPlaySound);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setOnNewReplyReceivedHandler(final Callback onNewReplyReceivedCallback) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Runnable onNewReplyReceivedRunnable = new Runnable() {
+                        @Override
+                        public void run() {
+                            sendEvent(Constants.LCQ_ON_NEW_REPLY_RECEIVED_CALLBACK, null);
+                        }
+                    };
+                    Replies.setOnNewReplyReceivedCallback(onNewReplyReceivedRunnable);
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+}

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqSessionReplayModule.java

@@ -0,0 +1,213 @@
+package ai.luciq.reactlibrary;
+
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import ai.luciq.library.OnSessionReplayLinkReady;
+import ai.luciq.library.SessionSyncListener;
+import ai.luciq.library.sessionreplay.SessionReplay;
+import ai.luciq.library.sessionreplay.model.SessionMetadata;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+import javax.annotation.Nonnull;
+
+public class RNLuciqSessionReplayModule extends EventEmitterModule {
+
+    public RNLuciqSessionReplayModule(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQSessionReplay";
+    }
+
+    @ReactMethod
+    public void setEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setEnabled(isEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setNetworkLogsEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setNetworkLogsEnabled(isEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+
+    @ReactMethod
+    public void setLuciqLogsEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setLuciqLogsEnabled(isEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void setUserStepsEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setUserStepsEnabled(isEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getSessionReplayLink(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                SessionReplay.getSessionReplayLink(new OnSessionReplayLinkReady() {
+                    @Override
+                    public void onSessionReplayLinkReady(@Nullable String link) {
+
+                        promise.resolve(link);
+                    }
+                });
+            }
+        });
+
+    }
+
+    public ReadableMap getSessionMetadataMap(SessionMetadata sessionMetadata){
+        WritableMap params = Arguments.createMap();
+        params.putString("appVersion",sessionMetadata.getAppVersion());
+        params.putString("OS",sessionMetadata.getOs());
+        params.putString("device",sessionMetadata.getDevice());
+        params.putDouble("sessionDurationInSeconds",(double)sessionMetadata.getSessionDurationInSeconds());
+        params.putBoolean("hasLinkToAppReview",sessionMetadata.getLinkedToReview());
+        params.putArray("networkLogs",getNetworkLogsArray(sessionMetadata.getNetworkLogs()));
+
+        String launchType = sessionMetadata.getLaunchType();
+        Long launchDuration = sessionMetadata.getLaunchDuration();
+
+        if (launchType != null) {
+            params.putString("launchType",ArgsRegistry.launchTypeReversed.get(sessionMetadata.getLaunchType()) );
+        } else {
+            params.putString("launchType",ArgsRegistry.launchType.get("unknown"));
+        }
+
+        if (launchDuration != null) {
+            params.putDouble("launchDuration", (double)launchDuration);
+        } else {
+            params.putDouble("launchDuration", 0.0);
+        }
+
+        return params;
+    }
+
+    public ReadableArray getNetworkLogsArray(List<SessionMetadata.NetworkLog> networkLogList ) {
+        WritableArray networkLogs = Arguments.createArray();
+
+        if (networkLogList != null) {
+            for (SessionMetadata.NetworkLog log : networkLogList) {
+                WritableMap networkLog = Arguments.createMap();
+                networkLog.putString("url", log.getUrl());
+                networkLog.putDouble("duration", log.getDuration());
+                networkLog.putInt("statusCode", log.getStatusCode());
+
+                networkLogs.pushMap(networkLog);
+            }
+        }
+
+        return networkLogs;
+    }
+
+    private boolean shouldSync = true;
+    private CountDownLatch latch;
+    @ReactMethod
+    public void setSyncCallback() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setSyncCallback(new SessionSyncListener() {
+                        @Override
+                        public boolean onSessionReadyToSync(@NonNull SessionMetadata sessionMetadata) {
+
+                            sendEvent(Constants.LCQ_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION,getSessionMetadataMap(sessionMetadata));
+
+                            latch = new CountDownLatch(1);
+
+                            try {
+                                latch.await();
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                                return true;
+                            }
+
+                            return shouldSync;
+                        }
+                    });
+                }
+                catch(Exception e){
+                    e.printStackTrace();
+                }
+
+            }
+        });
+    }
+
+    @ReactMethod
+    public void evaluateSync(boolean result) {
+        shouldSync = result;
+
+        if (latch != null) {
+            latch.countDown();
+        }
+    }
+
+
+
+}