interface CameraProps {
    accessibilityActions?: readonly Readonly<{
        label?: string;
        name: string;
    }>[];
    accessibilityElementsHidden?: boolean;
    accessibilityHint?: string;
    accessibilityIgnoresInvertColors?: boolean;
    accessibilityLabel?: string;
    accessibilityLabelledBy?: string | string[];
    accessibilityLanguage?: string;
    accessibilityLiveRegion?: "none" | "polite" | "assertive";
    accessibilityRole?: AccessibilityRole;
    accessibilityState?: AccessibilityState;
    accessibilityValue?: AccessibilityValue;
    accessibilityViewIsModal?: boolean;
    accessible?: boolean;
    androidPreviewViewType?: "surface-view" | "texture-view";
    aria-busy?: boolean;
    aria-checked?: boolean | "mixed";
    aria-disabled?: boolean;
    aria-expanded?: boolean;
    aria-hidden?: boolean;
    aria-label?: string;
    aria-labelledby?: string;
    aria-live?: "off" | "polite" | "assertive";
    aria-modal?: boolean;
    aria-selected?: boolean;
    aria-valuemax?: number;
    aria-valuemin?: number;
    aria-valuenow?: number;
    aria-valuetext?: string;
    audio?: boolean;
    children?: ReactNode;
    codeScanner?: CodeScanner;
    collapsable?: boolean;
    collapsableChildren?: boolean;
    device: CameraDevice;
    enableBufferCompression?: boolean;
    enableDepthData?: boolean;
    enableFpsGraph?: boolean;
    enableLocation?: boolean;
    enablePortraitEffectsMatteDelivery?: boolean;
    enableZoomGesture?: boolean;
    exposure?: number;
    focusable?: boolean;
    format?: CameraDeviceFormat;
    fps?: number | [minFps: number, maxFps: number];
    frameProcessor?: ReadonlyFrameProcessor | DrawableFrameProcessor;
    hasTVPreferredFocus?: boolean;
    hitSlop?: null | number | Insets;
    id?: string;
    importantForAccessibility?: "auto" | "yes" | "no" | "no-hide-descendants";
    isActive: boolean;
    isMirrored?: boolean;
    isTVSelectable?: boolean;
    lowLightBoost?: boolean;
    nativeID?: string;
    needsOffscreenAlphaCompositing?: boolean;
    onAccessibilityAction?: ((event) => void);
    onAccessibilityEscape?: (() => void);
    onAccessibilityTap?: (() => void);
    onError?: ((error) => void);
    onInitialized?: (() => void);
    onLayout?: ((event) => void);
    onMagicTap?: (() => void);
    onMoveShouldSetResponder?: ((event) => boolean);
    onMoveShouldSetResponderCapture?: ((event) => boolean);
    onOutputOrientationChanged?: ((outputOrientation) => void);
    onPointerCancel?: ((event) => void);
    onPointerCancelCapture?: ((event) => void);
    onPointerDown?: ((event) => void);
    onPointerDownCapture?: ((event) => void);
    onPointerEnter?: ((event) => void);
    onPointerEnterCapture?: ((event) => void);
    onPointerLeave?: ((event) => void);
    onPointerLeaveCapture?: ((event) => void);
    onPointerMove?: ((event) => void);
    onPointerMoveCapture?: ((event) => void);
    onPointerUp?: ((event) => void);
    onPointerUpCapture?: ((event) => void);
    onPreviewOrientationChanged?: ((previewOrientation) => void);
    onPreviewStarted?: (() => void);
    onPreviewStopped?: (() => void);
    onResponderEnd?: ((event) => void);
    onResponderGrant?: ((event) => void);
    onResponderMove?: ((event) => void);
    onResponderReject?: ((event) => void);
    onResponderRelease?: ((event) => void);
    onResponderStart?: ((event) => void);
    onResponderTerminate?: ((event) => void);
    onResponderTerminationRequest?: ((event) => boolean);
    onShutter?: ((event) => void);
    onStartShouldSetResponder?: ((event) => boolean);
    onStartShouldSetResponderCapture?: ((event) => boolean);
    onStarted?: (() => void);
    onStopped?: (() => void);
    onTouchCancel?: ((event) => void);
    onTouchEnd?: ((event) => void);
    onTouchEndCapture?: ((event) => void);
    onTouchMove?: ((event) => void);
    onTouchStart?: ((event) => void);
    onUIRotationChanged?: ((uiRotation) => void);
    outputOrientation?: OutputOrientation;
    photo?: boolean;
    photoHdr?: boolean;
    photoQualityBalance?: "speed" | "balanced" | "quality";
    pixelFormat?: "yuv" | "rgb";
    pointerEvents?: "box-none" | "none" | "box-only" | "auto";
    preview?: boolean;
    removeClippedSubviews?: boolean;
    renderToHardwareTextureAndroid?: boolean;
    resizeMode?: "contain" | "cover";
    role?: Role;
    shouldRasterizeIOS?: boolean;
    style?: StyleProp<ViewStyle>;
    tabIndex?: 0 | -1;
    testID?: string;
    torch?: "off" | "on";
    tvParallaxMagnification?: number;
    tvParallaxShiftDistanceX?: number;
    tvParallaxShiftDistanceY?: number;
    tvParallaxTiltAngle?: number;
    video?: boolean;
    videoHdr?: boolean;
    videoStabilizationMode?: VideoStabilizationMode;
    zoom?: number;
}

