@chipmobilesdk/rn-camera 0.1.0 → 0.2.0

package/src/react/VisionCameraFeed.tsx

@@ -1,155 +1,178 @@
-/**
- * The live VisionCamera surface rendered inside `CameraPreview`.
- *
- * Split into its own module so `CameraPreview` can require it lazily: consumers
- * that only use the pure utilities or the test adapter never load the native
- * module, while the hooks this component needs (`useCameraDevice`,
- * `usePhotoOutput`) can still be called normally.
- *
- * It also owns capture. In VisionCamera v5 the photo output belongs to the
- * session the `<Camera>` view configures, so the output only exists while this
- * surface is mounted; it is published to the engine through `visionSurface`.
- */
-
-import React, { useEffect, useMemo } from 'react';
-import { StyleSheet } from 'react-native';
-import {
-	Camera,
-	useCameraDevice,
-	usePhotoOutput,
-	type CameraPhotoOutput,
-} from 'react-native-vision-camera';
-
-import {
-	known,
-	unavailable,
-	type CameraPosition,
-	type CapturedImage,
-	type CaptureRequest,
-	type ResizeMode,
-} from '../config/types';
-import { clampMaxDimension, clampQuality } from '../core/captureController';
-import { CameraError } from '../diagnostics/errors';
-import { registerVisionSurface } from '../native/visionSurface';
-
-export interface VisionCameraFeedProps {
-	readonly cameraPosition: CameraPosition;
-	readonly resizeMode: ResizeMode;
-	readonly torchEnabled: boolean;
-}
-
-const styles = StyleSheet.create({
-	feed: { flex: 1 },
-});
-
-const MIME_TYPES: Record<string, string> = {
-	jpeg: 'image/jpeg',
-	heic: 'image/heic',
-	dng: 'image/x-adobe-dng',
-	tiff: 'image/tiff',
-};
-
-/** VisionCamera reports orientation as a compass value; the contract wants degrees. */
-const ORIENTATION_DEGREES: Record<string, number> = {
-	up: 0,
-	right: 90,
-	down: 180,
-	left: 270,
-};
-
-function toFileUri(path: string): string {
-	return path.startsWith('file://') ? path : `file://${path}`;
-}
-
-function toFilePath(uri: string): string {
-	return uri.startsWith('file://') ? uri.slice('file://'.length) : uri;
-}
-
-async function capturePhoto(
-	photoOutput: CameraPhotoOutput,
-	request: CaptureRequest,
-	cameraPosition: CameraPosition,
-): Promise<CapturedImage> {
-	const photo = await photoOutput.capturePhoto(
-		{ flashMode: request.flashMode ?? 'off' },
-		{},
-	);
-	try {
-		// A destination makes the artifact app-owned, so it is written straight
-		// there; otherwise it goes to a temporary file (FR-026a).
-		let path: string;
-		if (request.destination) {
-			try {
-				await photo.saveToFileAsync(toFilePath(request.destination));
-			} catch (error) {
-				throw new CameraError(
-					'storageFailure',
-					`Could not write the capture to the requested destination: ${
-						error instanceof Error ? error.message : 'unknown error'
-					}`,
-				);
-			}
-			path = request.destination;
-		} else {
-			path = await photo.saveToTemporaryFileAsync();
-		}
-
-		return {
-			uri: toFileUri(path),
-			mimeType: MIME_TYPES[photo.containerFormat] ?? 'application/octet-stream',
-			width: photo.width,
-			height: photo.height,
-			timestamp: Date.now(),
-			cameraPosition: request.cameraPosition ?? cameraPosition,
-			// Ownership is decided by the controller from the original request;
-			// this value is overwritten there and is only a safe default.
-			ownership: request.destination ? 'appOwned' : 'packageTemporary',
-			effectiveQuality: clampQuality(request.quality),
-			effectiveMaxDimension: clampMaxDimension(request.maxDimension),
-			// The native layer reports neither back after a save, and guessing them
-			// would be worse than saying so (FR-022).
-			fileSize: unavailable(),
-			orientation:
-				photo.orientation in ORIENTATION_DEGREES
-					? known(ORIENTATION_DEGREES[photo.orientation])
-					: unavailable(),
-		};
-	} finally {
-		// Large native buffers must not wait for the JS GC.
-		photo.dispose();
-	}
-}
-
-export const VisionCameraFeed: React.FC<VisionCameraFeedProps> = ({
-	cameraPosition,
-	resizeMode,
-	torchEnabled,
-}) => {
-	const device = useCameraDevice(cameraPosition);
-	const photoOutput = usePhotoOutput();
-
-	const surface = useMemo(
-		() => ({
-			capture: (request: CaptureRequest) =>
-				capturePhoto(photoOutput, request, cameraPosition),
-		}),
-		[photoOutput, cameraPosition],
-	);
-
-	useEffect(() => registerVisionSurface(surface), [surface]);
-
-	if (!device) {
-		return null;
-	}
-
-	return (
-		<Camera
-			style={styles.feed}
-			device={device}
-			outputs={[photoOutput]}
-			isActive={true}
-			resizeMode={resizeMode}
-			torchMode={torchEnabled ? 'on' : 'off'}
-		/>
-	);
-};
+/**
+ * The live VisionCamera surface rendered inside `CameraPreview`.
+ *
+ * Split into its own module so `CameraPreview` can require it lazily: consumers
+ * that only use the pure utilities or the test adapter never load the native
+ * module, while the hooks this component needs (`useCameraDevice`,
+ * `usePhotoOutput`) can still be called normally.
+ *
+ * It also owns capture. In VisionCamera v5 the photo output belongs to the
+ * session the `<Camera>` view configures, so the output only exists while this
+ * surface is mounted; it is published to the engine through `visionSurface`.
+ */
+
+import React, { useEffect, useMemo, useState } from 'react';
+import { StyleSheet } from 'react-native';
+import {
+	Camera,
+	useCameraDevice,
+	usePhotoOutput,
+	type CameraPhotoOutput,
+} from 'react-native-vision-camera';
+
+import {
+	known,
+	unavailable,
+	type CameraPosition,
+	type CapturedImage,
+	type CaptureRequest,
+	type ResizeMode,
+} from '../config/types';
+import { DEFAULT_QUALITY } from '../core/captureController';
+import { CameraError, isCameraError } from '../diagnostics/errors';
+import { registerVisionSurface } from '../native/visionSurface';
+
+export interface VisionCameraFeedProps {
+	readonly cameraPosition: CameraPosition;
+	readonly resizeMode: ResizeMode;
+	readonly torchEnabled: boolean;
+}
+
+const styles = StyleSheet.create({
+	feed: { flex: 1 },
+});
+
+const MIME_TYPES: Record<string, string> = {
+	jpeg: 'image/jpeg',
+	heic: 'image/heic',
+	dng: 'image/x-adobe-dng',
+	tiff: 'image/tiff',
+};
+
+/** VisionCamera reports orientation as a compass value; the contract wants degrees. */
+const ORIENTATION_DEGREES: Record<string, number> = {
+	up: 0,
+	right: 90,
+	down: 180,
+	left: 270,
+};
+
+function toFileUri(path: string): string {
+	return path.startsWith('file://') ? path : `file://${path}`;
+}
+
+function toFilePath(uri: string): string {
+	return uri.startsWith('file://') ? uri.slice('file://'.length) : uri;
+}
+
+/** Native failures carry no code and may name a file path; never surface them raw. */
+function asCameraError(error: unknown, code: 'captureFailed' | 'storageFailure'): CameraError {
+	return isCameraError(error) ? error : new CameraError(code);
+}
+
+async function capturePhoto(
+	photoOutput: CameraPhotoOutput,
+	request: CaptureRequest,
+	cameraPosition: CameraPosition,
+): Promise<CapturedImage> {
+	let photo: Awaited<ReturnType<CameraPhotoOutput['capturePhoto']>>;
+	try {
+		photo = await photoOutput.capturePhoto({ flashMode: request.flashMode ?? 'off' }, {});
+	} catch (error) {
+		throw asCameraError(error, 'captureFailed');
+	}
+	try {
+		// A destination makes the artifact app-owned, so it is written straight
+		// there; otherwise it goes to a temporary file (FR-026a).
+		let path: string;
+		if (request.destination) {
+			try {
+				await photo.saveToFileAsync(toFilePath(request.destination));
+			} catch {
+				throw new CameraError(
+					'storageFailure',
+					'Could not write the capture to the requested destination',
+				);
+			}
+			path = request.destination;
+		} else {
+			// VisionCamera's own temporary directory. The controller moves the file
+			// into the artifact store, when it has one, so cleanup can reach it.
+			try {
+				path = await photo.saveToTemporaryFileAsync();
+			} catch (error) {
+				throw asCameraError(error, 'storageFailure');
+			}
+		}
+
+		return {
+			uri: toFileUri(path),
+			mimeType: MIME_TYPES[photo.containerFormat] ?? 'application/octet-stream',
+			width: photo.width,
+			height: photo.height,
+			timestamp: Date.now(),
+			cameraPosition: request.cameraPosition ?? cameraPosition,
+			// Ownership is decided by the controller from the original request;
+			// this value is overwritten there and is only a safe default.
+			ownership: request.destination ? 'appOwned' : 'packageTemporary',
+			// Quality is fixed on the photo output, not per capture, and nothing here
+			// resizes. Report what was actually applied rather than echo the hints.
+			effectiveQuality: DEFAULT_QUALITY,
+			effectiveMaxDimension: unavailable(),
+			// The native layer reports neither back after a save, and guessing them
+			// would be worse than saying so (FR-022).
+			fileSize: unavailable(),
+			orientation:
+				photo.orientation in ORIENTATION_DEGREES
+					? known(ORIENTATION_DEGREES[photo.orientation])
+					: unavailable(),
+		};
+	} finally {
+		// Large native buffers must not wait for the JS GC.
+		photo.dispose();
+	}
+}
+
+export const VisionCameraFeed: React.FC<VisionCameraFeedProps> = ({
+	cameraPosition,
+	resizeMode,
+	torchEnabled,
+}) => {
+	const device = useCameraDevice(cameraPosition);
+	const photoOutput = usePhotoOutput({ quality: DEFAULT_QUALITY });
+
+	const surface = useMemo(
+		() => ({
+			capture: (request: CaptureRequest) =>
+				capturePhoto(photoOutput, request, cameraPosition),
+		}),
+		[photoOutput, cameraPosition],
+	);
+
+	useEffect(() => registerVisionSurface(surface), [surface]);
+
+	// VisionCamera applies `torchMode` on mount, before the camera is active, and
+	// leaves the native "Camera is not active" rejection unhandled — one red
+	// error per session start. Leave the prop unset until the torch is first
+	// turned on; after that 'off' must be sent explicitly to turn it back off.
+	const [torchTouched, setTorchTouched] = useState(false);
+	if (torchEnabled && !torchTouched) {
+		setTorchTouched(true);
+	}
+	const torchMode = torchEnabled ? 'on' : torchTouched ? 'off' : undefined;
+
+	if (!device) {
+		return null;
+	}
+
+	return (
+		<Camera
+			style={styles.feed}
+			device={device}
+			outputs={[photoOutput]}
+			isActive={true}
+			resizeMode={resizeMode}
+			torchMode={torchMode}
+		/>
+	);
+};

