react-native-scanbot-barcode-scanner-sdk 3.1.0-alpha1 → 3.1.0-beta10

package/ios/ScanbotBarcodeSdk.m

@@ -24,6 +24,8 @@ void runInBackground(void (^function)(void)) {
 
 @implementation ScanbotBarcodeSdk
 
+static UIViewController* activeViewController = nil;
+
 RCT_EXPORT_MODULE()
 
 // Necessary so that the start* methods get called on the UI thread.
@@ -45,7 +47,17 @@ RCT_EXPORT_METHOD(initializeSdk:(NSDictionary *)configuration
         @"engineMode": @{
                 @"LEGACY": @(SBSDKBarcodeEngineModeLegacy),
                 @"NEXT_GEN": @(SBSDKBarcodeEngineModeNextGen)
-        }
+        },
+        @"allowedInterfaceOrientations": @{
+            @"NONE": @(UIInterfaceOrientationMaskAll),
+            @"PORTRAIT": @(UIInterfaceOrientationMaskPortrait),
+            @"PORTRAIT_UPSIDE_DOWN": @(UIInterfaceOrientationMaskPortraitUpsideDown),
+            @"LANDSCAPE_LEFT": @(UIInterfaceOrientationMaskLandscapeLeft),
+            @"LANDSCAPE_RIGHT": @(UIInterfaceOrientationMaskLandscapeRight),
+            @"LANDSCAPE": @(UIInterfaceOrientationMaskLandscape),
+            @"ALL": @(UIInterfaceOrientationMaskAll),
+            @"ALL_BUT_UPSIDE_DOWN": @(UIInterfaceOrientationMaskAllButUpsideDown)
+        },
     }];
 
     // map config parameters and normalize some fields
@@ -121,11 +133,11 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
         return;
     }
     
-    // Need to manully extract because of naming disparity between iOS and Android
-    // Also, it is nullable, 'true' by default, so wrap it in an NSNumber
+    // Need to manually extract because of naming disparity between iOS and Android
+    // Also, it is nullable, 'true' by default, so we wrap it in an NSNumber
     NSNumber* gs1Decoding = [configuration objectForKey:@"gs1DecodingEnabled"];
     if (gs1Decoding != nil) {
-       additionalParameters.enableGS1Decoding = gs1Decoding;
+       additionalParameters.enableGS1Decoding = [gs1Decoding boolValue];
     }
 
     additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
@@ -137,7 +149,10 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
 
     SBSDKUIBarcodeScannerConfiguration* config = [[SBSDKUIBarcodeScannerConfiguration alloc] initWithUIConfiguration:uiConfig textConfiguration:textConfig behaviorConfiguration:behaviorConfig];
 
-    uiConfig.allowedInterfaceOrientations = [ObjectMapper orientationLockModeToUIInterfaceOrientationMask:configuration];
+    SBSDKUICameraConfiguration* cameraConfiguration = extractCameraConfiguration(configuration);
+    if (cameraConfiguration) {
+        config.cameraConfiguration.camera = cameraConfiguration.camera;
+    }
 
     bool shouldWaitForGeneratedImage = behaviorConfig.barcodeImageGenerationType != SBSDKBarcodeImageGenerationTypeNone;
     BarcodeScannerPromiseProxy* delegate = [[BarcodeScannerPromiseProxy alloc] initWithResolver: resolve
@@ -151,9 +166,13 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
         viewController = [SBSDKUIBarcodeScannerViewController createNewWithAcceptedMachineCodeTypes:machineCodeTypes configuration:config andDelegate:delegate];
     }
 
