@luciq/react-native 18.0.0

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

@@ -0,0 +1,444 @@
+package ai.luciq.reactlibrary;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import ai.luciq.bug.BugReporting;
+import ai.luciq.bug.invocation.Option;
+import ai.luciq.library.Feature;
+import ai.luciq.library.OnSdkDismissCallback;
+import ai.luciq.library.extendedbugreport.ExtendedBugReport;
+import ai.luciq.library.invocation.LuciqInvocationEvent;
+import ai.luciq.library.invocation.OnInvokeCallback;
+import ai.luciq.library.invocation.util.LuciqFloatingButtonEdge;
+import ai.luciq.library.invocation.util.LuciqVideoRecordingButtonPosition;
+import ai.luciq.reactlibrary.utils.ArrayUtil;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+import ai.luciq.bug.userConsent.ActionType;
+
+import java.util.ArrayList;
+
+import javax.annotation.Nonnull;
+
+public class RNLuciqBugReportingModule extends EventEmitterModule {
+    public RNLuciqBugReportingModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQBugReporting";
+    }
+
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
+    /**
+     * Enable or disable all BugReporting related features.
+     * @param isEnabled boolean indicating enabled or disabled.
+     */
+    @ReactMethod
+    public void setEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        BugReporting.setState(Feature.State.ENABLED);
+                    } else {
+                        BugReporting.setState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+    }
+
+
+    /**
+     * Enable/Disable screen recording
+     *
+     * @param autoScreenRecordingEnabled boolean for enable/disable
+     *                                   screen recording on crash feature
+     */
+    @TargetApi(21)
+    @ReactMethod
+    public void setAutoScreenRecordingEnabled(final boolean autoScreenRecordingEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    BugReporting.setAutoScreenRecordingEnabled(autoScreenRecordingEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets whether the extended bug report mode should be disabled,
+     * enabled with required fields,  or enabled with optional fields.
+     *
+     * @param extendedBugReportMode
+     */
+    @ReactMethod
+    public void setExtendedBugReportMode(final String extendedBugReportMode) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final ExtendedBugReport.State parsedState = ArgsRegistry.extendedBugReportStates.get(extendedBugReportMode);
+                    if (parsedState == null) return;
+                    BugReporting.setExtendedBugReportState(parsedState);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Enables or disables view hierarchy in the dashboard.
+     * @param isEnabled boolean indicating enabled or disabled.
+     */
+    @ReactMethod
+    public void setViewHierarchyEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        BugReporting.setViewHierarchyState(Feature.State.ENABLED);
+                    } else {
+                        BugReporting.setViewHierarchyState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the default corner at which the video recording floating button will be shown
+     *
+     * @param corner corner to stick the video recording floating button to
+     */
+    @ReactMethod
+    public void setVideoRecordingFloatingButtonPosition(final String corner) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final LuciqVideoRecordingButtonPosition parsedPosition = ArgsRegistry.recordButtonPositions.get(corner);
+                    if (parsedPosition == null) return;
+                    BugReporting.setVideoRecordingFloatingButtonPosition(parsedPosition);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets whether attachments in bug reporting and in-app messaging are enabled or not.
+     *
+     * @param  screenshot A boolean to enable or disable screenshot attachments.
+     * @param {boolean} extraScreenShot A boolean to enable or disable extra screenshot attachments.
+     * @param {boolean} galleryImage A boolean to enable or disable gallery image attachments.
+     * @param {boolean} screenRecording A boolean to enable or disable screen recording attachments.
+     */
+    @ReactMethod
+    public void setEnabledAttachmentTypes(final boolean screenshot, final boolean extraScreenshot, final boolean
+            galleryImage, final boolean screenRecording) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    BugReporting.setAttachmentTypesEnabled(screenshot, extraScreenshot, galleryImage,
+                            screenRecording);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the event used to invoke Luciq SDK
+     *
+     * @param invocationEventValues the invocation event value
+     * @see LuciqInvocationEvent
+     */
+    @ReactMethod
+    public void setInvocationEvents(final ReadableArray invocationEventValues) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final ArrayList<String> keys = ArrayUtil.parseReadableArrayOfStrings(invocationEventValues);
+                    final ArrayList<LuciqInvocationEvent> parsedInvocationEvents = ArgsRegistry.invocationEvents.getAll(keys);
+                    BugReporting.setInvocationEvents(parsedInvocationEvents.toArray(new LuciqInvocationEvent[0]));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the options for the features in the SDK
+     *
+     * @param optionValues the invocation option value
+     */
+    @ReactMethod
+    public void setOptions(final ReadableArray optionValues) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @SuppressLint("WrongConstant")
+            @Override
+            public void run() {
+                try {
+                    final ArrayList<String> keys = ArrayUtil.parseReadableArrayOfStrings(optionValues);
+                    final ArrayList<Integer> options = ArgsRegistry.invocationOptions.getAll(keys);
+
+                    for (int i = 0; i < options.size(); i++) {
+                        BugReporting.setOptions(options.get(i));
+                    }
+
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets a block of code to be executed just before the SDK's UI is presented.
+     * This block is executed on the UI thread. Could be used for performing any
+     * UI changes before the SDK's UI is shown.
+     *
+     * @param onInvokeHandler - A callback that gets executed before
+     *                             invoking the SDK
+     */
+    @ReactMethod
+    public void setOnInvokeHandler(final Callback onInvokeHandler) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    BugReporting.setOnInvokeCallback(new OnInvokeCallback() {
+                        @Override
+                        public void onInvoke() {
+                            sendEvent(Constants.LCQ_PRE_INVOCATION_HANDLER, null);
+                        }
+                    });
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the position of the Luciq floating button on the screen.
+     * @param floatingButtonEdge left or right edge of the screen.
+     * @param floatingButtonOffset integer offset from the left or right edge of the screen.
+     */
+    @ReactMethod
+    public void setFloatingButtonEdge(final String floatingButtonEdge, final int floatingButtonOffset) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                final LuciqFloatingButtonEdge parsedEdge = ArgsRegistry.floatingButtonEdges
+                        .getOrDefault(floatingButtonEdge, LuciqFloatingButtonEdge.RIGHT);
+                BugReporting.setFloatingButtonOffset(floatingButtonOffset);
+                BugReporting.setFloatingButtonEdge(parsedEdge);
+            }
+        });
+    }
+
+    /**
+     * Sets a block of code to be executed right after the SDK's UI is dismissed.
+     * This block is executed on the UI thread. Could be used for performing any
+     * UI changes after the SDK's UI is dismissed.
+     *
+     * @param handler - A callback to get executed after
+     *                              dismissing the SDK.
+     */
+    @ReactMethod
+    public void setOnSDKDismissedHandler(final Callback handler) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    BugReporting.setOnDismissCallback(new OnSdkDismissCallback() {
+                        @Override
+                        public void call(DismissType dismissType, ReportType reportType) {
+                            WritableMap params = Arguments.createMap();
+                            params.putString("dismissType", dismissType.toString());
+                            params.putString("reportType", reportType.toString());
+                            sendEvent(Constants.LCQ_POST_INVOCATION_HANDLER, params);
+                        }
+                    });
+                } catch (java.lang.Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the threshold value of the shake gesture for android devices.
+     * Default for android is an integer value equals 350.
+     * you could increase the shaking difficulty level by
+     * increasing the `350` value and vice versa.
+     *
+     * @param androidThreshold Threshold for android devices.
+     */
+    @ReactMethod
+    public void setShakingThresholdForAndroid(final int androidThreshold) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    BugReporting.setShakingThreshold(androidThreshold);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Sets the enabled report types to be shown in the prompt. Bug or Feedback or both.
+     * @param types
+     * @see BugReporting.ReportType
+     */
+    @ReactMethod
+    public void setReportTypes(final ReadableArray types) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @SuppressLint("WrongConstant")
+            @Override
+            public void run() {
+                try {
+                    final ArrayList<String> keys = ArrayUtil.parseReadableArrayOfStrings(types);
+                    final ArrayList<Integer> types = ArgsRegistry.reportTypes.getAll(keys);
+
+                    final int[] typesInts = new int[types.size()];
+                    for (int i = 0; i < types.size(); i++) {
+                        typesInts[i] = types.get(i);
+                    }
+
+                    BugReporting.setReportTypes(typesInts);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Shows a bug or feedback report with optional options.
+     * @param reportType Bug or Feedback.
+     * @param options array of options
+     * @see BugReporting.ReportType
+     * @see Option
+     */
+    @ReactMethod
+    public void show(final String reportType, final ReadableArray options) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                final Integer parsedReportType = ArgsRegistry.reportTypes.get(reportType);
+                if (parsedReportType == null) return;
+                BugReporting.show(parsedReportType);
+                setOptions(options);
+            }
+        });
+    }
+
+    /**
+    * Adds a disclaimer text within the bug reporting form, which can include hyperlinked text.
+    * @param text String text.
+    */
+    @ReactMethod
+    public void setDisclaimerText(final String text){
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                BugReporting.setDisclaimerText(text);
+            }
+        });
+    }
+    /**
+    * Sets a minimum number of characters as a requirement for the comments field in the different report types.
+    * @param limit int number of characters.
+    * @param reportTypes (Optional) Array of reportType. If it's not passed, the limit will apply to all report types.
+    */
+    @ReactMethod
+    public void setCommentMinimumCharacterCount(final int limit, final ReadableArray reportTypes){
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @SuppressLint("WrongConstant")
+            @Override
+            public void run() {
+                try {
+                    final ArrayList<String> keys = ArrayUtil.parseReadableArrayOfStrings(reportTypes);
+                    final ArrayList<Integer> types = ArgsRegistry.reportTypes.getAll(keys);
+
+                    final int[] typesInts = new int[types.size()];
+                    for (int i = 0; i < types.size(); i++) {
+                        typesInts[i] = types.get(i);
+                    }
+
+                    BugReporting.setCommentMinimumCharacterCountForBugReportType(limit, typesInts);                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+    * Adds a user consent item to the bug reporting
+    * @param key A unique identifier string for the consent item.
+    * @param description The text shown to the user describing the consent item.
+    * @param mandatory Whether the user must agree to this item before submitting a report.
+    * @param checked Whether the consent checkbox is pre-selected.
+    * @param actionType A string representing the action type to map to SDK behavior.
+    */
+    @ReactMethod
+    public void addUserConsent(String key, String description, boolean mandatory, boolean checked, @Nullable String actionType) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+            try {
+            String mappedActionType = ArgsRegistry.userConsentActionType.get(actionType);
+        BugReporting.addUserConsent(key, description, mandatory, checked, mappedActionType);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    });
+
+    }
+
+
+}

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

