railbird/react-native-vision-camera
10
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
react-native-vision-camera/docs/docs/api/classes/camera.camera-1.md
Marc Rousavy 0b7b4d50b5
Automatically build API documentation (#11) 
* Automatically build API documentation using Typedoc and Docusaurus
* Move MD and move to MDX for Docusaurus Guides
2021-03-03 12:37:43 +01:00

92 KiB
Raw Blame History

id title sidebar_label custom_edit_url hide_title
camera.camera-1 Class: Camera Camera.Camera null true

Class: Camera

Camera.Camera

A powerful <Camera> component.

The <Camera> component's most important (and therefore required) properties are:

  • device: Specifies the CameraDevice to use. Get a CameraDevice by using the useCameraDevices hook, or manually by using the Camera.getAvailableCameraDevices function.
  • isActive: A boolean value that specifies whether the Camera should actively stream video frames or not. This can be compared to a Video component, where isActive specifies whether the video is paused or not. If you fully unmount the <Camera> component instead of using isActive={false}, the Camera will take a bit longer to start again.

example

function App() {
  const devices = useCameraDevices('wide-angle-camera')
  const device = devices.back

  if (device == null) return <LoadingView />
  return (
    <Camera
      style={StyleSheet.absoluteFill}
      device={device}
      isActive={true}
    />
  )
}

component

Hierarchy

Constructors

constructor

+ new Camera(props: CameraProps): Camera

Parameters:

Name Type
props CameraProps

Returns: Camera

Defined in: src/Camera.tsx:210

Properties

context

• context: any

If using the new style context, re-declare this in your class to be the React.ContextType of your static contextType. Should be used with type annotation or static contextType.

static contextType = MyContext
// For TS pre-3.7:
context!: React.ContextType<typeof MyContext>
// For TS 3.7 and above:
declare context: React.ContextType<typeof MyContext>

see https://reactjs.org/docs/context.html

Defined in: node_modules/@types/react/index.d.ts:480

displayName

• displayName: string

Defined in: src/Camera.tsx:208

props

• Readonly props: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> & Readonly<{ children?: ReactNode }> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> & Readonly<{ children?: ReactNode }> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> & Readonly<{ children?: ReactNode }> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> & Readonly<{ children?: ReactNode }>

Defined in: node_modules/@types/react/index.d.ts:505

ref

• Private Readonly ref: RefObject<RefType>

Defined in: src/Camera.tsx:210

refs

• refs: object

deprecated https://reactjs.org/docs/refs-and-the-dom.html#legacy-api-string-refs

Type declaration:

Defined in: node_modules/@types/react/index.d.ts:511

state

• state: Readonly<CameraState>

Defined in: node_modules/@types/react/index.d.ts:506

contextType

▪ Optional Static contextType: undefined | Context<any>

If set, this.context will be set at runtime to the current value of the given Context.

Usage:

type MyContext = number
const Ctx = React.createContext<MyContext>(0)

class Foo extends React.Component {
  static contextType = Ctx
  context!: React.ContextType<typeof Ctx>
  render () {
    return <>My context's value: {this.context}</>;
  }
}

see https://reactjs.org/docs/context.html#classcontexttype

Defined in: node_modules/@types/react/index.d.ts:462

displayName

▪ Static displayName: string= 'Camera'

Defined in: src/Camera.tsx:207

Accessors

handle

• Privateget handle(): null | number

Returns: null | number

Defined in: src/Camera.tsx:221

Methods

UNSAFE_componentWillMount

▸ OptionalUNSAFE_componentWillMount(): void

Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use componentDidMount or the constructor instead

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Returns: void

Defined in: node_modules/@types/react/index.d.ts:716

UNSAFE_componentWillReceiveProps

▸ OptionalUNSAFE_componentWillReceiveProps(nextProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, nextContext: any): void

Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

Calling Component#setState generally does not trigger this method.

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use static getDerivedStateFromProps instead

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Parameters:

Name Type
nextProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
nextContext any

Returns: void

Defined in: node_modules/@types/react/index.d.ts:748

UNSAFE_componentWillUpdate

▸ OptionalUNSAFE_componentWillUpdate(nextProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, nextState: Readonly<CameraState>, nextContext: any): void

Called immediately before rendering when new props or state is received. Not called for the initial render.

Note: You cannot call Component#setState here.

This method will not stop working in React 17.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use getSnapshotBeforeUpdate instead

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Parameters:

Name Type
nextProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
nextState Readonly<CameraState>
nextContext any

Returns: void

Defined in: node_modules/@types/react/index.d.ts:776

componentDidCatch

▸ OptionalcomponentDidCatch(error: Error, errorInfo: ErrorInfo): void

Catches exceptions generated in descendant components. Unhandled exceptions will cause the entire component tree to unmount.

Parameters:

Name Type
error Error
errorInfo ErrorInfo

Returns: void

Defined in: node_modules/@types/react/index.d.ts:645

componentDidMount

▸ OptionalcomponentDidMount(): void

Called immediately after a component is mounted. Setting state here will trigger re-rendering.

Returns: void

Defined in: node_modules/@types/react/index.d.ts:624

componentDidUpdate

▸ OptionalcomponentDidUpdate(prevProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, prevState: Readonly<CameraState>, snapshot?: any): void

Called immediately after updating occurs. Not called for the initial render.

The snapshot is only present if getSnapshotBeforeUpdate is present and returns non-null.

Parameters:

Name Type
prevProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
prevState Readonly<CameraState>
snapshot? any

Returns: void

Defined in: node_modules/@types/react/index.d.ts:687

componentWillMount

▸ OptionalcomponentWillMount(): void

Called immediately before mounting occurs, and before Component#render. Avoid introducing any side-effects or subscriptions in this method.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use componentDidMount or the constructor instead; will stop working in React 17

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#initializing-state

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Returns: void

Defined in: node_modules/@types/react/index.d.ts:702

componentWillReceiveProps

▸ OptionalcomponentWillReceiveProps(nextProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, nextContext: any): void

Called when the component may be receiving new props. React may call this even if props have not changed, so be sure to compare new and existing props if you only want to handle changes.

Calling Component#setState generally does not trigger this method.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use static getDerivedStateFromProps instead; will stop working in React 17

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#updating-state-based-on-props

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Parameters:

Name Type
nextProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
nextContext any

Returns: void

Defined in: node_modules/@types/react/index.d.ts:731

componentWillUnmount

▸ OptionalcomponentWillUnmount(): void

Called immediately before a component is destroyed. Perform any necessary cleanup in this method, such as cancelled network requests, or cleaning up any DOM elements created in componentDidMount.

Returns: void

Defined in: node_modules/@types/react/index.d.ts:640

componentWillUpdate

▸ OptionalcomponentWillUpdate(nextProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, nextState: Readonly<CameraState>, nextContext: any): void

Called immediately before rendering when new props or state is received. Not called for the initial render.

Note: You cannot call Component#setState here.

Note: the presence of getSnapshotBeforeUpdate or getDerivedStateFromProps prevents this from being invoked.

deprecated 16.3, use getSnapshotBeforeUpdate instead; will stop working in React 17

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#reading-dom-properties-before-an-update

see https://reactjs.org/blog/2018/03/27/update-on-async-rendering.html#gradual-migration-path

Parameters:

Name Type
nextProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
nextState Readonly<CameraState>
nextContext any

Returns: void

Defined in: node_modules/@types/react/index.d.ts:761

focus

▸ focus(point: Point): Promise<void>

Focus the camera to a specific point in the coordinate system.

Parameters:

Name Type Description
point Point The point to focus to. This should be relative to the Camera view's coordinate system, and expressed in Pixel on iOS and Points on Android. * (0, 0) means top left. * (CameraView.width, CameraView.height) means bottom right. Make sure the value doesn't exceed the CameraView's dimensions.

Returns: Promise<void>

Defined in: src/Camera.tsx:326

forceUpdate

▸ forceUpdate(callback?: () => void): void

Parameters:

Name Type
callback? () => void

Returns: void

Defined in: node_modules/@types/react/index.d.ts:497

getAvailablePhotoCodecs

▸ getAvailablePhotoCodecs(): Promise<CameraPhotoCodec[]>

Get a list of photo codecs the current camera supports. Returned values are ordered by efficiency (descending).

This function can only be called after the camera has been initialized, so only use this after the onInitialized event has fired.

Returns: Promise<CameraPhotoCodec[]>

Defined in: src/Camera.tsx:353

getAvailableVideoCodecs

▸ getAvailableVideoCodecs(): Promise<CameraVideoCodec[]>

Get a list of video codecs the current camera supports. Returned values are ordered by efficiency (descending).

This function can only be called after the camera has been initialized, so only use this after the onInitialized event has fired.

Returns: Promise<CameraVideoCodec[]>

Defined in: src/Camera.tsx:340

getSnapshotBeforeUpdate

▸ OptionalgetSnapshotBeforeUpdate(prevProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, prevState: Readonly<CameraState>): any

Runs before React applies the result of render to the document, and returns an object to be given to componentDidUpdate. Useful for saving things such as scroll position before render causes changes to it.

Note: the presence of getSnapshotBeforeUpdate prevents any of the deprecated lifecycle events from running.

Parameters:

Name Type
prevProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
prevState Readonly<CameraState>

Returns: any

Defined in: node_modules/@types/react/index.d.ts:681

onCodeScanned

▸ PrivateonCodeScanned(event?: NativeSyntheticEvent<OnCodeScannedEvent>): void

Parameters:

Name Type
event? NativeSyntheticEvent<OnCodeScannedEvent>

Returns: void

Defined in: src/Camera.tsx:445

onError

▸ PrivateonError(event?: NativeSyntheticEvent<OnErrorEvent>): void

Parameters:

Name Type
event? NativeSyntheticEvent<OnErrorEvent>

Returns: void

Defined in: src/Camera.tsx:428

onInitialized

▸ PrivateonInitialized(): void

Returns: void

Defined in: src/Camera.tsx:441

render

▸ render(): ReactNode

Returns: ReactNode

Defined in: src/Camera.tsx:461

setState

▸ setState<K>(state: null | CameraState | (prevState: Readonly<CameraState>, props: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>) => null | CameraState | Pick<CameraState, K> | Pick<CameraState, K>, callback?: () => void): void

Type parameters:

Name Type
K cameraId

Parameters:

Name Type
state null | CameraState | (prevState: Readonly<CameraState>, props: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>) => null | CameraState | Pick<CameraState, K> | Pick<CameraState, K>
callback? () => void

Returns: void

Defined in: node_modules/@types/react/index.d.ts:492

shouldComponentUpdate

▸ OptionalshouldComponentUpdate(nextProps: Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>, nextState: Readonly<CameraState>, nextContext: any): boolean

Called to determine whether the change in props and state should trigger a re-render.

Component always returns true. PureComponent implements a shallow comparison on props and state and returns true if any props or states have changed.

If false is returned, Component#render, componentWillUpdate and componentDidUpdate will not be called.

Parameters:

Name Type
nextProps Readonly<CameraFormatProps & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<CameraFormatProps & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & CameraScannerPropsNever & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps> | Readonly<Pick<CameraFormatProps, never> & { colorSpace?: undefined | hlg-bt2020 | p3-d65 | srgb | yuv ; format?: undefined | Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }> ; fps?: undefined | number ; hdr?: undefined | boolean ; lowLightBoost?: undefined | boolean ; preset?: undefined } & Pick<CameraScannerPropsNever, never> & { onCodeScanned: (codes: Readonly<{ bounds: { height: number ; maxX: number ; maxY: number ; minX: number ; minY: number ; width: number } ; code?: undefined | string ; type: CodeType }>[]) => void ; scannableCodes: CodeType[] } & CameraDeviceProps & CameraDynamicProps & CameraEventProps & ViewProps>
nextState Readonly<CameraState>
nextContext any

