@exodus/react-native-screenshot-detector 1.1.2 → 1.2.1

package/index.ios.js

@@ -1,15 +1,91 @@
 import { NativeEventEmitter, NativeModules } from 'react-native'
 
 const { RNScreenshotDetector } = NativeModules
+
+console.log('[TEST] RNScreenshotDetector module loaded:', !!RNScreenshotDetector)
+console.log('[TEST] Available methods:', Object.keys(RNScreenshotDetector || {}))
+
 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()
+  console.log('[TEST] subscribe called - using NEW explicit method!')
+  
+  // Use the more explicit method name internally
+  if (RNScreenshotDetector && RNScreenshotDetector.subscribeToScreenshotAndScreenRecording) {
+    console.log('[TEST] Calling subscribeToScreenshotAndScreenRecording')
+    RNScreenshotDetector.subscribeToScreenshotAndScreenRecording()
+    console.log('[TEST] SUCCESS: subscribeToScreenshotAndScreenRecording called')
+  } else {
+    console.log('[TEST] ERROR: subscribeToScreenshotAndScreenRecording not available!')
+  }
+  
+  const sub = eventEmitter.addListener(SCREENSHOT_EVENT, (data) => {
+    console.log('[TEST] ScreenshotTaken event received:', data)
+    cb(data)
+  })
+  return () => {
+    console.log('[TEST] Unsubscribing from screenshot events')
+    sub.remove()
+    
+    // Use the more explicit method name internally
+    if (RNScreenshotDetector && RNScreenshotDetector.unsubscribeFromScreenshotAndScreenRecording) {
+      console.log('[TEST] Calling unsubscribeFromScreenshotAndScreenRecording')
+      RNScreenshotDetector.unsubscribeFromScreenshotAndScreenRecording()
+      console.log('[TEST] SUCCESS: unsubscribeFromScreenshotAndScreenRecording called')
+    } else {
+      console.log('[TEST] ERROR: unsubscribeFromScreenshotAndScreenRecording not available!')
+    }
+  }
 }
 
