Vision Camera

https://visioncamera.margelo.com/docs
Admin
Vision Camera is the fastest and most powerful camera library for React Native, built with Nitro...
Tokens:88,211
Snippets:757
Trust Score:7.1
Update:19 hours ago
Show doc for...
Tokens:
Raw
### Create CameraSession with <Camera /> view

Source: https://visioncamera.margelo.com/docs/camera-session

Use the <Camera /> view to automatically manage session configuration and lifecycle. The example shows a basic setup with isActive and device props.

```tsx
function App() {
  return (
    <Camera
      style={StyleSheet.absoluteFill}
      isActive={true}
      device="back"
    />
  )
}
```

--------------------------------

### Install react-native-vision-camera with bun

Source: https://visioncamera.margelo.com/docs

Use bun to install the react-native-vision-camera package.

```bash
bun add react-native-vision-camera
```

--------------------------------

### Install react-native-vision-camera with npm

Source: https://visioncamera.margelo.com/docs

Use npm to install the react-native-vision-camera package.

```bash
npm install react-native-vision-camera
```

--------------------------------

### Start recording with Recorder.startRecording

Source: https://visioncamera.margelo.com/docs/video-output

Starts a video recording. The callback receives the path and logs a message when finished; the error callback logs any error. Must be called on a prepared Recorder.

```javascript
await recorder.startRecording(
  (path) => console.log(`Recording finished!`),
  (error) => console.error(`Recording error!`, error)
)
```

--------------------------------

### Example device capabilities for constraint negotiation

Source: https://visioncamera.margelo.com/docs/constraints

Lists example device capabilities that the Constraints API may internally negotiate, showing how resolution and FPS combinations are evaluated.

```text
- 4k    @  30FPS  <-- resolution matches, but FPS doesn't - and FPS is more important
- 1080p @  60FPS  <-- will be selected; matches 60 FPS and has best resolution match
- 720p  @  60FPS  <-- FPS matches, but we can get better resolution
- 480p  @ 120FPS  <-- FPS matches, but we can get better resolution
```

--------------------------------

### Start a recording with callbacks

Source: https://visioncamera.margelo.com/docs/recorder

Starts a video recording, providing callbacks for recording finished, error, paused, and resumed events. The finished callback receives a path and reason.

```typescript
const recorder = ...
await recorder.startRecording(
  (path, reason) => console.log(`Recording finished! ${reason}`),
  (error) => console.error(`Recording error!`, error),
  () => console.log(`Recording paused!`),
  () => console.log(`Recording resumed!`)
)
```

--------------------------------

### Install nitro dependencies with bun

Source: https://visioncamera.margelo.com/docs

Install react-native-nitro-modules and react-native-nitro-image using bun.

```bash
bun add react-native-nitro-modules react-native-nitro-image
```

--------------------------------

### Install react-native-vision-camera with pnpm

Source: https://visioncamera.margelo.com/docs

Use pnpm to install the react-native-vision-camera package.

```bash
pnpm add react-native-vision-camera
```

--------------------------------

### Install react-native-vision-camera with yarn

Source: https://visioncamera.margelo.com/docs

Use yarn to install the react-native-vision-camera package.

```bash
yarn add react-native-vision-camera
```

--------------------------------

### usePhotoOutput with previewImageTargetSize

Source: https://visioncamera.margelo.com/docs/photo-output-callbacks

Example of configuring the photo output to deliver preview images by setting previewImageTargetSize.

```APIDOC
## usePhotoOutput(...)

### Description
Creates a CameraPhotoOutput with the specified options, including preview image target size.

### Method
usePhotoOutput

### Parameters
#### Options (PhotoOutputOptions)
- **previewImageTargetSize** (object) - Optional - The target size for the preview image, e.g., { width: 100, height: 150 }.

### Request Example
```
const photoOutput = usePhotoOutput({
  previewImageTargetSize: { width: 100, height: 150 }
})
```

### Response
Returns a CameraPhotoOutput instance.

```

--------------------------------

### Install nitro dependencies with pnpm

Source: https://visioncamera.margelo.com/docs

Install react-native-nitro-modules and react-native-nitro-image using pnpm.

```bash
pnpm add react-native-nitro-modules react-native-nitro-image
```

--------------------------------

### Install nitro dependencies with npm

Source: https://visioncamera.margelo.com/docs

