@succinctlabs/react-native-zcam1 0.2.5

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@succinctlabs/react-native-zcam1",
+  "version": "0.2.5",
+  "description": "ZCAM1 SDK",
+  "main": "./lib/module/index.js",
+  "codegenConfig": {
+    "name": "Zcam1SdkSpec",
+    "type": "modules",
+    "jsSrcsDir": "src"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/succinctlabs/zcam1-sdk.git"
+  },
+  "author": "leruaa",
+  "license": "MIT",
+  "homepage": "https://github.com/succinctlabs/zcam1-sdk#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.18.0",
+    "@react-native/babel-preset": "0.81.1",
+    "@types/react": "^19.1.0",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "prettier": "^3.8.1",
+    "react-native-builder-bob": "^0.40.17",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.0"
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "turbo-module",
+    "version": "0.54.8"
+  },
+  "dependencies": {
+    "@noble/hashes": "^2.0.1",
+    "@pagopa/io-react-native-crypto": "^1.2.4",
+    "@pagopa/io-react-native-integrity": "^0.3.2",
+    "@react-native-camera-roll/camera-roll": "^7.10.2",
+    "@scure/base": "^2.0.0",
+    "@shopify/flash-list": "^2.2.0",
+    "jail-monkey": "^2.8.5",
+    "react-native-create-thumbnail": "^2.2.0",
+    "react-native-encrypted-storage": "^4.0.0",
+    "react-native-file-access": "^3.2.0",
+    "uniffi-bindgen-react-native": "^0.29.3-1"
+  },
+  "peerDependencies": {
+    "react": ">=19",
+    "react-native": ">=0.81"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./proving": {
+      "source": "./src/proving/index.ts",
+      "types": "./lib/typescript/src/proving/index.d.ts",
+      "default": "./lib/module/proving/index.js"
+    },
+    "./app.plugin.js": "./app.plugin.js",
+    "./package.json": "./package.json"
+  },
+  "types": "./lib/typescript/src/index.d.ts",
+  "scripts": {
+    "ubrn:ios": "CARGO_FEATURE_NO_NEON=1 ubrn build ios --and-generate",
+    "ubrn:ios:proving": "CARGO_FEATURE_NO_NEON=1 ubrn build ios --config ubrn.config.proving.yaml --and-generate",
+    "ubrn:android": "ubrn build android --and-generate",
+    "ubrn:web": "ubrn build web",
+    "clean": "rm -rfv cpp/ android/CMakeLists.txt android/src/main/java android/*.cpp ios/ src/generated/",
+    "build": "bob build",
+    "prepack": "npm run ubrn:ios -- --release && npm run ubrn:ios:proving -- --release && npm run build && if [ -z \"$NPM_CONFIG_REGISTRY\" ]; then mv Zcam1Framework.xcframework Zcam1Framework.xcframework.excluded && mv Zcam1ProvingFramework.xcframework Zcam1ProvingFramework.xcframework.excluded; fi",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx}\"",
+    "preyalcpublish": "mv Zcam1Framework.xcframework.excluded Zcam1Framework.xcframework && mv Zcam1ProvingFramework.xcframework.excluded Zcam1ProvingFramework.xcframework",
+    "postyalcpublish": "mv Zcam1Framework.xcframework Zcam1Framework.xcframework.excluded && mv Zcam1ProvingFramework.xcframework Zcam1ProvingFramework.xcframework.excluded",
+    "postpublish": "if [ -e Zcam1Framework.xcframework.excluded ]; then mv Zcam1Framework.xcframework.excluded Zcam1Framework.xcframework; fi"
+  },
+  "files": [
+    "src",
+    "lib",
+    "cpp",
+    "ios",
+    "scripts",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "*.podspec",
+    "Zcam1Framework.xcframework",
+    "Zcam1ProvingFramework.xcframework",
+    "app.plugin.js",
+    "turbo.json"
+  ],
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      "typescript"
+    ]
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ]
+}

package/src/NativeZcam1Capture.ts

