cobrowse-sdk-react-native 2.11.2-unredaction.0 → 2.12.0

package/android/build.gradle

@@ -30,5 +30,5 @@ android {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+' // support react-native-v0.22-rc+
-    implementation 'io.cobrowse:cobrowse-sdk-android:2.21.4'
+    implementation 'io.cobrowse:cobrowse-sdk-android:2.23.0'
 }

package/android/src/main/java/io/cobrowse/reactnative/CobrowseIO.java

@@ -0,0 +1,22 @@
+package io.cobrowse.reactnative;
+
+import android.app.Activity;
+import android.view.View;
+
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public abstract class CobrowseIO {
+  public interface Delegate {
+  }
+
+  public interface RedactionDelegate extends Delegate {
+    @Nullable
+    List<View> redactedViews(@NonNull final Activity activity);
+
+    @Nullable
+    List<View> unredactedViews(@NonNull final Activity activity);
+  }
+}

package/android/src/main/java/io/cobrowse/reactnative/CobrowseIOModule.java

@@ -4,6 +4,8 @@ import android.app.Activity;
 import android.os.Handler;
 import android.util.Log;
 import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -15,13 +17,10 @@ import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.uimanager.NativeViewHierarchyManager;
 import com.facebook.react.uimanager.UIBlock;
 import com.facebook.react.uimanager.UIManagerModule;
-import com.facebook.react.views.view.ReactViewGroup;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 import androidx.annotation.NonNull;
@@ -35,7 +34,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
     CobrowseIO.SessionLoadDelegate, CobrowseIO.RedactionDelegate,
     CobrowseIO.RemoteControlRequestDelegate {
 
-    private static final String SESSION_LOADED = "session.loaded";
+  private static final String SESSION_LOADED = "session.loaded";
     private static final String SESSION_UPDATED = "session.updated";
     private static final String SESSION_ENDED = "session.ended";
     private static final String SESSION_REQUESTED = "session.requested";
@@ -60,6 +59,8 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
         });
     }
 
+    public static io.cobrowse.reactnative.CobrowseIO.Delegate delegate;
+
     @NonNull
     public String getName() {
         return "CobrowseIO";
@@ -93,6 +94,11 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                 .emit(SESSION_REQUESTED, Conversion.convert(session));
     }
 
+    @Override
+    public void handleRemoteControlRequest(@NonNull Activity activity, @NonNull Session session) {
+        // no-op, this will be handed on the JS side via an "updated" event handler
+        // this stub just disables the default native prompt in the SDK
+    }
     @ReactMethod
     public void setUnredactedTags(final ReadableArray reactTags, final Promise promise) {
         synchronized (unredactedTags) {
@@ -103,7 +109,7 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
         }
     }
 
-    private Set<View> unredactedViews() {
+    private Set<View> getUnredactedViews(@NonNull final Activity activity) {
         synchronized (unredactedTags) {
             HashSet<View> unredacted = new HashSet<>();
             for (Integer i : unredactedTags) {
@@ -113,68 +119,87 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
                    Log.i("CobrowseIO", "Failed to find unredacted view for tag " + i + ", error = " + e.getMessage());
                 }
             }
+            if (delegate instanceof io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) {
+              List<View> views = ((io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) delegate).unredactedViews(activity);
+              if (views != null) unredacted.addAll(views);
+            }
             return unredacted;
         }
     }
 
