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

package/ACKNOWLEDGEMENTS.md

@@ -0,0 +1,18 @@
+# Acknowledgements
+
+This module is adapted from [react-native-capture-protection](https://github.com/wn-na/react-native-capture-protection)
+version **2.3.0**, authored by **lethe / wn-na**. Thank you for the upstream
+screenshot, recording and app-switcher protection implementation.
+
+The migration adapts the public event values, iOS secure-text-field layer
+technique and opaque protection windows, and Android FLAG_SECURE and virtual
+display detection approach. It replaces the React Native bridge with Nitro,
+scopes subscriptions by native owner, and removes media-library screenshot
+observation, storage permission requests, custom overlays, providers and hooks.
+OneKey's prior fixes for per-runtime listener ownership and private virtual
+display events are preserved in the adapted implementation.
+
+The upstream code is distributed under the MIT license. Its copyright and full
+license are retained in [LICENSE.upstream](LICENSE.upstream). The main [LICENSE](LICENSE)
+also retains the upstream copyright for CocoaPods acknowledgements. Both are included
+in published package contents. Adapted source files identify this notice.

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+Copyright (c) 2022 lethe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.upstream

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2022 lethe
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,26 @@
-# Temporary Holding Version
+# @onekeyfe/react-native-capture-protection
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Permission-minimal capture protection for OneKey iOS and Android.
+
+```ts
+import {
+  CaptureProtection,
+  CaptureEventType,
+} from '@onekeyfe/react-native-capture-protection';
+
+await CaptureProtection.prevent();
+const subscription = CaptureProtection.addListener((event) => {
+  if (event === CaptureEventType.CAPTURED) {
+    /* Show a warning. */
+  }
+});
+subscription.remove();
+await CaptureProtection.allow();
+```
+
+Only the application's existing prevent/allow/listener API is supported.
+No photo-library or filesystem permission is declared or requested.
+Android screenshot notifications require Android 14; older Android versions still
+block capture with FLAG_SECURE. iOS secure-layer behavior requires device testing.
+
+See [SPEC](docs/SPEC.md) and [Acknowledgements](ACKNOWLEDGEMENTS.md).

package/ReactNativeCaptureProtection.podspec

@@ -0,0 +1,37 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeCaptureProtection"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-capture-protection.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.exclude_files = "ios/tests/**/*"
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'ReactNativeNativeLogger'
+
+  load 'nitrogen/generated/ios/ReactNativeCaptureProtection+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+
+  s.test_spec "Tests" do |test_spec|
+    test_spec.source_files = "ios/tests/**/*.swift"
+    test_spec.requires_app_host = true
+  end
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativecaptureprotection)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativecaptureprotection)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativecaptureprotection+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,130 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeCaptureProtection_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativecaptureprotection+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeCaptureProtection_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.reactnativecaptureprotection"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+
+  implementation project(":onekeyfe_react-native-native-logger")
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+ReactNativeCaptureProtection_kotlinVersion=1.9.25
+ReactNativeCaptureProtection_compileSdkVersion=35
+ReactNativeCaptureProtection_targetSdkVersion=35
+ReactNativeCaptureProtection_minSdkVersion=24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.DETECT_SCREEN_CAPTURE" android:minSdkVersion="34" />
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "reactnativecaptureprotectionOnLoad.hpp"
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::reactnativecaptureprotection::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/reactnativecaptureprotection/ReactNativeCaptureProtection.kt

