one 2.6.20 → 2.6.22

package/ios/OneNativeCameraView.swift

@@ -13,9 +13,28 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
   }
 }
 
+// one capture in flight; AVCapturePhotoOutput holds its delegate weakly.
+private final class CameraPhotoDelegate: NSObject, AVCapturePhotoCaptureDelegate {
+  let finish: (AVCapturePhoto?, Error?) -> Void
+
+  init(finish: @escaping (AVCapturePhoto?, Error?) -> Void) {
+    self.finish = finish
+  }
+
+  func photoOutput(
+    _ output: AVCapturePhotoOutput,
+    didFinishProcessingPhoto photo: AVCapturePhoto,
+    error: Error?
+  ) {
+    finish(photo, error)
+  }
+}
+
 @objcMembers public final class OneNativeCameraView: UIView {
   public var onStateChange: ((String) -> Void)?
   public var onCodeScanned: ((String, String) -> Void)?
+  // requestId, uri, width, height, base64, error ("" on success).
+  public var onPicture: ((Int, String, Int, Int, String, String) -> Void)?
 
   public override class var layerClass: AnyClass { AVCaptureVideoPreviewLayer.self }
 
@@ -32,6 +51,10 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
   private let sessionQueue = DispatchQueue(label: "dev.one.camera.capture")
   private var session: AVCaptureSession?
   private var metadataOutput: AVCaptureMetadataOutput?
+  // owned by sessionQueue.
+  private var photoOutput: AVCapturePhotoOutput?
+  private var captureDevice: AVCaptureDevice?
+  private var photoDelegates: [Int: CameraPhotoDelegate] = [:]
   private let metadataDelegate = CameraMetadataDelegate()
   private var sessionObservers: [NSObjectProtocol] = []
   private var rotationCoordinator: AVCaptureDevice.RotationCoordinator?
@@ -41,6 +64,9 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
   private var active = false
   private var facing = "back"
   private var codeTypes: [String] = []
+  private var flash = "off"
+  private var torch = false
+  private var zoom: Double = 0
   private var generation = 0
   private var lastState = ""
   private var activeObserver: NSObjectProtocol?
@@ -82,13 +108,132 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
     refresh(reconfigure: true)
   }
 
+  // flash, torch and zoom change the running device without restarting the session.
+  public func configureCapture(_ flash: String, torch: Bool, zoom: Double) {
+    guard self.flash != flash || self.torch != torch || self.zoom != zoom else { return }
+    self.flash = flash
+    self.torch = torch
+    self.zoom = zoom
+    sessionQueue.async { self.applyDeviceSettings(torch: torch, zoom: zoom) }
+  }
+
   public func reset() {
     active = false
     facing = "back"
     codeTypes = []
+    flash = "off"
+    torch = false
+    zoom = 0
     refresh()
   }
 
