@octane-xplat/camera 0.13.0 → 0.15.0

package/platforms/macos/src/XplatPhotoCaptureSheet.swift

@@ -0,0 +1,192 @@
+import AppKit
+import AVFoundation
+
+/// App-owned still-photo UI. No microphone input, movie output or Photos writes.
+@objc(XplatPhotoCaptureSheet)
+public final class XplatPhotoCaptureSheet: NSObject, NSWindowDelegate {
+	private let host = XplatCameraHost()
+	private let lifecycle = PhotoCaptureLifecycle()
+	private var sheet: NSWindow?
+	private weak var parent: NSWindow?
+	private var reply: ((String?) -> Void)?
+	private var timeout: DispatchWorkItem?
+	private var closeObserver: NSObjectProtocol?
+	private var preview: NSView?
+	private var captureButton: NSButton?
+	private var statusLabel: NSTextField?
+	private var options: NSDictionary = [:]
+	private var disposed = false
+	var operationTimeout: TimeInterval = 15
+
+	@objc public func permissionStatus() -> NSString { host.permissionStatus("camera") }
+
+	@objc public func present(_ options: NSDictionary, reply: @escaping (String?) -> Void) {
+		guard let parent = NSApp.keyWindow ?? NSApp.mainWindow else { reply(nil); return }
+		presentOnWindow(parent, options: options, reply: reply)
+	}
+
+	// Explicit host window also allows deterministic AppKit lifecycle checks.
+	func presentOnWindow(_ parent: NSWindow, options: NSDictionary, reply: @escaping (String?) -> Void) {
+		guard !disposed, sheet == nil, parent.attachedSheet == nil,
+			!(options["saveToGallery"] as? Bool ?? false)
+		else { reply(nil); return }
+		self.options = options
+		self.reply = reply
+		self.parent = parent
+		let sheet = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 640, height: 480),
+			styleMask: [.titled, .closable], backing: .buffered, defer: false)
+		sheet.title = "Take a photo"
+		sheet.delegate = self
+		let content = NSView(frame: NSRect(x: 0, y: 0, width: 640, height: 480))
+		let preview = NSView(frame: NSRect(x: 16, y: 80, width: 608, height: 384))
+		preview.wantsLayer = true
+		preview.layer?.backgroundColor = NSColor.black.cgColor
+		content.addSubview(preview)
+		let status = NSTextField(labelWithString: "Choose Capture to start the camera.")
+		status.frame = NSRect(x: 16, y: 48, width: 440, height: 22)
+		content.addSubview(status)
+		let cancel = NSButton(title: "Cancel", target: self, action: #selector(cancelPhoto))
+		cancel.keyEquivalent = "\u{1b}"
+		cancel.frame = NSRect(x: 432, y: 12, width: 92, height: 32)
+		content.addSubview(cancel)
+		let capture = NSButton(title: "Capture", target: self, action: #selector(capturePhoto))
+		capture.keyEquivalent = "\r"
+		capture.frame = NSRect(x: 528, y: 12, width: 96, height: 32)
+		content.addSubview(capture)
+		sheet.contentView = content
+		self.sheet = sheet
+		self.preview = preview
+		statusLabel = status
+		captureButton = capture
+		closeObserver = NotificationCenter.default.addObserver(forName: NSWindow.willCloseNotification,
+			object: parent, queue: .main) { [weak self] _ in self?.complete(nil) }
+		parent.beginSheet(sheet) { [weak self] _ in self?.complete(nil) }
+	}
+
+	private func deadline(_ token: Int) {
+		timeout?.cancel()
+		let work = DispatchWorkItem { [weak self] in
+			guard let self, lifecycle.accepts(token) else { return }
+			complete(nil)
+		}
+		timeout = work
+		DispatchQueue.main.asyncAfter(deadline: .now() + operationTimeout, execute: work)
+	}
+
+	@objc private func capturePhoto() {
+		if let token = lifecycle.prepare() {
+			captureButton?.isEnabled = false
+			statusLabel?.stringValue = "Starting camera…"
+			deadline(token)
+			// Authorization happens only after the user presses Capture.
+			host.requestPermission("camera") { [weak self] status in
+				guard let self, lifecycle.accepts(token) else { return }
+				guard status == "granted" else { complete(nil); return }
+				DispatchQueue.global(qos: .userInitiated).async { [self] in
+					let failure = self.host.configure(["photo": true, "audio": false])
+					DispatchQueue.main.async { [self] in
+						guard self.lifecycle.accepts(token) else { return }
+						guard failure == nil, let preview = self.preview else { self.complete(nil); return }
+						self.host.installObserver { [weak self] message in
+							guard let self, lifecycle.accepts(token),
+								let data = message.data(using: .utf8),
+								let event = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+							else { return }
+							if event["type"] as? String == "previewReady", event["ready"] as? Bool == true,
+								lifecycle.ready(token) {
+								timeout?.cancel()
+								captureButton?.isEnabled = true
+								statusLabel?.stringValue = "Frame your photo, then choose Capture."
+							} else if event["type"] as? String == "interrupted" ||
+								(event["type"] as? String == "availability" && event["available"] as? Bool == false) {
+								complete(nil)
+							}
+						}
+						if self.host.attachPreview(preview) != nil { self.complete(nil) }
+					}
+				}
+			}
+			return
+		}
+		guard let token = lifecycle.capture() else { return }
+		captureButton?.isEnabled = false
+		statusLabel?.stringValue = "Taking photo…"
+		deadline(token)
+		if host.capturePhoto({ [weak self] data in
+			guard let self, lifecycle.accepts(token) else { return }
+			guard let data, let result = persist(data as Data) else { complete(nil); return }
+			complete(result)
+		}) != nil { complete(nil) }
+	}
+
+	private func persist(_ data: Data) -> String? {
+		guard let source = NSBitmapImageRep(data: data) else { return nil }
+		let width = (options["width"] as? NSNumber)?.doubleValue ?? Double(source.pixelsWide)
+		let height = (options["height"] as? NSNumber)?.doubleValue ?? Double(source.pixelsHigh)
+		guard width.isFinite, height.isFinite, width >= 1, height >= 1, width <= 16384, height <= 16384, width * height <= 64_000_000 else { return nil }
+		let keepAspectRatio = options["keepAspectRatio"] as? Bool ?? true
+		let scale = min(width / Double(source.pixelsWide), height / Double(source.pixelsHigh), 1)
+		let size = NSSize(width: keepAspectRatio ? Double(source.pixelsWide) * scale : width,
+			height: keepAspectRatio ? Double(source.pixelsHigh) * scale : height)
+		guard let bitmap = NSBitmapImageRep(bitmapDataPlanes: nil, pixelsWide: Int(size.width),
+			pixelsHigh: Int(size.height), bitsPerSample: 8, samplesPerPixel: 4, hasAlpha: true,
+			isPlanar: false, colorSpaceName: .deviceRGB, bytesPerRow: 0, bitsPerPixel: 0),
+			let context = NSGraphicsContext(bitmapImageRep: bitmap) else { return nil }
+		NSGraphicsContext.saveGraphicsState()
+		NSGraphicsContext.current = context
+		let image = NSImage(size: NSSize(width: source.pixelsWide, height: source.pixelsHigh))
+		image.addRepresentation(source)
+		image.draw(in: NSRect(origin: .zero, size: size))
+		NSGraphicsContext.restoreGraphicsState()
+		guard let jpeg = bitmap.representation(using: .jpeg, properties: [.compressionFactor: 0.9]) else { return nil }
+		let name = "octane-capture-\(UUID().uuidString).jpg"
+		let url = FileManager.default.temporaryDirectory.appendingPathComponent(name)
+		do {
+			let payload: [String: String] = ["name": name, "uri": url.path,
+				"dataUrl": "data:image/jpeg;base64," + jpeg.base64EncodedString()]
+			let message = try JSONSerialization.data(withJSONObject: payload)
+			try jpeg.write(to: url, options: .atomic)
+			return String(data: message, encoding: .utf8)
+		} catch {
+			try? FileManager.default.removeItem(at: url)
+			return nil
+		}
+	}
+
+	@objc private func cancelPhoto() { complete(nil) }
+	public func windowShouldClose(_ sender: NSWindow) -> Bool { complete(nil); return false }
+
+	private func complete(_ result: String?) {
+		guard lifecycle.finish() else { return }
+		let callback = reply
+		reply = nil
+		dispose()
+		callback?(result)
+	}
+
+	@objc public func discard(_ path: String) {
+		let url = URL(fileURLWithPath: path).standardizedFileURL
+		guard url.deletingLastPathComponent() == FileManager.default.temporaryDirectory.standardizedFileURL,
+			url.lastPathComponent.hasPrefix("octane-capture-") else { return }
+		try? FileManager.default.removeItem(at: url)
+	}
+
+	@objc public func dispose() {
+		guard !disposed else { return }
+		disposed = true
+		timeout?.cancel()
+		timeout = nil
+		if let closeObserver { NotificationCenter.default.removeObserver(closeObserver) }
+		closeObserver = nil
+		host.dispose()
+		if let sheet { parent?.endSheet(sheet); sheet.orderOut(nil) }
+		sheet = nil
+		preview = nil
+		captureButton = nil
+		statusLabel = nil
+		// Disposal is also a cancellation, including an external owner teardown.
+		if lifecycle.finish() { let callback = reply; reply = nil; callback?(nil) }
+	}
+
+	deinit { dispose() }
+}