Install react-native-nitro-modules and react-native-nitro-image using npm.

```bash
npm install react-native-nitro-modules react-native-nitro-image
```

--------------------------------

### Get all Camera Devices (Imperative)

Source: https://visioncamera.margelo.com/docs/devices

Use the imperative API to get all camera devices and listen for changes.

```typescript
const deviceFactory = await VisionCamera.createDeviceFactory()
let devices = deviceFactory.cameraDevices
deviceFactory.addOnCameraDevicesChangedListener((d) => {
  devices = d
})
```

--------------------------------

### Set FPS with CameraSession imperative API

Source: https://visioncamera.margelo.com/docs/fps

Create a camera session and configure it with an `{ fps: 60 }` constraint for the 'back' input, then start the session.

```typescript
const session = await VisionCamera.createCameraSession(false)
await session.configure([
  {
    input: 'back',
    constraints: [
      { fps: 60 }
    ]
  }
], {})
await session.start()
```

--------------------------------

### Create CameraSession imperatively

Source: https://visioncamera.margelo.com/docs/camera-session

Manually create a CameraSession using VisionCamera.createCameraSession. Requires explicit configuration and start. The example shows creating a session, configuring it with an input device, and starting it.

```typescript
const device = ...

const isMultiCam = false
const session = await VisionCamera.createCameraSession(isMultiCam)
await session.configure([
  {
    input: device,
    outputs: [],
    constraints: []
  }
], {})
await session.start()
```

--------------------------------

### Get a Location with createLocationManager imperative API

Source: https://visioncamera.margelo.com/docs/location

Uses createLocationManager to create a LocationManager, requests permission if not authorized, starts updating, and listens for location changes.

```typescript
const locationManager = createLocationManager({ /* options */ })

if (locationManager.locationPermissionStatus !== 'authorized') {
  const hasPermission = await locationManager.requestLocationPermission()
  if (!hasPermission) return
}

await locationManager.startUpdating()
locationManager.addOnLocationChangedListener((location) => {
  console.log(location)
})
```

--------------------------------

### Get current exposure bias from CameraController

Source: https://visioncamera.margelo.com/docs/exposure-bias

Read the current exposure bias value from the CameraController's exposureBias property. The example logs the value, which is 0 by default.

```ts
const controller = ...
console.log(controller.exposureBias) // 0
```

--------------------------------

### Configure Multi-Camera Session with Front and Back Outputs

Source: https://visioncamera.margelo.com/docs/multi-camera

Creates preview and photo outputs for front and back cameras, configures the session with two connections, and starts the session. Each returned CameraController corresponds to the connection at that index.

```typescript
const frontPreviewOutput = VisionCamera.createPreviewOutput()
const frontPhotoOutput = VisionCamera.createPhotoOutput({})
const backPreviewOutput = VisionCamera.createPreviewOutput()
const backPhotoOutput = VisionCamera.createPhotoOutput({})

const [frontController, backController] = await session.configure([
  // Front Camera
  {
    input: frontDevice,
    outputs: [
      { output: frontPreviewOutput, mirrorMode: 'on' },
      { output: frontPhotoOutput, mirrorMode: 'off' },
    ],
    constraints: []
  },
  // Back Camera
  {
    input: backDevice,
    outputs: [
      { output: backPreviewOutput, mirrorMode: 'off' },
      { output: backPhotoOutput, mirrorMode: 'off' },
    ],
    constraints: []
  }
])
await session.start()
```

--------------------------------

### Using SkiaCamera with onFrame callback

Source: https://visioncamera.margelo.com/docs/skia-frame-processors

Example of using the <SkiaCamera /> component to render a camera feed with Skia. The onFrame callback receives a frame and a render function, allowing custom frame processing and drawing operations. Requires @Shopify/react-native-skia and react-native-vision-camera-skia to be installed.

```jsx
import { SkiaCamera } from 'react-native-vision-camera-skia'

function App() {
  return (
    <SkiaCamera
      style={StyleSheet.absoluteFill}
      isActive={true}
      device="back"
      onFrame={(frame, render) => {
        'worklet'
        // ... custom Frame processing logic
        render(({ frameTexture, canvas }) => {
          // ... custom drawing operations
          canvas.drawImage(frameTexture, 0, 0)
        })
        frame.dispose()
      }}
    />
  )
}
```