+  private func applyDeviceSettings(torch: Bool, zoom: Double) {
+    guard let device = captureDevice, (try? device.lockForConfiguration()) != nil else { return }
+    defer { device.unlockForConfiguration() }
+    let torchMode: AVCaptureDevice.TorchMode = torch ? .on : .off
+    if device.hasTorch, device.isTorchModeSupported(torchMode) { device.torchMode = torchMode }
+    let low = device.minAvailableVideoZoomFactor
+    let high = device.maxAvailableVideoZoomFactor
+    device.videoZoomFactor = low + CGFloat(zoom) * (high - low)
+  }
+
+  public func takePicture(_ requestId: Int, quality: Double, base64: Bool) {
+    let fail = { [weak self] (code: String, message: String) in
+      self?.onPicture?(requestId, "", 0, 0, "", "\(code): \(message)")
+    }
+    guard sessionReady, let coordinator = rotationCoordinator else {
+      let state = lastState.isEmpty ? "waiting" : lastState
+      fail("E_CAMERA_NOT_READY", "CameraView is not ready to take a picture (state: \(state))")
+      return
+    }
+    let angle = coordinator.videoRotationAngleForHorizonLevelCapture
+    let flashName = flash
+    let current = generation
+    sessionQueue.async { [weak self] in
+      guard let self, let output = self.photoOutput,
+        output.availablePhotoCodecTypes.contains(.jpeg)
+      else {
+        DispatchQueue.main.async { fail("E_CAMERA_NOT_READY", "CameraView has no photo output") }
+        return
+      }
+      let settings = AVCapturePhotoSettings(format: [
+        AVVideoCodecKey: AVVideoCodecType.jpeg,
+        AVVideoCompressionPropertiesKey: [AVVideoQualityKey: quality],
+      ])
+      let flashMode: AVCaptureDevice.FlashMode =
+        flashName == "on" ? .on : flashName == "auto" ? .auto : .off
+      if output.supportedFlashModes.contains(flashMode) { settings.flashMode = flashMode }
+      if let connection = output.connection(with: .video),
+        connection.isVideoRotationAngleSupported(angle)
+      {
+        connection.videoRotationAngle = angle
+      }
+      let delegate = CameraPhotoDelegate { [weak self] photo, error in
+        guard let self else { return }
+        // photo callbacks arrive on the output's private queue.
+        self.sessionQueue.async { self.photoDelegates[requestId] = nil }
+        let result = Self.savePicture(photo: photo, error: error, base64: base64)
+        DispatchQueue.main.async {
+          guard self.generation == current else {
+            fail("E_CAMERA_INACTIVE", "CameraView stopped before the picture was taken")
+            return
+          }
+          switch result {
+          case .success(let picture):
+            self.onPicture?(requestId, picture.uri, picture.width, picture.height, picture.base64, "")
+          case .failure(let failure):
+            fail("E_CAMERA_CAPTURE", failure.message)
+          }
+        }
+      }
+      self.photoDelegates[requestId] = delegate
+      output.capturePhoto(with: settings, delegate: delegate)
+    }
+  }
+
+  private struct SavedPicture {
+    let uri: String
+    let width: Int
+    let height: Int
+    let base64: String
+  }
+
+  private struct CaptureFailure: Error {
+    let message: String
+  }
+
+  // writes the jpeg to caches/Camera and reports its displayed size: exif
+  // orientations 5 to 8 are rotated a quarter turn, so their sides swap.
+  private static func savePicture(
+    photo: AVCapturePhoto?, error: Error?, base64: Bool
+  ) -> Result<SavedPicture, CaptureFailure> {
+    if let error { return .failure(CaptureFailure(message: error.localizedDescription)) }
+    guard let data = photo?.fileDataRepresentation(),
+      let source = CGImageSourceCreateWithData(data as CFData, nil),
+      let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any],
+      let pixelWidth = properties[kCGImagePropertyPixelWidth] as? Int,
+      let pixelHeight = properties[kCGImagePropertyPixelHeight] as? Int
+    else { return .failure(CaptureFailure(message: "The camera returned no image data")) }
+    let orientation = properties[kCGImagePropertyOrientation] as? Int ?? 1
+    let quarterTurn = (5...8).contains(orientation)
+    do {
+      let directory = try FileManager.default
+        .url(for: .cachesDirectory, in: .userDomainMask, appropriateFor: nil, create: true)
+        .appendingPathComponent("Camera", isDirectory: true)
+      try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+      let file = directory.appendingPathComponent("\(UUID().uuidString).jpg")
+      try data.write(to: file, options: .atomic)
+      return .success(SavedPicture(
+        uri: file.absoluteString,
+        width: quarterTurn ? pixelHeight : pixelWidth,
+        height: quarterTurn ? pixelWidth : pixelHeight,
+        base64: base64 ? data.base64EncodedString() : ""
+      ))
+    } catch {
+      return .failure(CaptureFailure(message: error.localizedDescription))
+    }
+  }
+
   private func emitState(_ state: String) {
     guard lastState != state else { return }
     lastState = state
@@ -115,6 +260,8 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
       sessionQueue.async {
         self.session?.stopRunning()
         self.session = nil
+        self.photoOutput = nil
+        self.captureDevice = nil
       }
       emitState("inactive")
       return
@@ -125,6 +272,8 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
       sessionQueue.async {
         self.session?.stopRunning()
         self.session = nil
+        self.photoOutput = nil
+        self.captureDevice = nil
       }
       emitState("permission-required")
       return
@@ -142,6 +291,8 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
       guard let self else { return }
       self.session?.stopRunning()
       self.session = nil
+      self.photoOutput = nil
+      self.captureDevice = nil
       guard let device = AVCaptureDevice.default(
         .builtInWideAngleCamera, for: .video, position: position
       ) else {
@@ -178,7 +329,16 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
         metadata.setMetadataObjectsDelegate(self.metadataDelegate, queue: self.sessionQueue)
         output = metadata
       }
+      let photo = AVCapturePhotoOutput()
+      guard next.canAddOutput(photo) else {
+        next.commitConfiguration()
+        self.emitState("failed", generation: current)
+        return
+      }
+      next.addOutput(photo)
       next.commitConfiguration()
+      self.photoOutput = photo
+      self.captureDevice = device
 
       var readyState = "ready"
       if let output {
@@ -211,8 +371,11 @@ private final class CameraMetadataDelegate: NSObject, AVCaptureMetadataOutputObj
         }
         self.observeSession(next)
         let queue = self.sessionQueue
+        let torch = self.torch
+        let zoom = self.zoom
         queue.async { [weak self] in
           next.startRunning()
+          self?.applyDeviceSettings(torch: torch, zoom: zoom)
           let running = next.isRunning
           DispatchQueue.main.async { [weak self] in
             guard let self, self.generation == current else { return }

package/nitrogen/generated/shared/c++/HybridOneCryptoSpec.cpp

@@ -17,6 +17,8 @@ namespace margelo::nitro::one {
       prototype.registerHybridMethod("fillRandomBytes", &HybridOneCryptoSpec::fillRandomBytes);
       prototype.registerHybridMethod("randomUUID", &HybridOneCryptoSpec::randomUUID);
       prototype.registerHybridMethod("digest", &HybridOneCryptoSpec::digest);
+      prototype.registerHybridMethod("aesEncrypt", &HybridOneCryptoSpec::aesEncrypt);
+      prototype.registerHybridMethod("aesDecrypt", &HybridOneCryptoSpec::aesDecrypt);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridOneCryptoSpec.hpp

@@ -18,6 +18,7 @@
 #include <NitroModules/ArrayBuffer.hpp>
 #include <string>
 #include <NitroModules/Promise.hpp>
+#include <optional>
 
 namespace margelo::nitro::one {
 
@@ -46,13 +47,15 @@ namespace margelo::nitro::one {
 
     public:
       // Properties
-
+      
 
     public:
       // Methods
       virtual void fillRandomBytes(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length) = 0;
       virtual std::string randomUUID() = 0;
       virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> digest(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& buffer, double offset, double length) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> aesEncrypt(const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv, const std::shared_ptr<ArrayBuffer>& plaintext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData, double tagLength) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> aesDecrypt(const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& iv, const std::shared_ptr<ArrayBuffer>& ciphertext, const std::optional<std::shared_ptr<ArrayBuffer>>& additionalData, double tagLength) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "one",
-  "version": "2.6.20",
+  "version": "2.6.22",
   "description": "One is a React framework for web, iOS, and Android apps.",
   "license": "BSD-3-Clause",
   "sideEffects": [
@@ -236,18 +236,18 @@
     "@react-navigation/native-stack": "8.0.0-alpha.58",
     "@react-navigation/routers": "8.0.0-alpha.20",
     "@ungap/structured-clone": "^1.2.0",
-    "@vxrn/color-scheme": "2.6.20",
-    "@vxrn/compiler": "2.6.20",
-    "@vxrn/resolve": "2.6.20",
-    "@vxrn/tslib-lite": "2.6.20",
-    "@vxrn/use-isomorphic-layout-effect": "2.6.20",
-    "@vxrn/utils": "2.6.20",
-    "@vxrn/vite-plugin-metro": "2.6.20",
+    "@vxrn/color-scheme": "2.6.22",
+    "@vxrn/compiler": "2.6.22",
+    "@vxrn/resolve": "2.6.22",
+    "@vxrn/tslib-lite": "2.6.22",
+    "@vxrn/use-isomorphic-layout-effect": "2.6.22",
+    "@vxrn/utils": "2.6.22",
+    "@vxrn/vite-plugin-metro": "2.6.22",
     "babel-dead-code-elimination": "1.0.10",
     "babel-plugin-module-resolver": "^5.0.2",
     "citty": "^0.1.6",
     "core-js": "^3.38.1",
-    "create-vxrn": "2.6.20",
+    "create-vxrn": "2.6.22",
     "escape-string-regexp": "^5.0.0",
     "fast-deep-equal": "^3.1.3",
     "fast-glob": "^3.3.3",
@@ -269,7 +269,7 @@
     "tsconfig-paths": "^4",
     "use-latest-callback": "^0.2.3",
     "vite": "^8.2.2",
-    "vxrn": "2.6.20",
+    "vxrn": "2.6.22",
     "web-streams-polyfill": "^4.3.0",
     "ws": "^8.21.0",
     "xxhashjs": "^0.2.2"
@@ -337,7 +337,7 @@
     "@types/react-dom": "^19.2.2",
     "@types/react-test-renderer": "^19.1.0",
     "@types/xxhashjs": "^0.2.4",
-    "@vxrn/emitter": "2.6.20",
+    "@vxrn/emitter": "2.6.22",
     "depcheck": "^1.4.7",
     "esbuild": "^0.25.12",
     "immer": "^10.1.1",
@@ -513,7 +513,7 @@
       }
     }
   },
-  "releaseSourceCommit": "1b992f990d752550fb6fc0894878f5e86f612d06",
+  "releaseSourceCommit": "04df94112b1398e221a0c7771f1d4357e6f70ef2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/onejs/one.git",

package/src/index.ts

@@ -1,6 +1,7 @@
 export { createApp } from './createApp'
 
 export { One } from './one'
+export { AESEncryptionKey, AESSealedData } from './platform'
 // native hooks and adaptive reads are named exports for react-hooks lint.
 export {
   useFonts,
@@ -64,6 +65,9 @@ export type {
   ComposeSnackbarShowOptions,
   ComposeSnackbarResult,
   ComposeModalBottomSheetRef,
+  CameraCapturedPicture,
+  CameraPictureOptions,
+  CameraViewRef,
 } from './platform'
 export type { OneRouter } from './interfaces/router'
 

package/src/one.ts

@@ -27,6 +27,7 @@ import {
   Purchases,
   ImageManipulator,
   Device,
+  Crypto as NativeCrypto,
   Localization,
   Motion,
   BackgroundTasks,
@@ -157,6 +158,7 @@ export type OneAPI = {
   readonly Purchases: typeof Purchases
   readonly ImageManipulator: typeof ImageManipulator
   readonly Device: typeof Device
+  readonly Crypto: typeof NativeCrypto
   readonly Localization: typeof Localization
   readonly Motion: typeof Motion
   readonly BackgroundTasks: typeof BackgroundTasks
@@ -268,6 +270,7 @@ export const One: OneAPI = Object.freeze({
   Purchases,
   ImageManipulator,
   Device,
+  Crypto: NativeCrypto,
   Localization,
   Motion,
   BackgroundTasks,

package/src/platform/camera/index.native.tsx

@@ -1,8 +1,43 @@
+import { forwardRef, useEffect, useImperativeHandle, useRef } from 'react'
 import { Platform } from 'react-native'
-import NativeCamera from '../specs/OneNativeCameraNativeComponent'
-import type { CameraCodeType, CameraState, CameraViewProps } from './types'
+import NativeCamera, { Commands } from '../specs/OneNativeCameraNativeComponent'
+import type {
+  CameraCapturedPicture,
+  CameraCodeType,
+  CameraState,
+  CameraViewProps,
+  CameraViewRef,
+} from './types'
 
-export type { CameraCode, CameraCodeType, CameraFacing, CameraState, CameraViewProps } from './types'
+export type {
+  CameraCapturedPicture,
+  CameraCode,
+  CameraCodeType,
+  CameraFacing,
+  CameraFlashMode,
+  CameraPictureOptions,
+  CameraState,
+  CameraViewProps,
+  CameraViewRef,
+} from './types'
+
+type PendingPicture = {
+  resolve: (picture: CameraCapturedPicture) => void
+  reject: (error: Error) => void
+  base64: boolean
+}
+
+let nextRequestId = 1
+
+function codedError(code: string, message: string) {
+  return Object.assign(new Error(message), { code })
+}
+
+// native failures arrive as "<code>: <message>", the same form nitro rejects with.
+function nativeError(value: string) {
+  const coded = /^((?:E|ERR)_[A-Z0-9_]+): ([\s\S]*)$/.exec(value)
+  return coded ? codedError(coded[1], coded[2]) : new Error(value)
+}
 
 function cameraState(value: string): CameraState {
   switch (value) {
@@ -41,14 +76,20 @@ function codeType(value: string): CameraCodeType {
   return value
 }
 
-export function CameraView({
-  active = true,
-  facing = 'back',
-  codeTypes = ['qr'],
-  onStateChange,
-  onCodeScanned,
-  ...viewProps
-}: CameraViewProps) {
+export const CameraView = forwardRef<CameraViewRef, CameraViewProps>(function CameraView(
+  {
+    active = true,
+    facing = 'back',
+    codeTypes = ['qr'],
+    flash = 'off',
+    enableTorch = false,
+    zoom = 0,
+    onStateChange,
+    onCodeScanned,
+    ...viewProps
+  },
+  ref
+) {
   if (Platform.OS !== 'ios' && Platform.OS !== 'android')
     throw new Error('CameraView requires a native build')
   if (typeof active !== 'boolean') throw new TypeError('CameraView.active must be a boolean')
@@ -58,16 +99,79 @@ export function CameraView({
   if (!Array.isArray(codeTypes) || codeTypes.some((type) => !isCodeType(type))) {
     throw new TypeError('CameraView.codeTypes contains an unsupported code type')
   }
+  if (flash !== 'off' && flash !== 'on' && flash !== 'auto') {
+    throw new TypeError('CameraView.flash must be off, on or auto')
+  }
+  if (typeof enableTorch !== 'boolean') {
+    throw new TypeError('CameraView.enableTorch must be a boolean')
+  }
+  if (typeof zoom !== 'number' || !(zoom >= 0 && zoom <= 1)) {
+    throw new RangeError('CameraView.zoom must be a number from 0 to 1')
+  }
+  const nativeRef = useRef<React.ElementRef<typeof NativeCamera>>(null)
+  const pending = useRef(new Map<number, PendingPicture>())
+
+  useEffect(() => {
+    const requests = pending.current
+    return () => {
+      for (const request of requests.values())
+        request.reject(codedError('E_CAMERA_UNMOUNTED', 'CameraView unmounted before the picture was taken'))
+      requests.clear()
+    }
+  }, [])
+
+  useImperativeHandle(
+    ref,
+    () => ({
+      takePicture(options = {}) {
+        const { quality = 1, base64 = false } = options
+        if (typeof quality !== 'number' || !(quality >= 0 && quality <= 1))
+          return Promise.reject(new RangeError('takePicture quality must be a number from 0 to 1'))
+        if (typeof base64 !== 'boolean')
+          return Promise.reject(new TypeError('takePicture base64 must be a boolean'))
+        const view = nativeRef.current
+        if (!view)
+          return Promise.reject(codedError('E_CAMERA_UNMOUNTED', 'CameraView is not mounted'))
+        const requestId = nextRequestId++
+        return new Promise<CameraCapturedPicture>((resolve, reject) => {
+          pending.current.set(requestId, { resolve, reject, base64 })
+          Commands.takePicture(view, requestId, quality, base64)
+        })
+      },
+    }),
+    []
+  )
+
   return (
     <NativeCamera
       {...viewProps}
+      ref={nativeRef}
       active={active}
       facing={facing}
       codeTypes={[...new Set(codeTypes)]}
+      flash={flash}
+      enableTorch={enableTorch}
+      zoom={zoom}
       onNativeCameraState={({ nativeEvent }) => onStateChange?.(cameraState(nativeEvent.state))}
       onNativeCameraCode={({ nativeEvent }) =>
         onCodeScanned?.({ type: codeType(nativeEvent.type), data: nativeEvent.data })
       }
+      onNativeCameraPicture={({ nativeEvent }) => {
+        const request = pending.current.get(nativeEvent.requestId)
+        if (!request) return
+        pending.current.delete(nativeEvent.requestId)
+        if (nativeEvent.error) {
+          request.reject(nativeError(nativeEvent.error))
+          return
+        }
+        request.resolve({
+          uri: nativeEvent.uri,
+          width: nativeEvent.width,
+          height: nativeEvent.height,
+          format: 'jpg',
+          ...(request.base64 ? { base64: nativeEvent.base64 } : {}),
+        })
+      }}
     />
   )
-}
+})

package/src/platform/camera/index.tsx

@@ -1,7 +1,18 @@
-import type { CameraViewProps } from './types'
+import { forwardRef } from 'react'
+import type { CameraViewProps, CameraViewRef } from './types'
 
-export type { CameraCode, CameraCodeType, CameraFacing, CameraState, CameraViewProps } from './types'
+export type {
+  CameraCapturedPicture,
+  CameraCode,
+  CameraCodeType,
+  CameraFacing,
+  CameraFlashMode,
+  CameraPictureOptions,
+  CameraState,
+  CameraViewProps,
+  CameraViewRef,
+} from './types'
 
-export function CameraView(_props: CameraViewProps): never {
+export const CameraView = forwardRef<CameraViewRef, CameraViewProps>(function CameraView(): never {
   throw new Error('CameraView requires a native build')
-}
+})

package/src/platform/camera/types.ts

@@ -27,10 +27,32 @@ export interface CameraCode {
   data: string
 }
 
+export type CameraFlashMode = 'off' | 'on' | 'auto'
+
 export interface CameraViewProps extends ViewProps {
   active?: boolean
   facing?: CameraFacing
   codeTypes?: readonly CameraCodeType[]
+  flash?: CameraFlashMode
+  enableTorch?: boolean
+  zoom?: number
   onStateChange?: (state: CameraState) => void
   onCodeScanned?: (code: CameraCode) => void
 }
+
+export interface CameraPictureOptions {
+  quality?: number
+  base64?: boolean
+}
+
+export interface CameraCapturedPicture {
+  uri: string
+  width: number
+  height: number
+  format: 'jpg'
+  base64?: string
+}
+
+export interface CameraViewRef {
+  takePicture(options?: CameraPictureOptions): Promise<CameraCapturedPicture>
+}