-export default {
+const disableScreenshots = () => {
+  console.log('[TEST] disableScreenshots called')
+  if (RNScreenshotDetector && RNScreenshotDetector.disableScreenshots) {
+    console.log('[TEST] Calling native disableScreenshots')
+    RNScreenshotDetector.disableScreenshots()
+    console.log('[TEST] SUCCESS: disableScreenshots called')
+  } else {
+    console.log('[TEST] ERROR: disableScreenshots not available!')
+  }
+}
+
+const enableScreenshots = () => {
+  console.log('[TEST] enableScreenshots called')
+  if (RNScreenshotDetector && RNScreenshotDetector.enableScreenshots) {
+    console.log('[TEST] Calling native enableScreenshots')
+    RNScreenshotDetector.enableScreenshots()
+    console.log('[TEST] SUCCESS: enableScreenshots called')
+  } else {
+    console.log('[TEST] ERROR: enableScreenshots not available!')
+  }
+}
+
+const isScreenRecording = async () => {
+  console.log('[TEST] isScreenRecording called')
+  if (RNScreenshotDetector && RNScreenshotDetector.isScreenRecording) {
+    try {
+      const result = await RNScreenshotDetector.isScreenRecording()
+      console.log('[TEST] isScreenRecording result:', result)
+      return result
+    } catch (error) {
+      console.log('[TEST] ERROR in isScreenRecording:', error)
+      return false
+    }
+  } else {
+    console.log('[TEST] ERROR: isScreenRecording not available!')
+    return false
+  }
+}
+
+// Main API - only expose what's actually used externally
+const ScreenshotDetector = {
   subscribe,
+  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,211 @@
 
 #import "RNScreenshotDetector.h"
 #import <React/RCTBridge.h>
+#import <UIKit/UIKit.h>
 
 @implementation RNScreenshotDetector
 {
-    id observer;
+    id screenshotObserver;
+    id screenRecordingObserver;
+    BOOL isProtectionEnabled;
 }
 
 RCT_EXPORT_MODULE();
 
-
 - (NSArray<NSString *> *)supportedEvents {
-    return @[@"ScreenshotTaken"];
+    NSLog(@"[TEST] supportedEvents called");
+    return @[@"ScreenshotTaken", @"ScreenRecordingChanged"];
 }
 
 - (void)startObserving {
-   // Now set up handler to detect if user takes a screenshot
+    NSLog(@"[TEST] startObserving called");
     NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
-    observer = [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationUserDidTakeScreenshotNotification
-                                                      object:nil
-                                                       queue:mainQueue
-                                                  usingBlock:^(NSNotification *notification) {
-                                                      [self screenshotDetected:notification];
-                                                  }];
+    
+    if (screenshotObserver == nil) {
+        screenshotObserver = [[NSNotificationCenter defaultCenter] 
+            addObserverForName:UIApplicationUserDidTakeScreenshotNotification
+            object:nil
+            queue:mainQueue
+            usingBlock:^(NSNotification *notification) {
+                [self screenshotDetected:notification];
+            }];
+        NSLog(@"[TEST] Screenshot observer registered successfully");
+    } else {
+        NSLog(@"[TEST] Screenshot observer already exists");
+    }
+    
+    if (screenRecordingObserver == nil) {
+        screenRecordingObserver = [[NSNotificationCenter defaultCenter]
+            addObserverForName:UIScreenCapturedDidChangeNotification
+            object:nil
+            queue:mainQueue
+            usingBlock:^(NSNotification *notification) {
+                [self screenRecordingChanged:notification];
+            }];
+        NSLog(@"[TEST] Screen recording observer registered successfully");
+    } else {
+        NSLog(@"[TEST] Screen recording observer already exists");
+    }
 }
 
 - (void)stopObserving {
-    if (observer != nil) {
-        [[NSNotificationCenter defaultCenter] removeObserver:observer];
+    NSLog(@"[TEST] stopObserving called");
+    if (screenshotObserver != nil) {
+        [[NSNotificationCenter defaultCenter] removeObserver:screenshotObserver];
+        screenshotObserver = nil;
+        NSLog(@"[TEST] Screenshot observer removed successfully");
+    }
+    
+    if (screenRecordingObserver != nil) {
+        [[NSNotificationCenter defaultCenter] removeObserver:screenRecordingObserver];
+        screenRecordingObserver = nil;
+        NSLog(@"[TEST] Screen recording observer removed successfully");
     }
 }
 
 - (void)screenshotDetected:(NSNotification *)notification {
-    if (observer != nil) {
+    NSLog(@"[TEST] 🚨 SCREENSHOT DETECTED! 🚨");
+    if (screenshotObserver != nil) {
+        NSLog(@"[TEST] Sending ScreenshotTaken event to JavaScript");
         [self sendEventWithName:@"ScreenshotTaken" body:@{}];
+        NSLog(@"[TEST] ScreenshotTaken event sent successfully");
+    } else {
+        NSLog(@"[TEST] ERROR: Screenshot observer is nil, not sending event");
     }
 }
 
-@end
+- (void)screenRecordingChanged:(NSNotification *)notification {
+    BOOL isRecording = [UIScreen mainScreen].isCaptured;
+    NSLog(@"[TEST] Screen recording changed: %@", isRecording ? @"STARTED" : @"STOPPED");
+    
+    if (screenRecordingObserver != nil) {
+        NSLog(@"[TEST] Sending ScreenRecordingChanged event to JavaScript");
+        [self sendEventWithName:@"ScreenRecordingChanged" body:@{@"isRecording": @(isRecording)}];
+        NSLog(@"[TEST] ScreenRecordingChanged event sent successfully");
+    } else {
+        NSLog(@"[TEST] ERROR: Screen recording observer is nil, not sending event");
+    }
+}
+
+RCT_EXPORT_METHOD(disableScreenshots) {
+    NSLog(@"[TEST] disableScreenshots called");
+    dispatch_async(dispatch_get_main_queue(), ^{
+        isProtectionEnabled = YES;
+        NSLog(@"[TEST] Protection enabled, calling enableTrueScreenshotPrevention");
+        [self enableTrueScreenshotPrevention];
+        NSLog(@"[TEST] disableScreenshots completed");
+    });
+}
+
+RCT_EXPORT_METHOD(enableScreenshots) {
+    NSLog(@"[TEST] enableScreenshots called");
+    dispatch_async(dispatch_get_main_queue(), ^{
+        isProtectionEnabled = NO;
+        NSLog(@"[TEST] Protection disabled, calling disableTrueScreenshotPrevention");
+        [self disableTrueScreenshotPrevention];
+        NSLog(@"[TEST] enableScreenshots completed");
+    });
+}
+
+RCT_EXPORT_METHOD(isScreenRecording:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    BOOL isRecording = [UIScreen mainScreen].isCaptured;
+    NSLog(@"[TEST] isScreenRecording called, result: %@", isRecording ? @"YES" : @"NO");
+    resolve(@(isRecording));
+}
+
+// Clear and explicit method names
+RCT_EXPORT_METHOD(subscribeToScreenshotAndScreenRecording) {
+    NSLog(@"[TEST] subscribeToScreenshotAndScreenRecording called - NEW EXPLICIT METHOD!");
+    [self startObserving];
+    NSLog(@"[TEST] subscribeToScreenshotAndScreenRecording completed");
+}
+
+RCT_EXPORT_METHOD(unsubscribeFromScreenshotAndScreenRecording) {
+    NSLog(@"[TEST] unsubscribeFromScreenshotAndScreenRecording called");
+    [self stopObserving];
+    NSLog(@"[TEST] unsubscribeFromScreenshotAndScreenRecording completed");
+}
+
+// Screenshot Prevention using Secure Text Field
+- (void)enableTrueScreenshotPrevention {
+    NSLog(@"[TEST] enableTrueScreenshotPrevention called");
+    if (self.secureTextField == nil) {
+        NSLog(@"[TEST] Creating new secureTextField");
+        self.secureTextField = [[UITextField alloc] init];
+        self.secureTextField.userInteractionEnabled = NO;
+        self.secureTextField.secureTextEntry = YES;
+        
+        UIWindow *keyWindow = [self getKeyWindow];
+        if (keyWindow != nil) {
+            NSLog(@"[TEST] Key window found, setting up secure text field");
+            [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];
+                NSLog(@"[TEST] ✅ Secure text field configured successfully - Screenshot prevention ACTIVE!");
+            } else {
+                NSLog(@"[TEST] ❌ No sublayers found in secure text field");
+            }
+        } else {
+            NSLog(@"[TEST] ❌ Key window not found!");
+        }
+    } else {
+        NSLog(@"[TEST] Secure text field already exists, enabling secureTextEntry");
+        self.secureTextField.secureTextEntry = YES;
+        NSLog(@"[TEST] ✅ Secure text field re-enabled - Screenshot prevention ACTIVE!");
+    }
+}
+
+- (void)disableTrueScreenshotPrevention {
+    NSLog(@"[TEST] disableTrueScreenshotPrevention called");
+    if (self.secureTextField != nil) {
+        NSLog(@"[TEST] Disabling secureTextEntry");
+        self.secureTextField.secureTextEntry = NO;
+        NSLog(@"[TEST] ✅ Screenshot prevention DISABLED");
+    } else {
+        NSLog(@"[TEST] Secure text field is nil");
+    }
+}
+
+- (UIWindow *)getKeyWindow {
+    NSLog(@"[TEST] getKeyWindow called");
+    UIWindow *keyWindow = nil;
+    
+    NSSet<UIScene *> *connectedScenes = [UIApplication sharedApplication].connectedScenes;
+    NSLog(@"[TEST] Connected scenes count: %lu", (unsigned long)connectedScenes.count);
+    
+    for (UIScene *scene in connectedScenes) {
+        if ([scene isKindOfClass:[UIWindowScene class]]) {
+            UIWindowScene *windowScene = (UIWindowScene *)scene;
+            NSLog(@"[TEST] Found window scene with %lu windows", (unsigned long)windowScene.windows.count);
+            for (UIWindow *window in windowScene.windows) {
+                if (window.isKeyWindow) {
+                    keyWindow = window;
+                    NSLog(@"[TEST] ✅ Found key window using UIScene method");
+                    break;
+                }
+            }
+            if (keyWindow) break;
+        }
+    }
+    
+    if (keyWindow == nil) {
+        NSLog(@"[TEST] ❌ Key window not found using UIScene method!");
+    }
+    
+    return keyWindow;
+}
+
+- (void)dealloc {
+    NSLog(@"[TEST] dealloc called");
+    [self stopObserving];
+    [self disableTrueScreenshotPrevention];
+}
+
+@end 

package/package.json

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