@octane-xplat/camera 0.0.0-nightly.g2e22171

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

@@ -0,0 +1,91 @@
+import { Application, isAndroid, isIOS } from '@nativescript/core'
+import { android } from '@octane-xplat/platform/android'
+
+let requestCode = 7719
+
+export function cameraHardwarePresent(): boolean {
+	if (isIOS) {
+		return typeof (globalThis as any).AVCaptureDevice !== 'undefined'
+	}
+
+	if (!isAndroid) {
+		return false
+	}
+
+	try {
+		const context = Application.android?.context ?? Application.android?.startActivity
+		return context?.getPackageManager()?.hasSystemFeature('android.hardware.camera.any') !== false
+	} catch {
+		return true
+	}
+}
+
+export async function ensureCameraPermission(): Promise<boolean> {
+	try {
+		if (isIOS) {
+			const av = (globalThis as any).AVCaptureDevice
+			const mediaType = (globalThis as any).AVMediaTypeVideo ?? 'vide'
+			const status = av?.authorizationStatusForMediaType?.(mediaType)
+			if (status === 3) {
+				return true
+			}
+
+			if (status === 1 || status === 2) {
+				return false
+			}
+
+			return await new Promise<boolean>((resolve) =>
+				av.requestAccessForMediaTypeCompletionHandler(mediaType, resolve),
+			)
+		}
+
+		if (isAndroid) {
+			const permission = 'android.permission.CAMERA'
+			const activity = Application.android.foregroundActivity ?? Application.android.startActivity
+			if (
+				activity?.checkSelfPermission?.(permission) ===
+				android.content.pm.PackageManager.PERMISSION_GRANTED
+			) {
+				return true
+			}
+
+			if (!activity) {
+				return false
+			}
+
+			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
+					}
+
+					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)
+
+				try {
+					activity.requestPermissions([permission], currentRequest)
+				} catch {
+					finish(false)
+				}
+			})
+		}
+	} catch {
+		return false
+	}
+
+	return false
+}

package/src/camera-permission.windows.ts

@@ -0,0 +1,76 @@
+/** Windows camera-permission probe for preview-only `CameraView` callers.
+ *  Uses `AppCapability` when projected and falls back to
+ *  `DeviceAccessInformation`; both are non-prompting checks — only
+ *  `RequestAccessAsync` may show the system prompt. */
+
+const windows = () => globalThis as any
+
+const toPromise = (op: any): Promise<any> => {
+	const { NSWinRT } = windows()
+	if (NSWinRT?.toPromise && op != null) {
+		return NSWinRT.toPromise(op)
+	}
+
+	if (op?.done) {
+		return new Promise((resolve, reject) => {
+			try {
+				op.done(resolve, reject)
+			} catch (cause) {
+				reject(cause)
+			}
+		})
+	}
+
+	return Promise.resolve(op)
+}
+
+export function cameraHardwarePresent(): boolean {
+	const { Windows, Microsoft } = windows()
+	return !!(
+		Windows?.Media?.Capture?.MediaCapture &&
+		Windows?.Devices?.Enumeration?.DeviceInformation &&
+		Microsoft?.UI?.Xaml?.Controls?.CaptureElement
+	)
+}
+
+export async function ensureCameraPermission(): Promise<boolean> {
+	try {
+		const { Windows } = windows()
+		const capability =
+			Windows?.Security?.Authorization?.AppCapabilityAccess?.AppCapability?.Create?.('webcam')
+
+		if (capability) {
+			const status = capability.CheckAccess()
+			// AppCapabilityAccessStatus: DeniedBySystem=0, NotDeclaredByApp=1,
+			// DeniedByUser=2, UserPromptRequired=3, Allowed=4.
+			if (status === 4) {
+				return true
+			}
+
+			if (status === 3) {
+				return (await toPromise(capability.RequestAccessAsync())) === 4
+			}
+
+			return false
+		}
+
+		const enumeration = Windows?.Devices?.Enumeration
+		const deviceClass = enumeration?.DeviceClass?.VideoCapture
+		const info =
+			deviceClass === undefined
+				? undefined
+				: enumeration?.DeviceAccessInformation?.CreateFromDeviceClass(deviceClass)
+
+		if (info) {
+			// DeviceAccessStatus: Unspecified=0, Allowed=1, DeniedByUser=2,
+			// DeniedBySystem=3. The enumeration API cannot prompt — an
+			// Unspecified outcome is resolved by the preview's own
+			// InitializeAsync, which runs the OS consent flow.
+			return info.CurrentStatus !== 2 && info.CurrentStatus !== 3
+		}
+	} catch {
+		return false
+	}
+
+	return false
+}

package/src/camera-session.ios.ts

@@ -0,0 +1,65 @@
+/** Attach an AVFoundation preview layer to a NativeScript UIView host. */
+export function startCameraPreview(
+	view: any,
+	facing: 'front' | 'back',
+	onReady?: () => void,
+): () => void {
+	const av = globalThis as any
+	const mediaType = av.AVMediaTypeVideo ?? 'vide'
+	const desiredPosition =
+		facing === 'front'
+			? (av.AVCaptureDevicePositionFront ?? 2)
+			: (av.AVCaptureDevicePositionBack ?? 1)
+
+	const devices = av.AVCaptureDevice.devicesWithMediaType(mediaType)
+	let device: any = null
+	for (let index = 0; index < devices.count; index++) {
+		const candidate = devices.objectAtIndex(index)
+		if (candidate.position === desiredPosition) {
+			device = candidate
+			break
+		}
+	}
+
+	if (!device) {
+		throw new Error('camera unavailable')
+	}
+
+	const session = av.AVCaptureSession.new()
+	const input = av.AVCaptureDeviceInput.deviceInputWithDeviceError(device)
+	if (!input || !session.canAddInput(input)) {
+		throw new Error('camera input unavailable')
+	}
+
+	session.addInput(input)
+	const layer = av.AVCaptureVideoPreviewLayer.layerWithSession(session)
+	layer.videoGravity = 'resizeAspectFill'
+	const connection = layer.connection
+	if (connection) {
+		connection.automaticallyAdjustsVideoMirroring = false
+		if (connection.isVideoMirroringSupported) {
+			connection.isVideoMirrored = facing === 'front'
+		}
+	}
+
+	const nativeView = view.ios ?? view.nativeViewProtected
+	if (!nativeView?.layer) {
+		throw new Error('camera preview host unavailable')
+	}
+
+	nativeView.layer.addSublayer(layer)
+	const updateFrame = () => {
+		layer.frame = nativeView.bounds
+	}
+
+	view.on?.('layoutChanged', updateFrame)
+	updateFrame()
+	session.startRunning()
+	onReady?.()
+
+	return () => {
+		view.off?.('layoutChanged', updateFrame)
+		session.stopRunning()
+		layer.removeFromSuperlayer()
+	}
+}

package/src/camera-session.macos.ts

@@ -0,0 +1,75 @@
+import '@nativescript/macos-node-api'
+
+interface CameraHost {
+	attachPreview(view: object): string | null
+	detachPreview(): void
+	installObserver(emit: (message: string) => void): void
+	permissionStatus(kind: string): string
+	requestPermissionReply(kind: string, reply: (status: string) => void): void
+	devices(): string
+	audioDeviceAvailable(): boolean
+	configure(options: { cameraId?: string; audio?: boolean; rotationAngle?: number }): string | null
+	dispose(): void
+}
+
+declare const XplatCameraHost: {
+	alloc(): { init(): CameraHost }
+}
+
+let helper: CameraHost | undefined
+const helperHost = () => (helper ??= XplatCameraHost.alloc().init())
+
+export function cameraHardwarePresent(): boolean {
+	try {
+		return JSON.parse(helperHost().devices()).length > 0
+	} catch {
+		return false
+	}
+}
+
+/** Preview-only permission entry point: prompts once from mount, mirrors the
+ *  iOS legacy path. Session code should use `session.requestPermission` —
+ *  explicit actions only. */
+export function ensureCameraPermission(): Promise<boolean> {
+	const status = helperHost().permissionStatus('camera')
+	if (status === 'granted') {
+		return Promise.resolve(true)
+	}
+
+	if (status === 'undeclared') {
+		return Promise.resolve(false)
+	}
+
+	return new Promise((resolve) =>
+		helperHost().requestPermissionReply('camera', (next) => resolve(next === 'granted')),
+	)
+}
+
+/** Legacy preview-only path: a dedicated XplatCameraHost owns the preview
+ *  session — shared with nothing, disposed with the view. The session-backed
+ *  path goes through `attachSessionPreview` instead. */
+export function startCameraPreview(
+	view: object,
+	_facing: 'front' | 'back',
+	onReady?: () => void,
+): () => void {
+	const host = XplatCameraHost.alloc().init()
+	host.installObserver(() => {})
+	const configured = host.configure({ audio: false })
+	if (configured) {
+		host.dispose()
+		throw new Error(`camera unavailable: ${configured}`)
+	}
+
+	const failure = host.attachPreview(view)
+	if (failure) {
+		host.dispose()
+		throw new Error(`camera unavailable: ${failure}`)
+	}
+
+	onReady?.()
+	return () => {
+		host.detachPreview()
+		host.dispose()
+	}
+}

package/src/camera-session.windows.ts

@@ -0,0 +1,126 @@
+/** Standalone (non-session) WinUI preview for `CameraView` without a
+ *  `session` prop. Owns a private `MediaCapture` bound to a
+ *  `CaptureElement`; the returned function stops preview and closes the
+ *  device. Session-backed previews share their capture through
+ *  `session-backend.windows.ts` instead. */
+
+const windows = () => globalThis as any
+
+const toPromise = (op: any): Promise<any> => {
+	const { NSWinRT } = windows()
+	if (NSWinRT?.toPromise && op != null) {
+		return NSWinRT.toPromise(op)
+	}
+
+	if (op?.done) {
+		return new Promise((resolve, reject) => {
+			try {
+				op.done(resolve, reject)
+			} catch (cause) {
+				reject(cause)
+			}
+		})
+	}
+
+	return Promise.resolve(op)
+}
+
+const vectorToArray = (items: any): any[] => {
+	const result: any[] = []
+	const size = Number(items?.Size ?? items?.Count ?? 0)
+	for (let index = 0; index < size; index += 1) {
+		result.push(items.GetAt(index))
+	}
+
+	return result
+}
+
+/** Attach a MediaCapture preview to the view's `CaptureElement`.
+ *  `facing` maps to enclosure panels; desktop cameras without a panel fall
+ *  back to the OS default — front/back is a preference, never a fabrication. */
+export async function startCameraPreview(
+	view: any,
+	facing: 'front' | 'back',
+	onReady?: () => void,
+): Promise<() => Promise<void>> {
+	const { Windows } = windows()
+	const enumeration = Windows?.Devices?.Enumeration
+	const captureApi = Windows?.Media?.Capture
+	if (!enumeration || !captureApi) {
+		throw new Error('camera preview unsupported')
+	}
+
+	const found = await toPromise(
+		enumeration.DeviceInformation.FindAllAsync(enumeration.DeviceClass.VideoCapture),
+	)
+
+	const devices = vectorToArray(found)
+	if (!devices.length) {
+		throw new Error('camera unavailable')
+	}
+
+	const wantedPanel = facing === 'front' ? 1 : 2
+	const device =
+		devices.find((entry: any) => Number(entry?.EnclosureLocation?.Panel) === wantedPanel) ??
+		devices[0]
+
+	const settings = new captureApi.MediaCaptureInitializationSettings()
+	settings.VideoDeviceId = String(device?.Id ?? device?.id ?? '')
+	settings.StreamingCaptureMode = 0 // Video
+	const capture = new captureApi.MediaCapture()
+	try {
+		await toPromise(capture.InitializeAsync(settings))
+	} catch (cause) {
+		try {
+			capture.Close()
+		} catch {
+			try {
+				capture.Dispose()
+			} catch {
+				// GC reclaims the device handle.
+			}
+		}
+
+		throw cause instanceof Error ? cause : new Error('camera unavailable')
+	}
+
+	const element = view?.nativeViewProtected ?? view
+	element.Source = capture
+	try {
+		if (
+			Number(device?.EnclosureLocation?.Panel) === 1 &&
+			typeof capture.SetPreviewMirroring === 'function'
+		) {
+			capture.SetPreviewMirroring(true)
+		}
+	} catch {
+		// Mirrored preview is cosmetic.
+	}
+
+	await toPromise(capture.StartPreviewAsync())
+	onReady?.()
+
+	return async () => {
+		try {
+			element.Source = null
+		} catch {
+			// The element may already be gone.
+		}
+
+		try {
+			await toPromise(capture.StopPreviewAsync())
+		} catch {
+			// The pipeline may already be down.
+		}
+
+		try {
+			capture.Close()
+		} catch {
+			try {
+				capture.Dispose()
+			} catch {
+				// GC reclaims the device handle.
+			}
+		}
+	}
+}