Hierarchy (view full)

Properties

accessibilityActions? accessibilityElementsHidden? accessibilityHint? accessibilityIgnoresInvertColors? accessibilityLabel? accessibilityLabelledBy? accessibilityLanguage? accessibilityLiveRegion? accessibilityRole? accessibilityState? accessibilityValue? accessibilityViewIsModal? accessible? androidPreviewViewType? aria-busy? aria-checked? aria-disabled? aria-expanded? aria-hidden? aria-label? aria-labelledby? aria-live? aria-modal? aria-selected? aria-valuemax? aria-valuemin? aria-valuenow? aria-valuetext? audio? children? codeScanner? collapsable? collapsableChildren? device enableBufferCompression? enableDepthData? enableFpsGraph? enableLocation? enablePortraitEffectsMatteDelivery? enableZoomGesture? exposure? focusable? format? fps? frameProcessor? hasTVPreferredFocus? hitSlop? id? importantForAccessibility? isActive isMirrored? isTVSelectable? lowLightBoost? nativeID? needsOffscreenAlphaCompositing? onAccessibilityAction? onAccessibilityEscape? onAccessibilityTap? onError? onInitialized? onLayout? onMagicTap? onMoveShouldSetResponder? onMoveShouldSetResponderCapture? onOutputOrientationChanged? onPointerCancel? onPointerCancelCapture? onPointerDown? onPointerDownCapture? onPointerEnter? onPointerEnterCapture? onPointerLeave? onPointerLeaveCapture? onPointerMove? onPointerMoveCapture? onPointerUp? onPointerUpCapture? onPreviewOrientationChanged? onPreviewStarted? onPreviewStopped? onResponderEnd? onResponderGrant? onResponderMove? onResponderReject? onResponderRelease? onResponderStart? onResponderTerminate? onResponderTerminationRequest? onShutter? onStartShouldSetResponder? onStartShouldSetResponderCapture? onStarted? onStopped? onTouchCancel? onTouchEnd? onTouchEndCapture? onTouchMove? onTouchStart? onUIRotationChanged? outputOrientation? photo? photoHdr? photoQualityBalance? pixelFormat? pointerEvents? preview? removeClippedSubviews? renderToHardwareTextureAndroid? resizeMode? role? shouldRasterizeIOS? style? tabIndex? testID? torch? tvParallaxMagnification? tvParallaxShiftDistanceX? tvParallaxShiftDistanceY? tvParallaxTiltAngle? video? videoHdr? videoStabilizationMode? zoom?

