expo-screen-capture 5.7.0 → 5.8.0

package/CHANGELOG.md

@@ -10,6 +10,12 @@
 
 ### 💡 Others
 
+## 5.8.0 — 2023-12-15
+
+### 🎉 New features
+
+- Added `getPermissionsAsync` and `requestPermissionsAsync` methods. ([#25849](https://github.com/expo/expo/pull/25849) by [@behenate](https://github.com/behenate))
+
 ## 5.7.0 — 2023-11-14
 
 ### 🛠 Breaking changes

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '5.7.0'
+version = '5.8.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -94,7 +94,7 @@ android {
   namespace "expo.modules.screencapture"
   defaultConfig {
     versionCode 7
-    versionName '5.7.0'
+    versionName '5.8.0'
   }
 }
 

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,4 @@
-<manifest>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.READ_MEDIA_IMAGES"/>
 </manifest>

package/android/src/main/java/expo/modules/screencapture/ScreenCaptureModule.kt

@@ -1,7 +1,11 @@
 package expo.modules.screencapture
 
+import android.Manifest
 import android.content.Context
+import android.os.Build
 import android.view.WindowManager
+import expo.modules.interfaces.permissions.Permissions
+import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.functions.Queues
 import expo.modules.kotlin.modules.Module
@@ -20,6 +24,22 @@ class ScreenCaptureModule : Module() {
       ScreenshotEventEmitter(context, appContext.legacyModuleRegistry)
     }
 
+    AsyncFunction("getPermissionsAsync") { promise: Promise ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        Permissions.getPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.READ_MEDIA_IMAGES)
+      } else {
+        Permissions.getPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.READ_EXTERNAL_STORAGE)
+      }
+    }
+
+    AsyncFunction("requestPermissionsAsync") { promise: Promise ->
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        Permissions.askForPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.READ_MEDIA_IMAGES)
+      } else {
+        Permissions.askForPermissionsWithPermissionsManager(appContext.permissions, promise, Manifest.permission.READ_EXTERNAL_STORAGE)
+      }
+    }
+
     AsyncFunction("preventScreenCapture") {
       currentActivity.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
     }.runOnQueue(Queues.MAIN)