package/src/react/hooks.ts

@@ -6,7 +6,7 @@
  * away (FR-016).
  */
 
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
 
 import type { CameraState } from '../config/types';
 import {
@@ -21,10 +21,23 @@ export function useCameraController(
 	// Options usually arrive as a fresh object literal each render; capturing
 	// them in a ref keeps the controller stable for the component's lifetime.
 	const optionsRef = useRef(options);
-	const controller = useMemo(() => createCameraController(optionsRef.current), []);
+	// Construction has no side effects (the controller subscribes on first use),
+	// so a controller React builds and discards here costs nothing.
+	const [controller, setController] = useState(() => createCameraController(optionsRef.current));
+	const disposedRef = useRef(new WeakSet<CameraController>());
 
 	useEffect(() => {
+		// StrictMode, and React's planned offscreen reuse, run the cleanup and then
+		// this effect again on the same component. Disposal is final, so the old
+		// controller cannot be revived; replace it. Before this, the screen kept a
+		// dead controller after the remount and the camera never started.
+		const disposed = disposedRef.current;
+		if (disposed.has(controller)) {
+			setController(createCameraController(optionsRef.current));
+			return undefined;
+		}
 		return () => {
+			disposed.add(controller);
 			controller.dispose().catch(() => undefined);
 		};
 	}, [controller]);
@@ -33,12 +46,13 @@ export function useCameraController(
 }
 
 export function useCameraState(controller: CameraController): CameraState {
-	const [state, setState] = useState<CameraState>(controller.state);
-
-	useEffect(() => {
-		setState(controller.state);
-		return controller.subscribe(setState);
-	}, [controller]);
-
-	return state;
+	// `subscribe` is a property of the controller object, so it is stable for the
+	// controller's lifetime, which is what useSyncExternalStore requires. The
+	// store read is tear-free, unlike the previous useState copy, which could
+	// miss a change made between render and effect.
+	return useSyncExternalStore(
+		controller.subscribe,
+		() => controller.state,
+		() => controller.state,
+	);
 }

package/src/storage/artifactStore.ts

@@ -16,6 +16,14 @@ export interface ArtifactStore {
 	remove(uri: string): Promise<void>;
 	/** Deletes owned artifacts older than `olderThanMs`; returns the count. */
 	sweep(olderThanMs: number): Promise<number>;
+	/**
+	 * Brings a fresh capture under the store and returns its managed URI: a file
+	 * already inside the store is recorded as created by this process, a file
+	 * anywhere else is moved in. Without this, a capture the engine wrote to its
+	 * own temporary directory is never owned, so `cleanup()` refuses it and the
+	 * sweep never sees it. Optional so app-written stores keep compiling.
+	 */
+	adopt?(uri: string): Promise<string>;
 }
 
 /** Minimal filesystem surface the adapter needs. Injectable for tests. */
@@ -26,6 +34,12 @@ export interface FileSystemBridge {
 	list(directory: string): Promise<readonly string[]>;
 	createdAt(path: string): Promise<number>;
 	ensureDirectory(directory: string): Promise<void>;
+	/**
+	 * Moves a file. Needed by `adopt()` to pull a capture out of the engine's own
+	 * temporary directory; a bridge without it can only adopt files already
+	 * inside the store.
+	 */
+	move?(from: string, to: string): Promise<void>;
 }
 
 export interface StoreOptions {
@@ -48,17 +62,19 @@ export function createArtifactStore(
 	// Artifacts created by this process are never swept, no matter their age.
 	const createdThisProcess = new Set<string>();
 
+	function owns(uri: string): boolean {
+		return normalize(uri).startsWith(`${normalizedRoot}/`);
+	}
+
 	return {
 		temporaryDirectory() {
 			return root;
 		},
 
-		owns(uri) {
-			return normalize(uri).startsWith(`${normalizedRoot}/`);
-		},
+		owns,
 
 		async remove(uri) {
-			if (!this.owns(uri)) {
+			if (!owns(uri)) {
 				return;
 			}
 			const path = normalize(uri);
@@ -88,6 +104,23 @@ export function createArtifactStore(
 			}
 			return removed;
 		},
+
+		async adopt(uri) {
+			const path = normalize(uri);
+			if (owns(uri)) {
+				createdThisProcess.add(path);
+				return uri;
+			}
+			if (!fs.move) {
+				throw new Error('This FileSystemBridge has no move(), so it cannot adopt a capture');
+			}
+			await fs.ensureDirectory(root);
+			const name = path.slice(path.lastIndexOf('/') + 1) || `capture-${Date.now()}.jpg`;
+			const target = `${root}/${name}`;
+			await fs.move(path, target);
+			createdThisProcess.add(normalize(target));
+			return uri.startsWith('file://') ? `file://${normalize(target)}` : target;
+		},
 	};
 }
 

package/src/testing/testCameraAdapter.ts

@@ -55,6 +55,13 @@ export function createMemoryFileSystem(root = '/cache'): MemoryFileSystem {
 		async ensureDirectory(directory) {
 			directories.add(directory);
 		},
+		async move(from, to) {
+			if (!files.has(from)) {
+				throw new Error('No such file');
+			}
+			files.set(to, files.get(from) ?? Date.now());
+			files.delete(from);
+		},
 		seed(path, createdAtMs) {
 			files.set(path, createdAtMs);
 		},