--------------------------------

### Create Video Output imperatively with CameraSession

Source: https://visioncamera.margelo.com/docs/video-output

Create a camera session and video output imperatively, then configure the session with the video output as an output.

```ts
const session = await VisionCamera.createCameraSession(false)
const videoOutput = VisionCamera.createVideoOutput({ /* options */ })

await session.configure([
  {
    input: 'back',
    outputs: [
      { output: videoOutput, mirrorMode: 'auto' }
    ],
    constraints: []
  }
], {})
await session.start()
```

--------------------------------

### Connect CameraOutputs to CameraSession imperatively

Source: https://visioncamera.margelo.com/docs/camera-outputs

Shows how to create a CameraSession and configure it with photo and video outputs using the imperative API. The session is started after configuration.

```ts
const session = await VisionCamera.createCameraSession(false)
const photoOutput = ...
const videoOutput = ...

await session.configure([
  {
    input: 'back',
    outputs: [
      { output: photoOutput, mirrorMode: 'auto' },
      { output: videoOutput, mirrorMode: 'auto' }
    ],
    constraints: []
  }
], {})
await session.start()
```

--------------------------------

### Create a Recorder

Source: https://visioncamera.margelo.com/docs/video-output

Before recording, create a Recorder using createRecorder on the video output. Options are passed to the recorder.

```ts
const recorder = await videoOutput.createRecorder({
  // ...options
})
```

--------------------------------

### Install nitro dependencies with yarn

Source: https://visioncamera.margelo.com/docs

Install react-native-nitro-modules and react-native-nitro-image using yarn.

```bash
yarn add react-native-nitro-modules react-native-nitro-image
```

--------------------------------

### Basic constraints with resolutionBias and fps (useCamera hook)

Source: https://visioncamera.margelo.com/docs/constraints

Shows how to pass constraints to the useCamera hook, with resolutionBias referencing a video output and fps set to 60. The order of constraints determines priority.

```tsx
function App() {
  const videoOutput = useVideoOutput({
    targetResolution: CommonResolutions.UHD_16_9
  })
  const device = useCameraDevice('back')
  const camera = useCamera({
    isActive: true,
    device: device,
    outputs: [videoOutput],
    constraints: [
      { resolutionBias: videoOutput },
      { fps: 60 }
    ]
  })

  return ...
}
```

--------------------------------

### React Native run iOS

Source: https://visioncamera.margelo.com/docs

Build a new binary for iOS after pod-install.

```bash
npm run ios
```

--------------------------------

### Enable a Camera Extension with the <Camera /> view

Source: https://visioncamera.margelo.com/docs/camera-extensions

Configure the cameraExtension prop on the <Camera /> component to enable a specific extension. The example finds the 'night' extension and passes it to the camera.

```tsx
function App() {
  const device = ...
  const extensions = useCameraDeviceExtensions(device)
  const extension = extensions.find((e) => e.type === 'night')

  return (
    <Camera
      style={StyleSheet.absoluteFill}
      isActive={true}
      device={device}
      cameraExtension={extension}
    />
  )
}
```

--------------------------------

### Get all Camera Devices (Hooks)

Source: https://visioncamera.margelo.com/docs/devices

Use the useCameraDevices hook to get all available camera devices on the system.

```typescript
const devices = useCameraDevices()
```

--------------------------------

### Expo run on iOS

Source: https://visioncamera.margelo.com/docs

Build a new binary for iOS after prebuild.

```bash
npx expo run:ios
```

--------------------------------

### Get default back camera device (Hooks)

Source: https://visioncamera.margelo.com/docs/devices

Use the useCameraDevice hook to get the default 'back' camera device in a React component.

```typescript
const device = useCameraDevice("back")
```

--------------------------------

### Set targetResolution to UHD_16_9 with createPhotoOutput

Source: https://visioncamera.margelo.com/docs/camera-outputs

Shows how to configure photo and video outputs to stream in 4k by setting targetResolution to CommonResolutions.UHD_16_9 using the imperative API.

```ts
const photoOutput = createPhotoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})
const videoOutput = createPhotoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})
```

--------------------------------

### Basic constraints with resolutionBias and fps (View component)

Source: https://visioncamera.margelo.com/docs/constraints

Shows how to pass constraints to the <Camera /> view component, with resolutionBias referencing a video output and fps set to 60. The order of constraints determines priority.