@@ -0,0 +1,285 @@
+// Adapted from react-native-capture-protection 2.3.0 by lethe; see LICENSE.upstream.
+package com.margelo.nitro.reactnativecaptureprotection
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.hardware.display.DisplayManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.Display
+import android.view.WindowManager
+import androidx.annotation.RequiresApi
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.ReactApplication
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import java.util.concurrent.FutureTask
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicLong
+
+@DoNotStrip
+class ReactNativeCaptureProtection : HybridReactNativeCaptureProtectionSpec() {
+  private val owner = nextOwner.incrementAndGet()
+  private var listener: ((Double) -> Unit)? = null
+
+  override fun prevent(): Promise<Unit> = onMain {
+    val context = NitroModules.applicationContext
+      ?: throw IllegalStateException("React context is unavailable.")
+    val app = context.applicationContext as Application
+    val activity = CaptureProtectionCoordinator.foregroundActivity(app)
+      ?: throw IllegalStateException("No foreground activity is available.")
+    CaptureProtectionCoordinator.prevent(owner, app, activity)
+  }
+
+  override fun allow(): Promise<Unit> = onMain {
+    CaptureProtectionCoordinator.allow(owner)
+  }
+
+  override fun setListener(callback: ((Double) -> Unit)?) {
+    mainSync {
+      if (callback == null) {
+        listener = null
+        CaptureProtectionCoordinator.unsubscribe(owner)
+      } else {
+        val context = NitroModules.applicationContext
+          ?: throw IllegalStateException("React context is unavailable.")
+        val weak = WeakReference(this)
+        val app = context.applicationContext as Application
+        CaptureProtectionCoordinator.subscribe(
+          owner, app, CaptureProtectionCoordinator.foregroundActivity(app)
+        ) { event -> weak.get()?.listener?.invoke(event) }
+        listener = callback
+        CaptureProtectionCoordinator.emitRecordingState(owner)
+      }
+    }
+  }
+
+  override fun dispose() {
+    release()
+    super.dispose()
+  }
+
+  @Suppress("unused")
+  protected fun finalize() {
+    release()
+  }
+
+  private fun release() {
+    mainHandler.post {
+      listener = null
+      CaptureProtectionCoordinator.unsubscribe(owner)
+      CaptureProtectionCoordinator.allow(owner)
+    }
+  }
+
+  private fun onMain(operation: () -> Unit): Promise<Unit> {
+    val promise = Promise<Unit>()
+    mainHandler.post {
+      try {
+        operation()
+        promise.resolve(Unit)
+      } catch (error: Exception) {
+        promise.reject(error)
+      }
+    }
+    return promise
+  }
+
+  private fun mainSync(operation: () -> Unit) {
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      operation()
+    } else {
+      val task = FutureTask(operation, Unit)
+      mainHandler.post(task)
+      try {
+        task.get(5, TimeUnit.SECONDS)
+      } finally {
+        task.cancel(false)
+      }
+    }
+  }
+
+  companion object {
+    private val nextOwner = AtomicLong()
+    private val mainHandler = Handler(Looper.getMainLooper())
+  }
+}
+
+private object CaptureProtectionCoordinator : Application.ActivityLifecycleCallbacks,
+  DisplayManager.DisplayListener {
+  private val handler = Handler(Looper.getMainLooper())
+  private val owners = mutableSetOf<Long>()
+  private val listeners = mutableMapOf<Long, (Double) -> Unit>()
+  private val originalFlags = WeakHashMap<Activity, Boolean>()
+  private val displays = mutableSetOf<Int>()
+  private var application: Application? = null
+  private var displayManager: DisplayManager? = null
+  private var currentActivity: WeakReference<Activity>? = null
+  private var callbackActivity: WeakReference<Activity>? = null
+  private var screenshotCallback: Any? = null
+
+  fun foregroundActivity(app: Application): Activity? {
+    // Nitro's global React context can belong to the background runtime.
+    // The application ReactHost is the UI host; lifecycle tracking survives recreation.
+    return (app as? ReactApplication)?.reactHost?.currentReactContext?.currentActivity
+      ?: currentActivity?.get()
+  }
+
+  private fun checkCapacity(owner: Long) {
+    val identities = owners + listeners.keys
+    check(owner in identities || identities.size < 32) {
+      "Capture protection supports at most 32 native owners."
+    }
+  }
+
+  fun prevent(owner: Long, app: Application, activity: Activity) {
+    checkCapacity(owner)
+    check(!activity.isFinishing && !activity.isDestroyed) { "Activity is unavailable." }
+    protect(activity)
+    owners.add(owner)
+    start(app, activity)
+  }
+
+  fun allow(owner: Long) {
+    owners.remove(owner)
+    if (owners.isEmpty()) {
+      for ((activity, wasSecure) in originalFlags.toMap()) {
+        if (!wasSecure) activity.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+      }
+      originalFlags.clear()
+    }
+    stopIfIdle()
+  }
+
+  fun subscribe(owner: Long, app: Application, activity: Activity?, callback: (Double) -> Unit) {
+    checkCapacity(owner)
+    listeners[owner] = callback
+    start(app, activity)
+  }
+
+  fun unsubscribe(owner: Long) {
+    listeners.remove(owner)
+    stopIfIdle()
+  }
+
+  fun emitRecordingState(owner: Long) {
+    if (displays.isNotEmpty()) listeners[owner]?.invoke(1.0)
+  }
+
+  private fun protect(activity: Activity) {
+    if (!originalFlags.containsKey(activity)) {
+      originalFlags[activity] = activity.window.attributes.flags and
+        WindowManager.LayoutParams.FLAG_SECURE != 0
+    }
+    activity.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+  }
+
+  private fun emit(event: Double) {
+    for ((owner, callback) in listeners.toMap()) {
+      if (listeners.containsKey(owner)) callback(event)
+    }
+  }
+
+  private fun start(app: Application, activity: Activity?) {
+    if (application == null) {
+      application = app
+      app.registerActivityLifecycleCallbacks(this)
+      displayManager = app.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+      displays.addAll(displayManager!!.displays.map { it.displayId }
+        .filter { it != Display.DEFAULT_DISPLAY })
+      displayManager!!.registerDisplayListener(this, handler)
+    }
+    if (activity != null) {
+      currentActivity = WeakReference(activity)
+      registerScreenshot(activity)
+    }
+  }
+
+  private fun stopIfIdle() {
+    if (owners.isNotEmpty() || listeners.isNotEmpty()) return
+    unregisterScreenshot()
+    displayManager?.unregisterDisplayListener(this)
+    application?.unregisterActivityLifecycleCallbacks(this)
+    displayManager = null
+    application = null
+    currentActivity = null
+    displays.clear()
+  }
+
+  private fun registerScreenshot(activity: Activity) {
+    if (Build.VERSION.SDK_INT < 34 || callbackActivity?.get() === activity) return
+    unregisterScreenshot()
+    try {
+      screenshotCallback = ScreenshotApi34.register(activity) { emit(3.0) }
+      callbackActivity = WeakReference(activity)
+    } catch (_: SecurityException) {
+      // A missing normal screenshot-detection permission must not remove protection.
+    }
+  }
+
+  private fun unregisterScreenshot() {
+    if (Build.VERSION.SDK_INT >= 34) {
+      val activity = callbackActivity?.get()
+      val callback = screenshotCallback
+      if (activity != null && callback != null) {
+        try {
+          ScreenshotApi34.unregister(activity, callback)
+        } catch (_: IllegalArgumentException) {
+          // The OS may have already disposed the activity's registration.
+        }
+      }
+    }
+    screenshotCallback = null
+    callbackActivity = null
+  }
+
+  override fun onActivityResumed(activity: Activity) {
+    currentActivity = WeakReference(activity)
+    if (owners.isNotEmpty()) protect(activity)
+    registerScreenshot(activity)
+  }
+
+  override fun onActivityPaused(activity: Activity) {
+    if (callbackActivity?.get() === activity) unregisterScreenshot()
+  }
+
+  override fun onActivityDestroyed(activity: Activity) {
+    if (callbackActivity?.get() === activity) unregisterScreenshot()
+    if (currentActivity?.get() === activity) currentActivity = null
+    originalFlags.remove(activity)
+  }
+
+  override fun onActivityCreated(activity: Activity, state: Bundle?) {}
+  override fun onActivityStarted(activity: Activity) {}
+  override fun onActivityStopped(activity: Activity) {}
+  override fun onActivitySaveInstanceState(activity: Activity, state: Bundle) {}
+
+  override fun onDisplayAdded(displayId: Int) {
+    // Private MediaProjection displays can be absent from getDisplay() here.
+    if (displayId != Display.DEFAULT_DISPLAY && displays.add(displayId)) emit(1.0)
+  }
+
+  override fun onDisplayRemoved(displayId: Int) {
+    if (displays.remove(displayId) && displays.isEmpty()) emit(2.0)
+  }
+
+  override fun onDisplayChanged(displayId: Int) {}
+}
+
+@RequiresApi(34)
+private object ScreenshotApi34 {
+  fun register(activity: Activity, onScreenshot: () -> Unit): Any {
+    val callback = Activity.ScreenCaptureCallback { onScreenshot() }
+    activity.registerScreenCaptureCallback(activity.mainExecutor, callback)
+    return callback
+  }
+
+  fun unregister(activity: Activity, callback: Any) {
+    activity.unregisterScreenCaptureCallback(callback as Activity.ScreenCaptureCallback)
+  }
+}

package/android/src/main/java/com/margelo/nitro/reactnativecaptureprotection/ReactNativeCaptureProtectionPackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.reactnativecaptureprotection
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativeCaptureProtectionPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("reactnativecaptureprotection")
+        }
+    }
+}