@octane-xplat/camera 0.0.0-nightly.g2e22171

package/src/host-movie.web.ts

@@ -0,0 +1,295 @@
+import { createHostClient, type HostClient } from '@octane-xplat/platform/host'
+import { createWebKitTransport } from '@octane-xplat/platform/host/web'
+import { CameraCaptureError } from './types'
+import type { MovieOutput, MovieOutputHandle } from './types'
+
+// Inside a desktop native webview the typed host channel may expose a
+// `camera` service: truthful macOS privacy status plus app-private durable
+// file storage. Outside a host — or when the service is absent — every probe
+// resolves absent and the adapter keeps its browser storage behavior.
+
+export interface CameraHostServices {
+	camera: {
+		permissionStatus(options: { kind: string }): Promise<{ status: string }>
+		requestPermission(options: { kind: string }): Promise<{ status: string }>
+		movieDirectory(): Promise<{ fileUrl: string | null }>
+		reserveMoviePath(options: {
+			fileUrl?: string
+			container?: string
+		}): Promise<{ reservation: { fileUrl: string } | null }>
+		writeMovieFile(options: {
+			fileUrl: string
+			base64: string
+		}): Promise<{ file: { name: string; uri: string } | null }>
+		movieFileInfo(options: {
+			fileUrl: string
+		}): 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 }>
+	}
+}
+
+const requiredMethods = [
+	'permissionStatus',
+	'requestPermission',
+	'movieDirectory',
+	'reserveMoviePath',
+	'writeMovieFile',
+	'movieFileInfo',
+	'readMovieFile',
+	'deleteMovieFile',
+]
+
+export type CameraHost = HostClient<CameraHostServices>
+
+let hostProbe: Promise<CameraHost | null> | undefined
+
+const probeHost = async (): Promise<CameraHost | null> => {
+	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 methods = capabilities?.camera
+		if (Array.isArray(methods) && requiredMethods.every((name) => methods.includes(name))) {
+			return client
+		}
+
+		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 dataToBase64 = (data: Uint8Array): string => {
+	let binary = ''
+	const chunk = 0x8000
+	for (let offset = 0; offset < data.length; offset += chunk) {
+		binary += String.fromCharCode(...data.subarray(offset, offset + chunk))
+	}
+
+	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)
+	for (let index = 0; index < binary.length; index++) {
+		data[index] = binary.charCodeAt(index)
+	}
+
+	return new Blob([data], { type })
+}
+
+const mimeForFileUrl = (fileUrl: string): string =>
+	fileUrl.endsWith('.webm')
+		? 'video/webm'
+		: fileUrl.endsWith('.mov')
+			? 'video/quicktime'
+			: 'video/mp4'
+
+/** Reserve a host-side movie file. `destinationFileUrl` is validated
+ *  host-side: it must be a new file inside the app-private storage root. */
+export const reserveHostMovie = async (
+	host: CameraHost,
+	options: { destinationFileUrl?: string; container?: string },
+): Promise<{ fileUrl: string }> => {
+	const { reservation } = await host.call('camera', 'reserveMoviePath', {
+		fileUrl: options.destinationFileUrl,
+		container: options.container,
+	})
+
+	if (!reservation?.fileUrl) {
+		throw error(
+			'destinationUnavailable',
+			options.destinationFileUrl
+				? 'destinationFileUrl must be a new file inside the app-private recordings directory'
+				: 'The host could not allocate a movie recording file',
+		)
+	}
+
+	return reservation
+}
+
+/** 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) {
+		throw error('storageFailed', 'The host could not write the recorded movie')
+	}
+
+	return { kind: 'nativeFile', resourceId: file.uri, fileUrl: file.uri }
+}
+
+/** Drop an uncommitted host reservation after a failed attempt. */
+export const removeHostReservation = async (host: CameraHost, fileUrl: string): Promise<void> => {
+	await host.call('camera', 'deleteMovieFile', { fileUrl }).catch(() => {})
+}
+
+/** Reopen a host-stored movie as a temporary playback URL. The durable
+ *  reference remains `fileUrl`; the returned url lives until `release()`. */
+export const openHostMovie = async (
+	host: CameraHost,
+	output: MovieOutput,
+): Promise<MovieOutputHandle> => {
+	if (output.kind !== 'nativeFile' || !output.fileUrl) {
+		throw new CameraCaptureError({
+			kind: 'invalidArgument',
+			operation: 'openOutput',
+			message: 'Only file-backed output can be opened through the desktop host',
+		})
+	}
+
+	const { info } = await host.call('camera', 'movieFileInfo', { fileUrl: output.fileUrl })
+	if (!info?.exists) {
+		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}`)
+	}
+
+	const url = URL.createObjectURL(base64ToBlob(base64, mimeForFileUrl(output.fileUrl)))
+	return {
+		url,
+		fileUrl: output.fileUrl,
+		release: () => URL.revokeObjectURL(url),
+	}
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+// Keep this relative import extensionless so the NativeScript resolver picks
+// the iOS or Android component for the current build target.
+export { CameraView } from './CameraView'
+export type { CameraAccessibilityRole, CameraViewHandle, CameraViewProps } from './props'
+export { createCameraSession } from './session'
+export { CameraCaptureError } from './types'
+export type {
+	CameraCaptureErrorKind,
+	CameraDeviceInfo,
+	CameraFacing,
+	CameraInterruptionReason,
+	CameraOrientation,
+	CameraPermissionKind,
+	CameraPermissionStatus,
+	CameraPreviewPoint,
+	CameraProfileCapability,
+	CameraRecorderState,
+	CameraSelection,
+	CameraSession,
+	CameraSessionCapabilities,
+	CameraSessionConfig,
+	CameraSessionEvent,
+	CameraSessionSnapshot,
+	CaptureIssue,
+	EffectiveCaptureConfig,
+	MovieClip,
+	MovieEndReason,
+	MovieOutcome,
+	MovieOutput,
+	MovieOutputHandle,
+	MovieTake,
+	StartRecordingOptions,
+} from './types'
+
+export { createMemoryCameraStorage, createSyntheticCameraSession } from './synthetic-session'
+export type { SyntheticCameraScript, SyntheticCameraStorage } from './synthetic-session'

package/src/index.web.ts

@@ -0,0 +1,34 @@
+export { CameraView } from './CameraView.web.tsrx'
+export type { CameraAccessibilityRole, CameraViewHandle, CameraViewProps } from './props'
+export { createCameraSession } from './session'
+export { CameraCaptureError } from './types'
+export type {
+	CameraCaptureErrorKind,
+	CameraDeviceInfo,
+	CameraFacing,
+	CameraInterruptionReason,
+	CameraOrientation,
+	CameraPermissionKind,
+	CameraPermissionStatus,
+	CameraPreviewPoint,
+	CameraProfileCapability,
+	CameraRecorderState,
+	CameraSelection,
+	CameraSession,
+	CameraSessionCapabilities,
+	CameraSessionConfig,
+	CameraSessionEvent,
+	CameraSessionSnapshot,
+	CaptureIssue,
+	EffectiveCaptureConfig,
+	MovieClip,
+	MovieEndReason,
+	MovieOutcome,
+	MovieOutput,
+	MovieOutputHandle,
+	MovieTake,
+	StartRecordingOptions,
+} from './types'
+
+export { createMemoryCameraStorage, createSyntheticCameraSession } from './synthetic-session'
+export type { SyntheticCameraScript, SyntheticCameraStorage } from './synthetic-session'

package/src/layout-child.ts

@@ -0,0 +1,81 @@
+import type { CameraViewProps } from './props'
+import { isIOS } from '@nativescript/core'
+
+/** NativeScript reads layout fields from a child view during parent layout. */
+export function layoutChildProps(props: CameraViewProps): Record<string, any> {
+	const result: Record<string, any> = {}
+	for (const key of [
+		'row',
+		'col',
+		'rowSpan',
+		'colSpan',
+		'dock',
+		'left',
+		'top',
+		'flexGrow',
+		'flexShrink',
+		'alignSelf',
+		'order',
+	] as const) {
+		if (props[key] !== undefined) {
+			result[key] = props[key]
+		}
+	}
+
+	return result
+}
+
+export function applyEscapeProps(view: any, props: { ios?: any; android?: any }): void {
+	if (!view) {
+		return
+	}
+
+	const bag = isIOS ? props.ios : props.android
+	if (bag) {
+		Object.assign(view, bag)
+	}
+}
+
+const nativeRoles: Record<string, string> = {
+	button: 'button',
+	link: 'link',
+	search: 'search',
+	image: 'image',
+	heading: 'header',
+	adjustable: 'adjustable',
+	summary: 'summary',
+	text: 'text',
+	none: 'none',
+	progressbar: 'progressBar',
+	checkbox: 'checkbox',
+	switch: 'switch',
+	radio: 'radioButton',
+	spinbutton: 'spinButton',
+	tab: 'button',
+}
+
+export function nativeAccessibilityRole(role?: string): string | undefined {
+	return role ? nativeRoles[role] : undefined
+}
+
+export function nativeAccessibilityState(
+	state?: CameraViewProps['accessibilityState'],
+): string | undefined {
+	if (state?.disabled) {
+		return 'disabled'
+	}
+
+	if (state?.selected) {
+		return 'selected'
+	}
+
+	if (state?.checked === true) {
+		return 'checked'
+	}
+
+	if (state?.checked === false) {
+		return 'unchecked'
+	}
+
+	return undefined
+}

package/src/layout-child.web.ts

@@ -0,0 +1,66 @@
+import type { CameraViewProps } from './props'
+
+export function layoutChildProps(props: CameraViewProps, baseStyle: any = props.style) {
+	const style = { ...baseStyle }
+	if (props.row !== undefined) {
+		style.gridRow = `${props.row + 1} / span ${props.rowSpan ?? 1}`
+	} else if (props.rowSpan !== undefined) {
+		style.gridRow = `span ${props.rowSpan}`
+	}
+
+	if (props.col !== undefined) {
+		style.gridColumn = `${props.col + 1} / span ${props.colSpan ?? 1}`
+	} else if (props.colSpan !== undefined) {
+		style.gridColumn = `span ${props.colSpan}`
+	}
+
+	if (props.left !== undefined) {
+		style.left = props.left
+	}
+
+	if (props.top !== undefined) {
+		style.top = props.top
+	}
+
+	if (props.flexGrow !== undefined) {
+		style.flexGrow = props.flexGrow
+	}
+
+	if (props.flexShrink !== undefined) {
+		style.flexShrink = props.flexShrink
+	}
+
+	if (props.alignSelf !== undefined) {
+		style.alignSelf = props.alignSelf
+	}
+
+	if (props.order !== undefined) {
+		style.order = props.order
+	}
+
+	return { style }
+}
+
+export function applyEscapeProps(element: any, props: { web?: any }): void {
+	if (!element || !props.web) {
+		return
+	}
+
+	for (const [key, value] of Object.entries(props.web)) {
+		if (key.includes('-')) {
+			if (value == null || value === false) {
+				element.removeAttribute(key)
+			} else {
+				element.setAttribute(key, value === true ? '' : String(value))
+			}
+		} else if (key in element) {
+			try {
+				element[key] = value
+			} catch {
+				element.setAttribute(key, String(value))
+			}
+		} else if (value != null) {
+			element.setAttribute(key, String(value))
+		}
+	}
+}

package/src/layout-child.windows.ts

@@ -0,0 +1,79 @@
+import type { CameraViewProps } from './props'
+
+/** Windows twins of the layout-child helpers — the unsuffixed module
+ *  resolves the platform escape bag through `isIOS`, which has no Windows
+ *  branch. Pure helpers are re-declared here to keep divergence at the file
+ *  boundary. */
+
+export function layoutChildProps(props: CameraViewProps): Record<string, any> {
+	const result: Record<string, any> = {}
+	for (const key of [
+		'row',
+		'col',
+		'rowSpan',
+		'colSpan',
+		'dock',
+		'left',
+		'top',
+		'flexGrow',
+		'flexShrink',
+		'alignSelf',
+		'order',
+	] as const) {
+		if (props[key] !== undefined) {
+			result[key] = props[key]
+		}
+	}
+
+	return result
+}
+
+export function applyEscapeProps(view: any, props: { windows?: any }): void {
+	if (view && props.windows) {
+		Object.assign(view, props.windows)
+	}
+}
+
+const nativeRoles: Record<string, string> = {
+	button: 'button',
+	link: 'link',
+	search: 'search',
+	image: 'image',
+	heading: 'header',
+	adjustable: 'adjustable',
+	summary: 'summary',
+	text: 'text',
+	none: 'none',
+	progressbar: 'progressBar',
+	checkbox: 'checkbox',
+	switch: 'switch',
+	radio: 'radioButton',
+	spinbutton: 'spinButton',
+	tab: 'button',
+}
+
+export function nativeAccessibilityRole(role?: string): string | undefined {
+	return role ? nativeRoles[role] : undefined
+}
+
+export function nativeAccessibilityState(
+	state?: CameraViewProps['accessibilityState'],
+): string | undefined {
+	if (state?.disabled) {
+		return 'disabled'
+	}
+
+	if (state?.selected) {
+		return 'selected'
+	}
+
+	if (state?.checked === true) {
+		return 'checked'
+	}
+
+	if (state?.checked === false) {
+		return 'unchecked'
+	}
+
+	return undefined
+}

package/src/movie-metadata.web.ts

@@ -0,0 +1,84 @@
+import { BlobSource, Input, MP4, WEBM } from 'mediabunny'
+import { CameraCaptureError } from './types'
+
+/** Read packet end timestamps and track metadata, never the wall-clock stop time. */
+export async function inspectMovie(bytes: Blob, audioRequested: boolean) {
+	if (!bytes.size) {
+		throw new CameraCaptureError({
+			kind: 'noMedia',
+			operation: 'finalize',
+			message: 'The recorder produced no movie bytes',
+		})
+	}
+
+	const input = new Input({ source: new BlobSource(bytes), formats: [WEBM, MP4] })
+	const read = async () => {
+		const video = await input.getPrimaryVideoTrack()
+		const audio = await input.getPrimaryAudioTrack()
+		if (!video) {
+			throw new CameraCaptureError({
+				kind: 'noMedia',
+				operation: 'finalize',
+				message: 'The movie contains no video track',
+			})
+		}
+
+		const videoDuration = await video.computeDuration()
+		const hasAudio = audio !== null && (await audio.computeDuration()) > 0
+		const durationMs = (await input.computeDuration()) * 1000
+		const width = await video.getDisplayWidth()
+		const height = await video.getDisplayHeight()
+		if (
+			!Number.isFinite(durationMs) ||
+			durationMs <= 0 ||
+			videoDuration <= 0 ||
+			width <= 0 ||
+			height <= 0
+		) {
+			throw new CameraCaptureError({
+				kind: 'noMedia',
+				operation: 'finalize',
+				message: 'The movie has no usable video media',
+			})
+		}
+
+		if (audioRequested && !hasAudio) {
+			throw new CameraCaptureError({
+				kind: 'captureFailed',
+				operation: 'finalize',
+				message: 'Requested audio is absent from the finalized movie',
+			})
+		}
+
+		return {
+			durationMs,
+			width,
+			height,
+			hasAudio,
+			mimeType: await input.getMimeType(),
+			orientation: 'unspecified' as const,
+		}
+	}
+
+	let timer: ReturnType<typeof setTimeout> | undefined
+	try {
+		return await Promise.race([
+			read(),
+			new Promise<never>((_resolve, reject) => {
+				timer = setTimeout(() => {
+					input.dispose()
+					reject(
+						new CameraCaptureError({
+							kind: 'finalizationFailed',
+							operation: 'metadata',
+							message: 'Movie metadata verification timed out',
+						}),
+					)
+				}, 30_000)
+			}),
+		])
+	} finally {
+		clearTimeout(timer)
+		input.dispose()
+	}
+}