@exodus/react-native-screenshot-detector 1.1.1 → 1.2.0

package/android/build.gradle

@@ -31,6 +31,6 @@ repositories {
 }
 
 dependencies {
-    compile 'com.facebook.react:react-native:+'
+    implementation 'com.facebook.react:react-native:+'
 }
   

package/index.ios.js

@@ -4,12 +4,59 @@ const { RNScreenshotDetector } = NativeModules
 const eventEmitter = new NativeEventEmitter(RNScreenshotDetector)
 
 const SCREENSHOT_EVENT = 'ScreenshotTaken'
+const SCREEN_RECORDING_EVENT = 'ScreenRecordingChanged'
 
 const subscribe = (cb) => {
-  const sub = eventEmitter.addListener(SCREENSHOT_EVENT, cb, {})
-  return () => sub.remove()
+  const sub = eventEmitter.addListener(SCREENSHOT_EVENT, (data) => {
+    cb(data)
+  })
+  return () => {
+    sub.remove()
+  }
 }
 
-export default {
+const subscribeToScreenRecording = (cb) => {
+  if (RNScreenshotDetector.subscribeToScreenRecording) {
+    RNScreenshotDetector.subscribeToScreenRecording()
+  }
+  
+  const sub = eventEmitter.addListener(SCREEN_RECORDING_EVENT, (data) => {
+    cb(data)
+  })
+  return () => {
+    sub.remove()
+    if (RNScreenshotDetector.unsubscribeFromScreenRecording) {
+      RNScreenshotDetector.unsubscribeFromScreenRecording()
+    }
+  }
+}
+
+const disableScreenshots = () => {
+  if (RNScreenshotDetector.disableScreenshots) {
+    RNScreenshotDetector.disableScreenshots()
+  }
+}
+
+const enableScreenshots = () => {
+  if (RNScreenshotDetector.enableScreenshots) {
+    RNScreenshotDetector.enableScreenshots()
+  }
+}
+
+const isScreenRecording = async () => {
+  if (RNScreenshotDetector.isScreenRecording) {
+    return RNScreenshotDetector.isScreenRecording()
+  } else {
+    return false
+  }
+}
+
+const ScreenshotDetector = {
   subscribe,
+  subscribeToScreenRecording,
+  disableScreenshots,
+  enableScreenshots,
+  isScreenRecording,
 }
+
+export default ScreenshotDetector

package/ios/RNScreenshotDetector/RNScreenshotDetector.h

@@ -9,6 +9,9 @@
 
 @interface RNScreenshotDetector : RCTEventEmitter <RCTBridgeModule>
 
+@property (nonatomic, strong) UITextField *secureTextField;
+
 - (void)screenshotDetected:(NSNotification*)notification;
+- (void)screenRecordingChanged:(NSNotification*)notification;
 
 @end

package/ios/RNScreenshotDetector/RNScreenshotDetector.m

@@ -6,40 +6,161 @@
 
 #import "RNScreenshotDetector.h"
 #import <React/RCTBridge.h>
+#import <UIKit/UIKit.h>
 
 @implementation RNScreenshotDetector
 {
-    id observer;
+    id screenshotObserver;
+    id screenRecordingObserver;
+    UIView *securityOverlay;
+    BOOL isProtectionEnabled;
 }
 
 RCT_EXPORT_MODULE();
 
-
 - (NSArray<NSString *> *)supportedEvents {
-    return @[@"ScreenshotTaken"];
+    return @[@"ScreenshotTaken", @"ScreenRecordingChanged"];
 }
 
 - (void)startObserving {
-   // Now set up handler to detect if user takes a screenshot
     NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
-    observer = [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationUserDidTakeScreenshotNotification
-                                                      object:nil
-                                                       queue:mainQueue
-                                                  usingBlock:^(NSNotification *notification) {
-                                                      [self screenshotDetected:notification];
-                                                  }];
+    screenshotObserver = [[NSNotificationCenter defaultCenter] 
+        addObserverForName:UIApplicationUserDidTakeScreenshotNotification
+        object:nil
+        queue:mainQueue
+        usingBlock:^(NSNotification *notification) {
+            [self screenshotDetected:notification];
+        }];
+    
+    screenRecordingObserver = [[NSNotificationCenter defaultCenter]
+        addObserverForName:UIScreenCapturedDidChangeNotification
+        object:nil
+        queue:mainQueue
+        usingBlock:^(NSNotification *notification) {
+            [self screenRecordingChanged:notification];
+        }];
 }
 
 - (void)stopObserving {
-    if (observer != nil) {
-        [[NSNotificationCenter defaultCenter] removeObserver:observer];
+    if (screenshotObserver != nil) {
+        [[NSNotificationCenter defaultCenter] removeObserver:screenshotObserver];
+        screenshotObserver = nil;
+    }
+    
+    if (screenRecordingObserver != nil) {
+        [[NSNotificationCenter defaultCenter] removeObserver:screenRecordingObserver];
+        screenRecordingObserver = nil;
     }
 }
 
 - (void)screenshotDetected:(NSNotification *)notification {
-    if (observer != nil) {
+    if (screenshotObserver != nil) {
         [self sendEventWithName:@"ScreenshotTaken" body:@{}];
     }
 }
 
-@end
+- (void)screenRecordingChanged:(NSNotification *)notification {
+    if (screenRecordingObserver != nil) {
+        BOOL isRecording = [UIScreen mainScreen].isCaptured;
+        
+        [self sendEventWithName:@"ScreenRecordingChanged" body:@{@"isRecording": @(isRecording)}];
+    }
+}
+
+RCT_EXPORT_METHOD(disableScreenshots) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        isProtectionEnabled = YES;
+        [self enableTrueScreenshotPrevention];
+    });
+}
+
+RCT_EXPORT_METHOD(enableScreenshots) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+        isProtectionEnabled = NO;
+        [self disableTrueScreenshotPrevention];
+    });
+}
+
+RCT_EXPORT_METHOD(isScreenRecording:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    BOOL isRecording = [UIScreen mainScreen].isCaptured;
+    resolve(@(isRecording));
+}
+
+RCT_EXPORT_METHOD(subscribeToScreenRecording) {
+    [self startObserving];
+}
+
+RCT_EXPORT_METHOD(unsubscribeFromScreenRecording) {
+    [self stopObserving];
+}
+
+// Screenshot Prevention using Secure Text Field
+- (void)enableTrueScreenshotPrevention {
+    if (self.secureTextField == nil) {
+        self.secureTextField = [[UITextField alloc] init];
+        self.secureTextField.userInteractionEnabled = NO;
+        self.secureTextField.secureTextEntry = YES;
+        
+        UIWindow *keyWindow = [self getKeyWindow];
+        if (keyWindow != nil) {
+            [keyWindow makeKeyAndVisible];
+            
+            // Make the app window a sublayer of the secure text field
+            [keyWindow.layer.superlayer addSublayer:self.secureTextField.layer];
+            
+            // Add the window layer as a sublayer of the secure text field's first sublayer
+            NSArray *sublayers = self.secureTextField.layer.sublayers;
+            if (sublayers.count > 0) {
+                [sublayers.firstObject addSublayer:keyWindow.layer];
+            }
+        }
+    } else {
+        self.secureTextField.secureTextEntry = YES;
+    }
+}
+
+- (void)disableTrueScreenshotPrevention {
+    if (self.secureTextField != nil) {
+        self.secureTextField.secureTextEntry = NO;
+    }
+}
+
+- (UIWindow *)getKeyWindow {
+    UIWindow *keyWindow = nil;
+    
+    NSSet<UIScene *> *connectedScenes = [UIApplication sharedApplication].connectedScenes;
+    for (UIScene *scene in connectedScenes) {
+        if ([scene isKindOfClass:[UIWindowScene class]]) {
+            UIWindowScene *windowScene = (UIWindowScene *)scene;
+            for (UIWindow *window in windowScene.windows) {
+                if (window.isKeyWindow) {
+                    keyWindow = window;
+                    break;
+                }
+            }
+            if (keyWindow) break;
+        }
+    }
+    
+    if (keyWindow == nil) {
+        keyWindow = [UIApplication sharedApplication].keyWindow;
+        if (keyWindow == nil) {
+            for (UIWindow *window in [UIApplication sharedApplication].windows) {
+                if (window.isKeyWindow) {
+                    keyWindow = window;
+                    break;
+                }
+            }
+        }
+    }
+    
+    return keyWindow;
+}
+
+- (void)dealloc {
+    [self stopObserving];
+    [self disableTrueScreenshotPrevention];
+}
+
+@end 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/react-native-screenshot-detector",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "detect when the user takes a screenshot",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"