-    @Override
-    public void handleRemoteControlRequest(@NonNull Activity activity, @NonNull Session session) {
-      // no-op, this will be handed on the JS side via an "updated" event handler
-      // this stub just disables the default native prompt in the SDK
+    private Set<View> getRedactedViews(@NonNull final Activity activity) {
+      HashSet<View> redacted = new HashSet<>(RedactedViewManager.redactedViews.keySet());
+      if (delegate instanceof io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) {
+        List<View> views = ((io.cobrowse.reactnative.CobrowseIO.RedactionDelegate) delegate).redactedViews(activity);
+        if (views != null) redacted.addAll(views);
+      }
+      return redacted;
     }
 
     @Override
-    public List<View> redactedViews(@NonNull final Activity activity) {
-        HashSet<View> redacted = new HashSet<>();
-        Set<View> unredacted = unredactedViews();
-        // By default everything is redacted for Activities that contain
-        // a ReactRootView.
-        Set<View> rootViews = TreeUtils.findAllClosest(
-          activity.getWindow().getDecorView().getRootView(),
-          new Predicate<View>() {
-            @Override
-            public boolean test(View view) {
-              return TreeUtils.isReactView(view);
-            }
-          });
-        for (View root : rootViews) redacted.addAll(TreeUtils.directChildren(root));
-
-        // Now we can actually start working out what should be unredacted
-        // First work out the set of all parents of unredact()'ed nodes
-        // Ignores nested unredacted nodes
-        HashSet<View> unredactedParents = new HashSet<>();
-        for (View v : unredacted) {
-            if (!TreeUtils.hasAnyParent(v, unredacted))
-              unredactedParents.addAll(TreeUtils.reactParents(v));
+    public List<View> redactedViews(@NonNull final Activity activity)  {
+      final Set<View> redacted = this.getRedactedViews(activity);
+      final Set<View> unredacted = this.getUnredactedViews(activity);
+
+      // Project all unredactions to the root to get the full set of unredacted nodes
+      HashSet<View> projectedUnredacted = new HashSet<>();
+      for (View view : unredacted) {
+          projectedUnredacted.add(view);
+          projectedUnredacted.addAll(TreeUtils.allParents(view));
+      }
+
+      // Work out which nodes are explicitly redacted but need to be unredacted
+      // due to a nested unredaction tag (these redactions will be moved towards the
+      // leaves of the view hierarchy instead)
+      HashSet<View> redactedProjectedUnredactions = new HashSet<>(redacted);
+      redactedProjectedUnredactions.retainAll(projectedUnredacted);
+
+      // Start to build the set of redactions we should actually apply. We start off with
+      // the set of explicitly redacted nodes
+      HashSet<View> toRedact = new HashSet<>(redacted);
+
+      // remove any redactions that have unredacted decendants (i.e. any that appear in the
+      // projection of the unredaction). These are the redacted nodes we need to move towards
+      // the leaves of the tree
+      toRedact.removeAll(redactedProjectedUnredactions);
+
+      // Work out the set of all nodes that are siblings of any projected unredacted node
+      HashSet<View> projectedUnredactionSiblings = new HashSet<>();
+      for (View view : projectedUnredacted) {
+          ViewParent parent = view.getParent();
+          if (parent instanceof ViewGroup)
+            projectedUnredactionSiblings.addAll(TreeUtils.directChildren((ViewGroup) parent));
+      }
+
+      // Subtract the projected unredactions from the set of all siblings of projected
+      // unredactions. i.e. subtract things that should be definitely unredacted to leave
+      // a set we're not sure yet whether to redact or not
+      HashSet<View> potentiallyRedactedUnredactedSiblings = new HashSet<View>(projectedUnredactionSiblings);
+      potentiallyRedactedUnredactedSiblings.removeAll(projectedUnredacted);
+
+      // for each node we're not sure about yet, check if the closest redacted or unredacted ancestor
+      // is a redacted node, if so this descendant should also be redacted
+      for (View view : potentiallyRedactedUnredactedSiblings) {
+      View closest = TreeUtils.closest(view, new Predicate<View>() {
+          @Override
+          public boolean test(View view) {
+            return redacted.contains(view) || unredacted.contains(view);
+          }
+        });
+        if (redacted.contains(closest)) toRedact.add(view);
+      }
+
+      // Remove any empty ViewGroup from the redacted set, they're often used for wrapping
+      // or sizing other elements, and do not usually need to be redacted
+      // If it's absolutely necessary they are redacted, they can always be replaced with
+      // a <Redacted> tag instead
+      for (View v : new HashSet<>(toRedact)) {
+        if (v instanceof ViewGroup && ((ViewGroup) v).getChildCount() == 0) {
+          toRedact.remove(v);
         }
+      }
 
-        // Then work out the set of all direct children of any unredacted parents
-        // This should give us the set including unredacted nodes, their siblings,
-        // and all their parents.
-        for (View parent : unredactedParents) redacted.addAll(TreeUtils.directChildren(parent));
-
-        // Then we can subtract the set of unredacted parents to find just the
-        // set of unredacted nodes that are leaves of the parent subtree
-        redacted.removeAll(unredactedParents);
-
-        // Finally we can subtract the set of unredacted views to get the minimal
-        // set of redactions that will redact everything that's not explicitly unredacted
-        // whilst allowing the unredacted views to be visible
-        redacted.removeAll(unredacted);
-
-        // Remove any empty ReactViewGroup from the redacted set, they're often used for wrapping
-        // or sizing other elements, and do not usually need to be redacted
-        // If it's absolutely necessary they are redacted, they can always be replaced with
-        // a <Redacted> tag instead
-        for (View v : new HashSet<>(redacted))
-            if (v instanceof ReactViewGroup && ((ReactViewGroup) v).getChildCount() == 0)
-                redacted.remove(v);
-
-        // Any explicitly redacted views surrounded by <Redacted> tags take precedence, so
-        // re-add any tagged as such that the process above might have removed
-        redacted.addAll(RedactedViewManager.redactedViews.keySet());
-
-        return new ArrayList<>(redacted);
+      return new ArrayList<>(toRedact);
     }
 
     @ReactMethod
@@ -350,4 +375,5 @@ public class CobrowseIOModule extends ReactContextBaseJavaModule
     public void accessibilityServiceIsRunning(final Promise promise) {
         promise.resolve(CobrowseAccessibilityService.isRunning(getReactApplicationContext()));
     }
+
 }

package/android/src/main/java/io/cobrowse/reactnative/TreeUtils.java

@@ -4,11 +4,7 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
 
-import com.facebook.react.ReactRootView;
-import com.facebook.react.views.view.ReactViewGroup;
-
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -38,32 +34,10 @@ class TreeUtils {
         return parents;
     }
 
-    public static List<View> reactParents(View root) {
-      List<View> parents = allParents(root);
-      ArrayList<View> reactParents = new ArrayList<>(parents);
-      for (View v : parents) {
-        if (isReactView(v)) break;
-        reactParents.remove(v);
-      }
-      return reactParents;
-    }
-
-    public static Set<View> findAllClosest(View root, Predicate<View> predicate) {
-        HashSet<View> found = new HashSet<>();
-        if (predicate.test(root)) found.add(root);
-        else {
-            for (View v : directChildren(root)) {
-               found.addAll(findAllClosest(v, predicate));
-           }
-       }
-       return found;
-    }
-
-    public static boolean isReactView(View view) {
-      return view instanceof ReactRootView || view instanceof ReactViewGroup;
-    }
-
-    public static boolean hasAnyParent(View node, Set<View> matches) {
-      return !Collections.disjoint(TreeUtils.allParents(node), matches);
+    public static View closest(View root, Predicate<View> predicate) {
+      if (predicate.test(root)) return root;
+      ViewParent parent = root.getParent();
+      if (parent instanceof ViewGroup) return closest((ViewGroup)parent, predicate);
+      return null;
     }
 }

package/cobrowse-sdk-react-native.podspec

@@ -11,7 +11,7 @@ Pod::Spec.new do |s|
   s.homepage      = package["homepage"]
   s.source        = { :git => 'https://github.com/cobrowseio/cobrowse-sdk-react-native.git' }
   s.platform      = :ios, '9.0'
-  s.dependency      'CobrowseIO/XCFramework', '2.19.0'
+  s.dependency      'CobrowseIO/XCFramework', '2.21.2'
   s.dependency      'React'
   s.source_files =  'ios/*.{h,m}'
 end

package/ios/RCTCBIOTreeUtils.h

@@ -4,12 +4,6 @@
 
 +(NSArray*) allParents: (UIView*) root;
 
-+(NSArray*) reactParents: (UIView*) root;
-
-+(NSMutableSet*) findAllClosest: (BOOL (^)(UIView* view))predicate under: (UIView*) root;
-
-+(bool) isReactView: (UIView*) view;
-
-+(bool) hasAnyParent: (UIView*) view matches: (NSSet*) matches;
++(UIView*) closest: (BOOL (^)(UIView* view))predicate from: (UIView*) root;
 
 @end

package/ios/RCTCBIOTreeUtils.m

@@ -1,6 +1,4 @@
 #import "RCTCBIOTreeUtils.h"
-#import <React/RCTRootView.h>
-#import <React/RCTView.h>
 
 @implementation RCTCBIOTreeUtils
 
@@ -14,34 +12,10 @@
     return parents;
 }
 
-+(NSArray*) reactParents: (UIView*) root {
-    NSArray* allParents = [self allParents: root];
-    NSMutableArray* reactParents = [allParents mutableCopy];
-    for (id view in allParents) {
-        if ([self isReactView:view]) break;
-        [reactParents removeObject: view];
-    }
-    return reactParents;
-}
-
-+(NSMutableSet*) findAllClosest: (BOOL (^)(UIView* view))predicate under: (UIView*) root {
-    NSMutableSet* found = [NSMutableSet set];
-    if (predicate(root)) [found addObject:root];
-    else {
-        for (UIView* child in root.subviews) {
-            [found addObjectsFromArray: [self findAllClosest:predicate under:child].allObjects];
-        }
-    }
-    return found;
-}
-
-+(bool) isReactView: (UIView*) view {
-    return [view isKindOfClass:RCTRootView.class] || [view isKindOfClass: RCTView.class];
-}
-
-+(bool) hasAnyParent: (UIView*) view matches: (NSSet*) matches {
-    NSSet* parents = [NSSet setWithArray: [self allParents:view]];
-    return [parents intersectsSet: matches];
++(UIView*) closest: (BOOL (^)(UIView* view))predicate from: (UIView*) root {
+    if (predicate(root)) return root;
+    else if (!root.superview) return nil;
+    else return [self closest:predicate from:root.superview];
 }
 
 @end

package/ios/RCTCobrowseIO.h

@@ -4,6 +4,20 @@
 
 @import CobrowseIO;
 
+
+@protocol RCTCobrowseIODelegate <NSObject>
+
+@optional
+
+-(nonnull NSArray<UIView*>*) cobrowseRedactedViewsForViewController: (nonnull UIViewController*) vc;
+-(nonnull NSArray<UIView*>*) cobrowseUnredactedViewsForViewController: (nonnull UIViewController*) vc;
+
+@end
+
+
 @interface RCTCobrowseIO: RCTEventEmitter <RCTBridgeModule, CobrowseIODelegate>
 
+@property (class, nullable) id<RCTCobrowseIODelegate> delegate;
+
 @end
+

package/ios/RCTCobrowseIO.m

@@ -14,6 +14,8 @@
 #define SESSION_ENDED "session.ended"
 #define SESSION_REQUESTED "session.requested"
 
+static id<RCTCobrowseIODelegate> _Nullable _delegate;
+
 @import CobrowseIO;
 
 @implementation RCTCobrowseIO {
@@ -32,6 +34,14 @@ RCT_EXPORT_MODULE();
     return self;
 }
 
++(id<RCTCobrowseIODelegate>)delegate {
+    return _delegate;
+}
+
++(void)setDelegate:(id<RCTCobrowseIODelegate>)delegate {
+    _delegate = delegate;
+}
+
 + (BOOL)requiresMainQueueSetup {
     return YES;
 }
@@ -56,7 +66,15 @@ RCT_EXPORT_MODULE();
     if (hasListeners) [self sendEventWithName:@SESSION_LOADED body:[session toDict]];
 }
 
--(NSSet<UIView*>*) unredactedViews {
+-(NSSet<UIView*>*) redactedViews: (UIViewController*) vc {
+    NSMutableSet* views = [CBIOCobrowseRedactedManager.redactedViews mutableCopy];
+    if ([RCTCobrowseIO.delegate respondsToSelector:@selector(cobrowseRedactedViewsForViewController:)]) {
+        [views addObjectsFromArray: [RCTCobrowseIO.delegate cobrowseRedactedViewsForViewController:vc]];
+    }
+    return views;
+}
+
+-(NSSet<UIView*>*) unredactedViews: (UIViewController*) vc {
     NSMutableSet* views = [NSMutableSet set];
     @synchronized(unredactedTags) {
         for (id tag in unredactedTags) {
@@ -64,6 +82,9 @@ RCT_EXPORT_MODULE();
             if (v != nil) [views addObject:v];
         }
     }
+    if ([RCTCobrowseIO.delegate respondsToSelector:@selector(cobrowseUnredactedViewsForViewController:)]) {
+        [views addObjectsFromArray: [RCTCobrowseIO.delegate cobrowseUnredactedViewsForViewController:vc]];
+    }
     return views;
 }
 
@@ -85,59 +106,60 @@ RCT_EXPORT_MODULE();
 }
 
 -(NSArray<UIView *> *)cobrowseRedactedViewsForViewController:(UIViewController *)vc {
-    NSMutableSet* redacted = [NSMutableSet set];
-    NSSet* unredacted = self.unredactedViews;
-
-    // By default everything managed by react is redacted for view controllers
-    // that contain react views. If we were to always redact vc.view this would lead
-    // to instances where windows that do not contain a RN context could
-    // not be unredacted.
-    // A simple example of this is the overlay window that cobrowse adds to
-    // render its annotations. This window sits on top of all the other windows
-    // and would always be redacted, effecivley redacting the entire screen all
-    // the time.
-    // To get around this, we only redact views below RCTViews or RCTRootViews
-    // (not inclusive), as then it's always possible to add an unredact()'ed component
-    // around a subview in the react tree to make parent visible.
-    NSSet* rootViews = [RCTCBIOTreeUtils findAllClosest:^BOOL(UIView *view) {
-        return [RCTCBIOTreeUtils isReactView: view];
-    } under: vc.view];
-    for (UIView* v in rootViews) [redacted addObjectsFromArray: v.subviews];
-
-    // Now we can actually start working out what should be unredacted
-    // First work out the set of all parents of unredact()'ed nodes
-    // that are inside a react view (ignoring any nested unredaction)
-    NSMutableSet* unredactedParents = [NSMutableSet set];
+    NSSet* redacted = [self redactedViews: vc];
+    NSSet* unredacted = [self unredactedViews: vc];
+    
+    // Project all unredactions to the root to get the full set of unredacted nodes
+    NSMutableSet* projectedUnredacted = [NSMutableSet set];
     for (id view in unredacted) {
-        if (![RCTCBIOTreeUtils hasAnyParent:view matches:unredacted])
-            [unredactedParents addObjectsFromArray: [RCTCBIOTreeUtils reactParents: view]];
+        [projectedUnredacted addObject:view];
+        [projectedUnredacted addObjectsFromArray: [RCTCBIOTreeUtils allParents: view]];
     }
-    // Then work out the set of all direct children of any unredacted parents
-    // This should give us the set including unredacted nodes, their siblings,
-    // and all their parents.
-    for (UIView* parent in unredactedParents) [redacted addObjectsFromArray: parent.subviews];
-
-    // Then we can subtract the set of unredacted parents to find just the
-    // set of unredacted nodes that are leaves of the parent subtree
-    for (id v in unredactedParents) [redacted removeObject:v];
-
-    // Finally we can subtract the set of unredacted views to get the minimal
-    // set of redactions that will redact everything that's not explicitly unredacted
-    // whilst allowing the unredacted views to be visible
-    for (UIView* v in unredacted) [redacted removeObject:v];
 
+    // Work out which nodes are explicitly redacted but need to be unredacted
+    // due to a nested unredaction tag (these redactions will be moved towards the
+    // leaves of the view hierarchy instead)
+    NSMutableSet* redactedProjectedUnredactions = [redacted mutableCopy];
+    [redactedProjectedUnredactions intersectSet: projectedUnredacted];
+    
+    // Start to build the set of redactions we should actually apply. We start off with
+    // the set of explicitly redacted nodes
+    NSMutableSet* toRedact = [redacted mutableCopy];
+    
+    // remove any redactions that have unredacted decendants (i.e. any that appear in the
+    // projection of the unredaction). These are the redacted nodes we need to move towards
+    // the leaves of the tree
+    [toRedact minusSet: redactedProjectedUnredactions];
+    
+    // Work out the set of all nodes that are siblings of any projected unredacted node
+    NSMutableSet* projectedUnredactionSiblings = [NSMutableSet set];
+    for (UIView* view in projectedUnredacted) {
+        [projectedUnredactionSiblings addObjectsFromArray: view.superview.subviews];
+    }
+    
+    // Subtract the projected unredactions from the set of all siblings of projected
+    // unredactions. i.e. subtract things that should be definitely unredacted to leave
+    // a set we're not sure yet whether to redact or not
+    NSMutableSet* potentiallyRedactedUnredactedSiblings = [projectedUnredactionSiblings mutableCopy];
+    [potentiallyRedactedUnredactedSiblings minusSet:projectedUnredacted];
+    
+    // for each node we're not sure about yet, check if the closest redacted or unredacted ancestor
+    // is a redacted node, if so this descendant should also be redacted
+    for (UIView* view in potentiallyRedactedUnredactedSiblings) {
+        UIView* closest = [RCTCBIOTreeUtils closest:^BOOL(UIView *v) {
+            return [redacted containsObject:v] || [unredacted containsObject:v];
+        } from: view];
+        if ([redacted containsObject: closest]) [toRedact addObject: view];
+    }
+    
     // Remove any empty RCTViews from the redacted set, they're often used for wrapping
     // or sizing other elements, and do not usually need to be redacted
     // If it's absolutely necessary they are redacted, they can always be replaced with
     // a <Redacted> tag instead
-    for (UIView* v in [redacted copy])
-        if ([v isKindOfClass:RCTView.class] && v.subviews.count == 0) [redacted removeObject: v];
-
-    // Any explicitly redacted views surroudned by <Redacted> tags take precedence, so
-    // re-add any tagged as such that the process above might have removed
-    for (id v in CBIOCobrowseRedactedManager.redactedViews.allObjects) [redacted addObject: v];
+    for (UIView* v in [toRedact copy])
+        if ([v isKindOfClass:RCTView.class] && v.subviews.count == 0) [toRedact removeObject: v];
 
-    return redacted.allObjects;;
+    return toRedact.allObjects;
 }
 
 - (bool) cobrowseShouldCaptureWindow:(UIWindow *)window {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cobrowse-sdk-react-native",
-  "version": "2.11.2-unredaction.0",
+  "version": "2.12.0",
   "description": "Cobrowse SDK for React Native",
   "main": "js/index.js",
   "types": "ts/index.d.ts",
@@ -27,17 +27,17 @@
   ],
   "license": "Apache-2.0",
   "optionalDependencies": {
-    "@types/react": "^17.0.38",
-    "@types/react-native": "^0.66.15"
+    "@types/react": "^18.0.18",
+    "@types/react-native": "^0.69.6"
   },
   "dependencies": {
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@types/react": "^17.0.38",
-    "@types/react-native": "^0.66.15",
-    "nodemon": "^2.0.15",
+    "@types/react": "^18.0.18",
+    "@types/react-native": "^0.69.6",
+    "nodemon": "^2.0.19",
     "ts-standard": "^11.0.0",
-    "typescript": "^4.5.5"
+    "typescript": "^4.8.2"
   }
 }