-    [viewController setModalPresentationStyle:UIModalPresentationFullScreen];
-    UIViewController* rootViewController = [UIApplication sharedApplication].delegate.window.rootViewController;
-    [rootViewController presentViewController:viewController animated:true completion:nil];
+    [self presentActiveViewController:viewController];
+}
+
+RCT_EXPORT_METHOD(closeBarcodeScanner:(RCTPromiseResolveBlock)resolve
+                  failure:(RCTPromiseRejectBlock)reject) {
+    [self dismissActiveViewController: [SBSDKUIBarcodeScannerViewController class]];
+    resolve(nil);
 }
 
 RCT_EXPORT_METHOD(startBatchBarcodeScanner:(NSDictionary*)configuration
@@ -179,28 +198,52 @@ RCT_EXPORT_METHOD(startBatchBarcodeScanner:(NSDictionary*)configuration
     }
     
     // Need to manully extract because of naming disparity between iOS and Android
-    // Also, it is nullable, 'true' by default, so wrap it in an NSNumber
+    // Also, it is nullable, 'true' by default, so we wrap it in an NSNumber
     NSNumber* gs1Decoding = [configuration objectForKey:@"gs1DecodingEnabled"];
     if (gs1Decoding != nil) {
-       additionalParameters.enableGS1Decoding = gs1Decoding;
+       additionalParameters.enableGS1Decoding = [gs1Decoding boolValue];
     }
 
     additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
     
     behavior.additionalDetectionParameters = additionalParameters;
     
-    SBSDKUIBarcodesBatchScannerConfiguration *config = [[SBSDKUIBarcodesBatchScannerConfiguration alloc] initWithUIConfiguration:ui textConfiguration:text behaviorConfiguration:behavior];
+    SBSDKUIBarcodesBatchScannerConfiguration *config = [[SBSDKUIBarcodesBatchScannerConfiguration alloc]
+                                                        initWithUIConfiguration:ui
+                                                        textConfiguration:text
+                                                        behaviorConfiguration:behavior];
     
     NSArray* machineCodeTypes = extractBarcodeTypesFromConfiguration(configuration);
+    NSArray* acceptedDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
+
+    SBSDKUICameraConfiguration* cameraConfiguration = extractCameraConfiguration(configuration);
+    if (cameraConfiguration) {
+        config.cameraConfiguration.camera = cameraConfiguration.camera;
+    }
+
     BatchBarcodeScannerPromiseProxy* delegate = [[BatchBarcodeScannerPromiseProxy alloc] initWithResolver:resolve];
-    SBSDKUIBarcodesBatchScannerViewController* controller =
-            [SBSDKUIBarcodesBatchScannerViewController createNewWithAcceptedMachineCodeTypes: machineCodeTypes configuration:config andDelegate:delegate];
+
+    SBSDKUIBarcodesBatchScannerViewController* viewController = NULL;
+
+    if (acceptedDocumentTypes && acceptedDocumentTypes.count > 0) {
+        viewController = [SBSDKUIBarcodesBatchScannerViewController createNewWithAcceptedMachineCodeTypes:machineCodeTypes
+                                                                          withAcceptedDocumentTypes:acceptedDocumentTypes
+                                                                                      configuration:config
+                                                                                        andDelegate:delegate];
+    } else {
+        viewController = [SBSDKUIBarcodesBatchScannerViewController createNewWithAcceptedMachineCodeTypes:machineCodeTypes
+                                                                                      configuration:config
+                                                                                        andDelegate:delegate];
+    }
     
-    [controller setModalPresentationStyle:UIModalPresentationFullScreen];
-    UIViewController* rootViewController = [UIApplication sharedApplication].delegate.window.rootViewController;
-    [rootViewController presentViewController:controller animated:true completion:nil];
+    [self presentActiveViewController:viewController];
 }
 
