@react-native-ohos/react-native-qr-decode-image-camera 1.1.4-rc.1

package/harmony/qr_decode_image_camera/src/ohosTest/ets/testability/TestAbility.ets

@@ -0,0 +1,47 @@
+import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit';
+import { abilityDelegatorRegistry } from '@kit.TestKit';
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { window } from '@kit.ArkUI';
+import { Hypium } from '@ohos/hypium';
+import testsuite from '../test/List.test';
+
+export default class TestAbility extends UIAbility {
+  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onCreate');
+    hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? '');
+    hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? '');
+    let abilityDelegator: abilityDelegatorRegistry.AbilityDelegator;
+    abilityDelegator = abilityDelegatorRegistry.getAbilityDelegator();
+    let abilityDelegatorArguments: abilityDelegatorRegistry.AbilityDelegatorArgs;
+    abilityDelegatorArguments = abilityDelegatorRegistry.getArguments();
+    hilog.info(0x0000, 'testTag', '%{public}s', 'start run testcase!!!');
+    Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite);
+  }
+
+  onDestroy() {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onDestroy');
+  }
+
+  onWindowStageCreate(windowStage: window.WindowStage) {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageCreate');
+    windowStage.loadContent('testability/pages/Index', (err) => {
+      if (err.code) {
+        hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? '');
+        return;
+      }
+      hilog.info(0x0000, 'testTag', 'Succeeded in loading the content.');
+    });
+  }
+
+  onWindowStageDestroy() {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageDestroy');
+  }
+
+  onForeground() {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onForeground');
+  }
+
+  onBackground() {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onBackground');
+  }
+}

package/harmony/qr_decode_image_camera/src/ohosTest/ets/testability/pages/Index.ets

@@ -0,0 +1,17 @@
+@Entry
+@Component
+struct Index {
+  @State message: string = 'Hello World';
+
+  build() {
+    Row() {
+      Column() {
+        Text(this.message)
+          .fontSize(50)
+          .fontWeight(FontWeight.Bold)
+      }
+      .width('100%')
+    }
+    .height('100%')
+  }
+}

package/harmony/qr_decode_image_camera/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ets

@@ -0,0 +1,90 @@
+import { abilityDelegatorRegistry, TestRunner } from '@kit.TestKit';
+import { UIAbility, Want } from '@kit.AbilityKit';
+import { BusinessError } from '@kit.BasicServicesKit';
+import { hilog } from '@kit.PerformanceAnalysisKit';
+import { resourceManager } from '@kit.LocalizationKit';
+import { util } from '@kit.ArkTS';
+
+let abilityDelegator: abilityDelegatorRegistry.AbilityDelegator;
+let abilityDelegatorArguments: abilityDelegatorRegistry.AbilityDelegatorArgs;
+let jsonPath: string = 'mock/mock-config.json';
+let tag: string = 'testTag';
+
+async function onAbilityCreateCallback(data: UIAbility) {
+  hilog.info(0x0000, 'testTag', 'onAbilityCreateCallback, data: ${}', JSON.stringify(data));
+}
+
+async function addAbilityMonitorCallback(err: BusinessError) {
+  hilog.info(0x0000, 'testTag', 'addAbilityMonitorCallback : %{public}s', JSON.stringify(err) ?? '');
+}
+
+export default class OpenHarmonyTestRunner implements TestRunner {
+  constructor() {
+  }
+
+  onPrepare() {
+    hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner OnPrepare');
+  }
+
+  async onRun() {
+    let tag = 'testTag';
+    hilog.info(0x0000, tag, '%{public}s', 'OpenHarmonyTestRunner onRun run');
+    abilityDelegatorArguments = abilityDelegatorRegistry.getArguments()
+    abilityDelegator = abilityDelegatorRegistry.getAbilityDelegator()
+    let moduleName = abilityDelegatorArguments.parameters['-m'];
+    let context = abilityDelegator.getAppContext().getApplicationContext().createModuleContext(moduleName);
+    let mResourceManager = context.resourceManager;
+    await checkMock(abilityDelegator, mResourceManager);
+    const bundleName = abilityDelegatorArguments.bundleName;
+    const testAbilityName: string = 'TestAbility';
+    let lMonitor: abilityDelegatorRegistry.AbilityMonitor = {
+      abilityName: testAbilityName,
+      onAbilityCreate: onAbilityCreateCallback,
+      moduleName: moduleName
+    };
+    abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback)
+    const want: Want = {
+      bundleName: bundleName,
+      abilityName: testAbilityName,
+      moduleName: moduleName
+    };
+    abilityDelegator.startAbility(want, (err: BusinessError, data: void) => {
+      hilog.info(0x0000, tag, 'startAbility : err : %{public}s', JSON.stringify(err) ?? '');
+      hilog.info(0x0000, tag, 'startAbility : data : %{public}s', JSON.stringify(data) ?? '');
+    })
+    hilog.info(0x0000, tag, '%{public}s', 'OpenHarmonyTestRunner onRun end');
+  }
+}
+
+async function checkMock(abilityDelegator: abilityDelegatorRegistry.AbilityDelegator, resourceManager: resourceManager.ResourceManager) {
+  let rawFile: Uint8Array;
+  try {
+    rawFile = resourceManager.getRawFileContentSync(jsonPath);
+    hilog.info(0x0000, tag, 'MockList file exists');
+    let mockStr: string = util.TextDecoder.create('utf-8', { ignoreBOM: true }).decodeWithStream(rawFile);
+    let mockMap: Record<string, string> = getMockList(mockStr);
+    try {
+      abilityDelegator.setMockList(mockMap)
+    } catch (error) {
+      let code = (error as BusinessError).code;
+      let message = (error as BusinessError).message;
+      hilog.error(0x0000, tag, `abilityDelegator.setMockList failed, error code: ${code}, message: ${message}.`);
+    }
+  } catch (error) {
+    let code = (error as BusinessError).code;
+    let message = (error as BusinessError).message;
+    hilog.error(0x0000, tag, `ResourceManager:callback getRawFileContent failed, error code: ${code}, message: ${message}.`);
+  }
+}
+
+function getMockList(jsonStr: string) {
+  let jsonObj: Record<string, Object> = JSON.parse(jsonStr);
+  let map: Map<string, object> = new Map<string, object>(Object.entries(jsonObj));
+  let mockList: Record<string, string> = {};
+  map.forEach((value: object, key: string) => {
+    let realValue: string = value['source'].toString();
+    mockList[key] = realValue;
+  });
+  hilog.info(0x0000, tag, '%{public}s', 'mock-json value:' + JSON.stringify(mockList) ?? '');
+  return mockList;
+}