```tsx
function App() {
  const videoOutput = useVideoOutput({
    targetResolution: CommonResolutions.UHD_16_9
  })
  return (
    <Camera
      style={StyleSheet.absoluteFill}
      isActive={true}
      device="back"
      outputs={[videoOutput]}
      constraints={[
        { resolutionBias: videoOutput },
        { fps: 60 }
      ]}
    />
  )
}
```

--------------------------------

### Get default back camera device (Imperative)

Source: https://visioncamera.margelo.com/docs/devices

Use the imperative API to create a device factory and get the default 'back' camera device.

```typescript
const deviceFactory = await VisionCamera.createDeviceFactory()
const device = deviceFactory.getDefaultCamera("back")
```

--------------------------------

### Get a Location with useLocation hook

Source: https://visioncamera.margelo.com/docs/location

Uses the useLocation hook to get a Location object. Checks permission and requests it if not granted, then logs the location when permission is available.

```typescript
const location = useLocation({ /* options */ })

useEffect(() => {
  if (!location.hasPermission) {
    location.requestPermission()
  }
}, [location.hasPermission])

if (location.hasPermission) {
  console.log(location.location)
}
```

--------------------------------

### Select simpler camera device with Imperative API

Source: https://visioncamera.margelo.com/docs/performance

Use getCameraDevice with physicalDevices option to prefer a simpler device for faster initialization. The example shows faster and slower device configurations.

```typescript
const deviceFactory = await VisionCamera.createDeviceFactory()
const fasterDevice = getCameraDevice(deviceFactory, 'back', {
  physicalDevices: ['wide-angle-camera'],
})
const slowerDevice = getCameraDevice(deviceFactory, 'back', {
  physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera', 'telephoto-camera'],
})
```

--------------------------------

### Implement MyCustomOutputFactory in Swift (iOS)

Source: https://visioncamera.margelo.com/docs/custom-native-camera-outputs

Swift implementation of the factory method that returns a MyCustomOutput instance. Requires AVFoundation and VisionCamera imports.

```swift
import AVFoundation
import VisionCamera

class MyCustomOutputFactory: HybridMyCustomOutputFactorySpec {
  func createMyCustomOutput() -> any HybridCameraOutputSpec {
    return MyCustomOutput()
  }
}
```

--------------------------------

### Get current white balance gains

Source: https://visioncamera.margelo.com/docs/locking-ae-af-awb

Read the whiteBalanceGains property to get the current white balance gains. If the device does not support manual control, invalid values (e.g., 0) are returned.

```javascript
const controller = ...
console.log(controller.whiteBalanceGains)
```

--------------------------------

### Enable Audio imperatively with createVideoOutput

Source: https://visioncamera.margelo.com/docs/video-output

Set enableAudio to true when creating a video output imperatively. Requires microphone permission.

```ts
const videoOutput = VisionCamera.createVideoOutput({
  enableAudio: true
})
```

--------------------------------

### Basic constraints with resolutionBias and fps (CameraSession imperative)

Source: https://visioncamera.margelo.com/docs/constraints

Shows how to pass constraints to the CameraSession imperative API, with resolutionBias referencing a video output and fps set to 60. The order of constraints determines priority.

```ts
const session = await VisionCamera.createCameraSession(false)
const videoOutput = createVideoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})

await session.configure([
  {
    input: 'back',
    outputs: [videoOutput],
    constraints: [
      { resolutionBias: videoOutput },
      { fps: 60 }
    ]
  }
], {})
await session.start()
```

--------------------------------

### CameraController.exposureBias

Source: https://visioncamera.margelo.com/docs/exposure-bias

Gets the current exposure bias value from a CameraController.

```APIDOC
## CameraController.exposureBias

### Description
Returns the current exposure bias value of the camera.

### Property
`exposureBias: number`

### Example
```js
const controller = ...
console.log(controller.exposureBias) // 0
```
```

--------------------------------

### Create Object Output with CameraSession imperative API

Source: https://visioncamera.margelo.com/docs/object-output

Create a camera session, create an object output with enabledObjectTypes, set a callback, configure the session with the output, and start it.