Returns: boolean

Defined in: node_modules/@types/react/index.d.ts:635

startRecording

▸ startRecording(options: RecordVideoOptions): void

Start a new video recording.

Records in the following formats:

  • iOS: QuickTime (.mov)
  • Android: MPEG4 (.mp4)

blocking This function is synchronized/blocking.

throws {CameraCaptureError} When any kind of error occured. Use the CameraCaptureError.code property to get the actual error

example

camera.current.startRecording({
  onRecordingFinished: (video) => console.log(video),
  onRecordingError: (error) => console.error(error),
})
setTimeout(() => {
  camera.current.stopRecording()
}, 5000)

Parameters:

Name Type
options RecordVideoOptions

Returns: void

Defined in: src/Camera.tsx:282

stopRecording

▸ stopRecording(): Promise<void>

Stop the current video recording.

example

await camera.current.startRecording()
setTimeout(async () => {
 const video = await camera.current.stopRecording()
}, 5000)

Returns: Promise<void>

Defined in: src/Camera.tsx:309

takePhoto

▸ takePhoto(options?: TakePhotoOptions): Promise<Readonly<Readonly<{ path: string }> & { height: number ; isRawPhoto: boolean ; metadata: { DPIHeight: number ; DPIWidth: number ; Orientation: number ; {Exif}: { ApertureValue: number ; BrightnessValue: number ; ColorSpace: number ; DateTimeDigitized: string ; DateTimeOriginal: string ; ExifVersion: string ; ExposureBiasValue: number ; ExposureMode: number ; ExposureProgram: number ; ExposureTime: number ; FNumber: number ; Flash: number ; FocalLenIn35mmFilm: number ; FocalLength: number ; ISOSpeedRatings: number[] ; LensMake: string ; LensModel: string ; LensSpecification: number[] ; MeteringMode: number ; OffsetTime: string ; OffsetTimeDigitized: string ; OffsetTimeOriginal: string ; PixelXDimension: number ; PixelYDimension: number ; SceneType: number ; SensingMethod: number ; ShutterSpeedValue: number ; SubjectArea: number[] ; SubsecTimeDigitized: string ; SubsecTimeOriginal: string ; WhiteBalance: number } ; {MakerApple}?: undefined | Record<string, unknown> ; {TIFF}: { DateTime: string ; HostComputer?: undefined | string ; Make: string ; Model: string ; ResolutionUnit: number ; Software: string ; XResolution: number ; YResolution: number } } ; thumbnail?: undefined | Record<string, unknown> ; width: number }>>