package/android/src/main/java/expo/modules/screencapture/ScreenShotEventEmitter.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.content.pm.PackageManager
 import android.database.ContentObserver
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
@@ -35,7 +36,7 @@ class ScreenshotEventEmitter(val context: Context, moduleRegistry: ModuleRegistr
       override fun onChange(selfChange: Boolean, uri: Uri?) {
         super.onChange(selfChange, uri)
         if (isListening) {
-          if (!hasReadExternalStoragePermission(context)) {
+          if (!hasPermissions(context)) {
             Log.e("expo-screen-capture", "Could not listen for screenshots, do not have READ_EXTERNAL_STORAGE permission.")
             return
           }
@@ -62,7 +63,12 @@ class ScreenshotEventEmitter(val context: Context, moduleRegistry: ModuleRegistr
     // Do nothing
   }
 
-  private fun hasReadExternalStoragePermission(context: Context): Boolean {
+  private fun hasPermissions(context: Context): Boolean {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      return ContextCompat.checkSelfPermission(context, permission.DETECT_SCREEN_CAPTURE) == PackageManager.PERMISSION_GRANTED
+    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      return ContextCompat.checkSelfPermission(context, permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED
+    }
     return ContextCompat.checkSelfPermission(context, permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
   }
 
@@ -86,7 +92,8 @@ class ScreenshotEventEmitter(val context: Context, moduleRegistry: ModuleRegistr
   }
 
   private fun isPathOfNewScreenshot(path: String): Boolean {
-    if (!path.lowercase().contains("screenshot")) {
+    // Ignore paths that are not screenshots and pending screenshots
+    if (!path.lowercase().contains("screenshot") || path.lowercase().contains(".pending")) {
       return false
     }
     // Cannot check that the onChange event is for an insert operation until API level 30

package/build/ScreenCapture.d.ts

@@ -1,4 +1,4 @@
-import { Subscription } from 'expo-modules-core';
+import { Subscription, PermissionResponse, PermissionStatus, PermissionHookOptions } from 'expo-modules-core';
 /**
  * Returns whether the Screen Capture API is available on the current device.
  *
@@ -68,5 +68,27 @@ export declare function addScreenshotListener(listener: () => void): Subscriptio
  * @param subscription Subscription returned by `addScreenshotListener`.
  */
 export declare function removeScreenshotListener(subscription: Subscription): void;
-export { Subscription };
+/**
+ * Checks user's permissions for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ */
+export declare function getPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Asks the user to grant permissions necessary for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ * */
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Check or request permissions necessary for detecting when a screenshot is taken.
+ * This uses both [`requestPermissionsAsync`](#screencapturerequestpermissionsasync) and [`getPermissionsAsync`](#screencapturegetpermissionsasync) to interact with the permissions.
+ *
+ * @example
+ * ```js
+ * const [status, requestPermission] = ScreenCapture.useScreenCapturePermissions();
+ * ```
+ */
+export declare const usePermissions: (options?: PermissionHookOptions<object> | undefined) => [PermissionResponse | null, () => Promise<PermissionResponse>, () => Promise<PermissionResponse>];
+export { Subscription, PermissionResponse, PermissionStatus, PermissionHookOptions };
 //# sourceMappingURL=ScreenCapture.d.ts.map

package/build/ScreenCapture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenCapture.d.ts","sourceRoot":"","sources":["../src/ScreenCapture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAuB,MAAM,mBAAmB,CAAC;AAWpF;;;;;GAKG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAEzD;AAGD;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAAC,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAStF;AAGD;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CASpF;AAGD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAE,MAAkB,GAAG,IAAI,CAQrE;AAGD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,YAAY,CAExE;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,QAElE;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"ScreenCapture.d.ts","sourceRoot":"","sources":["../src/ScreenCapture.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAEZ,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAW3B;;;;;GAKG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC,CAEzD;AAGD;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAAC,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAStF;AAGD;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CASpF;AAGD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAE,MAAkB,GAAG,IAAI,CAQrE;AAGD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,YAAY,CAExE;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,QAElE;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAKvE;AAED;;;;KAIK;AACL,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAK3E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,4JAGzB,CAAC;AASH,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,CAAC"}

package/build/ScreenCapture.js

@@ -1,4 +1,4 @@
-import { EventEmitter, UnavailabilityError } from 'expo-modules-core';
+import { EventEmitter, UnavailabilityError, PermissionStatus, createPermissionHook, } from 'expo-modules-core';
 import { useEffect } from 'react';
 import ExpoScreenCapture from './ExpoScreenCapture';
 const activeTags = new Set();
@@ -108,4 +108,46 @@ export function addScreenshotListener(listener) {
 export function removeScreenshotListener(subscription) {
     emitter.removeSubscription(subscription);
 }
+/**
+ * Checks user's permissions for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ */
+export async function getPermissionsAsync() {
+    if (ExpoScreenCapture.getPermissionsAsync) {
+        return ExpoScreenCapture.getPermissionsAsync();
+    }
+    return defaultPermissionsResponse;
+}
+/**
+ * Asks the user to grant permissions necessary for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ * */
+export async function requestPermissionsAsync() {
+    if (ExpoScreenCapture.requestPermissionsAsync) {
+        return ExpoScreenCapture.requestPermissionsAsync();
+    }
+    return defaultPermissionsResponse;
+}
+/**
+ * Check or request permissions necessary for detecting when a screenshot is taken.
+ * This uses both [`requestPermissionsAsync`](#screencapturerequestpermissionsasync) and [`getPermissionsAsync`](#screencapturegetpermissionsasync) to interact with the permissions.
+ *
+ * @example
+ * ```js
+ * const [status, requestPermission] = ScreenCapture.useScreenCapturePermissions();
+ * ```
+ */
+export const usePermissions = createPermissionHook({
+    getMethod: getPermissionsAsync,
+    requestMethod: requestPermissionsAsync,
+});
+const defaultPermissionsResponse = {
+    granted: true,
+    expires: 'never',
+    canAskAgain: true,
+    status: PermissionStatus.GRANTED,
+};
+export { PermissionStatus };
 //# sourceMappingURL=ScreenCapture.js.map

package/build/ScreenCapture.js.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenCapture.js","sourceRoot":"","sources":["../src/ScreenCapture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAgB,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AAEpD,MAAM,UAAU,GAAgB,IAAI,GAAG,EAAE,CAAC;AAC1C,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,iBAAiB,CAAC,CAAC;AAEpD,MAAM,qBAAqB,GAAG,cAAc,CAAC;AAE7C,cAAc;AACd;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,CAAC,CAAC,iBAAiB,CAAC,oBAAoB,IAAI,CAAC,CAAC,iBAAiB,CAAC,kBAAkB,CAAC;AAC5F,CAAC;AAED,cAAc;AACd;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAAC,MAAc,SAAS;IACrE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,EAAE;QAC3C,MAAM,IAAI,mBAAmB,CAAC,eAAe,EAAE,2BAA2B,CAAC,CAAC;KAC7E;IAED,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QACxB,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,iBAAiB,CAAC,oBAAoB,EAAE,CAAC;KAChD;AACH,CAAC;AAED,cAAc;AACd;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,MAAc,SAAS;IACnE,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,EAAE;QAC3C,MAAM,IAAI,mBAAmB,CAAC,eAAe,EAAE,yBAAyB,CAAC,CAAC;KAC3E;IAED,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACvB,IAAI,UAAU,CAAC,IAAI,KAAK,CAAC,EAAE;QACzB,MAAM,iBAAiB,CAAC,kBAAkB,EAAE,CAAC;KAC9C;AACH,CAAC;AAED,cAAc;AACd;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CAAC,MAAc,SAAS;IAC7D,SAAS,CAAC,GAAG,EAAE;QACb,yBAAyB,CAAC,GAAG,CAAC,CAAC;QAE/B,OAAO,GAAG,EAAE;YACV,uBAAuB,CAAC,GAAG,CAAC,CAAC;QAC/B,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACZ,CAAC;AAED,cAAc;AACd;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAoB;IACxD,OAAO,OAAO,CAAC,WAAW,CAAO,qBAAqB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC;AAED,cAAc;AACd;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,wBAAwB,CAAC,YAA0B;IACjE,OAAO,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;AAC3C,CAAC","sourcesContent":["import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-core';\nimport { useEffect } from 'react';\n\nimport ExpoScreenCapture from './ExpoScreenCapture';\n\nconst activeTags: Set<string> = new Set();\nconst emitter = new EventEmitter(ExpoScreenCapture);\n\nconst onScreenshotEventName = 'onScreenshot';\n\n// @needsAudit\n/**\n * Returns whether the Screen Capture API is available on the current device.\n *\n * @returns A promise that resolves to a `boolean` indicating whether the Screen Capture API is available on the current\n * device. Currently, this resolves to `true` on Android and iOS only.\n */\nexport async function isAvailableAsync(): Promise<boolean> {\n  return !!ExpoScreenCapture.preventScreenCapture && !!ExpoScreenCapture.allowScreenCapture;\n}\n\n// @needsAudit\n/**\n * Prevents screenshots and screen recordings until `allowScreenCaptureAsync` is called or the app is restarted. If you are\n * already preventing screen capture, this method does nothing (unless you pass a new and unique `key`).\n *\n * > Please note that on iOS, this will only prevent screen recordings, and is only available on\n * iOS 11 and newer. On older iOS versions, this method does nothing.\n *\n * @param key Optional. If provided, this will help prevent multiple instances of the `preventScreenCaptureAsync`\n * and `allowScreenCaptureAsync` methods (and `usePreventScreenCapture` hook) from conflicting with each other.\n * When using multiple keys, you'll have to re-allow each one in order to re-enable screen capturing.\n * Defaults to `'default'`.\n */\nexport async function preventScreenCaptureAsync(key: string = 'default'): Promise<void> {\n  if (!ExpoScreenCapture.preventScreenCapture) {\n    throw new UnavailabilityError('ScreenCapture', 'preventScreenCaptureAsync');\n  }\n\n  if (!activeTags.has(key)) {\n    activeTags.add(key);\n    await ExpoScreenCapture.preventScreenCapture();\n  }\n}\n\n// @needsAudit\n/**\n * Re-allows the user to screen record or screenshot your app. If you haven't called\n * `preventScreenCapture()` yet, this method does nothing.\n *\n * @param key This will prevent multiple instances of the `preventScreenCaptureAsync` and\n * `allowScreenCaptureAsync` methods from conflicting with each other. If provided, the value must\n * be the same as the key passed to `preventScreenCaptureAsync` in order to re-enable screen\n * capturing. Defaults to 'default'.\n */\nexport async function allowScreenCaptureAsync(key: string = 'default'): Promise<void> {\n  if (!ExpoScreenCapture.preventScreenCapture) {\n    throw new UnavailabilityError('ScreenCapture', 'allowScreenCaptureAsync');\n  }\n\n  activeTags.delete(key);\n  if (activeTags.size === 0) {\n    await ExpoScreenCapture.allowScreenCapture();\n  }\n}\n\n// @needsAudit\n/**\n * A React hook to prevent screen capturing for as long as the owner component is mounted.\n *\n * @param key. If provided, this will prevent multiple instances of this hook or the\n * `preventScreenCaptureAsync` and `allowScreenCaptureAsync` methods from conflicting with each other.\n * This argument is useful if you have multiple active components using the `allowScreenCaptureAsync`\n * hook. Defaults to `'default'`.\n */\nexport function usePreventScreenCapture(key: string = 'default'): void {\n  useEffect(() => {\n    preventScreenCaptureAsync(key);\n\n    return () => {\n      allowScreenCaptureAsync(key);\n    };\n  }, [key]);\n}\n\n// @needsAudit\n/**\n * Adds a listener that will fire whenever the user takes a screenshot while the app is foregrounded.\n * On Android, this method requires the `READ_EXTERNAL_STORAGE` permission. You can request this\n * with [`MediaLibrary.requestPermissionsAsync()`](./media-library/#medialibraryrequestpermissionsasync).\n *\n * @param listener The function that will be executed when the user takes a screenshot.\n * This function accepts no arguments.\n *\n * @return A `Subscription` object that you can use to unregister the listener, either by calling\n * `remove()` or passing it to `removeScreenshotListener`.\n */\nexport function addScreenshotListener(listener: () => void): Subscription {\n  return emitter.addListener<void>(onScreenshotEventName, listener);\n}\n\n// @needsAudit\n/**\n * Removes the subscription you provide, so that you are no longer listening for screenshots.\n *\n * If you prefer, you can also call `remove()` on that `Subscription` object, for example:\n *\n * ```ts\n * let mySubscription = addScreenshotListener(() => {\n *   console.log(\"You took a screenshot!\");\n * });\n * ...\n * mySubscription.remove();\n * // OR\n * removeScreenshotListener(mySubscription);\n * ```\n *\n * @param subscription Subscription returned by `addScreenshotListener`.\n */\nexport function removeScreenshotListener(subscription: Subscription) {\n  emitter.removeSubscription(subscription);\n}\n\nexport { Subscription };\n"]}
+{"version":3,"file":"ScreenCapture.js","sourceRoot":"","sources":["../src/ScreenCapture.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EventEmitter,\n  Subscription,\n  UnavailabilityError,\n  PermissionResponse,\n  PermissionStatus,\n  createPermissionHook,\n  PermissionHookOptions,\n} from 'expo-modules-core';\nimport { useEffect } from 'react';\n\nimport ExpoScreenCapture from './ExpoScreenCapture';\n\nconst activeTags: Set<string> = new Set();\nconst emitter = new EventEmitter(ExpoScreenCapture);\n\nconst onScreenshotEventName = 'onScreenshot';\n\n// @needsAudit\n/**\n * Returns whether the Screen Capture API is available on the current device.\n *\n * @returns A promise that resolves to a `boolean` indicating whether the Screen Capture API is available on the current\n * device. Currently, this resolves to `true` on Android and iOS only.\n */\nexport async function isAvailableAsync(): Promise<boolean> {\n  return !!ExpoScreenCapture.preventScreenCapture && !!ExpoScreenCapture.allowScreenCapture;\n}\n\n// @needsAudit\n/**\n * Prevents screenshots and screen recordings until `allowScreenCaptureAsync` is called or the app is restarted. If you are\n * already preventing screen capture, this method does nothing (unless you pass a new and unique `key`).\n *\n * > Please note that on iOS, this will only prevent screen recordings, and is only available on\n * iOS 11 and newer. On older iOS versions, this method does nothing.\n *\n * @param key Optional. If provided, this will help prevent multiple instances of the `preventScreenCaptureAsync`\n * and `allowScreenCaptureAsync` methods (and `usePreventScreenCapture` hook) from conflicting with each other.\n * When using multiple keys, you'll have to re-allow each one in order to re-enable screen capturing.\n * Defaults to `'default'`.\n */\nexport async function preventScreenCaptureAsync(key: string = 'default'): Promise<void> {\n  if (!ExpoScreenCapture.preventScreenCapture) {\n    throw new UnavailabilityError('ScreenCapture', 'preventScreenCaptureAsync');\n  }\n\n  if (!activeTags.has(key)) {\n    activeTags.add(key);\n    await ExpoScreenCapture.preventScreenCapture();\n  }\n}\n\n// @needsAudit\n/**\n * Re-allows the user to screen record or screenshot your app. If you haven't called\n * `preventScreenCapture()` yet, this method does nothing.\n *\n * @param key This will prevent multiple instances of the `preventScreenCaptureAsync` and\n * `allowScreenCaptureAsync` methods from conflicting with each other. If provided, the value must\n * be the same as the key passed to `preventScreenCaptureAsync` in order to re-enable screen\n * capturing. Defaults to 'default'.\n */\nexport async function allowScreenCaptureAsync(key: string = 'default'): Promise<void> {\n  if (!ExpoScreenCapture.preventScreenCapture) {\n    throw new UnavailabilityError('ScreenCapture', 'allowScreenCaptureAsync');\n  }\n\n  activeTags.delete(key);\n  if (activeTags.size === 0) {\n    await ExpoScreenCapture.allowScreenCapture();\n  }\n}\n\n// @needsAudit\n/**\n * A React hook to prevent screen capturing for as long as the owner component is mounted.\n *\n * @param key. If provided, this will prevent multiple instances of this hook or the\n * `preventScreenCaptureAsync` and `allowScreenCaptureAsync` methods from conflicting with each other.\n * This argument is useful if you have multiple active components using the `allowScreenCaptureAsync`\n * hook. Defaults to `'default'`.\n */\nexport function usePreventScreenCapture(key: string = 'default'): void {\n  useEffect(() => {\n    preventScreenCaptureAsync(key);\n\n    return () => {\n      allowScreenCaptureAsync(key);\n    };\n  }, [key]);\n}\n\n// @needsAudit\n/**\n * Adds a listener that will fire whenever the user takes a screenshot while the app is foregrounded.\n * On Android, this method requires the `READ_EXTERNAL_STORAGE` permission. You can request this\n * with [`MediaLibrary.requestPermissionsAsync()`](./media-library/#medialibraryrequestpermissionsasync).\n *\n * @param listener The function that will be executed when the user takes a screenshot.\n * This function accepts no arguments.\n *\n * @return A `Subscription` object that you can use to unregister the listener, either by calling\n * `remove()` or passing it to `removeScreenshotListener`.\n */\nexport function addScreenshotListener(listener: () => void): Subscription {\n  return emitter.addListener<void>(onScreenshotEventName, listener);\n}\n\n// @needsAudit\n/**\n * Removes the subscription you provide, so that you are no longer listening for screenshots.\n *\n * If you prefer, you can also call `remove()` on that `Subscription` object, for example:\n *\n * ```ts\n * let mySubscription = addScreenshotListener(() => {\n *   console.log(\"You took a screenshot!\");\n * });\n * ...\n * mySubscription.remove();\n * // OR\n * removeScreenshotListener(mySubscription);\n * ```\n *\n * @param subscription Subscription returned by `addScreenshotListener`.\n */\nexport function removeScreenshotListener(subscription: Subscription) {\n  emitter.removeSubscription(subscription);\n}\n\n/**\n * Checks user's permissions for detecting when a screenshot is taken.\n * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.\n * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.\n */\nexport async function getPermissionsAsync(): Promise<PermissionResponse> {\n  if (ExpoScreenCapture.getPermissionsAsync) {\n    return ExpoScreenCapture.getPermissionsAsync();\n  }\n  return defaultPermissionsResponse;\n}\n\n/**\n * Asks the user to grant permissions necessary for detecting when a screenshot is taken.\n * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.\n * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.\n * */\nexport async function requestPermissionsAsync(): Promise<PermissionResponse> {\n  if (ExpoScreenCapture.requestPermissionsAsync) {\n    return ExpoScreenCapture.requestPermissionsAsync();\n  }\n  return defaultPermissionsResponse;\n}\n\n/**\n * Check or request permissions necessary for detecting when a screenshot is taken.\n * This uses both [`requestPermissionsAsync`](#screencapturerequestpermissionsasync) and [`getPermissionsAsync`](#screencapturegetpermissionsasync) to interact with the permissions.\n *\n * @example\n * ```js\n * const [status, requestPermission] = ScreenCapture.useScreenCapturePermissions();\n * ```\n */\nexport const usePermissions = createPermissionHook({\n  getMethod: getPermissionsAsync,\n  requestMethod: requestPermissionsAsync,\n});\n\nconst defaultPermissionsResponse: PermissionResponse = {\n  granted: true,\n  expires: 'never',\n  canAskAgain: true,\n  status: PermissionStatus.GRANTED,\n};\n\nexport { Subscription, PermissionResponse, PermissionStatus, PermissionHookOptions };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-screen-capture",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "description": "ExpoScreenCapture standalone module",
   "main": "build/ScreenCapture.js",
   "types": "build/ScreenCapture.d.ts",
@@ -39,5 +39,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "3142a086578deffd8704a8f1b6f0f661527d836c"
+  "gitHead": "1a7c4e8ffed182e00cf1cf654ca2401441a7377a"
 }

package/src/ScreenCapture.ts

@@ -1,4 +1,12 @@
-import { EventEmitter, Subscription, UnavailabilityError } from 'expo-modules-core';
+import {
+  EventEmitter,
+  Subscription,
+  UnavailabilityError,
+  PermissionResponse,
+  PermissionStatus,
+  createPermissionHook,
+  PermissionHookOptions,
+} from 'expo-modules-core';
 import { useEffect } from 'react';
 
 import ExpoScreenCapture from './ExpoScreenCapture';
@@ -121,4 +129,49 @@ export function removeScreenshotListener(subscription: Subscription) {
   emitter.removeSubscription(subscription);
 }
 
-export { Subscription };
+/**
+ * Checks user's permissions for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ */
+export async function getPermissionsAsync(): Promise<PermissionResponse> {
+  if (ExpoScreenCapture.getPermissionsAsync) {
+    return ExpoScreenCapture.getPermissionsAsync();
+  }
+  return defaultPermissionsResponse;
+}
+
+/**
+ * Asks the user to grant permissions necessary for detecting when a screenshot is taken.
+ * > Only Android requires additional permissions to detect screenshots. On iOS devices, this method will always resolve to a `granted` permission response.
+ * @return A promise that resolves to a [PermissionResponse](#permissionresponse) object.
+ * */
+export async function requestPermissionsAsync(): Promise<PermissionResponse> {
+  if (ExpoScreenCapture.requestPermissionsAsync) {
+    return ExpoScreenCapture.requestPermissionsAsync();
+  }
+  return defaultPermissionsResponse;
+}
+
+/**
+ * Check or request permissions necessary for detecting when a screenshot is taken.
+ * This uses both [`requestPermissionsAsync`](#screencapturerequestpermissionsasync) and [`getPermissionsAsync`](#screencapturegetpermissionsasync) to interact with the permissions.
+ *
+ * @example
+ * ```js
+ * const [status, requestPermission] = ScreenCapture.useScreenCapturePermissions();
+ * ```
+ */
+export const usePermissions = createPermissionHook({
+  getMethod: getPermissionsAsync,
+  requestMethod: requestPermissionsAsync,
+});
+
+const defaultPermissionsResponse: PermissionResponse = {
+  granted: true,
+  expires: 'never',
+  canAskAgain: true,
+  status: PermissionStatus.GRANTED,
+};
+
+export { Subscription, PermissionResponse, PermissionStatus, PermissionHookOptions };