```ts
const session = await VisionCamera.createCameraSession(false)
const objectOutput = VisionCamera.createObjectOutput({
  enabledObjectTypes: ['qr']
})
objectOutput.setOnObjectsScannedCallback((objects) => {
  console.log(`Scanned ${objects.length} objects!`)
})

await session.configure([
  {
    input: 'back',
    outputs: [
      { output: objectOutput, mirrorMode: 'auto' }
    ],
    constraints: []
  }
], {})
await session.start()
```

--------------------------------

### useLocation Hook

Source: https://visioncamera.margelo.com/docs/location

React hook to get a Location object and request permission.

```APIDOC
## useLocation Hook

### Description
Gets a Location object using the useLocation hook from react-native-vision-camera-location. Handles permission requests.

### Usage
```
const location = useLocation({ /* options */ })

useEffect(() => {
  if (!location.hasPermission) {
    location.requestPermission()
  }
}, [location.hasPermission])

if (location.hasPermission) {
  console.log(location.location)
}
```
```

--------------------------------

### Start zoom animation on CameraController

Source: https://visioncamera.margelo.com/docs/zooming

Animate zoom to a target value over a duration (in seconds).

```ts
const controller = ...
const zoom = ...
await controller.startZoomAnimation(zoom, 2)
```

--------------------------------

### Use onConfigured callback with imperative CameraSession

Source: https://visioncamera.margelo.com/docs/camera-outputs

Shows how to use the onConfigured callback with the imperative CameraSession API to perform actions on an output once it is configured and ready.

```ts
const session = await VisionCamera.createCameraSession(false)
const output = ...

await session.configure([
  {
    input: 'back',
    outputs: [
      { output: output, mirrorMode: 'auto' }
    ],
    constraints: []
  }
], {})
await session.start()
output.doSomething()
```

--------------------------------

### capturePhoto with CapturePhotoCallbacks

Source: https://visioncamera.margelo.com/docs/photo-output-callbacks

Example of passing CapturePhotoCallbacks to capturePhoto to receive capture event callbacks.

```APIDOC
## capturePhoto(...)

### Description
Captures a photo and invokes the provided callbacks at each stage of the capture pipeline.

### Method
capturePhoto

### Parameters
#### Callbacks (CapturePhotoCallbacks)
- **onWillBeginCapture** (function) - Required - Called when the capture is about to begin.
- **onWillCapturePhoto** (function) - Required - Called just before the photo is captured.
- **onDidCapturePhoto** (function) - Required - Called after the photo has been captured.

### Request Example
```
const photoOutput = ...
const photo = await photoOutput.capturePhoto(
  { /* options */ },
  {
    onWillBeginCapture: () => console.log('will begin capture'),
    onWillCapturePhoto: () => console.log('about to capture'),
    onDidCapturePhoto: () => console.log('did capture'),
  }
)
```

### Response
Returns a Promise that resolves to a Photo object.

```

--------------------------------

### Getting current White Balance Gains

Source: https://visioncamera.margelo.com/docs/locking-ae-af-awb

Retrieves the current white balance gains from the CameraController.

```APIDOC
## Getting current White Balance Gains

### Description
Get the current white balance gains via the `whiteBalanceGains` property.

### Properties
- **whiteBalanceGains** (object) - Current white balance gains.

### Example
```
const controller = ...
console.log(controller.whiteBalanceGains)
```
```

--------------------------------

### Select simpler camera device with Hooks API

Source: https://visioncamera.margelo.com/docs/performance

Use useCameraDevice with physicalDevices option to prefer a simpler device (e.g., wide-angle) for faster initialization. The example shows faster and slower device configurations.

```typescript
const fasterDevice = useCameraDevice('back', {
  physicalDevices: ['wide-angle-camera'],
})
const slowerDevice = useCameraDevice('back', {
  physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera', 'telephoto-camera'],
})
```

--------------------------------

### Getting current Exposure Duration/ISO

Source: https://visioncamera.margelo.com/docs/locking-ae-af-awb

Retrieves the current exposure duration and ISO values from the CameraController.

```APIDOC
## Getting current Exposure Duration/ISO

### Description
Get the current exposure values (e.g., to use VisionCamera as a light meter) via the `exposureDuration` and `iso` properties.

### Properties
- **exposureDuration** (number) - Current exposure duration.
- **iso** (number) - Current ISO value.

### Example
```
const controller = ...
console.log(controller.exposureDuration)
console.log(controller.iso)
```
```

--------------------------------

### Expo prebuild command