Take a single photo and write it's content to a temporary file.

throws {CameraCaptureError} When any kind of error occured. Use the CameraCaptureError.code property to get the actual error

Parameters:

Name Type
options? TakePhotoOptions

Returns: Promise<Readonly<Readonly<{ path: string }> & { height: number ; isRawPhoto: boolean ; metadata: { DPIHeight: number ; DPIWidth: number ; Orientation: number ; {Exif}: { ApertureValue: number ; BrightnessValue: number ; ColorSpace: number ; DateTimeDigitized: string ; DateTimeOriginal: string ; ExifVersion: string ; ExposureBiasValue: number ; ExposureMode: number ; ExposureProgram: number ; ExposureTime: number ; FNumber: number ; Flash: number ; FocalLenIn35mmFilm: number ; FocalLength: number ; ISOSpeedRatings: number[] ; LensMake: string ; LensModel: string ; LensSpecification: number[] ; MeteringMode: number ; OffsetTime: string ; OffsetTimeDigitized: string ; OffsetTimeOriginal: string ; PixelXDimension: number ; PixelYDimension: number ; SceneType: number ; SensingMethod: number ; ShutterSpeedValue: number ; SubjectArea: number[] ; SubsecTimeDigitized: string ; SubsecTimeOriginal: string ; WhiteBalance: number } ; {MakerApple}?: undefined | Record<string, unknown> ; {TIFF}: { DateTime: string ; HostComputer?: undefined | string ; Make: string ; Model: string ; ResolutionUnit: number ; Software: string ; XResolution: number ; YResolution: number } } ; thumbnail?: undefined | Record<string, unknown> ; width: number }>>