Properties

accessibilityActions?: readonly Readonly<{
    label?: string;
    name: string;
}>[]

Provides an array of custom actions available for accessibility.

accessibilityElementsHidden?: boolean

A Boolean value indicating whether the accessibility elements contained within this accessibility element are hidden to the screen reader.

Platform

ios

accessibilityHint?: string

An accessibility hint helps users understand what will happen when they perform an action on the accessibility element when that result is not obvious from the accessibility label.

accessibilityIgnoresInvertColors?: boolean

Platform

ios

accessibilityLabel?: string

Overrides the text that's read by the screen reader when the user interacts with the element. By default, the label is constructed by traversing all the children and accumulating all the Text nodes separated by space.

accessibilityLabelledBy?: string | string[]

Identifies the element that labels the element it is applied to. When the assistive technology focuses on the component with this props, the text is read aloud. The value should should match the nativeID of the related element.

Platform

android

accessibilityLanguage?: string

By using the accessibilityLanguage property, the screen reader will understand which language to use while reading the element's label, value and hint. The provided string value must follow the BCP 47 specification (https://www.rfc-editor.org/info/bcp47). https://reactnative.dev/docs/accessibility#accessibilitylanguage-ios

Platform

ios

accessibilityLiveRegion?: "none" | "polite" | "assertive"

Indicates to accessibility services whether the user should be notified when this view changes. Works for Android API >= 19 only.

accessibilityRole?: AccessibilityRole

Accessibility Role tells a person using either VoiceOver on iOS or TalkBack on Android the type of element that is focused on.

accessibilityState?: AccessibilityState

Accessibility State tells a person using either VoiceOver on iOS or TalkBack on Android the state of the element currently focused on.

accessibilityValue?: AccessibilityValue

Represents the current value of a component. It can be a textual description of a component's value, or for range-based components, such as sliders and progress bars, it contains range information (minimum, current, and maximum).

accessibilityViewIsModal?: boolean

A Boolean value indicating whether VoiceOver should ignore the elements within views that are siblings of the receiver.

Platform

ios

accessible?: boolean

When true, indicates that the view is an accessibility element. By default, all the touchable elements are accessible.

androidPreviewViewType?: "surface-view" | "texture-view"

Specifies the implementation mode for the Preview View on Android.

  • "surface-view": Uses a SurfaceView for rendering. This is more efficient and supports HDR rendering, but doesn't support masks, transparency, rotations or clipping.
  • "texture-view": Uses a TextureView for rendering. This is less efficient and doesn't support HDR rendering, but supports masks, transparency, rotations and clipping.

Default

'surface-view'
aria-busy?: boolean
aria-checked?: boolean | "mixed"
aria-disabled?: boolean
aria-expanded?: boolean
aria-hidden?: boolean

A value indicating whether the accessibility elements contained within this accessibility element are hidden.

aria-label?: string
aria-labelledby?: string

Identifies the element that labels the element it is applied to. When the assistive technology focuses on the component with this props, the text is read aloud. The value should should match the nativeID of the related element.

Platform

android

aria-live?: "off" | "polite" | "assertive"

Indicates to accessibility services whether the user should be notified when this view changes. Works for Android API >= 19 only.

aria-modal?: boolean
aria-selected?: boolean
aria-valuemax?: number
aria-valuemin?: number
aria-valuenow?: number
aria-valuetext?: string
audio?: boolean

Enables audio capture for video recordings (see "Recording Videos")

Note: Requires audio permission.

children?: ReactNode
codeScanner?: CodeScanner

A CodeScanner that can detect QR-Codes or Barcodes using platform-native APIs.

See

See the Code Scanner documentation for more information

Example

const codeScanner = useCodeScanner({
codeTypes: ['qr', 'ean-13'],
onCodeScanned: (codes) => {
console.log(`Scanned ${codes.length} codes!`)
}
})