@@ -0,0 +1,335 @@
+import { type TurboModule, TurboModuleRegistry } from "react-native";
+
+export type TakeNativePhotoFormat = "jpeg" | "dng";
+
+export interface TakeNativePhotoOptions {
+  /**
+   * Desired output format. Defaults to "jpeg" if not provided.
+   */
+  format?: TakeNativePhotoFormat;
+
+  /**
+   * Optional quality hint for JPEG captures (0–1).
+   * Ignored for DNG.
+   */
+  quality?: number;
+}
+
+export interface TakeNativePhotoResult {
+  /**
+   * Local filesystem path to the captured image file.
+   * This is typically a "file://" URL or absolute path.
+   */
+  filePath: string;
+
+  /**
+   * The actual format of the captured file.
+   */
+  format: TakeNativePhotoFormat;
+
+  /**
+   * Optional metadata extracted by the native layer (EXIF, etc).
+   */
+  metadata?: { [key: string]: unknown } | null;
+
+  /**
+   * Depth data extracted from the captured photo (if available).
+   *
+   * This is only returned when the caller requested it via the `includeDepthData`
+   * parameter on `takeNativePhoto(...)`, and only on devices/capture formats that
+   * support depth delivery.
+   */
+  depthData?: { [key: string]: unknown } | null;
+}
+
+export type NativeVideoRecordingFormat = "mov";
+
+export interface StartNativeVideoRecordingResult {
+  /**
+   * Indicates that recording successfully started.
+   */
+  status: "recording";
+
+  /**
+   * Local filesystem path to the in-progress movie file.
+   */
+  filePath: string;
+
+  /**
+   * Container format for the recording.
+   */
+  format: NativeVideoRecordingFormat;
+
+  /**
+   * Whether audio is included in this recording.
+   * This depends on microphone permission and native session configuration.
+   */
+  hasAudio: boolean;
+}
+
+export interface StopNativeVideoRecordingResult {
+  /**
+   * Local filesystem path to the finalized movie file.
+   */
+  filePath: string;
+
+  /**
+   * Container format for the recording.
+   */
+  format: NativeVideoRecordingFormat;
+
+  /**
+   * Whether audio is included in this recording.
+   */
+  hasAudio: boolean;
+
+  /**
+   * Device make (if available).
+   */
+  deviceMake: string;
+
+  /**
+   * Device model (if available).
+   */
+  deviceModel: string;
+
+  /**
+   * Software version (if available).
+   */
+  softwareVersion: string;
+
+  /**
+   * Duration of the recorded clip in seconds (if available).
+   */
+  durationSeconds: number;
+
+  /**
+   * File size in bytes (if available).
+   */
+  fileSizeBytes: number;
+
+  /**
+   * Video pixel width (rotation-corrected, if available).
+   */
+  width: number;
+
+  /**
+   * Video pixel height (rotation-corrected, if available).
+   */
+  height: number;
+
+  /**
+   * Rotation in degrees derived from the video track transform (if available).
+   * Common values: 0, 90, 180, 270.
+   */
+  rotationDegrees: number;
+
+  /**
+   * Nominal frame rate (fps, if available).
+   */
+  frameRate: number;
+
+  /**
+   * Video codec FourCC (e.g. "avc1", "hvc1") if available.
+   */
+  videoCodec?: string;
+
+  /**
+   * Audio codec FourCC (e.g. "aac ") if available.
+   */
+  audioCodec?: string;
+
+  /**
+   * Audio sample rate in Hz (if available).
+   */
+  audioSampleRate?: number;
+
+  /**
+   * Audio channel count (if available).
+   */
+  audioChannels?: number;
+}
+
+export type FlashMode = "off" | "on" | "auto";
+
+export type AspectRatio = "4:3" | "16:9" | "1:1";
+
+export type Orientation = "auto" | "portrait" | "landscape";
+
+/**
+ * Physical device orientation as reported by the accelerometer.
+ * Unlike Orientation (which is a capture setting), this reflects the
+ * actual device position and is emitted via onOrientationChange events.
+ */
+export type DeviceOrientation =
+  | "portrait"
+  | "portraitUpsideDown"
+  | "landscapeLeft"
+  | "landscapeRight";
+
+export interface Spec extends TurboModule {
+  /**
+   * Capture a photo using the native camera stack (Swift/AVFoundation)
+   * without going through react-native-vision-camera.
+   *
+   * The native implementation is responsible for:
+   * - Handling permissions
+   * - Presenting a preview / capture UI as needed
+   * - Writing the resulting JPEG or DNG file and returning its path
+   *
+   * @param includeDepthData When true, native should request depth (+ calibration)
+   * data delivery for this capture (if supported). When false, native should avoid
+   * enabling depth delivery and `depthData` will be omitted from the result.
+   * @param skipPostProcessing When true, returns raw sensor output without cropping
+   * or rotation. Useful for developers who want to handle their own post-processing.
+   */
+  takeNativePhoto(
+    format: TakeNativePhotoFormat,
+    position: "front" | "back",
+    flash: FlashMode,
+    includeDepthData: boolean,
+    aspectRatio: AspectRatio,
+    orientation: Orientation,
+    skipPostProcessing: boolean,
+  ): Promise<TakeNativePhotoResult>;
+
+  /**
+   * Start recording a video using the native camera stack.
+   *
+   * The recording is written to a temporary file and continues until
+   * `stopNativeVideoRecording()` is called or the optional duration cap is reached.
+   *
+   * @param position Which camera to use.
+   * @param maxDurationSeconds Maximum recording duration in seconds. The native
+   *   layer will automatically stop recording when this limit is reached. Pass 0
+   *   for unlimited recording.
+   */
+  startNativeVideoRecording(
+    position: "front" | "back",
+    maxDurationSeconds: number,
+  ): Promise<StartNativeVideoRecordingResult>;
+
+  /**
+   * Stop an in-progress recording and return the finalized file path + metadata.
+   */
+  stopNativeVideoRecording(): Promise<StopNativeVideoRecordingResult>;
+
+  /**
+   * Set zoom factor programmatically (instant, no animation).
+   * For virtual devices with ultra-wide, 1.0 is ultra-wide (0.5x user-facing),
+   * 2.0 is wide-angle (1x user-facing), etc.
+   * @param factor Device zoom factor (use getMinZoom/getMaxZoom for valid range)
+   */
+  setZoom(factor: number): void;
+
+  /**
+   * Set zoom factor with smooth animation (recommended for pinch-to-zoom gestures).
+   * Uses native AVFoundation ramp for smooth transitions across lens switchover boundaries.
+   * @param factor Device zoom factor (use getMinZoom/getMaxZoom for valid range)
+   */
+  setZoomAnimated(factor: number): void;
+
+  /**
+   * Get the minimum supported zoom factor.
+   * For virtual devices with ultra-wide, this is 1.0 (corresponds to 0.5x user-facing).
+   */
+  getMinZoom(): Promise<number>;
+
+  /**
+   * Get the maximum supported zoom factor (capped at 15x for UX).
+   */
+  getMaxZoom(): Promise<number>;
+
+  /**
+   * Get the zoom factors where the device switches between physical lenses.
+   * Returns empty array for single-camera devices.
+   * For triple camera: typically [2.0, 6.0] meaning:
+   * - Below 2.0: ultra-wide lens (0.5x-1x user-facing)
+   * - At 2.0: switches FROM ultra-wide TO wide lens (1x user-facing)
+   * - At 6.0: switches FROM wide TO telephoto lens (3x user-facing)
+   */
+  getSwitchOverZoomFactors(): Promise<number[]>;
+
+  /**
+   * Check if the current device has an ultra-wide camera.
+   * This is true for builtInTripleCamera and builtInDualWideCamera (iPhone 11+, Pro models).
+   * This is false for builtInDualCamera (Wide + Telephoto, e.g., iPhone X/XS) and single-lens devices.
+   *
+   * Use this to correctly interpret zoom factors:
+   * - If hasUltraWide: minZoom (1.0) = 0.5x user-facing, switchOverFactors[0] (2.0) = 1x user-facing
+   * - If !hasUltraWide: minZoom (1.0) = 1x user-facing, switchOverFactors[0] (2.0) = 2x user-facing (telephoto)
+   */
+  hasUltraWideCamera(): Promise<boolean>;
+
+  /**
+   * Get the supported exposure compensation range in EV units.
+   * Returns the device's min and max exposure target bias values.
+   */
+  getExposureRange(): Promise<{ min: number; max: number }>;
+
+  /**
+   * Reset exposure compensation to neutral (0 EV).
+   */
+  resetExposure(): void;
+
+  /**
+   * Focus at a normalized point in the preview.
+   * Also adjusts exposure point if supported.
+   * @param x Normalized x coordinate (0-1, left to right)
+   * @param y Normalized y coordinate (0-1, top to bottom)
+   */
+  focusAtPoint(x: number, y: number): void;
+
+  /**
+   * Get diagnostic info about the current camera device for debugging.
+   * Returns device type, supported zoom range, switching behavior, and more.
+   * Useful for debugging zoom issues on different device configurations.
+   */
+  getDeviceDiagnostics(): Promise<{
+    deviceType: string;
+    minZoom: number;
+    maxZoom: number;
+    currentZoom: number;
+    switchOverFactors: number[];
+    switchingBehavior: number;
+    isVirtualDevice: boolean;
+    currentExposureBias: number;
+    minExposureBias: number;
+    maxExposureBias: number;
+    currentISO: number;
+    exposureDuration: number;
+  }>;
+
+  /**
+   * Check if the current camera device supports depth data capture.
+   * Returns true for dual/triple rear cameras and TrueDepth front camera.
+   * Returns false for single rear cameras (iPhone SE, 16e, Air).
+   */
+  isDepthSupported(): Promise<boolean>;
+
+  /**
+   * Check if enabling depth would restrict zoom on this device.
+   * Returns true if zoom is limited to discrete levels (min == max in all ranges).
+   * This typically happens on dual-camera devices (iPhone 12-16 base).
+   * Returns false for triple-camera devices (Pro) and TrueDepth front cameras.
+   */
+  hasDepthZoomLimitations(): Promise<boolean>;
+
+  /**
+   * Get zoom ranges supported when depth data delivery is enabled.
+   * Returns array of [min, max] pairs. If min == max, it's a discrete level.
+   * Empty array means no depth support or no zoom restrictions.
+   *
+   * Example for dual-camera iPhone: [[2.0, 2.0], [4.0, 4.0]] (discrete 1x and 2x only)
+   * Example for triple-camera iPhone: [[1.0, 6.0]] (continuous zoom supported)
+   */
+  getDepthSupportedZoomRanges(): Promise<number[][]>;
+
+  /**
+   * Present a native full-screen preview for any file using QLPreviewController.
+   * Supports images, videos, PDFs, and other common file types.
+   * @param filePath Absolute filesystem path to the file.
+   */
+  previewFile(filePath: string): Promise<void>;
+}
+export default TurboModuleRegistry.getEnforcing<Spec>("Zcam1Capture");