Defined in: src/Camera.tsx:234

takeSnapshot

▸ takeSnapshot(options?: TakeSnapshotOptions): Promise<Readonly<Readonly<{ path: string }> & { height: number ; isRawPhoto: boolean ; metadata: { DPIHeight: number ; DPIWidth: number ; Orientation: number ; {Exif}: { ApertureValue: number ; BrightnessValue: number ; ColorSpace: number ; DateTimeDigitized: string ; DateTimeOriginal: string ; ExifVersion: string ; ExposureBiasValue: number ; ExposureMode: number ; ExposureProgram: number ; ExposureTime: number ; FNumber: number ; Flash: number ; FocalLenIn35mmFilm: number ; FocalLength: number ; ISOSpeedRatings: number[] ; LensMake: string ; LensModel: string ; LensSpecification: number[] ; MeteringMode: number ; OffsetTime: string ; OffsetTimeDigitized: string ; OffsetTimeOriginal: string ; PixelXDimension: number ; PixelYDimension: number ; SceneType: number ; SensingMethod: number ; ShutterSpeedValue: number ; SubjectArea: number[] ; SubsecTimeDigitized: string ; SubsecTimeOriginal: string ; WhiteBalance: number } ; {MakerApple}?: undefined | Record<string, unknown> ; {TIFF}: { DateTime: string ; HostComputer?: undefined | string ; Make: string ; Model: string ; ResolutionUnit: number ; Software: string ; XResolution: number ; YResolution: number } } ; thumbnail?: undefined | Record<string, unknown> ; width: number }>>

Take a snapshot of the current preview view.

This can be used as an alternative to takePhoto() if speed is more important than quality

platform Android

Parameters:

Name Type
options? TakeSnapshotOptions

