@onekeyfe/react-native-capture-protection 0.0.0-stage → 3.0.166

package/docs/SPEC.md

@@ -0,0 +1,117 @@
+# Capture protection contract
+
+Status: Implemented. Native runtime acceptance is pending.
+
+## Purpose and scope
+
+Protect wallet-sensitive screens without photo-library or file access. Support
+OneKey iOS/Android callers of `prevent()`, `allow()` and `addListener()`. This is
+not the full upstream API: providers, hooks, custom text/image overlays,
+permission requests and media-library screenshot detection are not exported.
+Web/desktop callers use their existing platform hooks and do not load this module.
+
+## Ownership and boundaries
+
+The OS window and protection state belong to a process-wide native coordinator.
+Each Nitro object has its own owner identifier and callback; main and background
+JS runtimes have separate objects/heaps and initialize independently. One owner's
+`allow()` must not release another owner's protection. JS callbacks remain scoped
+to their owning object/runtime. No image bytes, album entries, file paths or
+product secrets enter this module. Only the UI runtime uses it in the app.
+
+## Public API and defaults
+
+- `CaptureProtection.prevent(): Promise<void>` enables screenshot, recording and
+  app-switcher protection together. Repeated calls by one object are idempotent.
+- `CaptureProtection.allow(): Promise<void>` releases only that object's protection.
+- `CaptureProtection.addListener(callback): { remove(): void }` registers a local
+  subscriber; removal is idempotent. At most 128 JS subscribers per runtime.
+- `CaptureEventType`: NONE=0, RECORDING=1, END_RECORDING=2, CAPTURED=3,
+  APP_SWITCHING=4, UNKNOWN=5, ALLOW=8, PREVENT_SCREEN_CAPTURE=16,
+  PREVENT_SCREEN_RECORDING=32, PREVENT_SCREEN_APP_SWITCHING=64.
+- Nitro methods are `prevent`, `allow`, `setListener(callback | undefined)`.
+  Protection failures reject; missing native registration throws instead of
+  silently pretending sensitive screens are protected.
+
+## Lifecycle and concurrency
+
+All native state and window operations run on the UI thread in dispatch order.
+There is at most one native subscription per object; JS fans events out to its
+current subscribers. Removing the final subscriber releases its native callback.
+Native observers start on first owner/subscriber and stop on the last. Callbacks
+are weakly connected to objects; disposal releases that owner's state and listener.
+Android resolves the foreground activity through the application UI ReactHost
+and lifecycle tracking, never Nitro's last-initialized global React context.
+Android reapplies FLAG_SECURE on activity resume while protection is requested,
+unregisters screenshot callbacks on pause and unregisters activity/display
+observers when no owners/subscribers remain. iOS reload notification resets
+obsolete owners and observers. Protection is fail-closed across activity pause;
+activity destruction does not clear the owners of still-running JS runtimes.
+Events reflect OS notifications, not screenshot image contents. No deduplication
+or 1-second artificial event reset is added; the existing app hook debounces warnings.
+
+## Data, cache and identity
+
+Only in-memory owner IDs, listeners, observer registrations and overlay windows
+are retained. No storage, persistence, cache, migrations or network access.
+
+## Platform contract
+
+| Behavior              | iOS                                                 | Android                                               |
+| --------------------- | --------------------------------------------------- | ----------------------------------------------------- |
+| Screenshot protection | Upstream-derived secure UITextField layer technique | FLAG_SECURE                                           |
+| Recording protection  | Secure layer plus opaque window while captured      | FLAG_SECURE                                           |
+| App switcher          | Opaque window before resign/background              | FLAG_SECURE                                           |
+| Screenshot event      | UIApplication notification                          | Android 14+ system callback                           |
+| Recording event       | UIScreen capture change notification                | Upstream-derived virtual-display heuristic            |
+| Permissions           | None                                                | DETECT_SCREEN_CAPTURE, normal permission, Android 14+ |
+
+Android below 14 intentionally has no screenshot notification; blocking remains
+available. Android virtual-display events are a heuristic and may also represent
+casting/external displays; they are not proof that a recording was made.
+iOS secure-text-field wrapping is inherited from upstream, is not a documented
+system-wide screenshot prevention API, and requires OS-version/device acceptance.
+Existing recordings when subscribing emit RECORDING when identifiable. Existing
+Android private virtual displays may not be visible to DisplayManager enumeration.
+
+## Failure, fallback and safety
+
+Missing foreground activity/window or unavailable secure layer rejects prevent.
+Never fall back to MediaStore queries, filesystem scanning or storage permissions.
+Screenshot observer errors must not disable FLAG_SECURE. Only FLAG_SECURE flags
+introduced by this coordinator may be cleared; preserve pre-existing flags.
+A native coordinator admits at most 32 owner/subscriber identities, rejecting
+excess registration. No custom overlays, bytes or unbounded event queues.
+
+## Performance and resources
+
+UI work is limited to flags, notifications, layer configuration and at most two
+opaque windows on iOS. No polling, I/O, image processing or detached coroutines.
+Recording/display changes are event-driven. Listener registration synchronously marshals to the UI thread; Android rejects
+a wait exceeding 5 seconds. Protection operations return promises. No performance
+claim is made.
+
+## Conformance and acceptance
+
+Source: `src/index.tsx`, `ios/ReactNativeCaptureProtection.swift` and Android
+`ReactNativeCaptureProtection.kt`. JS tests cover listener fan-out/removal and
+missing registration. iOS XCTest is provided for independent object subscriptions,
+disposal and secure-layer owner isolation; physical capture acceptance remains
+separate.
+Required runtime acceptance: prevent/allow, nested sensitive pages, repeated
+navigation, recording started before/after subscription, background snapshots,
+activity recreation, subscription cleanup, and main/background object isolation.
+Inspect merged Android manifest and packaged iOS plist for media-read permissions.
+Build/type/unit results do not prove screenshot prevention on physical devices.
+
+## Template deviations and attribution
+
+Generated from `yarn create:module react-native-capture-protection`. Remove the
+hello example and unused Babel module-resolver alias only; retain template build
+conventions. The alias is not used by this package and the template does not
+declare its Babel plugin. Match the repository React Native patched dependency. Use the repository
+FlatCompat ESLint pattern because the template calls an unavailable
+createEslintConfig export. The XCTest spec requires an app host for UIKit tests.
+Add SPEC, focused tests,
+ACKNOWLEDGEMENTS and the upstream MIT notice. See ACKNOWLEDGEMENTS.md for source
+provenance and the precise subset adapted.

