@luciq/react-native 18.0.0

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

@@ -0,0 +1,98 @@
+package ai.luciq.reactlibrary;
+
+import android.annotation.SuppressLint;
+
+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 ai.luciq.featuresrequest.FeatureRequests;
+import ai.luciq.library.Feature;
+import ai.luciq.reactlibrary.utils.ArrayUtil;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+
+import java.util.ArrayList;
+
+import javax.annotation.Nonnull;
+
+public class RNLuciqFeatureRequestsModule extends ReactContextBaseJavaModule {
+
+    public RNLuciqFeatureRequestsModule(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "LCQFeatureRequests";
+    }
+
+    /**
+     * Sets whether email field is required or not when submitting
+     * new-feature-request/new-comment-on-feature
+     *
+     * @param isEmailRequired set true to make email field required
+     * @param actionTypes Bitwise-or of actions
+     */
+    @ReactMethod
+    public void setEmailFieldRequiredForFeatureRequests(final boolean isEmailRequired, final ReadableArray actionTypes) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @SuppressLint("WrongConstant")
+            @Override
+            public void run() {
+                try {
+                    final ArrayList<String> keys = ArrayUtil.parseReadableArrayOfStrings(actionTypes);
+                    final ArrayList<Integer> types = ArgsRegistry.actionTypes.getAll(keys);
+
+                    final int[] typesInts = new int[types.size()];
+                    for (int i = 0; i < types.size(); i++) {
+                        typesInts[i] = types.get(i);
+                    }
+
+                    FeatureRequests.setEmailFieldRequired(isEmailRequired, typesInts);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Shows the UI for feature requests list
+     */
+    @ReactMethod
+    public void show() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    FeatureRequests.show();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+
+    /**
+     * Enables or disables feature requests.
+     * @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) {
+                        FeatureRequests.setState(Feature.State.ENABLED);
+                    } else {
+                        FeatureRequests.setState(Feature.State.DISABLED);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,195 @@
+package ai.luciq.reactlibrary;
+
+
+import static ai.luciq.apm.configuration.cp.APMFeature.APM_NETWORK_PLUGIN_INSTALLED;
+import static ai.luciq.apm.configuration.cp.APMFeature.CP_NATIVE_INTERCEPTION_ENABLED;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+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.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import ai.luciq.apm.InternalAPM;
+import ai.luciq.apm.sanitization.OnCompleteCallback;
+import ai.luciq.library.logging.listeners.networklogs.NetworkLogSnapshot;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+public class RNLuciqNetworkLoggerModule extends EventEmitterModule {
+
+    public final ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>> callbackMap = new ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>>();
+
+    public RNLuciqNetworkLoggerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "LCQNetworkLogger";
+    }
+
+
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
+    private boolean getFlagValue(String key) {
+        return InternalAPM._isFeatureEnabledCP(key, "");
+    }
+
+    private WritableMap convertFromMapToWritableMap(Map<String, Object> map) {
+        WritableMap writableMap = new WritableNativeMap();
+        for (String key : map.keySet()) {
+            Object value = map.get(key);
+            writableMap.putString(key, (String) value);
+        }
+        return writableMap;
+    }
+
+    private Map<String, Object> convertReadableMapToMap(ReadableMap readableMap) {
+        Map<String, Object> map = new HashMap<>();
+        if (readableMap != null) {
+            ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+            while (iterator.hasNextKey()) {
+                String key = iterator.nextKey();
+                map.put(key, readableMap.getString(key));
+            }
+        }
+        return map;
+    }
+
+    /**
+     * Get first time Value of [cp_native_interception_enabled] flag
+     */
+    @ReactMethod
+    public void isNativeInterceptionEnabled(Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    promise.resolve(getFlagValue(CP_NATIVE_INTERCEPTION_ENABLED));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    promise.resolve(false); // Will rollback to JS interceptor
+                }
+
+            }
+        });
+    }
+
+    /**
+     * Indicate if user added APM Network plugin or not
+     * [true] means user added the APM plugin
+     * [false] means not
+     */
+    @ReactMethod
+    public void hasAPMNetworkPlugin(Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    promise.resolve(getFlagValue(APM_NETWORK_PLUGIN_INSTALLED));
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    promise.resolve(false);  // Will rollback to JS interceptor
+                }
+
+            }
+        });
+    }
+
+
+    @ReactMethod
+    public void registerNetworkLogsListener() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                InternalAPM._registerNetworkLogSanitizer((networkLogSnapshot, onCompleteCallback) -> {
+                    final String id = String.valueOf(onCompleteCallback.hashCode());
+                    callbackMap.put(id, onCompleteCallback);
+
+                    WritableMap networkSnapshotParams = Arguments.createMap();
+                    networkSnapshotParams.putString("id", id);
+                    networkSnapshotParams.putString("url", networkLogSnapshot.getUrl());
+                    networkSnapshotParams.putInt("responseCode", networkLogSnapshot.getResponseCode());
+                    networkSnapshotParams.putString("requestBody", networkLogSnapshot.getRequestBody());
+                    networkSnapshotParams.putString("response", networkLogSnapshot.getResponse());
+                    final Map<String, Object> requestHeaders = networkLogSnapshot.getRequestHeaders();
+                    if (requestHeaders != null) {
+                        networkSnapshotParams.putMap("requestHeader", convertFromMapToWritableMap(requestHeaders));
+                    }
+                    final Map<String, Object> responseHeaders = networkLogSnapshot.getResponseHeaders();
+                    if (responseHeaders != null) {
+                        networkSnapshotParams.putMap("responseHeader", convertFromMapToWritableMap(responseHeaders));
+                    }
+
+                    sendEvent(Constants.LCQ_NETWORK_LOGGER_HANDLER, networkSnapshotParams);
+                });
+            }
+        });
+    }
+
+    @ReactMethod
+    public void resetNetworkLogsListener() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                InternalAPM._registerNetworkLogSanitizer(null);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void updateNetworkLogSnapshot(
+            String url,
+            String callbackID,
+            String requestBody,
+            String responseBody,
+            int responseCode,
+            ReadableMap requestHeaders,
+            ReadableMap responseHeaders
+    ) {
+        try {
+            // Convert ReadableMap to a Java Map for easier handling
+            Map<String, Object> requestHeadersMap = convertReadableMapToMap(requestHeaders);
+            Map<String, Object> responseHeadersMap = convertReadableMapToMap(responseHeaders);
+
+            NetworkLogSnapshot modifiedSnapshot = null;
+            if (!url.isEmpty()) {
+                modifiedSnapshot = new NetworkLogSnapshot(url, requestHeadersMap, requestBody, responseHeadersMap, responseBody, responseCode);
+            }
+
+            final OnCompleteCallback<NetworkLogSnapshot> callback = callbackMap.get(callbackID);
+            if (callback != null) {
+                callback.onComplete(modifiedSnapshot);
+                callbackMap.remove(callbackID);
+            }
+        } catch (Exception e) {
+            // Reject the promise to indicate an error occurred
+            Log.e("IB-CP-Bridge", "LuciqNetworkLogger.updateNetworkLogSnapshot failed to parse the network snapshot object.");
+        }
+    }
+}