Returns: Promise<Readonly<Readonly<{ path: string }> & { height: number ; isRawPhoto: boolean ; metadata: { DPIHeight: number ; DPIWidth: number ; Orientation: number ; {Exif}: { ApertureValue: number ; BrightnessValue: number ; ColorSpace: number ; DateTimeDigitized: string ; DateTimeOriginal: string ; ExifVersion: string ; ExposureBiasValue: number ; ExposureMode: number ; ExposureProgram: number ; ExposureTime: number ; FNumber: number ; Flash: number ; FocalLenIn35mmFilm: number ; FocalLength: number ; ISOSpeedRatings: number[] ; LensMake: string ; LensModel: string ; LensSpecification: number[] ; MeteringMode: number ; OffsetTime: string ; OffsetTimeDigitized: string ; OffsetTimeOriginal: string ; PixelXDimension: number ; PixelYDimension: number ; SceneType: number ; SensingMethod: number ; ShutterSpeedValue: number ; SubjectArea: number[] ; SubsecTimeDigitized: string ; SubsecTimeOriginal: string ; WhiteBalance: number } ; {MakerApple}?: undefined | Record<string, unknown> ; {TIFF}: { DateTime: string ; HostComputer?: undefined | string ; Make: string ; Model: string ; ResolutionUnit: number ; Software: string ; XResolution: number ; YResolution: number } } ; thumbnail?: undefined | Record<string, unknown> ; width: number }>>

Defined in: src/Camera.tsx:249

getAvailableCameraDevices

▸ StaticgetAvailableCameraDevices(): Promise<Readonly<{ devices: PhysicalCameraDeviceType[] ; formats: Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }>[] ; hasFlash: boolean ; hasTorch: boolean ; id: string ; isMultiCam: boolean ; maxZoom: number ; minZoom: number ; name: string ; neutralZoom: number ; position: CameraPosition ; supportsLowLightBoost: boolean }>[]>

Get a list of all available camera devices on the current phone.

Returns: Promise<Readonly<{ devices: PhysicalCameraDeviceType[] ; formats: Readonly<{ autoFocusSystem: AutoFocusSystem ; colorSpaces: ColorSpace[] ; fieldOfView: number ; frameRateRanges: Readonly<{ maxFrameRate: number ; minFrameRate: number }>[] ; isHighestPhotoQualitySupported?: undefined | boolean ; maxISO: number ; maxZoom: number ; minISO: number ; photoHeight: number ; photoWidth: number ; supportsPhotoHDR: boolean ; supportsVideoHDR: boolean ; videoHeight?: undefined | number ; videoStabilizationModes: VideoStabilizationMode[] ; videoWidth?: undefined | number }>[] ; hasFlash: boolean ; hasTorch: boolean ; id: string ; isMultiCam: boolean ; maxZoom: number ; minZoom: number ; name: string ; neutralZoom: number ; position: CameraPosition ; supportsLowLightBoost: boolean }>[]>

Defined in: src/Camera.tsx:366

getCameraPermissionStatus

▸ StaticgetCameraPermissionStatus(): Promise<CameraPermissionStatus>

Gets the current Camera Permission Status. Check this before mounting the Camera to ensure the user has permitted the app to use the camera.

To actually prompt the user for camera permission, use Camera.requestCameraPermission().

Returns: Promise<CameraPermissionStatus>

Defined in: src/Camera.tsx:379

getDerivedStateFromProps

▸ StaticgetDerivedStateFromProps(props: CameraProps, state: CameraState): null | CameraState

Parameters:

Name Type
props CameraProps
state CameraState

Returns: null | CameraState

Defined in: src/Camera.tsx:454

getMicrophonePermissionStatus

▸ StaticgetMicrophonePermissionStatus(): Promise<CameraPermissionStatus>

Gets the current Microphone-Recording Permission Status. Check this before mounting the Camera to ensure the user has permitted the app to use the microphone.

To actually prompt the user for microphone permission, use Camera.requestMicrophonePermission().

Returns: Promise<CameraPermissionStatus>

Defined in: src/Camera.tsx:392

requestCameraPermission

▸ StaticrequestCameraPermission(): Promise<CameraPermissionRequestResult>

Shows a "request permission" alert to the user, and resolves with the new camera permission status.

If the user has previously blocked the app from using the camera, the alert will not be shown and "denied" will be returned.

Returns: Promise<CameraPermissionRequestResult>

Defined in: src/Camera.tsx:405

requestMicrophonePermission

▸ StaticrequestMicrophonePermission(): Promise<CameraPermissionRequestResult>

Shows a "request permission" alert to the user, and resolves with the new microphone permission status.

If the user has previously blocked the app from using the microphone, the alert will not be shown and "denied" will be returned.

Returns: Promise<CameraPermissionRequestResult>

Defined in: src/Camera.tsx:418