@chipmobilesdk/rn-camera 0.2.0 → 0.2.1

package/src/react/VisionCameraFeed.tsx

@@ -1,178 +1,177 @@
-/**
- * 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}
-		/>
-	);
-};
+/**
+ * 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

@@ -1,58 +1,56 @@
-/**
- * React bindings for the camera controller.
- *
- * `useCameraController` owns the controller lifetime and disposes it on
- * unmount, which is what guarantees the camera is released when a screen goes
- * away (FR-016).
- */
-
-import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
-
-import type { CameraState } from '../config/types';
-import {
-	createCameraController,
-	type CameraController,
-	type CameraControllerOptions,
-} from '../core/controller';
-
-export function useCameraController(
-	options: CameraControllerOptions = {},
-): CameraController {
-	// 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);
-	// 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]);
-
-	return controller;
-}
-
-export function useCameraState(controller: CameraController): CameraState {
-	// `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,
-	);
-}
+/**
+ * React bindings for the camera controller.
+ *
+ * `useCameraController` owns the controller lifetime and disposes it on
+ * unmount, which is what guarantees the camera is released when a screen goes
+ * away (FR-016).
+ */
+
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react';
+
+import type { CameraState } from '../config/types';
+import {
+	createCameraController,
+	type CameraController,
+	type CameraControllerOptions,
+} from '../core/controller';
+
+export function useCameraController(options: CameraControllerOptions = {}): CameraController {
+	// 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);
+	// 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]);
+
+	return controller;
+}
+
+export function useCameraState(controller: CameraController): CameraState {
+	// `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,
+	);
+}