package/harmony/qr_decode_image_camera/src/ohosTest/module.json5

@@ -0,0 +1,36 @@
+{
+  "module": {
+    "name": "qr_decode_image_camera_test",
+    "type": "feature",
+    "description": "$string:module_test_desc",
+    "mainElement": "TestAbility",
+    "deviceTypes": [
+      "2in1"
+    ],
+    "deliveryWithInstall": true,
+    "installationFree": false,
+    "pages": "$profile:test_pages",
+    "abilities": [
+      {
+        "name": "TestAbility",
+        "srcEntry": "./ets/testability/TestAbility.ets",
+        "description": "$string:TestAbility_desc",
+        "icon": "$media:icon",
+        "label": "$string:TestAbility_label",
+        "exported": true,
+        "startWindowIcon": "$media:icon",
+        "startWindowBackground": "$color:start_window_background",
+        "skills": [
+          {
+            "actions": [
+              "action.system.home"
+            ],
+            "entities": [
+              "entity.system.home"
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}

package/harmony/qr_decode_image_camera/src/ohosTest/resources/base/element/color.json

@@ -0,0 +1,8 @@
+{
+  "color": [
+    {
+      "name": "start_window_background",
+      "value": "#FFFFFF"
+    }
+  ]
+}

package/harmony/qr_decode_image_camera/src/ohosTest/resources/base/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_test_desc",
+      "value": "test ability description"
+    },
+    {
+      "name": "TestAbility_desc",
+      "value": "the test ability"
+    },
+    {
+      "name": "TestAbility_label",
+      "value": "test label"
+    }
+  ]
+}

package/harmony/qr_decode_image_camera/src/ohosTest/resources/base/profile/test_pages.json

@@ -0,0 +1,5 @@
+{
+  "src": [
+    "testability/pages/Index"
+  ]
+}

package/harmony/qr_decode_image_camera/src/test/List.test.ets

@@ -0,0 +1,5 @@
+import localUnitTest from './LocalUnit.test';
+
+export default function testsuite() {
+  localUnitTest();
+}

package/harmony/qr_decode_image_camera/src/test/LocalUnit.test.ets

@@ -0,0 +1,33 @@
+import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium';
+
+export default function localUnitTest() {
+  describe('localUnitTest', () => {
+    // Defines a test suite. Two parameters are supported: test suite name and test suite function.
+    beforeAll(() => {
+      // Presets an action, which is performed only once before all test cases of the test suite start.
+      // This API supports only one parameter: preset action function.
+    });
+    beforeEach(() => {
+      // Presets an action, which is performed before each unit test case starts.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: preset action function.
+    });
+    afterEach(() => {
+      // Presets a clear action, which is performed after each unit test case ends.
+      // The number of execution times is the same as the number of test cases defined by **it**.
+      // This API supports only one parameter: clear action function.
+    });
+    afterAll(() => {
+      // Presets a clear action, which is performed after all test cases of the test suite end.
+      // This API supports only one parameter: clear action function.
+    });
+    it('assertContain', 0, () => {
+      // Defines a test case. This API supports three parameters: test case name, filter parameter, and test case function.
+      let a = 'abc';
+      let b = 'b';
+      // Defines a variety of assertion methods, which are used to declare expected boolean conditions.
+      expect(a).assertContain(b);
+      expect(a).assertEqual(a);
+    });
+  });
+}

package/harmony/qr_decode_image_camera/ts.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+export * from './src/main/ets/RNQrDecodeImageCameraPackage';
+export * from "./src/main/ets/RNQrDecodeImageCameraTurboModule";

package/index.js

@@ -0,0 +1,15 @@
+import QRscanner from './src/QRScanner'
+import { NativeModules } from 'react-native';
+import { Platform, TurboModuleRegistry } from "react-native"
+var getQr = TurboModuleRegistry ?
+  TurboModuleRegistry.get('QrDecodeImageCameraNativeModule') : NativeModules.QRScanReader;
+const QRreader = (fileUrl) => {
+  if (Platform.OS == 'harmony') {
+    return getQr.QRreader(fileUrl)
+  } else {
+    var QRScanReader = NativeModules.QRScanReader;
+    return QRScanReader.readerQR(fileUrl);
+  }
+}
+
+export { QRscanner, QRreader }

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@react-native-ohos/react-native-qr-decode-image-camera",
+  "version": "1.1.4-rc.1",
+  "description": "Decode react native from gallery and camera",
+  "license": "MIT",
+  "main": "index.js",
+  "nativePackage": true,
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "codegen-lib": "react-native codegen-lib-harmony --no-safety-check --npm-package-name react-native-qr-decode-image-camera --cpp-output-path ./harmony/qr_decode_image_camera/src/main/cpp/generated --ets-output-path ./harmony/qr_decode_image_camera/src/main/ets/generated --turbo-modules-spec-paths ./src/NativeQrDecodeImageCamera.ts" 
+  },
+  "harmony": {
+    "alias":  "react-native-qr-decode-image-camera"
+  },
+  "keywords": [
+    "QRCode",
+    "Decode",
+    "scanner",
+    "react-native",
+    "harmony"
+  ],
+  "dependencies": {
+    "prop-types": "^15.8.1",
+    "react-native-qr-decode-image-camera":"^1.1.3",
+    "react-native": "0.72.2",
+    "@react-native-oh/react-native-harmony-cli": "npm:@react-native-oh/react-native-harmony-cli@^0.0.27"
+  },
+  "homepage": "https://gitcode.com/openharmony-sig/rntpc_react-native-qr-decode-image-camera#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://gitcode.com/openharmony-sig/rntpc_react-native-qr-decode-image-camera.git"
+  },
+  "devDependencies": {
+    "react": "^18.2.0",
+    "react-native": "^0.69.0",
+    "react-native-vision-camera":"^4.0.1",
+    "react-native-qr-decode-image-camera":"^1.1.3"
+  }
+}