+RCT_EXPORT_METHOD(closeBatchBarcodeScanner:(RCTPromiseResolveBlock)resolve
+                  failure:(RCTPromiseRejectBlock)reject) {
+    [self dismissActiveViewController: [SBSDKUIBarcodesBatchScannerViewController class]];
+    resolve(nil);
+}
 
 RCT_EXPORT_METHOD(detectBarcodesOnImage:(NSDictionary *)configuration
     resolve:(RCTPromiseResolveBlock)resolve
@@ -334,6 +377,33 @@ RCT_EXPORT_METHOD(cleanup:(RCTPromiseResolveBlock)resolve
     return nil;
 }
 
+- (void) presentActiveViewController:(UIViewController*) viewController {
+    if (!viewController) {
+        return;
+    }
+
+    UIViewController *rootViewController = [UIApplication sharedApplication].delegate.window.rootViewController;
+    [viewController setModalPresentationStyle:UIModalPresentationFullScreen];
+    [rootViewController presentViewController:viewController animated:YES completion:nil];
+
+    activeViewController = viewController;
+}
+
+- (_Bool) dismissActiveViewController:(Class _Nullable)vcClass {
+    if (!activeViewController) {
+        return false;
+    }
+
+    if (vcClass && ![activeViewController isKindOfClass:vcClass]) {
+        return false;
+    }
+
+    [activeViewController dismissViewControllerAnimated:true completion:nil];
+    activeViewController = nil;
+
+    return true;
+}
+
 @end
 
 /// Barcode Scanner Delegate

package/ios/Utils/BarcodeMapping.h

@@ -128,9 +128,9 @@ static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgo
     if (algorithm != nil) {
         if ([algorithm isEqualToString:@"None"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmNone;
         if ([algorithm isEqualToString:@"Mod10"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
+        if ([algorithm isEqualToString:@"Mod1010"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1010;
         if ([algorithm isEqualToString:@"Mod11IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11IBM;
         if ([algorithm isEqualToString:@"Mod11NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11NCR;
-        if ([algorithm isEqualToString:@"Mod1010"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1010;
         if ([algorithm isEqualToString:@"Mod1110IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110IBM;
         if ([algorithm isEqualToString:@"Mod1110NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110NCR;
     }
@@ -138,4 +138,21 @@ static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgo
     return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
 }
 
+static inline SBSDKUICameraConfiguration* extractCameraConfiguration(NSDictionary* configuration) {
+    SBSDKUICameraConfiguration* cameraConfiguration = [[SBSDKUICameraConfiguration alloc] init];
+    
+    NSString* cameraModule = [configuration objectForKey:@"cameraModule"];
+    if(!cameraModule) {
+        return nil;
+    }
+    
+    if ([cameraModule isEqualToString:@"FRONT"]) {
+        cameraConfiguration.camera = SBSDKCameraDevice.defaultFrontFacingCamera;
+    } else if ([cameraModule isEqualToString:@"BACK"]) {
+        cameraConfiguration.camera = SBSDKCameraDevice.defaultBackFacingCamera;
+    }
+    
+    return cameraConfiguration;
+}
+
 #endif /* BarcodeMapping_h */

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "react-native-scanbot-barcode-scanner-sdk",
   "title": "Scanbot Barcode Scanner SDK for React Native",
-  "version": "3.1.0-alpha1",
+  "version": "3.1.0-beta10",
   "description": "React Native plugin for the Scanbot Barcode Scanner SDK on Android and iOS",
   "main": "index.js",
   "files": [
     "src/*.js",
     "src/*.ts",
+    "src/components/**/*.ts",
+    "src/components/**/*.tsx",
+    "src/components/**/*.js",
     "android/**",
     "ios/**",
     "index.d.ts",
@@ -43,8 +46,8 @@
     "react-native": ">=0.60 <1.0.x"
   },
   "devDependencies": {
-    "react": "^16.8.3",
-    "react-native": "^0.60"
+    "react": "^17.0.2",
+    "react-native": "^0.65"
   },
   "contributors": [
     {

package/src/components/barcode-camera-view/scanbot-barcode-camera-view-types.tsx

@@ -0,0 +1,121 @@
+import { StyleProp, ViewStyle } from 'react-native';
+import {
+  BarcodeDocumentFormat,
+  BarcodeFormat,
+  EngineMode,
+  MSIPlesseyChecksumAlgorithm,
+} from '../../enum';
+import { FinderAspectRatio } from '../../model';
+
+export interface ScanbotBarcodeCameraViewProperties {
+  onBarcodeScannerResult?: (result: ScanbotBarcodeCameraViewResult) => void;
+  requestComponentReload?: () => void;
+  configuration?: ScanbotBarcodeCameraViewConfiguration;
+  style: StyleProp<ViewStyle>;
+}
+
+export interface ScanbotBarcodeCameraViewBarcode {
+  text: string;
+  type: string;
+}
+
+export type ScanbotBarcodeCameraViewResult = {
+  status: 'OK' | 'CANCELED';
+  barcodes: ScanbotBarcodeCameraViewBarcode[];
+};
+
+export interface ScanbotBarcodeCameraViewConfiguration {
+  /**
+   * The finder view is a rectangular overlay view that clips the camera view,
+   * so that the detection will focus just a specific area. You can specify
+   * the size and positioning, as well as other UI properties.
+   * Set this property to `true` if you want to use the Finder View, `false` otherwise (default: false)
+   */
+  shouldUseFinderView?: boolean;
+  /**
+   * The finder view rectangular overlay border width
+   */
+  finderLineWidth?: number;
+  /**
+   * The finder view rectangular overlay border color
+   */
+  finderLineColor?: string;
+  /**
+   * The overlay background color, around the finder view rectangle
+   */
+  finderBackgroundColor?: string;
+  /**
+   * The overlay background color opacity, around the finder view rectangle
+   */
+  finderBackgroundOpacity?: number;
+  /**
+   * The finder view rectangle aspect ratio
+   */
+  finderAspectRatio?: FinderAspectRatio;
+  /**
+   * The finder view minimum padding from the bounds of the screen
+   */
+  finderMinimumPadding?: number;
+  /**
+   * How many pixel units the finder view should be moved vertically;
+   *
+   * Positive values -> (UP); Negative values -> (DOWN)
+   */
+  finderVerticalOffset?: number;
+  /**
+   * Whether flash is toggled on or off.
+   */
+  flashEnabled?: boolean;
+  /**
+   * List of accepted Barcode Formats; any formats that are not included in this
+   * list will not be detected by the `BarcodeCameraView`. By default, the list
+   * includes all supported barcode types.
+   */
+  barcodeFormats?: BarcodeFormat[];
+  /**
+   * List of accepted Document Formats; any document formats that are not included
+   * in this list will be ignored by the `BarcodeCameraView`. By default, the list
+   * includes all supported document types.
+   */
+  acceptedDocumentFormats?: BarcodeDocumentFormat[];
+  /**
+   * The checksum algorithm for MSI Plessey barcodes.
+   * The default value is `Mod10'
+   */
+  msiPlesseyChecksumAlgorithm?: MSIPlesseyChecksumAlgorithm;
+  /**
+   * The engine mode of the barcode recognizer. Defaults to NEXT_GEN.
+   * To use legacy recognizer, please specify LEGACY
+   */
+  engineMode?: EngineMode;
+  /**
+   * The relative initial zoom level of the camera in the range [0,1], where 0 is zoomed out and 1 is zoomed in.
+   * The default value is 0.
+   */
+  cameraZoomFactor?: number;
+  /**
+   * When set to `true`, the scanner assumes that the barcode can be a GS1 barcode.
+   * Turn it off, if you don't want to see decoded FNC1 characters ("]C1" and ASCII char 29).
+   * The default value is `true`.
+   * NOTE: Currently works for CODE128 barcodes only.
+   */
+  gs1DecodingEnabled?: boolean;
+  /**
+   * Optional minimum required text length of the detected barcode.
+   * The default is 0 (setting is turned off).
+   * NOTE: This feature works on ITF barcodes only.
+   */
+  minimumTextLength?: number;
+  /**
+   * Optional maximum required text length of the detected barcode.
+   * The default is 0 (setting is turned off).
+   * NOTE: This feature works on ITF barcodes only.
+   */
+  maximumTextLength?: number;
+  /**
+   * With this option enabled, the scanner removes checks digits for UPC, EAN and MSI Plessey codes.
+   * Has no effect if both single and double digit MSI Plessey checksums are enabled.
+   * The default is `false`
+   */
+  stripCheckDigits?: boolean;
+}

package/src/components/barcode-camera-view/scanbot-barcode-camera-view.tsx

@@ -0,0 +1,163 @@
+import React from 'react';
+import {Platform} from 'react-native';
+import {Dimensions} from 'react-native';
+import {ScanbotBarcodeCameraViewProperties} from './scanbot-barcode-camera-view-types';
+import ScanbotNativeBarcodeCameraView from './scanbot-native-barcode-camera-view';
+
+const Device = {
+  isPortrait: () => {
+    const dim = Dimensions.get('screen');
+    return dim.height >= dim.width;
+  },
+  isLandscape: () => {
+    const dim = Dimensions.get('screen');
+    return dim.width >= dim.height;
+  },
+};
+
+interface ScanbotBarcodeCameraViewState {
+  orientation: string;
+}
+
+type Properties = ScanbotBarcodeCameraViewProperties;
+export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
+  // String length of auto-generated component key
+  static UNIQUE_VIEW_KEY_LENGTH = 6;
+
+  // This attribute allows us to retrieve a key for the component depending on the current state.
+  // If the component has been invalidated, it returns a new key and the view gets recreated,
+  // otherwise it uses the last generated one
+  _cameraKey = '';
+  get cameraKey(): string {
+    if (!this.isDirty) {
+      return this._cameraKey;
+    }
+    this.isDirty = false;
+    this._cameraKey = ScanbotBarcodeCameraView.getRandomId(
+      ScanbotBarcodeCameraView.UNIQUE_VIEW_KEY_LENGTH,
+    );
+    return this._cameraKey;
+  }
+
+  // We keep track of the state of children components, so that we can re-render the component
+  // in some special cases (Android)
+  previousChildrenIds: string[] = [];
+  get childrenIds(): string[] {
+    const children = this.props.children
+      ? React.Children.map(this.props.children, child => child)
+      : [];
+
+    return children?.map((c: any) => `${c.type.name}-${c.key}`) ?? [];
+  }
+
+  // When true, a new component key will be generated on the next render,
+  // causing the component to be recreated
+  isDirty = true;
+
+  state: ScanbotBarcodeCameraViewState = {
+    orientation: Device.isPortrait() ? 'portrait' : 'landscape',
+  };
+
+  // Returns a random string ID of the given length
+  static getRandomId(
+    length: number = ScanbotBarcodeCameraView.UNIQUE_VIEW_KEY_LENGTH,
+  ): string {
+    let result = '';
+    const characters =
+      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+  }
+
+  // Event Listener for orientation changes
+  orientationChangeHandler = () => {
+    this.isDirty = true;
+    this.setState({
+      orientation: Device.isPortrait() ? 'portrait' : 'landscape',
+    });
+  };
+
+  // Maps the native bridge callback event from the Barcode Scanner
+  _onBarcodeScannerResult = (event: any) => {
+    if (!this.props.onBarcodeScannerResult) {
+      return;
+    }
+
+    this.props.onBarcodeScannerResult(event.nativeEvent.result);
+  };
+
+  render() {
+    this.evaluateComponentState();
+
+    const style = this.preprocessStyle();
+    const props = this.preprocessProps();
+
+    return (
+      <ScanbotNativeBarcodeCameraView
+        {...props}
+        style={style}
+        key={this.cameraKey}
+        requestComponentReload={this._invalidate}
+        onBarcodeScannerResult={this._onBarcodeScannerResult}
+      />
+    );
+  }
+
+  componentDidMount() {
+    Dimensions.addEventListener('change', this.orientationChangeHandler);
+    this.previousChildrenIds = this.childrenIds;
+  }
+
+  componentWillUnmount() {
+    Dimensions.removeEventListener('change', this.orientationChangeHandler);
+    this.previousChildrenIds = [];
+  }
+
+  evaluateComponentState = () => {
+    // We want to force a re-layout every time new children are added or removed
+    // from the BarcodeCameraView on Android; this will allow the native code to
+    // re-compute the size of every view inside the layout
+    if (Platform.OS === 'android') {
+      const currentChildrenIds = this.childrenIds;
+
+      const invalidate = () => {
+        this._invalidate();
+        this.previousChildrenIds = currentChildrenIds;
+      };
+      if (currentChildrenIds.length !== this.previousChildrenIds.length) {
+        invalidate();
+        return;
+      }
+
+      for (let i = 0; i < this.previousChildrenIds.length; i++) {
+        const previous = this.previousChildrenIds[i];
+        const current = currentChildrenIds[i];
+        if (previous !== current) {
+          invalidate();
+          return;
+        }
+      }
+    }
+  };
+
+  preprocessStyle = () => {
+    const style = this.props.style as any;
+    const newStyle = {...style} || {};
+    // Override / Define styles here
+    return newStyle;
+  };
+
+  preprocessProps = () => {
+    const props = {...this.props};
+    delete props.style;
+    return props;
+  };
+
+  // Invalidates the component so that it gets recreated on the next render
+  _invalidate = () => {
+    this.isDirty = true;
+  };
+}

package/src/components/barcode-camera-view/scanbot-native-barcode-camera-view.tsx

@@ -0,0 +1,6 @@
+import {requireNativeComponent} from 'react-native';
+import {ScanbotBarcodeCameraViewProperties} from './scanbot-barcode-camera-view-types';
+
+export default requireNativeComponent<ScanbotBarcodeCameraViewProperties>(
+  'ScanbotBarcodeCameraView',
+);