chore: add the Android implementation for network obfuscation and filtering.

Author: andrewdanieldev

android/src/main/java/com/instabug/reactlibrary/RNInstabugNetworkLoggerModule.java

@@ -7,20 +7,37 @@
 
 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.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.instabug.apm.InternalAPM;
+import com.instabug.apm.sanitization.AsyncSanitizer;
+import com.instabug.apm.sanitization.OnCompleteCallback;
+import com.instabug.library.logging.listeners.networklogs.NetworkLogSnapshot;
 import com.instabug.reactlibrary.utils.EventEmitterModule;
 import com.instabug.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 RNInstabugNetworkLoggerModule extends EventEmitterModule {
 
+    private final ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>> callbackMap = new ConcurrentHashMap<String, OnCompleteCallback<NetworkLogSnapshot>>();
+
     public RNInstabugNetworkLoggerModule(ReactApplicationContext reactContext) {
         super(reactContext);
     }
 
+
     @NonNull
     @Override
     public String getName() {
@@ -39,7 +56,17 @@ public void removeListeners(Integer count) {
     }
 
     private boolean getFlagValue(String key) {
-        return InternalAPM._isFeatureEnabledCP( key , "");
+        return InternalAPM._isFeatureEnabledCP(key, "");
+    }
+
+    private WritableMap convertFromMapToWriteableMap(Map map) {
+        WritableMap writableMap = new WritableNativeMap();
+        for (int i = 0; i < map.size(); i++) {
+            Object key = map.keySet().toArray()[i];
+            Object value = map.get(key);
+            writableMap.putString((String) key, (String) value);
+        }
+        return writableMap;
     }
 
     /**
@@ -81,4 +108,68 @@ public void run() {
             }
         });
     }
+
+
+    @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", convertFromMapToWriteableMap(networkLogSnapshot.getRequestHeaders()));
+                    }
+                    final Map<String, Object> responseHeaders = networkLogSnapshot.getResponseHeaders();
+                    if (responseHeaders != null) {
+                        networkSnapshotParams.putMap("responseHeader", convertFromMapToWriteableMap(networkLogSnapshot.getResponseHeaders()));
+                    }
+
+                    sendEvent("IBGNetworkLoggerHandler", networkSnapshotParams);
+                });
+            }
+        });
+    }
+
+    @ReactMethod
+    protected void updateNetworkLogSnapshot(String jsonString) {
+
+        JSONObject newJSONObject = null;
+        String url = "";
+        NetworkLogSnapshot modifiedSnapshot = null;
+        try {
+            newJSONObject = new JSONObject(jsonString);
+            url = newJSONObject.optString("url");
+        } catch (JSONException e) {
+            throw new RuntimeException(e);
+        }
+        final String ID = newJSONObject.optString("id");
+
+        if (!url.isEmpty()) {
+            modifiedSnapshot = new NetworkLogSnapshot(
+                    url,
+                    null,
+                    null,
+                    null,
+                    null,
+                    newJSONObject.optInt("responseCode")
+            );
+        }
+
+        final OnCompleteCallback<NetworkLogSnapshot> callback = callbackMap.get(ID);
+        if (callback != null) {
+            callback.onComplete(modifiedSnapshot);
+        }
+        callbackMap.remove(ID);
+
+    }
 }

src/modules/NetworkLogger.ts

@@ -115,9 +115,10 @@ export const setRequestFilterExpression = (expression: string) => {
         // For iOS True == Request will be saved, False == will be ignored
         NativeNetworkLogger.setNetworkLoggingRequestFilterPredicateIOS(networkSnapshot.id, !value);
       } else {
-        // For Android Setting the passed data to empty string will ignore the request;
+        // For Android Setting the [url] to an empty string will ignore the request;
         if (value) {
-          NativeNetworkLogger.updateNetworkLogSnapshot('');
+          networkSnapshot.url = '';
+          NativeNetworkLogger.updateNetworkLogSnapshot(JSON.stringify(networkSnapshot));
         }
       }
     });