package/src/Camera.tsx

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import React, { useState, useEffect } from 'react';
+import {
+  PixelRatio
+} from "react-native";
+import { Camera, useCameraDevice, useCameraPermission } from 'react-native-vision-camera'
+export const ComponentCamera = (props) => {
+  const CODE_TYPES = [
+    'code-128',
+    'code-39',
+    'code-93',
+    'codabar',
+    'ean-13',
+    'ean-8',
+    'itf',
+    'upc-e',
+    'upc-a',
+    'qr',
+    'pdf-417',
+    'aztec',
+    'data-matrix'
+  ]
+  const device = useCameraDevice('back');
+  const { hasPermission, requestPermission } = useCameraPermission();
+
+  if (!hasPermission) {
+    requestPermission();
+  }
+
+  const codeScanner =   {  
+      codeTypes: CODE_TYPES,
+      onCodeScanned: (codes) => {
+        // console.log(`Scanned ${codes.length} codes:`, codes)
+        const value = codes[0]
+        if (value) {
+          props.onRead(value)
+        } else {
+          if (value == null) return
+        }
+      }
+  }  
+
+
+  return (
+    <Camera
+      isActive={props.isActive}
+      preview={true}
+      device={device}
+      codeScanner={codeScanner}
+      torch={props.torch ? "on" : "off"}
+    /> 
+  )
+}