Source: https://visioncamera.margelo.com/docs

Compile the mods for Expo projects.

```bash
npx expo prebuild
```

--------------------------------

### Get available extensions with CameraDeviceFactory.getSupportedExtensions

Source: https://visioncamera.margelo.com/docs/camera-extensions

Use the imperative CameraDeviceFactory.getSupportedExtensions method to retrieve supported extensions. Requires creating a device factory via VisionCamera.createDeviceFactory().

```typescript
const device = ...
const deviceFactory = await VisionCamera.createDeviceFactory()
const extensions = await deviceFactory.getSupportedExtensions(device)
```

--------------------------------

### React Native pod-install

Source: https://visioncamera.margelo.com/docs

Rebuild Pods for React Native projects.

```bash
npx pod-install
```

--------------------------------

### Access Barcode Raw Value

Source: https://visioncamera.margelo.com/docs/a-barcode

Use the rawValue property to get the decoded string value of the barcode.

```javascript
const barcode = ...
console.log(barcode.rawValue) // "https://margelo.com"
```

--------------------------------

### createLocationManager

Source: https://visioncamera.margelo.com/docs/location

Imperative API to create a LocationManager, request permission, start updating, and listen for location changes.

```APIDOC
## createLocationManager

### Description
Creates a LocationManager instance for imperative location tracking. Use to request permission, start updates, and listen for location changes.

### Usage
```
const locationManager = createLocationManager({ /* options */ })

if (locationManager.locationPermissionStatus !== 'authorized') {
  const hasPermission = await locationManager.requestLocationPermission()
  if (!hasPermission) return
}

await locationManager.startUpdating()
locationManager.addOnLocationChangedListener((location) => {
  console.log(location)
})
```
```

--------------------------------

### Create Preview Output with CameraSession imperative API

Source: https://visioncamera.margelo.com/docs/preview-output

Create a preview output imperatively using VisionCamera.createPreviewOutput() and configure a camera session with it. The session is started after configuration.

```typescript
const session = await VisionCamera.createCameraSession(false)
const previewOutput = VisionCamera.createPreviewOutput()

await session.configure([
  {
    input: 'back',
    outputs: [
      { output: previewOutput, mirrorMode: 'auto' }
    ],
    constraints: []
  }
], {})
await session.start()
```

--------------------------------

### ScannedObject subclass detection

Source: https://visioncamera.margelo.com/docs/a-scannedobject

Example showing how to check the type of a ScannedObject using isScannedCode and isScannedFace guards.

```APIDOC
## ScannedObject subclass detection

### Description
Demonstrates how to differentiate between ScannedCode and ScannedFace objects using type guards.

### Code Example
```typescript
const scannedObject = ...
if (isScannedCode(scannedObject)) {
  console.log(`Code: ${scannedObject.value}`)
} else if (isScannedFace(scannedObject)) {
  console.log(`Face: ${scannedObject.faceID}`)
} else {
  console.log(`Any Object: ${scannedObject.type}`)
}
```
```

--------------------------------

### Use constraints with CameraSession (fps: 99999)

Source: https://visioncamera.margelo.com/docs/constraints

Imperative API: creates a camera session, configures it with a constraint, and starts it. The constraint is negotiated to a valid configuration.

```ts
const session = await VisionCamera.createCameraSession(false)
const videoOutput = createVideoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})

await session.configure([
  {
    input: 'back',
    outputs: [videoOutput],
    constraints: [
      { fps: 99999 }
    ]
  }
], {})
await session.start()
```

--------------------------------

### Set targetResolution to UHD_16_9 with usePhotoOutput

Source: https://visioncamera.margelo.com/docs/camera-outputs

Shows how to configure photo and video outputs to stream in 4k by setting targetResolution to CommonResolutions.UHD_16_9 using the hooks API.

```tsx
const photoOutput = usePhotoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})
const videoOutput = usePhotoOutput({
  targetResolution: CommonResolutions.UHD_16_9
})
```

--------------------------------

### Create AsyncRunner with createAsyncRunner (Imperative)

Source: https://visioncamera.margelo.com/docs/async-frame-processing

Creates an AsyncRunner using the createAsyncRunner function. Requires react-native-vision-camera-worklets and react-native-worklets to be installed.

```typescript
const asyncRunner = createAsyncRunner()
```
Tokens:
Raw