@@ -0,0 +1,169 @@
+package ai.luciq.reactlibrary;
+
+import static ai.luciq.reactlibrary.utils.LuciqUtil.getMethod;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+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 ai.luciq.crash.CrashReporting;
+import ai.luciq.crash.models.LuciqNonFatalException;
+import ai.luciq.library.Feature;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+
+import org.json.JSONObject;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class RNLuciqCrashReportingModule extends ReactContextBaseJavaModule {
+
+    public RNLuciqCrashReportingModule(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQCrashReporting";
+    }
+
+    /**
+     * Sets whether crash reporting feature is Enabled or Disabled
+     *
+     * @param isEnabled Exception object to be sent to Luciq's servers
+     */
+    @ReactMethod
+    public void setEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        CrashReporting.setState(Feature.State.ENABLED);
+                    } else {
+                        CrashReporting.setState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Send unhandled JS error object
+     *
+     * @param exceptionObject Exception object to be sent to Luciq's servers
+     * @param promise         This makes sure that the RN side crashes the app only after the Android SDK
+     *                        finishes processing/handling the crash.
+     */
+    @ReactMethod
+    public void sendJSCrash(final String exceptionObject, final Promise promise) {
+        try {
+            JSONObject jsonObject = new JSONObject(exceptionObject);
+            sendJSCrashByReflection(jsonObject, false, new Runnable() {
+                @Override
+                public void run() {
+                    promise.resolve(null);
+                }
+            });
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Send handled JS error object
+     *
+     * @param exceptionObject Exception object to be sent to Luciq's servers
+     * @param userAttributes  (Optional) extra user attributes attached to the crash
+     * @param fingerprint     (Optional) key used to customize how crashes are grouped together
+     * @param level       different severity levels for errors
+     */
+    @ReactMethod
+    public void sendHandledJSCrash(final String exceptionObject, @Nullable final ReadableMap userAttributes, @Nullable final String fingerprint, @Nullable final String level) {
+        try {
+            final JSONObject jsonObject = new JSONObject(exceptionObject);
+            MainThreadHandler.runOnMainThread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        Method method = getMethod(Class.forName("ai.luciq.crash.CrashReporting"), "reportException", JSONObject.class, boolean.class,
+                                Map.class, JSONObject.class, LuciqNonFatalException.Level.class);
+                        if (method != null) {
+                            LuciqNonFatalException.Level nonFatalExceptionLevel = ArgsRegistry.nonFatalExceptionLevel.getOrDefault(level, LuciqNonFatalException.Level.ERROR);
+                            Map<String, Object> userAttributesMap = userAttributes == null ? null : userAttributes.toHashMap();
+                            JSONObject fingerprintObj = fingerprint == null ? null : CrashReporting.getFingerprintObject(fingerprint);
+
+                            method.invoke(null, jsonObject, true, userAttributesMap, fingerprintObj, nonFatalExceptionLevel);
+
+                            RNLuciqReactnativeModule.clearCurrentReport();
+                        }
+                    } catch (ClassNotFoundException | IllegalAccessException |
+                             InvocationTargetException e) {
+                        e.printStackTrace();
+                    }
+                }
+            });
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void sendJSCrashByReflection(final JSONObject exceptionObject, final boolean isHandled, @Nullable final Runnable onComplete) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Method method = getMethod(Class.forName("ai.luciq.crash.CrashReporting"), "reportException", JSONObject.class, boolean.class);
+                    if (method != null) {
+                        method.invoke(null, exceptionObject, isHandled);
+                        RNLuciqReactnativeModule.clearCurrentReport();
+                    }
+                } catch (ClassNotFoundException e) {
+                    e.printStackTrace();
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                } catch (InvocationTargetException e) {
+                    e.printStackTrace();
+                } finally {
+                    if (onComplete != null) {
+                        onComplete.run();
+                    }
+                }
+            }
+        });
+    }
+
+    /**
+     * Enables and disables capturing native C++ NDK crash reporting.
+     *
+     * @param isEnabled boolean indicating enabled or disabled.
+     */
+    @ReactMethod
+    public void setNDKCrashesEnabled(final boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (isEnabled) {
+                        CrashReporting.setNDKCrashesState(Feature.State.ENABLED);
+                    } else {
+                        CrashReporting.setNDKCrashesState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}