package/src/NativeQrDecodeImageCamera.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { TurboModuleRegistry } from 'react-native';
+
+interface IPath {
+    uri:string;
+}
+export interface Spec extends TurboModule {
+    QRreader: (path:IPath) => Promise<any>;
+}   
+ 
+export default TurboModuleRegistry.get<Spec>('QrDecodeImageCameraNativeModule') as Spec | null;

package/src/NativeScan.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import type { ViewProps } from "react-native/Libraries/Components/View/ViewPropTypes";
+import type { HostComponent } from "react-native";
+import type {
+  BubblingEventHandler, Float, Int32,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
+
+type OnReadEvent = Readonly<{
+  result: string;
+}>
+
+export interface NativeProps extends ViewProps {
+  text?: string,
+  onRead?: BubblingEventHandler<OnReadEvent>,
+  flashMode?:boolean | null,
+  zoom?:Float,
+}
+
+export default codegenNativeComponent<NativeProps>("NativeScan") as HostComponent<NativeProps>;

package/src/QRScanner.harmony.jsx

@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import React, { Component } from "react";
+import PropTypes from "prop-types";
+
+import {
+  StyleSheet,
+  View,
+  Text,
+  Vibration,
+  PixelRatio
+} from "react-native";
+import QRScannerView from "./QRScannerView";
+import { ComponentCamera } from "./Camera";
+
+
+export default class QRScannerHarmony extends Component {
+
+  constructor(props) {
+    super(props);
+    this.state = {
+      scanning: false,
+      barCodeSize: {},
+      isActive: true
+    };
+  }
+
+  static defaultProps = {
+    onRead: () => { },
+    renderTopView: () => { },
+    renderBottomView: () => (
+      <View style={{ flex: 1, backgroundColor: "#0000004D" }} />
+    ),
+    rectHeight: 200,
+    rectWidth: 200,
+    flashMode: false, // Flashlight mode
+    finderX: 0, // Viewfinder X-axis offset
+    finderY: 0, // Viewfinder Y-axis offset
+    zoom: 0.2, // Zoom range 0 - 1
+    translucent: false,
+    isRepeatScan: false,
+    cameraType: "back",
+    notAuthorizedView: () => (
+      <View style={styles.authorizationContainer}>
+        <Text style={styles.notAuthorizedText}>Camera not authorized</Text>
+      </View>
+    ),
+    vibrate: true,
+  };
+
+  render() {
+
+    return (
+      <View
+        style={{
+          flex: 1
+        }}
+      >
+        <ComponentCamera
+          isRepeatScan={this.props.isRepeatScan}
+          zoom={this.props.zoom}
+          torch={this.props.flashMode}
+          onRead={this._handleBarCodeRead}
+          isActive={this.state.isActive}
+        />
+        <View style={[styles.topButtonsContainer, this.props.topViewStyle]}>
+          {this.props.renderTopView()}
+        </View>
+        <QRScannerView
+          maskColor={this.props.maskColor}
+          cornerColor={this.props.cornerColor}
+          borderColor={this.props.borderColor}
+          rectHeight={this.props.rectHeight}
+          rectWidth={this.props.rectWidth}
+          borderWidth={this.props.borderWidth}
+          cornerBorderWidth={this.props.cornerBorderWidth}
+          cornerBorderLength={this.props.cornerBorderLength}
+          cornerOffsetSize={this.props.cornerOffsetSize}
+          isCornerOffset={this.props.isCornerOffset}
+          bottomHeight={this.props.bottomHeight}
+          scanBarAnimateTime={this.props.scanBarAnimateTime}
+          scanBarColor={this.props.scanBarColor}
+          scanBarHeight={this.props.scanBarHeight}
+          scanBarMargin={this.props.scanBarMargin}
+          hintText={this.props.hintText}
+          hintTextStyle={this.props.hintTextStyle}
+          scanBarImage={this.props.scanBarImage}
+          hintTextPosition={this.props.hintTextPosition}
+          isShowScanBar={this.props.isShowScanBar}
+          finderX={this.props.finderX}
+          finderY={this.props.finderY}
+          returnSize={this.barCodeSize}
+        />
+        <View
+          style={[styles.bottomButtonsContainer, this.props.bottomViewStyle]}
+        >
+          {this.props.renderBottomView()}
+        </View>
+
+      </View>
+    )
+
+  }
+
+  isShowCode = false;
+
+  barCodeSize = size => this.setState({ barCodeSize: size });
+
+  returnMax = (a, b) => (a > b ? a : b);
+
+  returnMin = (a, b) => (a < b ? a : b);
+  oldValue = null;
+  newValue = null;
+
+  harmonyBarCode(e) {
+    const { x, y, width, height } = this.state.barCodeSize;
+    const xInPx = PixelRatio.getPixelSizeForLayoutSize(x);
+    const yInPx = PixelRatio.getPixelSizeForLayoutSize(y);
+    const widthInPx = PixelRatio.getPixelSizeForLayoutSize(width);
+    const heightInPx = PixelRatio.getPixelSizeForLayoutSize(height);
+    const findXInPx = PixelRatio.getPixelSizeForLayoutSize(this.props.finderX);
+    const findYInPx = PixelRatio.getPixelSizeForLayoutSize(this.props.finderY);
+    let x_px = Number(e.frame.x);
+    let y_px = Number(e.frame.y);
+    let width_px = e.frame.width;
+    let height_px = e.frame.height;
+    let viewMinX = Number(xInPx - findXInPx);
+    let viewMinY = yInPx - findYInPx;
+    let viewMaxX = xInPx + widthInPx - width_px - findXInPx;
+    let viewMaxY = yInPx + heightInPx - height_px - findYInPx;
+    if (x_px > viewMinX && y_px > viewMinY && x_px < viewMaxX && y_px < viewMaxY) {
+      this.newValue = e.value;
+      if (this.props.isRepeatScan) {
+        if (this.newValue !== this.oldValue) {
+          this.oldValue = this.newValue;
+          this.setState({ isActive: true });
+          Vibration.vibrate();
+          this.props.onRead(e);
+        }
+        return
+      } else {
+        if (!this.isShowCode) {
+          this.isShowCode = true;
+          this.setState({ isActive: false });
+          Vibration.vibrate();
+          this.props.onRead(e);
+        }
+      }
+    } else {
+      this.newValue = null;
+      this.oldValue = null;
+    }
+  }
+
+
+  _handleBarCodeRead = e => {
+    this.harmonyBarCode(e);
+  };
+}
+
+const styles = StyleSheet.create({
+  topButtonsContainer: {
+    position: "absolute",
+    height: 100,
+    top: 0,
+    left: 0,
+    right: 0
+  },
+  bottomButtonsContainer: {
+    position: "absolute",
+    height: 100,
+    bottom: 0,
+    left: 0,
+    right: 0
+  },
+  authorizationContainer: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  notAuthorizedText: {
+    textAlign: "center",
+    fontSize: 16
+  }
+});
+
+QRScannerHarmony.propTypes = {
+  isRepeatScan: PropTypes.bool,
+  onRead: PropTypes.func,
+  maskColor: PropTypes.string,
+  borderColor: PropTypes.string,
+  cornerColor: PropTypes.string,
+  borderWidth: PropTypes.number,
+  cornerBorderWidth: PropTypes.number,
+  cornerBorderLength: PropTypes.number,
+  rectHeight: PropTypes.number,
+  rectWidth: PropTypes.number,
+  isCornerOffset: PropTypes.bool, //Whether the corners are offset
+  cornerOffsetSize: PropTypes.number,
+  bottomHeight: PropTypes.number,
+  scanBarAnimateTime: PropTypes.number,
+  scanBarColor: PropTypes.string,
+  scanBarImage: PropTypes.any,
+  scanBarHeight: PropTypes.number,
+  scanBarMargin: PropTypes.number,
+  hintText: PropTypes.string,
+  hintTextStyle: PropTypes.object,
+  hintTextPosition: PropTypes.number,
+  renderTopView: PropTypes.func,
+  renderBottomView: PropTypes.func,
+  isShowScanBar: PropTypes.bool,
+  topViewStyle: PropTypes.object,
+  bottomViewStyle: PropTypes.object,
+  flashMode: PropTypes.bool,
+  finderX: PropTypes.number,
+  finderY: PropTypes.number,
+  zoom: PropTypes.number,
+  translucent: PropTypes.bool,
+  cameraType: PropTypes.string,
+  vibrate: PropTypes.bool,
+};