package/src/CameraView.android.tsrx

@@ -4,9 +4,12 @@ import { Application, View } from '@nativescript/core'
 import { registerElement } from '@nativescript-community/octane'
 import type { Attributes } from '@nativescript-community/octane/intrinsics'
 import type { CameraViewProps } from './props'
+import { attachSessionPreview } from './session'
 import { cameraHardwarePresent, ensureCameraPermission } from './camera-permission.mobile'
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from './layout-child'
-import { cx } from './cx.mobile'
+import { observePreviewTap } from './preview-tap'
+import { java } from '@octane-xplat/platform/android'
+
 
 class CameraPreview extends View {
 	createNativeView() {
@@ -44,6 +47,25 @@ export function CameraView(props: CameraViewProps) @{
 		if (!active) return () => nativeView.setCameraActive(false)
 
 		const fail = (message: string) => props.onError?.({ message })
+		if (props.session) {
+			if (props.facing !== undefined) {
+				fail('camera session conflicts with facing')
+				return () => nativeView.setCameraActive(false)
+			}
+
+			try {
+				const detach = attachSessionPreview(props.session, nativeView, {
+					onReady: props.onReady,
+					onError: (issue) => fail(issue.message),
+				})
+
+				return () => { detach(); nativeView.setCameraActive(false) }
+			} catch (error: any) {
+				fail(error?.message ?? 'camera session error')
+				return () => nativeView.setCameraActive(false)
+			}
+		}
+
 		if (!cameraHardwarePresent()) {
 			fail('camera unsupported')
 			return () => nativeView.setCameraActive(false)
@@ -98,7 +120,7 @@ export function CameraView(props: CameraViewProps) @{
 				} catch {}
 			}
 		}
-	}, [active, facing])
+	}, [active, facing, props.session])
 
 	useEffect(() => {
 		const view = host.current
@@ -106,11 +128,13 @@ export function CameraView(props: CameraViewProps) @{
 		applyEscapeProps(view.android, props)
 	}, [props.ref, props.android])
 
+	useEffect(() => observePreviewTap(host.current, props.onTap), [props.onTap])
+
 	<gridlayout
 		id={props.id}
 		rows="*"
 		columns="*"
-		className={cx('vx-layers', 'vx-cameraview', props.className)}
+		className={['vx-layers', 'vx-cameraview', props.className]}
 		style={{ backgroundColor: '#000', ...props.style }}
 		{...layoutChildProps(props)}
 		accessible={props.accessible}

package/src/CameraView.ios.tsrx

@@ -3,10 +3,13 @@ import { useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
 import type { CameraViewProps } from './props'
 import { cameraHardwarePresent, ensureCameraPermission } from './camera-permission.mobile'
 import { startCameraPreview } from './camera-session.ios'
+import { attachSessionPreview } from './session'
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from './layout-child'
-import { cx } from './cx.mobile'
+import { observePreviewTap } from './preview-tap'
 
-/** Live iOS preview backed by AVFoundation. */
+/** Live iOS preview backed by AVFoundation. With `session`, the preview
+ *  attaches to the session-owned AVCaptureSession so movie recording can
+ *  share it; without one the view owns its session as before. */
 export function CameraView(props: CameraViewProps) @{
 	const host = useRef<any>(null)
 	const active = props.active !== false
@@ -24,6 +27,29 @@ export function CameraView(props: CameraViewProps) @{
 		let stopPreview: (() => void) | undefined
 		const fail = (message: string) => props.onError?.({ message })
 
+		if (props.session) {
+			if (props.facing !== undefined) {
+				fail('camera session conflicts with facing')
+				return
+			}
+
+			try {
+				const detach = attachSessionPreview(props.session, view, {
+					onReady: () => {
+						if (!disposed) props.onReady?.()
+					},
+				})
+
+				return () => {
+					disposed = true
+					detach()
+				}
+			} catch (error: any) {
+				fail(error?.message ?? 'camera session error')
+				return
+			}
+		}
+
 		if (!cameraHardwarePresent()) {
 			fail('camera unsupported')
 			return
@@ -47,7 +73,7 @@ export function CameraView(props: CameraViewProps) @{
 			disposed = true
 			stopPreview?.()
 		}
-	}, [active, facing])
+	}, [active, facing, props.session])
 
 	useEffect(() => {
 		const view = host.current
@@ -55,12 +81,14 @@ export function CameraView(props: CameraViewProps) @{
 		applyEscapeProps(view.ios ?? view.nativeViewProtected, props)
 	}, [props.ref, props.ios])
 
+	useEffect(() => observePreviewTap(host.current, props.onTap), [props.onTap])
+
 	<gridlayout
 		ref={bindHost}
 		id={props.id}
 		rows="*"
 		columns="*"
-		className={cx('vx-layers', 'vx-cameraview', props.className)}
+		className={['vx-layers', 'vx-cameraview', props.className]}
 		style={{ backgroundColor: '#000', ...props.style }}
 		{...layoutChildProps(props)}
 		accessible={props.accessible}

package/src/CameraView.macos.tsrx

@@ -0,0 +1,95 @@
+/** @jsxImportSource @octane-xplat/macos-renderer */
+import { useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
+import type { CameraViewProps } from './props'
+import { cameraHardwarePresent, ensureCameraPermission, startCameraPreview } from './camera-session.macos'
+import { attachSessionPreview } from './session'
+import { layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from './layout-child'
+import { observePreviewTap } from './preview-tap'
+
+/** Live AppKit preview backed by AVFoundation. With `session`, the preview
+ *  attaches to the session-owned AVCaptureSession so movie recording can
+ *  share it; without one the view owns its session as before. */
+export function CameraView(props: CameraViewProps) @{
+	const host = useRef<any>(null)
+	const active = props.active !== false
+	const facing = props.facing ?? 'back'
+	useImperativeHandle(props.ref, () => ({ native: host.current }), [])
+
+	const bindHost = useCallback((view: any) => {
+		host.current = view
+	}, [])
+
+	useEffect(() => {
+		const view = host.current
+		if (!view || !active) return
+		let disposed = false
+		let stopPreview: (() => void) | undefined
+		const fail = (message: string) => props.onError?.({ message })
+
+		if (props.session) {
+			if (props.facing !== undefined) {
+				fail('camera session conflicts with facing')
+				return
+			}
+
+			try {
+				const detach = attachSessionPreview(props.session, view, {
+					onReady: () => {
+						if (!disposed) props.onReady?.()
+					},
+				})
+
+				return () => {
+					disposed = true
+					detach()
+				}
+			} catch (error: any) {
+				fail(error?.message ?? 'camera session error')
+				return
+			}
+		}
+
+		if (!cameraHardwarePresent()) {
+			fail('camera unsupported')
+			return
+		}
+
+		ensureCameraPermission().then((granted) => {
+			if (disposed) return
+			if (!granted) {
+				fail('camera permission denied')
+				return
+			}
+
+			try {
+				stopPreview = startCameraPreview(view, facing, props.onReady)
+			} catch (error: any) {
+				fail(error?.message ?? 'camera error')
+			}
+		})
+
+		return () => {
+			disposed = true
+			stopPreview?.()
+		}
+	}, [active, facing, props.session])
+
+	useEffect(() => observePreviewTap(host.current, props.onTap), [props.onTap])
+
+	<gridlayout
+		ref={bindHost}
+		id={props.id}
+		rows="*"
+		columns="*"
+		className={['vx-layers', 'vx-cameraview', props.className]}
+		style={{ backgroundColor: '#000000', ...props.style }}
+		{...layoutChildProps(props)}
+		accessible={props.accessible}
+		accessibilityLabel={props.accessibilityLabel}
+		accessibilityRole={nativeAccessibilityRole(props.accessibilityRole) as any}
+		accessibilityHint={props.accessibilityHint}
+		accessibilityValue={props.accessibilityValue}
+		accessibilityState={nativeAccessibilityState(props.accessibilityState) as any}
+		accessibilityLiveRegion={props.accessibilityLiveRegion as any}
+	/>
+}

package/src/CameraView.web.tsrx

@@ -1,5 +1,6 @@
 import { useImperativeHandle, useEffect, useRef } from 'octane'
 import type { CameraViewProps } from './props'
+import { attachSessionPreview } from './session'
 import { applyEscapeProps, layoutChildProps } from './layout-child.web'
 
 /** Live web preview backed by getUserMedia. */
@@ -13,6 +14,23 @@ export function CameraView(props: CameraViewProps) @{
 	useEffect(() => {
 		const element = video.current
 		if (!element || !active) return
+		if (props.session) {
+			if (props.facing !== undefined) {
+				props.onError?.({ message: 'camera session conflicts with facing' })
+				return
+			}
+
+			try {
+				return attachSessionPreview(props.session, element, {
+					onReady: props.onReady,
+					onError: (issue) => props.onError?.({ message: issue.message }),
+				})
+			} catch (error: any) {
+				props.onError?.({ message: error?.message ?? 'camera session error' })
+				return
+			}
+		}
+
 		const mediaDevices = navigator.mediaDevices
 		if (!mediaDevices?.getUserMedia) {
 			props.onError?.({ message: 'camera unsupported' })
@@ -51,7 +69,7 @@ export function CameraView(props: CameraViewProps) @{
 			element.srcObject = null
 			if (stream) for (const track of stream.getTracks()) track.stop()
 		}
-	}, [active, facing])
+	}, [active, facing, props.session])
 
 	useImperativeHandle(props.ref, () => ({ native: hostRef.current }), undefined);
 
@@ -85,6 +103,17 @@ export function CameraView(props: CameraViewProps) @{
 				muted={true}
 				autoplay={true}
 				playsInline={true}
+				onClick={(event: MouseEvent) => {
+					const onTap = props.onTap
+					const target = event.currentTarget as HTMLElement | null
+					if (!onTap || !target) return
+					const rect = target.getBoundingClientRect()
+					if (!(rect.width > 0) || !(rect.height > 0)) return
+					onTap({
+						x: Math.min(1, Math.max(0, (event.clientX - rect.left) / rect.width)),
+						y: Math.min(1, Math.max(0, (event.clientY - rect.top) / rect.height)),
+					})
+				}}
 				style={{
 					display: 'block',
 					width: '100%',
@@ -93,7 +122,7 @@ export function CameraView(props: CameraViewProps) @{
 					transform: facing === 'front' ? 'scaleX(-1)' : undefined,
 				}}
 				onPlaying={() => {
-					if (readyFired.current) return
+					if (props.session || readyFired.current) return
 					readyFired.current = true
 					props.onReady?.()
 				}}

package/src/CameraView.windows.tsrx

@@ -0,0 +1,126 @@
+/** @jsxImportSource @nativescript-community/octane */
+import { useImperativeHandle, useCallback, useEffect, useRef } from 'octane'
+import { View } from '@nativescript/core'
+import { registerElement } from '@nativescript-community/octane'
+import type { Attributes } from '@nativescript-community/octane/intrinsics'
+import type { CameraViewProps } from './props'
+import { attachSessionPreview } from './session'
+import { cameraHardwarePresent, ensureCameraPermission } from './camera-permission.windows'
+import { startCameraPreview } from './camera-session.windows'
+import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from './layout-child.windows'
+import { observePreviewTap } from './preview-tap'
+
+class CameraPreview extends View {
+	createNativeView() {
+		const { Microsoft } = globalThis as any
+		return new Microsoft.UI.Xaml.Controls.CaptureElement()
+	}
+}
+
+declare module '@nativescript-community/octane/intrinsics' {
+	interface NativeScriptElements {
+		camerapreview: Attributes<typeof CameraPreview>
+	}
+}
+
+registerElement('camerapreview', CameraPreview)
+
+/** Live Windows preview backed by WinUI `CaptureElement` + `MediaCapture`.
+ *  With `session`, the preview attaches to the session-owned capture so
+ *  movie recording shares it; without one the view owns its capture. */
+export function CameraView(props: CameraViewProps) @{
+	const host = useRef<any>(null)
+	const active = props.active !== false
+	const facing = props.facing ?? 'back'
+	useImperativeHandle(props.ref, () => ({ native: host.current?.nativeViewProtected }), [])
+
+	const bindHost = useCallback((view: any) => {
+		host.current = view
+	}, [])
+
+	useEffect(() => {
+		const view = host.current
+		if (!view || !active) return
+		let disposed = false
+		let stopPreview: (() => Promise<void>) | undefined
+		const fail = (message: string) => props.onError?.({ message })
+
+		if (props.session) {
+			if (props.facing !== undefined) {
+				fail('camera session conflicts with facing')
+				return
+			}
+
+			try {
+				const detach = attachSessionPreview(props.session, view, {
+					onReady: () => {
+						if (!disposed) props.onReady?.()
+					},
+					onError: (issue) => {
+						if (!disposed) fail(issue.message)
+					},
+				})
+
+				return () => {
+					disposed = true
+					detach()
+				}
+			} catch (error: any) {
+				fail(error?.message ?? 'camera session error')
+				return
+			}
+		}
+
+		if (!cameraHardwarePresent()) {
+			fail('camera unsupported')
+			return
+		}
+
+		ensureCameraPermission().then(async (granted) => {
+			if (disposed) return
+			if (!granted) {
+				fail('camera permission denied')
+				return
+			}
+
+			try {
+				stopPreview = await startCameraPreview(view, facing, () => {
+					if (!disposed) props.onReady?.()
+				})
+			} catch (error: any) {
+				if (!disposed) fail(error?.message ?? 'camera error')
+			}
+		})
+
+		return () => {
+			disposed = true
+			void stopPreview?.()
+		}
+	}, [active, facing, props.session])
+
+	useEffect(() => {
+		const view = host.current
+		if (!view) return
+		applyEscapeProps(view.nativeViewProtected, props)
+	}, [props.ref, props.windows])
+
+	useEffect(() => observePreviewTap(host.current, props.onTap), [props.onTap])
+
+	<gridlayout
+		id={props.id}
+		rows="*"
+		columns="*"
+		className={['vx-layers', 'vx-cameraview', props.className]}
+		style={{ backgroundColor: '#000', ...props.style }}
+		{...layoutChildProps(props)}
+		accessible={props.accessible}
+		accessibilityLabel={props.accessibilityLabel}
+		accessibilityRole={nativeAccessibilityRole(props.accessibilityRole) as any}
+		accessibilityHint={props.accessibilityHint}
+		accessibilityValue={props.accessibilityValue}
+		accessibilityState={nativeAccessibilityState(props.accessibilityState) as any}
+		accessibilityLiveRegion={props.accessibilityLiveRegion as any}
+	>
+		<camerapreview ref={bindHost} row={0} col={0} />
+	</gridlayout>
+}

package/src/camera-permission.mobile.ts

@@ -1,4 +1,5 @@
 import { Application, isAndroid, isIOS } from '@nativescript/core'
+import { android } from '@octane-xplat/platform/android'
 
 let requestCode = 7719
 
@@ -54,19 +55,32 @@ export async function ensureCameraPermission(): Promise<boolean> {
 
 			return await new Promise<boolean>((resolve) => {
 				const currentRequest = requestCode++
+				const finish = (granted: boolean) => {
+					clearTimeout(timer)
+					Application.android.off(Application.android.activityRequestPermissionsEvent, onResult)
+
+					resolve(granted)
+				}
+
 				const onResult = (args: any) => {
 					if (args.requestCode !== currentRequest) {
 						return
 					}
 
-					Application.android.off(Application.android.activityRequestPermissionsEvent, onResult)
-
-					resolve(args.grantResults?.[0] === android.content.pm.PackageManager.PERMISSION_GRANTED)
+					finish(args.grantResults?.[0] === android.content.pm.PackageManager.PERMISSION_GRANTED)
 				}
 
+				// Same bound the session adapter uses — an activity destroyed or
+				// rotated before the result must not hang the caller or leak the
+				// listener.
+				const timer = setTimeout(() => finish(false), 120_000)
 				Application.android.on(Application.android.activityRequestPermissionsEvent, onResult)
 
-				activity.requestPermissions([permission], currentRequest)
+				try {
+					activity.requestPermissions([permission], currentRequest)
+				} catch {
+					finish(false)
+				}
 			})
 		}
 	} catch {