return <Camera {...props} codeScanner={codeScanner} />
collapsable?: boolean

Views that are only used to layout their children or otherwise don't draw anything may be automatically removed from the native hierarchy as an optimization. Set this property to false to disable this optimization and ensure that this View exists in the native view hierarchy.

collapsableChildren?: boolean

Setting to false prevents direct children of the view from being removed from the native view hierarchy, similar to the effect of setting collapsable={false} on each child.

device: CameraDevice

The Camera Device to use.

See the Camera Devices section in the documentation for more information about Camera Devices.

Example

const device = useCameraDevice('back')

if (device == null) return <NoCameraErrorView />
return (
<Camera
device={device}
isActive={true}
style={StyleSheet.absoluteFill}
/>
)
enableBufferCompression?: boolean

Enables or disables lossy buffer compression for the video stream. If you only use video or a frameProcessor, this can increase the efficiency and lower memory usage of the Camera.

If buffer compression is enabled, the video pipeline will try to use a lossy-compressed pixel format instead of the normal one.

If you use a frameProcessor, you might need to change how pixels are read inside your native frame processor function as this is different from the usual yuv or rgb layout.

If buffer compression is not available but this property is enabled, the normal pixel formats will be used and no error will be thrown.

Platform

iOS

Default

- true // if frameProcessor={undefined}
- false // otherwise
enableDepthData?: boolean

Enables or disables depth data delivery for photo capture.

Make sure the given format supports depth data (see format.supportsDepthCapture).

Default

false
enableFpsGraph?: boolean

If true, show a debug view to display the FPS of the Video Pipeline (Frame Processor). This is useful for debugging your Frame Processor's speed.

Default

false
enableLocation?: boolean

Enables location streaming to add GPS EXIF tags to captured photos and videos.

Note: Requires location permission.

Note: This property will throw a system/location-not-enabled error if the Location APIs are not enabled at build-time. See the "GPS Location Tags" documentation for more information.

enablePortraitEffectsMatteDelivery?: boolean

A boolean specifying whether the photo render pipeline is prepared for portrait effects matte delivery.

When enabling this, you must also set enableDepthData to true.

Platform

iOS 12.0+

Default

false
enableZoomGesture?: boolean

Enables or disables the native pinch to zoom gesture.

If you want to implement a custom zoom gesture, see the Zooming with Reanimated documentation.

Default

false
exposure?: number

Specifies the Exposure bias of the current camera. A lower value means darker images, a higher value means brighter images.

The Camera will still continue to auto-adjust exposure and focus, but will premultiply the exposure setting with the provided value here.

This values ranges from device.minExposure to device.maxExposure.

The value between min- and max supported exposure is considered the default, neutral value.

focusable?: boolean

Whether this View should be focusable with a non-touch input device, eg. receive focus with a hardware keyboard.

Selects a given format. By default, the best matching format is chosen. See CameraDeviceFormat

The format defines the possible values for properties like:

In other words; enableDepthData can only be set to true if format.supportsDepthCapture is true.

fps?: number | [minFps: number, maxFps: number]

Specify a the number of frames per second this camera should stream frames at.

  • If fps is a single number, the Camera will be streaming at a fixed FPS value.
  • If fps is a tuple/array, the Camera will be free to choose a FPS value between minFps and maxFps, depending on current lighting conditions. Allowing a lower minFps value can result in better photos and videos, as the Camera can take more time to properly receive light for frames.

Make sure the given format can stream at the target fps value (see format.minFps and format.maxFps).

A worklet which will be called for every frame the Camera "sees".

See

See the Frame Processors documentation for more information

Example

const frameProcessor = useFrameProcessor((frame) => {
'worklet'
const faces = scanFaces(frame)
console.log(`Faces: ${faces}`)
}, [])

return <Camera {...cameraProps} frameProcessor={frameProcessor} />
hasTVPreferredFocus?: boolean

