expo-camera 12.1.2 → 12.2.0

package/src/Camera.types.ts

@@ -7,85 +7,63 @@ import {
 import { ViewProps } from 'react-native';
 
 export enum CameraType {
-  /**
-   * @platforms ios, android, web
-   */
   front = 'front',
-  /**
-   * @platforms ios, android, web
-   */
   back = 'back',
 }
 
 export enum FlashMode {
-  /**
-   * @platforms ios, android, web
-   */
   on = 'on',
-  /**
-   * @platforms ios, android, web
-   */
   off = 'off',
-  /**
-   * @platforms ios, android, web
-   */
   auto = 'auto',
-  /**
-   * @platforms ios, android, web
-   */
   torch = 'torch',
 }
 
 export enum AutoFocus {
-  /**
-   * @platforms ios, android, web
-   */
   on = 'on',
-  /**
-   * @platforms ios, android, web
-   */
   off = 'off',
   /**
-   * @platforms web
+   * @platform web
    */
   auto = 'auto',
   /**
-   * @platforms web
+   * @platform web
    */
   singleShot = 'singleShot',
 }
 
 export enum WhiteBalance {
-  /**
-   * @platforms ios, android, web
-   */
   auto = 'auto',
   /**
-   * @platforms ios, android
+   * @platform android
+   * @platform ios
    */
   sunny = 'sunny',
   /**
-   * @platforms ios, android
+   * @platform android
+   * @platform ios
    */
   cloudy = 'cloudy',
   /**
-   * @platforms ios, android
+   * @platform android
+   * @platform ios
    */
   shadow = 'shadow',
   /**
-   * @platforms ios, android
+   * @platform android
+   * @platform ios
    */
   incandescent = 'incandescent',
   /**
-   * @platforms ios, android
+   * @platform android
+   * @platform ios
    */
   fluorescent = 'fluorescent',
   /**
-   * @platforms web
+   * @platform web
    */
   continuous = 'continuous',
   /**
-   * @platforms web
+   * @platform web
    */
   manual = 'manual',
 }
@@ -97,30 +75,34 @@ export enum ImageType {
 
 /**
  * This option specifies what codec to use when recording a video.
+ * @platform ios
  */
 export enum VideoCodec {
-  /**
-   * @platforms ios
-   */
   H264 = 'avc1',
-  /**
-   * @platforms ios
-   */
   HEVC = 'hvc1',
-  /**
-   * @platforms ios
-   */
   JPEG = 'jpeg',
-  /**
-   * @platforms ios
-   */
   AppleProRes422 = 'apcn',
-  /**
-   * @platforms ios
-   */
   AppleProRes4444 = 'ap4h',
 }
 
+// @needsAudit
+export enum VideoStabilization {
+  off = 'off',
+  standard = 'standard',
+  cinematic = 'cinematic',
+  auto = 'auto',
+}
+
+// @needsAudit
+export enum VideoQuality {
+  '2160p' = '2160p',
+  '1080p' = '1080p',
+  '720p' = '720p',
+  '480p' = '480p',
+  '4:3' = '4:3',
+}
+
+// @needsAudit
 export type ImageParameters = {
   imageType: ImageType;
   quality: number | null;
@@ -146,53 +128,109 @@ export type WebCameraSettings = Partial<{
   zoom: number;
 }>;
 
-export type CapturedPicture = {
+export type CameraCapturedPicture = {
   width: number;
   height: number;
   uri: string;
   base64?: string;
-  // note(bacon): The types are currently only defined for web.
-  exif?: Partial<MediaTrackSettings>;
+  exif?: Partial<MediaTrackSettings> | any;
 };
 
+// @needsAudit @docsMissing
 export type CameraPictureOptions = {
+  /**
+   * Specify the quality of compression, from 0 to 1. 0 means compress for small size, 1 means compress for maximum quality.
+   */
   quality?: number;
+  /**
+   * Whether to also include the image data in Base64 format.
+   */
   base64?: boolean;
+  /**
+   * Whether to also include the EXIF data for the image.
+   */
   exif?: boolean;
+  /**
+   * A callback invoked when picture is saved. If set, the promise of this method will resolve immediately with no data after picture is captured.
+   * The data that it should contain will be passed to this callback. If displaying or processing a captured photo right after taking it
+   * is not your case, this callback lets you skip waiting for it to be saved.
+   * @param picture
+   */
   onPictureSaved?: (picture: CameraCapturedPicture) => void;
   // TODO(Bacon): Is it possible to implement this in the browser?
+  /**
+   * If set to `true`, camera skips orientation adjustment and returns an image straight from the device's camera.
+   * If enabled, `quality` option is discarded (processing pipeline is skipped as a whole).
+   * Although enabling this option reduces image delivery time significantly, it may cause the image to appear in a wrong orientation
+   * in the `Image` component (at the time of writing, it does not respect EXIF orientation of the images).
+   * > **Note**: Enabling `skipProcessing` would cause orientation uncertainty. `Image` component does not respect EXIF
+   * > stored orientation information, that means obtained image would be displayed wrongly (rotated by 90°, 180° or 270°).
+   * > Different devices provide different orientations. For example some Sony Xperia or Samsung devices don't provide
+   * > correctly oriented images by default. To always obtain correctly oriented image disable `skipProcessing` option.
+   */
   skipProcessing?: boolean;
-  // Web-only
+  /**
+   * @platform web
+   */
   scale?: number;
+  /**
+   * @platform web
+   */
   imageType?: ImageType;
+  /**
+   * @platform web
+   */
   isImageMirror?: boolean;
-  // internal
+  /**
+   * @hidden
+   */
   id?: number;
+  /**
+   * @hidden
+   */
   fastMode?: boolean;
 };
 
+// @needsAudit
 export type CameraRecordingOptions = {
+  /**
+   * Maximum video duration in seconds.
+   */
   maxDuration?: number;
+  /**
+   * Maximum video file size in bytes.
+   */
   maxFileSize?: number;
+  /**
+   * Specify the quality of recorded video. Usage: `Camera.Constants.VideoQuality.<value>`,
+   * possible values: for 16:9 resolution `2160p`, `1080p`, `720p`, `480p` : `Android only` and for 4:3 `4:3` (the size is 640x480).
+   * If the chosen quality is not available for a device, the highest available is chosen.
+   */
   quality?: number | string;
+  /**
+   * If present, video will be recorded with no sound.
+   */
   mute?: boolean;
+  /**
+   * If `true`, the recorded video will be flipped along the vertical axis. iOS flips videos recorded with the front camera by default,
+   * but you can reverse that back by setting this to `true`. On Android, this is handled in the user's device settings.
+   * @platform ios
+   */
   mirror?: boolean;
-  // Android
+  /**
+   * Only works if `useCamera2Api` is set to `true`. This option specifies a desired video bitrate. For example, `5*1000*1000` would be 5Mbps.
+   * @platform android
+   */
   videoBitrate?: number;
-  // iOS
+  /**
+   * This option specifies what codec to use when recording the video. See [`Camera.Constants.VideoCodec`](#video-codec) for the possible values.
+   * @platform ios
+   */
   codec?: VideoCodec;
 };
 
-export type CameraCapturedPicture = {
-  width: number;
-  height: number;
-  uri: string;
-  base64?: string;
-  exif?: any;
-};
-
 export type PictureSavedListener = (event: {
-  nativeEvent: { data: CapturedPicture; id: number };
+  nativeEvent: { data: CameraCapturedPicture; id: number };
 }) => void;
 
 export type CameraReadyListener = () => void;
@@ -201,17 +239,26 @@ export type MountErrorListener = (event: { nativeEvent: CameraMountError }) => v
 
 export type CameraMountError = { message: string };
 
-type Point = {
+export type Point = {
   x: number;
   y: number;
 };
 
 export type BarCodePoint = Point;
 
+// @needsAudit
 export type BarCodeScanningResult = {
+  /**
+   * The barcode type.
+   */
   type: string;
+  /**
+   * The information encoded in the bar code.
+   */
   data: string;
-  /** @platform web */
+  /**
+   * Corner points of the bounding box.
+   */
   cornerPoints?: BarCodePoint[];
 };
 
@@ -244,32 +291,118 @@ export type Face = {
 export type FaceDetectionResult = { faces: Face[] };
 
 export type ConstantsType = {
-  Type: typeof CameraType;
-  FlashMode: typeof FlashMode;
-  AutoFocus: typeof AutoFocus;
-  WhiteBalance: typeof WhiteBalance;
-  VideoQuality: any;
-  VideoStabilization: any;
-  VideoCodec: typeof VideoCodec;
+  Type: CameraType;
+  FlashMode: FlashMode;
+  AutoFocus: AutoFocus;
+  WhiteBalance: WhiteBalance;
+  VideoQuality: VideoQuality;
+  VideoStabilization: VideoStabilization;
+  VideoCodec: VideoCodec;
 };
 
+// @needsAudit
 export type CameraProps = ViewProps & {
-  type?: number | keyof typeof CameraType;
-  flashMode?: number | keyof typeof FlashMode;
-  whiteBalance?: number | keyof typeof WhiteBalance;
-  autoFocus?: boolean | number | keyof typeof AutoFocus;
+  /**
+   * Camera facing. Use one of `Camera.Constants.Type`. When `Type.front`, use the front-facing camera.
+   * When `Type.back`, use the back-facing camera.
+   * @default Type.back
+   */
+  type?: number | CameraType;
+  /**
+   * Camera flash mode. Use one of `Camera.Constants.FlashMode`. When `on`, the flash on your device will
+   * turn on when taking a picture, when `off`, it won't. Setting to `auto` will fire flash if required,
+   * `torch` turns on flash during the preview.
+   * @default FlashMode.off
+   */
+  flashMode?: number | FlashMode;
+  /**
+   * Camera white balance. Use one of [`Camera.Constants.WhiteBalance`](#whitebalance). If a device does not support any of these values previous one is used.
+   */
+  whiteBalance?: number | WhiteBalance;
+  /**
+   * State of camera auto focus. Use one of [`Camera.Constants.AutoFocus`](#autofocus). When `on`,
+   * auto focus will be enabled, when `off`, it won't and focus will lock as it was in the moment of change,
+   * but it can be adjusted on some devices via `focusDepth` prop.
+   */
+  autoFocus?: boolean | number | AutoFocus;
+  /**
+   * A value between `0` and `1` being a percentage of device's max zoom. `0` - not zoomed, `1` - maximum zoom.
+   * @default 0
+   */
   zoom?: number;
+  /**
+   * A string representing aspect ratio of the preview, eg. `4:3`, `16:9`, `1:1`. To check if a ratio is supported
+   * by the device use [`getSupportedRatiosAsync`](#getsupportedratiosasync).
+   * @default 4:3.
+   * @platform android
+   */
   ratio?: string;
+  /**
+   * Distance to plane of the sharpest focus. A value between `0` and `1` where: `0` - infinity focus, `1` - focus as close as possible.
+   * For Android this is available only for some devices and when `useCamera2Api` is set to `true`.
+   * @default 0
+   */
   focusDepth?: number;
-  onCameraReady?: Function;
+  /**
+   * Callback invoked when camera preview has been set.
+   */
+  onCameraReady?: () => void;
+  /**
+   * Whether to use Android's Camera2 API. See `Note` at the top of this page.
+   * @platform android
+   */
   useCamera2Api?: boolean;
+  /**
+   * A string representing the size of pictures [`takePictureAsync`](#takepictureasync) will take.
+   * Available sizes can be fetched with [`getAvailablePictureSizesAsync`](#getavailablepicturesizesasync).
+   */
   pictureSize?: string;
+  /**
+   * The video stabilization mode used for a video recording. Use one of [`Camera.Constants.VideoStabilization`](#videostabilization).
+   * You can read more about each stabilization type in [Apple Documentation](https://developer.apple.com/documentation/avfoundation/avcapturevideostabilizationmode).
+   * @platform ios
+   */
   videoStabilizationMode?: number;
+  /**
+   * Callback invoked when camera preview could not been started.
+   * @param event Error object that contains a `message`.
+   */
   onMountError?: (event: CameraMountError) => void;
+  /**
+   * Settings exposed by [`BarCodeScanner`](bar-code-scanner) module. Supported settings: **barCodeTypes**.
+   * @example
+   * ```tsx
+   * <Camera
+   *   barCodeScannerSettings={{
+   *     barCodeTypes: [BarCodeScanner.Constants.BarCodeType.qr],
+   *   }}
+   * />
+   * ```
+   */
   barCodeScannerSettings?: object;
+  /**
+   * Callback that is invoked when a bar code has been successfully scanned. The callback is provided with
+   * an object of the [`BarCodeScanningResult`](#barcodescanningresult) shape, where the `type`
+   * refers to the bar code type that was scanned and the `data` is the information encoded in the bar code
+   * (in this case of QR codes, this is often a URL). See [`BarCodeScanner.Constants.BarCodeType`](bar-code-scanner#supported-formats)
+   * for supported values.
+   * @param scanningResult
+   */
   onBarCodeScanned?: (scanningResult: BarCodeScanningResult) => void;
+  /**
+   * A settings object passed directly to an underlying module providing face detection features.
+   * See [`DetectionOptions`](facedetector/#detectionoptions) in FaceDetector documentation for details.
+   */
   faceDetectorSettings?: object;
+  /**
+   * Callback invoked with results of face detection on the preview. See [FaceDetector documentation](facedetector/#detectionresult) for details.
+   * @param faces
+   */
   onFacesDetected?: (faces: FaceDetectionResult) => void;
+  /**
+   * A URL for an image to be shown while the camera is loading.
+   * @platform web
+   */
   poster?: string;
 };
 
@@ -294,10 +427,8 @@ export type CameraNativeProps = {
   faceDetectorSettings?: object;
   barCodeScannerEnabled?: boolean;
   faceDetectorEnabled?: boolean;
-  // Android
   ratio?: string;
   useCamera2Api?: boolean;
-  // Web
   poster?: string;
 };
 

package/src/WebCameraUtils.ts

@@ -3,7 +3,7 @@ import invariant from 'invariant';
 
 import {
   CameraType,
-  CapturedPicture,
+  CameraCapturedPicture,
   ImageSize,
   ImageType,
   WebCameraSettings,
@@ -248,10 +248,10 @@ export function capture(
   video: HTMLVideoElement,
   settings: MediaTrackSettings,
   config: CameraPictureOptions
-): CapturedPicture {
+): CameraCapturedPicture {
   const base64 = captureImage(video, config);
 
-  const capturedPicture: CapturedPicture = {
+  const capturedPicture: CameraCapturedPicture = {
     uri: base64,
     base64,
     width: 0,
@@ -384,7 +384,7 @@ export function setVideoSource(
   } else if (typeof (video as any).mozSrcObject !== 'undefined') {
     (video as any).mozSrcObject = stream;
   } else if (stream && createObjectURL) {
-    video.src = createObjectURL(stream);
+    video.src = createObjectURL(stream as MediaSource | Blob);
   }
 
   if (!stream) {

package/src/index.ts

@@ -7,15 +7,28 @@ export {
   requestCameraPermissionsAsync,
   getMicrophonePermissionsAsync,
   requestMicrophonePermissionsAsync,
+} from './Camera';
+
+export {
+  BarCodePoint,
+  BarCodeScanningResult,
   CameraCapturedPicture,
+  CameraMountError,
   CameraNativeProps,
   CameraPictureOptions,
   CameraProps,
   CameraRecordingOptions,
+  ConstantsType,
+  FaceDetectionResult,
   PermissionResponse,
   PermissionStatus,
   PermissionExpiration,
-  BarCodeScanningResult,
-  FaceDetectionResult,
-  CameraMountError,
-} from './Camera';
+  Point,
+  AutoFocus,
+  FlashMode,
+  CameraType,
+  VideoCodec,
+  VideoQuality,
+  VideoStabilization,
+  WhiteBalance,
+} from './Camera.types';

package/src/useWebQRScanner.ts

@@ -1,20 +1,19 @@
 import { useWorker } from '@koale/useworker';
 import * as React from 'react';
 
-import { CameraPictureOptions } from './Camera';
-import { BarCodeScanningResult, MountErrorListener } from './Camera.types';
+import { BarCodeScanningResult, CameraPictureOptions, MountErrorListener } from './Camera.types';
 import { captureImageData } from './WebCameraUtils';
 
 const qrWorkerMethod = ({ data, width, height }: ImageData): any => {
   // eslint-disable-next-line no-undef
   const decoded = (self as any).jsQR(data, width, height, {
-    inversionAttempts: 'dontInvert',
+    inversionAttempts: 'attemptBoth',
   });
 
   let parsed;
   try {
     parsed = JSON.parse(decoded);
-  } catch (err) {
+  } catch {
     parsed = decoded;
   }