package/ios/ReactNativeCaptureProtection.swift

@@ -0,0 +1,251 @@
+// Adapted from react-native-capture-protection 2.3.0 by lethe; see LICENSE.upstream.
+import Foundation
+import NitroModules
+import React
+import UIKit
+
+class ReactNativeCaptureProtection: HybridReactNativeCaptureProtectionSpec {
+  private let owner = UUID()
+  private var listener: ((Double) -> Void)?
+
+  func prevent() throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    DispatchQueue.main.async {
+      do {
+        try CaptureProtectionCoordinator.shared.prevent(owner: self.owner)
+        promise.resolve(withResult: ())
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+
+  func allow() throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    DispatchQueue.main.async {
+      CaptureProtectionCoordinator.shared.allow(owner: self.owner)
+      promise.resolve(withResult: ())
+    }
+    return promise
+  }
+
+  func setListener(callback: ((Double) -> Void)?) throws {
+    try onMain {
+      let coordinator = CaptureProtectionCoordinator.shared
+      if let callback {
+        try coordinator.subscribe(owner: self.owner) { [weak self] event in
+          self?.listener?(event)
+        }
+        self.listener = callback
+        coordinator.emitRecordingState(owner: self.owner)
+      } else {
+        self.listener = nil
+        coordinator.unsubscribe(owner: self.owner)
+      }
+    }
+  }
+
+  func dispose() {
+    DispatchQueue.main.async {
+      self.listener = nil
+      CaptureProtectionCoordinator.shared.unsubscribe(owner: self.owner)
+      CaptureProtectionCoordinator.shared.allow(owner: self.owner)
+    }
+  }
+
+  deinit {
+    let identifier = owner
+    DispatchQueue.main.async {
+      CaptureProtectionCoordinator.shared.unsubscribe(owner: identifier)
+      CaptureProtectionCoordinator.shared.allow(owner: identifier)
+    }
+  }
+
+  private func onMain(_ operation: () throws -> Void) rethrows {
+    if Thread.isMainThread {
+      try operation()
+    } else {
+      try DispatchQueue.main.sync(execute: operation)
+    }
+  }
+}
+
+private final class CaptureProtectionCoordinator {
+  static let shared = CaptureProtectionCoordinator()
+  private var owners = Set<UUID>()
+  private var listeners: [UUID: (Double) -> Void] = [:]
+  private var observers: [NSObjectProtocol] = []
+  private var secureField: UITextField?
+  private weak var protectedWindow: UIWindow?
+  private var recordWindow: UIWindow?
+  private var switcherWindow: UIWindow?
+  private var recording = false
+
+  private var window: UIWindow? {
+    if let delegated = UIApplication.shared.delegate?.window ?? nil { return delegated }
+    return UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }.first { $0.isKeyWindow }
+  }
+
+  private func checkCapacity(_ owner: UUID) throws {
+    let identities = owners.union(listeners.keys)
+    if !identities.contains(owner) && identities.count >= 32 {
+      throw failure("Capture protection supports at most 32 native owners.")
+    }
+  }
+
+  func prevent(owner: UUID) throws {
+    try checkCapacity(owner)
+    guard let window else { throw failure("No application window is available.") }
+    if owners.isEmpty {
+      try secureScreenshot(window: window)
+    }
+    owners.insert(owner)
+    startObservers()
+    refreshRecording()
+    if UIApplication.shared.applicationState != .active { showSwitcher() }
+  }
+
+  func allow(owner: UUID) {
+    owners.remove(owner)
+    if owners.isEmpty {
+      secureField?.isSecureTextEntry = false
+      removeRecordWindow()
+      removeSwitcherWindow()
+    }
+    stopObserversIfIdle()
+  }
+
+  func subscribe(owner: UUID, callback: @escaping (Double) -> Void) throws {
+    try checkCapacity(owner)
+    listeners[owner] = callback
+    startObservers()
+  }
+
+  func unsubscribe(owner: UUID) {
+    listeners.removeValue(forKey: owner)
+    stopObserversIfIdle()
+  }
+
+  func emitRecordingState(owner: UUID) {
+    if UIScreen.main.isCaptured { listeners[owner]?(1) }
+  }
+
+  private func emit(_ event: Double) {
+    for (owner, callback) in Array(listeners) where listeners[owner] != nil {
+      callback(event)
+    }
+  }
+
+  private func startObservers() {
+    guard observers.isEmpty else { return }
+    let center = NotificationCenter.default
+    recording = UIScreen.main.isCaptured
+    observers.append(center.addObserver(
+      forName: UIApplication.userDidTakeScreenshotNotification, object: nil, queue: .main
+    ) { [weak self] _ in self?.emit(3) })
+    observers.append(center.addObserver(
+      forName: UIScreen.capturedDidChangeNotification, object: nil, queue: .main
+    ) { [weak self] _ in self?.refreshRecording() })
+    for name in [UIApplication.willResignActiveNotification, UIApplication.didEnterBackgroundNotification] {
+      observers.append(center.addObserver(forName: name, object: nil, queue: .main) {
+        [weak self] _ in
+        self?.showSwitcher()
+      })
+    }
+    observers.append(center.addObserver(
+      forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
+    ) { [weak self] _ in
+      self?.removeSwitcherWindow()
+      self?.refreshRecording()
+    })
+    observers.append(center.addObserver(
+      forName: NSNotification.Name.RCTTriggerReloadCommand, object: nil, queue: .main
+    ) { [weak self] _ in self?.reset() })
+  }
+
+  private func stopObserversIfIdle() {
+    guard owners.isEmpty && listeners.isEmpty else { return }
+    for observer in observers { NotificationCenter.default.removeObserver(observer) }
+    observers.removeAll()
+  }
+
+  private func reset() {
+    owners.removeAll()
+    listeners.removeAll()
+    secureField?.isSecureTextEntry = false
+    removeRecordWindow()
+    removeSwitcherWindow()
+    stopObserversIfIdle()
+  }
+
+  private func refreshRecording() {
+    let captured = UIScreen.main.isCaptured
+    if captured != recording {
+      recording = captured
+      emit(captured ? 1 : 2)
+    }
+    if captured && !owners.isEmpty {
+      if recordWindow == nil { recordWindow = makeOverlay() }
+    } else {
+      removeRecordWindow()
+    }
+  }
+
+  private func secureScreenshot(window: UIWindow) throws {
+    if let secureField, protectedWindow === window {
+      secureField.isSecureTextEntry = true
+      return
+    }
+    let field = UITextField(frame: .zero)
+    field.isUserInteractionEnabled = false
+    field.isSecureTextEntry = true
+    field.layoutIfNeeded()
+    guard let canvas = field.layer.sublayers?.last else {
+      throw failure("The secure text layer is unavailable.")
+    }
+    // Keep the upstream secure-layer technique; no photo or file access is involved.
+    window.layer.superlayer?.addSublayer(field.layer)
+    canvas.addSublayer(window.layer)
+    secureField?.isSecureTextEntry = false
+    secureField = field
+    protectedWindow = window
+  }
+
+  private func makeOverlay() -> UIWindow? {
+    guard let protectedWindow = protectedWindow ?? window else { return nil }
+    let overlay: UIWindow
+    if let scene = protectedWindow.windowScene {
+      overlay = UIWindow(windowScene: scene)
+      overlay.frame = protectedWindow.frame
+    } else {
+      overlay = UIWindow(frame: protectedWindow.frame)
+    }
+    let controller = UIViewController()
+    controller.view.backgroundColor = .white
+    overlay.rootViewController = controller
+    overlay.windowLevel = .alert + 1
+    overlay.isHidden = false
+    return overlay
+  }
+
+  private func showSwitcher() {
+    guard !owners.isEmpty else { return }
+    if switcherWindow == nil { switcherWindow = makeOverlay() }
+  }
+
+  private func removeRecordWindow() {
+    recordWindow?.isHidden = true
+    recordWindow = nil
+  }
+
+  private func removeSwitcherWindow() {
+    switcherWindow?.isHidden = true
+    switcherWindow = nil
+  }
+
+  private func failure(_ message: String) -> NSError {
+    NSError(domain: "CaptureProtection", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+  }
+}

package/ios/tests/CaptureProtectionTests.swift

@@ -0,0 +1,50 @@
+import NitroModules
+import UIKit
+import XCTest
+@testable import ReactNativeCaptureProtection
+
+@MainActor
+final class CaptureProtectionTests: XCTestCase {
+  func testNativeSubscriptionsRemainScopedToTheirObjects() throws {
+    let first = ReactNativeCaptureProtection()
+    let second = ReactNativeCaptureProtection()
+    var firstEvents: [Double] = []
+    var secondEvents: [Double] = []
+    try first.setListener { firstEvents.append($0) }
+    try second.setListener { secondEvents.append($0) }
+    NotificationCenter.default.post(name: UIApplication.userDidTakeScreenshotNotification, object: nil)
+    XCTAssertEqual(firstEvents, [3])
+    XCTAssertEqual(secondEvents, [3])
+    try first.setListener(callback: nil)
+    NotificationCenter.default.post(name: UIApplication.userDidTakeScreenshotNotification, object: nil)
+    XCTAssertEqual(firstEvents, [3])
+    XCTAssertEqual(secondEvents, [3, 3])
+    try second.setListener(callback: nil)
+  }
+
+  func testDisposalStopsNativeEvents() async throws {
+    let instance = ReactNativeCaptureProtection()
+    var events: [Double] = []
+    try instance.setListener { events.append($0) }
+    instance.dispose()
+    // allow is queued after disposal and provides a deterministic UI-thread barrier.
+    try await instance.allow().await()
+    NotificationCenter.default.post(name: UIApplication.userDidTakeScreenshotNotification, object: nil)
+    XCTAssertTrue(events.isEmpty)
+  }
+
+  func testOneOwnerCannotReleaseAnotherOwnersSecureLayer() async throws {
+    let window = try XCTUnwrap(UIApplication.shared.delegate?.window ?? nil)
+    let first = ReactNativeCaptureProtection()
+    let second = ReactNativeCaptureProtection()
+    try await first.prevent().await()
+    try await second.prevent().await()
+    let field = window.layer.superlayer?.superlayer?.delegate as? UITextField
+    XCTAssertNotNil(field)
+    XCTAssertEqual(field?.isSecureTextEntry, true)
+    try await first.allow().await()
+    XCTAssertEqual(field?.isSecureTextEntry, true)
+    try await second.allow().await()
+    XCTAssertEqual(field?.isSecureTextEntry, false)
+  }
+}

package/lib/module/ReactNativeCaptureProtection.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeCaptureProtection.nitro.js.map

package/lib/module/ReactNativeCaptureProtection.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativeCaptureProtection.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+// Adapted from react-native-capture-protection 2.3.0; see LICENSE.upstream.
+export let CaptureEventType = /*#__PURE__*/function (CaptureEventType) {
+  CaptureEventType[CaptureEventType["NONE"] = 0] = "NONE";
+  CaptureEventType[CaptureEventType["RECORDING"] = 1] = "RECORDING";
+  CaptureEventType[CaptureEventType["END_RECORDING"] = 2] = "END_RECORDING";
+  CaptureEventType[CaptureEventType["CAPTURED"] = 3] = "CAPTURED";
+  CaptureEventType[CaptureEventType["APP_SWITCHING"] = 4] = "APP_SWITCHING";
+  CaptureEventType[CaptureEventType["UNKNOWN"] = 5] = "UNKNOWN";
+  CaptureEventType[CaptureEventType["ALLOW"] = 8] = "ALLOW";
+  CaptureEventType[CaptureEventType["PREVENT_SCREEN_CAPTURE"] = 16] = "PREVENT_SCREEN_CAPTURE";
+  CaptureEventType[CaptureEventType["PREVENT_SCREEN_RECORDING"] = 32] = "PREVENT_SCREEN_RECORDING";
+  CaptureEventType[CaptureEventType["PREVENT_SCREEN_APP_SWITCHING"] = 64] = "PREVENT_SCREEN_APP_SWITCHING";
+  return CaptureEventType;
+}({});
+let native;
+const subscribers = new Map();
+function getNative() {
+  native ??= NitroModules.createHybridObject('ReactNativeCaptureProtection');
+  return native;
+}
+export const CaptureProtection = {
+  prevent() {
+    return getNative().prevent();
+  },
+  allow() {
+    return getNative().allow();
+  },
+  addListener(callback) {
+    if (subscribers.size >= 128) {
+      throw new Error('Capture protection supports at most 128 subscribers.');
+    }
+    const id = Symbol();
+    subscribers.set(id, callback);
+    if (subscribers.size === 1) {
+      try {
+        getNative().setListener(event => {
+          // Read current subscriptions so queued events cannot reach removed callers.
+          for (const [key, listener] of Array.from(subscribers)) {
+            if (subscribers.has(key)) {
+              listener(event);
+            }
+          }
+        });
+      } catch (error) {
+        subscribers.delete(id);
+        throw error;
+      }
+    }
+    return {
+      remove() {
+        if (subscribers.delete(id) && subscribers.size === 0) {
+          getNative().setListener(undefined);
+        }
+      }
+    };
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","CaptureEventType","native","subscribers","Map","getNative","createHybridObject","CaptureProtection","prevent","allow","addListener","callback","size","Error","id","Symbol","set","setListener","event","key","listener","Array","from","has","error","delete","remove","undefined"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD;AACA,WAAYC,gBAAgB,0BAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAhBA,gBAAgB,CAAhBA,gBAAgB;EAAA,OAAhBA,gBAAgB;AAAA;AAc5B,IAAIC,MAAgD;AACpD,MAAMC,WAAW,GAAG,IAAIC,GAAG,CAA0B,CAAC;AAEtD,SAASC,SAASA,CAAA,EAAiC;EACjDH,MAAM,KAAKF,YAAY,CAACM,kBAAkB,CACxC,8BACF,CAAC;EACD,OAAOJ,MAAM;AACf;AAEA,OAAO,MAAMK,iBAAiB,GAAG;EAC/BC,OAAOA,CAAA,EAAkB;IACvB,OAAOH,SAAS,CAAC,CAAC,CAACG,OAAO,CAAC,CAAC;EAC9B,CAAC;EACDC,KAAKA,CAAA,EAAkB;IACrB,OAAOJ,SAAS,CAAC,CAAC,CAACI,KAAK,CAAC,CAAC;EAC5B,CAAC;EACDC,WAAWA,CAACC,QAAyB,EAAsB;IACzD,IAAIR,WAAW,CAACS,IAAI,IAAI,GAAG,EAAE;MAC3B,MAAM,IAAIC,KAAK,CAAC,sDAAsD,CAAC;IACzE;IACA,MAAMC,EAAE,GAAGC,MAAM,CAAC,CAAC;IACnBZ,WAAW,CAACa,GAAG,CAACF,EAAE,EAAEH,QAAQ,CAAC;IAC7B,IAAIR,WAAW,CAACS,IAAI,KAAK,CAAC,EAAE;MAC1B,IAAI;QACFP,SAAS,CAAC,CAAC,CAACY,WAAW,CAAEC,KAAK,IAAK;UACjC;UACA,KAAK,MAAM,CAACC,GAAG,EAAEC,QAAQ,CAAC,IAAIC,KAAK,CAACC,IAAI,CAACnB,WAAW,CAAC,EAAE;YACrD,IAAIA,WAAW,CAACoB,GAAG,CAACJ,GAAG,CAAC,EAAE;cACxBC,QAAQ,CAACF,KAAyB,CAAC;YACrC;UACF;QACF,CAAC,CAAC;MACJ,CAAC,CAAC,OAAOM,KAAK,EAAE;QACdrB,WAAW,CAACsB,MAAM,CAACX,EAAE,CAAC;QACtB,MAAMU,KAAK;MACb;IACF;IACA,OAAO;MACLE,MAAMA,CAAA,EAAG;QACP,IAAIvB,WAAW,CAACsB,MAAM,CAACX,EAAE,CAAC,IAAIX,WAAW,CAACS,IAAI,KAAK,CAAC,EAAE;UACpDP,SAAS,CAAC,CAAC,CAACY,WAAW,CAACU,SAAS,CAAC;QACpC;MACF;IACF,CAAC;EACH;AACF,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/ReactNativeCaptureProtection.nitro.d.ts

@@ -0,0 +1,10 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface ReactNativeCaptureProtection extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    prevent(): Promise<void>;
+    allow(): Promise<void>;
+    setListener(callback: ((event: number) => void) | undefined): void;
+}
+//# sourceMappingURL=ReactNativeCaptureProtection.nitro.d.ts.map

package/lib/typescript/src/ReactNativeCaptureProtection.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativeCaptureProtection.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativeCaptureProtection.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,4BACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;CACpE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,22 @@
+export declare enum CaptureEventType {
+    NONE = 0,
+    RECORDING = 1,
+    END_RECORDING = 2,
+    CAPTURED = 3,
+    APP_SWITCHING = 4,
+    UNKNOWN = 5,
+    ALLOW = 8,
+    PREVENT_SCREEN_CAPTURE = 16,
+    PREVENT_SCREEN_RECORDING = 32,
+    PREVENT_SCREEN_APP_SWITCHING = 64
+}
+type CaptureCallback = (event: CaptureEventType) => void;
+export declare const CaptureProtection: {
+    prevent(): Promise<void>;
+    allow(): Promise<void>;
+    addListener(callback: CaptureCallback): {
+        remove(): void;
+    };
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAIA,oBAAY,gBAAgB;IAC1B,IAAI,IAAI;IACR,SAAS,IAAI;IACb,aAAa,IAAI;IACjB,QAAQ,IAAI;IACZ,aAAa,IAAI;IACjB,OAAO,IAAI;IACX,KAAK,IAAI;IACT,sBAAsB,KAAK;IAC3B,wBAAwB,KAAK;IAC7B,4BAA4B,KAAK;CAClC;AAED,KAAK,eAAe,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAWzD,eAAO,MAAM,iBAAiB;eACjB,OAAO,CAAC,IAAI,CAAC;aAGf,OAAO,CAAC,IAAI,CAAC;0BAGA,eAAe,GAAG;QAAE,MAAM,IAAI,IAAI,CAAA;KAAE;CA6B3D,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["reactnativecaptureprotection"],
+  "ios": {
+    "iosModuleName": "ReactNativeCaptureProtection"
+  },
+  "android": {
+    "androidNamespace": ["reactnativecaptureprotection"],
+    "androidCxxLibName": "reactnativecaptureprotection"
+  },
+  "autolinking": {
+    "ReactNativeCaptureProtection": {
+      "swift": "ReactNativeCaptureProtection",
+      "kotlin": "ReactNativeCaptureProtection"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JFunc_void_double.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::reactnativecaptureprotection {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecaptureprotection/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double event) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* event */)>("invoke");
+      method(self(), event);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* event */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double event) {
+      _func(event);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativecaptureprotection/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativecaptureprotection