@octane-xplat/camera 0.14.0 → 0.15.0

package/src/CameraView.android.tsrx

@@ -7,7 +7,9 @@ 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() {
@@ -126,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

@@ -5,7 +5,7 @@ import { cameraHardwarePresent, ensureCameraPermission } from './camera-permissi
 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. With `session`, the preview
  *  attaches to the session-owned AVCaptureSession so movie recording can
@@ -81,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

@@ -4,7 +4,7 @@ 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 { cx } from './cx.macos'
+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
@@ -74,12 +74,14 @@ export function CameraView(props: CameraViewProps) @{
 		}
 	}, [active, facing, props.session])
 
+	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: '#000000', ...props.style }}
 		{...layoutChildProps(props)}
 		accessible={props.accessible}

package/src/CameraView.web.tsrx

@@ -103,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%',

package/src/CameraView.windows.tsrx

@@ -8,7 +8,7 @@ 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 { cx } from './cx.windows'
+import { observePreviewTap } from './preview-tap'
 
 class CameraPreview extends View {
 	createNativeView() {
@@ -104,11 +104,13 @@ export function CameraView(props: CameraViewProps) @{
 		applyEscapeProps(view.nativeViewProtected, props)
 	}, [props.ref, props.windows])
 
+	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/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 {

package/src/camera-session.windows.ts

@@ -87,7 +87,10 @@ export async function startCameraPreview(
 	const element = view?.nativeViewProtected ?? view
 	element.Source = capture
 	try {
-		if (Number(device?.EnclosureLocation?.Panel) === 1 && typeof capture.SetPreviewMirroring === 'function') {
+		if (
+			Number(device?.EnclosureLocation?.Panel) === 1 &&
+			typeof capture.SetPreviewMirroring === 'function'
+		) {
 			capture.SetPreviewMirroring(true)
 		}
 	} catch {

package/src/host-movie.web.ts

@@ -26,6 +26,19 @@ export interface CameraHostServices {
 		}): Promise<{ info: { exists: boolean; fileUrl?: string; size?: number } | null }>
 		readMovieFile(options: { fileUrl: string }): Promise<{ base64: string | null }>
 		deleteMovieFile(options: { fileUrl: string }): Promise<{ removed: boolean }>
+		/** Optional chunked variants — a multi-hundred-MB movie must not
+		 *  round-trip through the bridge as one base64 payload. Absent on
+		 *  hosts built before the chunked contract; detected per client. */
+		writeMovieFileChunk?(options: {
+			fileUrl: string
+			base64: string
+			final?: boolean
+		}): Promise<{ file: { name: string; uri: string } | { ok: boolean } | null }>
+		readMovieFileChunk?(options: {
+			fileUrl: string
+			offset: number
+			length: number
+		}): Promise<{ base64: string | null }>
 	}
 }
 
@@ -44,40 +57,49 @@ export type CameraHost = HostClient<CameraHostServices>
 
 let hostProbe: Promise<CameraHost | null> | undefined
 
-/** The camera-capable desktop host client, or null outside a qualified host. */
-export function cameraHost(): Promise<CameraHost | null> {
-	hostProbe ??= (async () => {
-		try {
-			const transport = createWebKitTransport()
-			if (!transport) {
-				return null
-			}
-
-			const client = createHostClient<CameraHostServices>(transport)
-			const capabilities = (await client.capabilities().catch(() => null)) as {
-				camera?: string[]
-			} | null
+const probeHost = async (): Promise<CameraHost | null> => {
+	try {
+		const transport = createWebKitTransport()
+		if (!transport) {
+			return null
+		}
 
-			const methods = capabilities?.camera
-			if (Array.isArray(methods) && requiredMethods.every((name) => methods.includes(name))) {
-				return client
-			}
+		const client = createHostClient<CameraHostServices>(transport)
+		const capabilities = (await client.capabilities().catch(() => null)) as {
+			camera?: string[]
+		} | null
 
-			client.dispose()
-			return null
-		} catch {
-			return null
+		const methods = capabilities?.camera
+		if (Array.isArray(methods) && requiredMethods.every((name) => methods.includes(name))) {
+			return client
 		}
-	})()
 
-	return hostProbe
+		client.dispose()
+		return null
+	} catch {
+		return null
+	}
+}
+
+/** The camera-capable desktop host client, or null outside a qualified host.
+ *  Only a confirmed client stays cached — a null result may be a transient
+ *  transport or capabilities failure, so the next call probes again rather
+ *  than sticking 'absent' for the page lifetime. */
+export async function cameraHost(): Promise<CameraHost | null> {
+	hostProbe ??= probeHost()
+	const host = await hostProbe
+	if (!host) {
+		hostProbe = probeHost()
+		return hostProbe
+	}
+
+	return host
 }
 
 const error = (kind: 'destinationUnavailable' | 'storageFailed' | 'unavailable', message: string) =>
 	new CameraCaptureError({ kind, operation: 'storage', message })
 
-const blobToBase64 = async (bytes: Blob): Promise<string> => {
-	const data = new Uint8Array(await bytes.arrayBuffer())
+const dataToBase64 = (data: Uint8Array): string => {
 	let binary = ''
 	const chunk = 0x8000
 	for (let offset = 0; offset < data.length; offset += chunk) {
@@ -87,6 +109,9 @@ const blobToBase64 = async (bytes: Blob): Promise<string> => {
 	return btoa(binary)
 }
 
+const blobToBase64 = async (bytes: Blob): Promise<string> =>
+	dataToBase64(new Uint8Array(await bytes.arrayBuffer()))
+
 const base64ToBlob = (base64: string, type: string): Blob => {
 	const binary = atob(base64)
 	const data = new Uint8Array(binary.length)
@@ -127,12 +152,64 @@ export const reserveHostMovie = async (
 	return reservation
 }
 
-/** Commit finalized movie bytes to host-side app-private storage. */
+/** Bytes bridged per call when the host exposes the chunked movie contract —
+ *  large enough to amortize IPC, small enough to keep peak copies bounded. */
+const MOVIE_CHUNK_BYTES = 4 * 1024 * 1024
+
+const chunkedSupport = new WeakMap<CameraHost, Promise<boolean>>()
+
+/** A host built before the chunked contract lacks the methods entirely —
+ *  the capabilities probe answers that without a probe call. */
+const supportsChunkedMovies = (host: CameraHost): Promise<boolean> => {
+	let probe = chunkedSupport.get(host)
+	if (!probe) {
+		probe = host
+			.capabilities()
+			.then((capabilities) => {
+				const methods = (capabilities as { camera?: string[] }).camera ?? []
+				return methods.includes('writeMovieFileChunk') && methods.includes('readMovieFileChunk')
+			})
+			.catch(() => false)
+
+		chunkedSupport.set(host, probe)
+	}
+
+	return probe
+}
+
+/** Commit finalized movie bytes to host-side app-private storage. Hosts
+ *  with the chunked contract stream 4MB slices — a multi-hundred-MB
+ *  recording no longer materializes ~3-4x its size across the bridge. */
 export const commitHostMovie = async (
 	host: CameraHost,
 	fileUrl: string,
 	bytes: Blob,
 ): Promise<MovieOutput> => {
+	if (await supportsChunkedMovies(host)) {
+		for (let offset = 0; ; offset += MOVIE_CHUNK_BYTES) {
+			const slice = bytes.slice(offset, offset + MOVIE_CHUNK_BYTES)
+			const final = offset + MOVIE_CHUNK_BYTES >= bytes.size
+			const { file } = await host.call('camera', 'writeMovieFileChunk', {
+				fileUrl,
+				base64: dataToBase64(new Uint8Array(await slice.arrayBuffer())),
+				final,
+			})
+
+			if (final) {
+				const committed = file && 'uri' in file ? file : null
+				if (!committed?.uri) {
+					throw error('storageFailed', 'The host could not write the recorded movie')
+				}
+
+				return { kind: 'nativeFile', resourceId: committed.uri, fileUrl: committed.uri }
+			}
+
+			if (!file || !('ok' in file) || file.ok !== true) {
+				throw error('storageFailed', 'The host could not write a recorded movie chunk')
+			}
+		}
+	}
+
 	const base64 = await blobToBase64(bytes)
 	const { file } = await host.call('camera', 'writeMovieFile', { fileUrl, base64 })
 	if (!file?.uri) {
@@ -166,6 +243,44 @@ export const openHostMovie = async (
 		throw error('unavailable', `Movie file is missing at ${output.fileUrl}`)
 	}
 
+	const size = Number(info.size ?? -1)
+	if (size > 0 && (await supportsChunkedMovies(host))) {
+		const data = new Uint8Array(size)
+		for (let offset = 0; offset < size; offset += MOVIE_CHUNK_BYTES) {
+			const { base64: chunk } = await host.call('camera', 'readMovieFileChunk', {
+				fileUrl: output.fileUrl,
+				offset,
+				length: Math.min(MOVIE_CHUNK_BYTES, size - offset),
+			})
+
+			if (chunk == null) {
+				throw error('unavailable', `Movie file could not be read at ${output.fileUrl}`)
+			}
+
+			let decoded: string
+			try {
+				decoded = atob(chunk)
+			} catch {
+				throw error('unavailable', 'The host returned invalid movie bytes')
+			}
+
+			if (decoded.length !== Math.min(MOVIE_CHUNK_BYTES, size - offset)) {
+				throw error('unavailable', 'The stored movie changed or could not be read completely')
+			}
+
+			for (let index = 0; index < decoded.length; index += 1) {
+				data[offset + index] = decoded.charCodeAt(index)
+			}
+		}
+
+		const url = URL.createObjectURL(new Blob([data], { type: mimeForFileUrl(output.fileUrl) }))
+		return {
+			url,
+			fileUrl: output.fileUrl,
+			release: () => URL.revokeObjectURL(url),
+		}
+	}
+
 	const { base64 } = await host.call('camera', 'readMovieFile', { fileUrl: output.fileUrl })
 	if (!base64) {
 		throw error('unavailable', `Movie file could not be read at ${output.fileUrl}`)

package/src/index.ts

@@ -12,6 +12,7 @@ export type {
 	CameraOrientation,
 	CameraPermissionKind,
 	CameraPermissionStatus,
+	CameraPreviewPoint,
 	CameraProfileCapability,
 	CameraRecorderState,
 	CameraSelection,

package/src/index.web.ts

@@ -10,6 +10,7 @@ export type {
 	CameraOrientation,
 	CameraPermissionKind,
 	CameraPermissionStatus,
+	CameraPreviewPoint,
 	CameraProfileCapability,
 	CameraRecorderState,
 	CameraSelection,

package/src/preview-tap.ts

@@ -0,0 +1,34 @@
+import type { CameraPreviewPoint } from './types'
+
+/** Attach a notification-only 'tap' observer to a preview host view and
+ *  report each tap as a `CameraPreviewPoint` normalized to the view's
+ *  bounds. The tap gesture never consumes the touch — recognizers layered
+ *  above the preview still see it. Platforms whose runtime never
+ *  dispatches 'tap' simply never fire the callback. */
+export function observePreviewTap(
+	view: any,
+	onTap: ((point: CameraPreviewPoint) => void) | undefined,
+): () => void {
+	if (!view || !onTap || typeof view.on !== 'function') {
+		return () => {}
+	}
+
+	const handler = (args: any) => {
+		const size = view.getActualSize?.()
+		const width = size?.width ?? 0
+		const height = size?.height ?? 0
+		const x = typeof args?.getX === 'function' ? args.getX() : NaN
+		const y = typeof args?.getY === 'function' ? args.getY() : NaN
+		if (!(width > 0) || !(height > 0) || !Number.isFinite(x) || !Number.isFinite(y)) {
+			return
+		}
+
+		onTap({
+			x: Math.min(1, Math.max(0, x / width)),
+			y: Math.min(1, Math.max(0, y / height)),
+		})
+	}
+
+	view.on('tap', handler)
+	return () => view.off?.('tap', handler)
+}

package/src/props.ts

@@ -1,5 +1,5 @@
 import type { Octane } from 'octane/jsx-runtime'
-import type { CameraSession } from './types'
+import type { CameraPreviewPoint, CameraSession } from './types'
 
 export type CameraAccessibilityRole =
 	| 'button'
@@ -60,6 +60,13 @@ export interface CameraViewProps {
 	/** Fires after the preview surface starts. */
 	onReady?: () => void
 	onError?: (error: { message?: string }) => void
+	/** Notification-only tap event — fires with the normalized
+	 *  preview-space position (`CameraPreviewPoint`) and never consumes
+	 *  the gesture, so recognizers layered above the preview (double-tap,
+	 *  pan) still run. Pair with `session.focusAtPoint` for tap-to-focus.
+	 *  Delivered on iOS, Android, and web; desktop runtimes do not dispatch
+	 *  it yet. */
+	onTap?: (point: CameraPreviewPoint) => void
 	/** Native preview surface for platform-specific controls. */
 	ref?: Octane.Ref<CameraViewHandle>
 	/** Platform-specific properties applied to the preview surface. */

package/src/session-backend.android.ts

@@ -1,5 +1,6 @@
 import { Application } from '@nativescript/core'
 import { CameraCaptureError } from './types'
+import { canonicalizePath } from './session-core'
 import type {
 	BackendCaptureSink,
 	BackendObserver,
@@ -235,6 +236,11 @@ export function createSessionBackend(config: CameraSessionConfig): CameraSession
 				cameras: value.cameras,
 				profiles: value.profiles,
 				audio: context().getPackageManager().hasSystemFeature('android.hardware.microphone'),
+				// The bridge only reports metering support once a camera is
+				// bound — absent fields read as unsupported, which is honest
+				// for the current acquisition state.
+				focusPointOfInterest: value.focusPointOfInterest === true,
+				exposurePointOfInterest: value.exposurePointOfInterest === true,
 				orientations: [],
 				durationLimit: 'native',
 				elapsedTime: 'nativeMedia',
@@ -339,8 +345,44 @@ export function createSessionBackend(config: CameraSessionConfig): CameraSession
 				bridge.attach(host, selected())
 			}
 		},
+		focusAtPoint: (point) => {
+			try {
+				bridge?.focusAtPoint?.(point.x, point.y)
+			} catch {
+				// A missed metering pass must not fault the session.
+			}
+		},
 		startCapture: (request, target) => {
 			sink = target
+			if (request.destinationPath) {
+				// Durable output stays app-private like every other leaf —
+				// canonicalize so '..' cannot escape the files root.
+				const destination = canonicalizePath(request.destinationPath)
+				let filesRoot = ''
+				try {
+					filesRoot = context()?.getFilesDir?.().getAbsolutePath?.() ?? ''
+				} catch {
+					filesRoot = ''
+				}
+
+				if (!filesRoot || !destination.startsWith(`${filesRoot}/`)) {
+					sink = undefined
+					target.settled({
+						kind: 'failed',
+						stage: 'preparation',
+						issue: error(
+							'destinationUnavailable',
+							'startRecording',
+							'destinationFileUrl must resolve inside the app-private files directory',
+						),
+					})
+
+					return
+				}
+
+				request = { ...request, destinationPath: destination }
+			}
+
 			try {
 				bridge.start(
 					request.audio,