(Apple TV only) May be set to true to force the Apple TV focus engine to move focus to this view.

Platform

ios

hitSlop?: null | number | Insets

This defines how far a touch event can start away from the view. Typical interface guidelines recommend touch targets that are at least 30 - 40 points/density-independent pixels. If a Touchable view has a height of 20 the touchable height can be extended to 40 with hitSlop={{top: 10, bottom: 10, left: 0, right: 0}} NOTE The touch area never extends past the parent view bounds and the Z-index of sibling views always takes precedence if a touch hits two overlapping views.

id?: string

Used to reference react managed views from native code.

importantForAccessibility?: "auto" | "yes" | "no" | "no-hide-descendants"

[Android] Controlling if a view fires accessibility events and if it is reported to accessibility services.

isActive: boolean

Whether the Camera should actively stream video frames, or not. See the documentation about the isActive prop for more information.

This can be compared to a Video component, where isActive specifies whether the video is paused or not.

Note

If you fully unmount the <Camera> component instead of using isActive={false}, the Camera will take a bit longer to start again. In return, it will use less resources since the Camera will be completely destroyed when unmounted.

isMirrored?: boolean

Enables or disables mirroring of outputs alongside the vertical axis.

Mirroring only affects the photo-, video-, or snapshot-output, but not preview. The Preview is always mirrored for front cameras, and not mirrored for back cameras.

Default

false (back camera), true (front camera)
isTVSelectable?: boolean

(Apple TV only) When set to true, this view will be focusable and navigable using the Apple TV remote.

Platform

ios

lowLightBoost?: boolean

Enables or disables low-light boost on this camera device.

Enabling low light boost allows the FPS rate to be throttled to up to half of what it is set to to allow for more exposure in low light conditions.

On Android, lowLightBoost might even use a vendor-specific "night-mode" extension to allow for even more visibility in low-light conditions.

Make sure the given device supports low-light-boost (see device.supportsLowLightBoost).

nativeID?: string

Used to reference react managed views from native code.

needsOffscreenAlphaCompositing?: boolean

Whether this view needs to rendered offscreen and composited with an alpha in order to preserve 100% correct colors and blending behavior. The default (false) falls back to drawing the component and its children with an alpha applied to the paint used to draw each element instead of rendering the full component offscreen and compositing it back with an alpha value. This default may be noticeable and undesired in the case where the View you are setting an opacity on has multiple overlapping elements (e.g. multiple overlapping Views, or text and a background).