package/src/NativeZcam1Sdk.ts

@@ -0,0 +1,10 @@
+// Generated by uniffi-bindgen-react-native
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  installRustCrate(): boolean;
+  cleanupRustCrate(): boolean;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Zcam1Sdk');

package/src/bindings.tsx

@@ -0,0 +1,49 @@
+// Generated by uniffi-bindgen-react-native
+import installer from './NativeZcam1Sdk';
+
+// Register the rust crate with Hermes
+// - the boolean flag ensures this loads exactly once, even if the JS
+//   code is reloaded (e.g. during development with metro).
+let rustInstalled = false;
+if (!rustInstalled) {
+  installer.installRustCrate();
+  rustInstalled = true;
+}
+
+// Export the generated bindings to the app.
+export * from './generated/zcam1_c2pa_utils';
+export * from './generated/zcam1_certs_utils';
+export * from './generated/zcam1_verify_utils';
+
+// Now import the bindings so we can:
+// - intialize them
+// - export them as namespaced objects as the default export.
+import * as zcam1_c2pa_utils from './generated/zcam1_c2pa_utils';
+import * as zcam1_certs_utils from './generated/zcam1_certs_utils';
+import * as zcam1_verify_utils from './generated/zcam1_verify_utils';
+
+// Initialize the generated bindings: mostly checksums, but also callbacks.
+// - the boolean flag ensures this loads exactly once, even if the JS code
+//   is reloaded (e.g. during development with metro).
+let initialized = false;
+if (!initialized) {
+  zcam1_c2pa_utils.default.initialize();
+  zcam1_certs_utils.default.initialize();
+  zcam1_verify_utils.default.initialize();
+  initialized = true;
+}
+
+// This provides parity with the index.web.ts version of this file.
+// The web version relies on an asynchronous fetch, which this doesn't
+// need, so we just no-op.
+export async function uniffiInitAsync() {
+  // NOOP.
+}
+
+// Export the crates as individually namespaced objects.
+export default {
+  zcam1_c2pa_utils,
+  zcam1_certs_utils,
+  zcam1_verify_utils,
+};
+