Rendering offscreen to preserve correct alpha behavior is extremely expensive and hard to debug for non-native developers, which is why it is not turned on by default. If you do need to enable this property for an animation, consider combining it with renderToHardwareTextureAndroid if the view contents are static (i.e. it doesn't need to be redrawn each frame). If that property is enabled, this View will be rendered off-screen once, saved in a hardware texture, and then composited onto the screen with an alpha each frame without having to switch rendering targets on the GPU.

onAccessibilityAction?: ((event) => void)

When accessible is true, the system will try to invoke this function when the user performs an accessibility custom action.

Type declaration

onAccessibilityEscape?: (() => void)

When accessible is true, the system will invoke this function when the user performs the escape gesture (scrub with two fingers).

Type declaration

    • (): void
    • Returns void

Platform

ios

onAccessibilityTap?: (() => void)

When accessible is true, the system will try to invoke this function when the user performs accessibility tap gesture.

Type declaration

    • (): void
    • Returns void

Platform

ios

onError?: ((error) => void)

Called when any kind of runtime error occured.

Type declaration

onInitialized?: (() => void)

Called when the camera session was successfully initialized and is ready for capture.

At this point, the Camera ref can be used and methods like takePhoto(..) can be called.

This is called everytime the device or one of the outputs changes.

Type declaration

    • (): void
    • Returns void

onLayout?: ((event) => void)

Invoked on mount and layout changes with

{nativeEvent: { layout: {x, y, width, height}}}.

Type declaration

onMagicTap?: (() => void)

When accessible is true, the system will invoke this function when the user performs the magic tap gesture.

Type declaration

    • (): void
    • Returns void

Platform

ios

onMoveShouldSetResponder?: ((event) => boolean)

Called for every touch move on the View when it is not the responder: does this view want to "claim" touch responsiveness?

Type declaration

onMoveShouldSetResponderCapture?: ((event) => boolean)

onStartShouldSetResponder and onMoveShouldSetResponder are called with a bubbling pattern, where the deepest node is called first. That means that the deepest component will become responder when multiple Views return true for *ShouldSetResponder handlers. This is desirable in most cases, because it makes sure all controls and buttons are usable.

However, sometimes a parent will want to make sure that it becomes responder. This can be handled by using the capture phase. Before the responder system bubbles up from the deepest component, it will do a capture phase, firing on*ShouldSetResponderCapture. So if a parent View wants to prevent the child from becoming responder on a touch start, it should have a onStartShouldSetResponderCapture handler which returns true.

Type declaration

onOutputOrientationChanged?: ((outputOrientation) => void)

Called whenever the output orientation changed. This might happen even if the screen/interface rotation is locked.

Type declaration

    • (outputOrientation): void
    • Parameters

      Returns void

onPointerCancel?: ((event) => void)

Type declaration

onPointerCancelCapture?: ((event) => void)

Type declaration

onPointerDown?: ((event) => void)

Type declaration

onPointerDownCapture?: ((event) => void)

Type declaration

onPointerEnter?: ((event) => void)

Type declaration

onPointerEnterCapture?: ((event) => void)

Type declaration

onPointerLeave?: ((event) => void)

Type declaration

onPointerLeaveCapture?: ((event) => void)

Type declaration

onPointerMove?: ((event) => void)

Type declaration

onPointerMoveCapture?: ((event) => void)

Type declaration

onPointerUp?: ((event) => void)

Type declaration

onPointerUpCapture?: ((event) => void)

Type declaration

onPreviewOrientationChanged?: ((previewOrientation) => void)

Called whenever the preview orientation changed. This will happen whenever the screen/interface rotates.

Type declaration

    • (previewOrientation): void
    • Parameters

      Returns void

onPreviewStarted?: (() => void)

Called when the Preview View has received it's first frame and is now started.

Type declaration

    • (): void
    • Returns void

Note

This will only be called if preview is true, and no Skia Frame Processor is used

onPreviewStopped?: (() => void)

Called when the Preview View has stoppped streaming frames and is now stopped.

Type declaration

    • (): void
    • Returns void

Note

This will only be called if preview is true, and no Skia Frame Processor is used

onResponderEnd?: ((event) => void)

If the View returns true and attempts to become the responder, one of the following will happen:

Type declaration

onResponderGrant?: ((event) => void)

The View is now responding for touch events. This is the time to highlight and show the user what is happening

Type declaration

onResponderMove?: ((event) => void)

The user is moving their finger

Type declaration

onResponderReject?: ((event) => void)

Something else is the responder right now and will not release it

Type declaration

onResponderRelease?: ((event) => void)

Fired at the end of the touch, ie "touchUp"

Type declaration

onResponderStart?: ((event) => void)

Type declaration

onResponderTerminate?: ((event) => void)

The responder has been taken from the View. Might be taken by other views after a call to onResponderTerminationRequest, or might be taken by the OS without asking (happens with control center/ notification center on iOS)

Type declaration

onResponderTerminationRequest?: ((event) => boolean)

Something else wants to become responder. Should this view release the responder? Returning true allows release

Type declaration

onShutter?: ((event) => void)

Called just before a photo or snapshot is captured.

Inside this callback you can play a custom shutter sound or show visual feedback to the user.

Type declaration

onStartShouldSetResponder?: ((event) => boolean)

Does this view want to become responder on the start of a touch?

Type declaration

onStartShouldSetResponderCapture?: ((event) => boolean)

onStartShouldSetResponder and onMoveShouldSetResponder are called with a bubbling pattern, where the deepest node is called first. That means that the deepest component will become responder when multiple Views return true for *ShouldSetResponder handlers. This is desirable in most cases, because it makes sure all controls and buttons are usable.

However, sometimes a parent will want to make sure that it becomes responder. This can be handled by using the capture phase. Before the responder system bubbles up from the deepest component, it will do a capture phase, firing on*ShouldSetResponderCapture. So if a parent View wants to prevent the child from becoming responder on a touch start, it should have a onStartShouldSetResponderCapture handler which returns true.

Type declaration

onStarted?: (() => void)

Called when the camera started the session. (isActive={true})

At this point, outputs can start receiving frames from the Camera, but might not have received any yet.

Type declaration

    • (): void
    • Returns void

onStopped?: (() => void)

Called when the camera stopped the session. (isActive={false})

At this point, outputs will stop receiving frames from the Camera.

Type declaration

    • (): void
    • Returns void

onTouchCancel?: ((event) => void)

Type declaration

onTouchEnd?: ((event) => void)

Type declaration

onTouchEndCapture?: ((event) => void)

Type declaration

onTouchMove?: ((event) => void)

Type declaration

onTouchStart?: ((event) => void)

Type declaration

onUIRotationChanged?: ((uiRotation) => void)

Called whenever the target UI rotation/orientation changes.

Type declaration

    • (uiRotation): void
    • Parameters

      • uiRotation: number

        The degrees that UI elements need to be rotated by to appear up-right.

      Returns void

outputOrientation?: OutputOrientation

Sets the orientation of all Camera Outputs (Photo, Snapshot and Video).

  • 'preview': Use the same orientation as the preview view. If the device rotation is locked, the user cannot take photos or videos in different orientations.
  • 'device': Use whatever orientation the device is held in, even if the preview view is not rotated to that orientation. If the device rotation is locked, the user can still rotate his phone to take photos or videos in different orientations than the preview view.

Note

Preview orientation will not be affected by this property, as it is always dependant on screen orientation

Note

Frame Processors will not be affected by this property, as their buffer size (respective to Frame.orientation) is always the same

See

See the Orientation documentation for more information

Default

'device'
photo?: boolean

Enables photo capture with the takePhoto function (see "Taking Photos")

photoHdr?: boolean

Enables or disables HDR Photo Capture via a double capture routine that combines low- and high exposure photos.

On Android, photoHdr uses a vendor-specific "HDR" extension which is not compatible with videoHdr, so only one of video- or photo-HDR can be enabled at a time.

Make sure the given format supports HDR (see format.supportsPhotoHdr).

photoQualityBalance?: "speed" | "balanced" | "quality"

Configures the photo pipeline for a specific quality balance prioritization.

  • 'speed': Prioritizes fast capture speed over quality (faster edge-detection, distortion correction, AF/AE/AWB times, etc.)
  • 'balanced': A balanced set of prioritization configurations
  • 'quality': Prioritizes high quality capture over speed (higher accuracy edge-detection, distortion correction, AF/AE/AWB times, etc.)

Default

'balanced'
pixelFormat?: "yuv" | "rgb"

Specifies the pixel format of Frames streamed from a Frame Processor.

While 'yuv' is the most efficient format, some ML models (such as TensorFlow Face Detection Models) require input Frames to be in RGB colorspace, otherwise they just output nonsense.

The following values are supported:

  • yuv: The YUV (Y'CbCr 4:2:0 or NV21, 8-bit) format, either video- or full-range, depending on hardware capabilities. This is the most efficient format.
  • rgb: The RGB (RGBA or BGRA, 8-bit) format. This is less efficient format and sometimes requires explicit conversion.

Default

'yuv'
pointerEvents?: "box-none" | "none" | "box-only" | "auto"

In the absence of auto property, none is much like CSS's none value. box-none is as if you had applied the CSS class:

.box-none { pointer-events: none; } .box-none * { pointer-events: all; }

box-only is the equivalent of

.box-only { pointer-events: all; } .box-only * { pointer-events: none; }

But since pointerEvents does not affect layout/appearance, and we are already deviating from the spec by adding additional modes, we opt to not include pointerEvents on style. On some platforms, we would need to implement it as a className anyways. Using style or not is an implementation detail of the platform.

preview?: boolean

Enables preview streaming.

Preview is enabled by default, and disabled when using a Skia Frame Processor as Skia will use the video stream as it's preview.

Default

true
removeClippedSubviews?: boolean

This is a special performance property exposed by RCTView and is useful for scrolling content when there are many subviews, most of which are offscreen. For this property to be effective, it must be applied to a view that contains many subviews that extend outside its bound. The subviews must also have overflow: hidden, as should the containing view (or one of its superviews).

renderToHardwareTextureAndroid?: boolean

Whether this view should render itself (and all of its children) into a single hardware texture on the GPU.

On Android, this is useful for animations and interactions that only modify opacity, rotation, translation, and/or scale: in those cases, the view doesn't have to be redrawn and display lists don't need to be re-executed. The texture can just be re-used and re-composited with different parameters. The downside is that this can use up limited video memory, so this prop should be set back to false at the end of the interaction/animation.

resizeMode?: "contain" | "cover"

Specifies the Preview's resize mode.

  • "cover": Keep aspect ratio and fill entire parent view (centered).
  • "contain": Keep aspect ratio and make sure the entire content is visible inside the parent view, even if it introduces additional blank areas (centered).

Default

"cover"
role?: Role

Indicates to accessibility services to treat UI component like a specific role.

shouldRasterizeIOS?: boolean

Whether this view should be rendered as a bitmap before compositing.

On iOS, this is useful for animations and interactions that do not modify this component's dimensions nor its children; for example, when translating the position of a static view, rasterization allows the renderer to reuse a cached bitmap of a static view and quickly composite it during each frame.

Rasterization incurs an off-screen drawing pass and the bitmap consumes memory. Test and measure when using this property.

tabIndex?: 0 | -1

Indicates whether this View should be focusable with a non-touch input device, eg. receive focus with a hardware keyboard. See https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex for more details.

Supports the following values:

  • 0 (View is focusable)
  • -1 (View is not focusable)
testID?: string

Used to locate this view in end-to-end tests.

torch?: "off" | "on"

Set the current torch mode.

Make sure the given device has a torch (see device.hasTorch).

Default

"off"
tvParallaxMagnification?: number

(Apple TV only) May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus. Defaults to 1.0.

Platform

ios

tvParallaxShiftDistanceX?: number

(Apple TV only) May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus. Defaults to 2.0.

Platform

ios

tvParallaxShiftDistanceY?: number

(Apple TV only) May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus. Defaults to 2.0.

Platform

ios

tvParallaxTiltAngle?: number

(Apple TV only) May be used to change the appearance of the Apple TV parallax effect when this view goes in or out of focus. Defaults to 0.05.

Platform

ios

video?: boolean

Enables video capture with the startRecording function (see "Recording Videos")

videoHdr?: boolean

Enables or disables HDR Video Streaming for Preview, Video and Frame Processor via a 10-bit wide-color pixel format.

Make sure the given format supports HDR (see format.supportsVideoHdr).

videoStabilizationMode?: VideoStabilizationMode

Specifies the video stabilization mode to use.

Make sure the given format supports the given videoStabilizationMode.

zoom?: number

Specifies the zoom factor of the current camera, in "factor"/scale.

This value ranges from minZoom (e.g. 1) to maxZoom (e.g. 128). It is recommended to set this value to the CameraDevice's neutralZoom per default and let the user zoom out to the fish-eye (ultra-wide) camera on demand (if available)

Note: Linearly increasing this value always appears logarithmic to the user.

Default

1.0