react-native-scanbot-barcode-scanner-sdk 3.0.0-beta7 → 3.1.0-alpha3

package/ios/Components/BarcodeCameraView/RNScanbotBarcodeCameraView.m

@@ -0,0 +1,235 @@
+//
+//  RNScanbotCameraView.m
+//  RNScanbotSDK
+//
+//  Created by Marco Saia on 18.05.21.
+//
+
+#import "RNScanbotBarcodeCameraView.h"
+#import "ObjectMapper.h"
+#import "BarcodeMapping.h"
+
+@import ScanbotBarcodeScannerSDK;
+@import Foundation;
+
+@implementation RNScanbotBarcodeCameraView {
+    SBSDKBarcodeScannerViewController* viewController;
+    RNScanbotCameraViewConfiguration* _cameraViewConfiguration;
+    CGFloat _userDefinedCameraZoomFactor;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    self.barcodes = [[NSMutableArray alloc] init];
+    self.shouldUseFinderView = false;
+    _cameraViewConfiguration = [[RNScanbotCameraViewConfiguration alloc] init];
+    _userDefinedCameraZoomFactor = -1;
+    return self;
+}
+
+- (void)layoutSubviews {
+    if (_cameraViewController) {
+        _cameraViewController.view.frame = [self bounds];
+        return;
+    }
+    
+    __weak typeof(self) weakSelf = self;
+    
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 0.5 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+        [weakSelf createCameraViewController];
+    });
+}
+
+- (void)createCameraViewController {
+    UIViewController* parentViewController = [self getParentViewController];
+    if (!parentViewController) {
+        return;
+    }
+    
+    if (!_cameraViewController) {
+        viewController = [[SBSDKBarcodeScannerViewController alloc] initWithParentViewController:parentViewController
+                                                                                      parentView:self];
+        viewController.delegate = self;
+
+        _cameraViewController = viewController;
+    }
+    
+    [self updateWithConfiguration];
+}
+
+- (void)setConfiguration:(NSDictionary *)configuration {
+    _configuration = configuration;
+    if (configuration == NULL) {
+        return;
+    }
+    RNScanbotCameraViewConfiguration* cameraViewConfiguration = [[RNScanbotCameraViewConfiguration alloc] init];
+    
+    NSMutableDictionary* config = [configuration mutableCopy];
+    if ([config objectForKey:@"barcodeFormats"]) {
+        cameraViewConfiguration.barcodeFormats = extractBarcodeTypesFromConfiguration(config);
+        [config removeObjectForKey:@"barcodeFormats"];
+    }
+    
+    @try {
+        [ObjectMapper populateInstance:cameraViewConfiguration fromDictionary:config];
+    } @catch (NSException *exception) {
+        NSLog(@"%@", [exception reason]);
+        return;
+    }
+    
+    cameraViewConfiguration.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
+    
+    _cameraViewConfiguration = cameraViewConfiguration;
+    
+    if(viewController) {
+        [self updateWithConfiguration];
+    }
+}
+
+- (void)updateWithConfiguration {
+
+    // Non-Nullable Properties
+    viewController.viewFinderLineWidth = _cameraViewConfiguration.finderLineWidth;
+    viewController.viewFinderLineColor = _cameraViewConfiguration.finderLineColor;
+    viewController.viewFinderBackgroundColor = _cameraViewConfiguration.finderBackgroundColor;
+    viewController.viewFinderBackgroundColor = [viewController.viewFinderBackgroundColor colorWithAlphaComponent:_cameraViewConfiguration.finderBackgroundOpacity];
+    viewController.finderAspectRatio = _cameraViewConfiguration.finderAspectRatio;
+    
+    CGFloat offset = _cameraViewConfiguration.finderVerticalOffset;
+    CGFloat padding = _cameraViewConfiguration.finderMinimumPadding;
+    viewController.finderMinimumInset = UIEdgeInsetsMake(padding + offset > 0 ? offset : 0,
+                                                         padding,
+                                                         padding + offset < 0 ? -1*offset : 0,
+                                                         padding);
+    
+    // Nullable Properties
+    if (_cameraViewConfiguration.shouldUseFinderView) {
+        viewController.shouldUseFinderFrame = [_cameraViewConfiguration.shouldUseFinderView boolValue];
+    }
+    if (_cameraViewConfiguration.barcodeFormats) {
+        viewController.acceptedBarcodeTypes = _cameraViewConfiguration.barcodeFormats;
+    }
+    if (_cameraViewConfiguration.acceptedDocumentFormats) {
+        viewController.acceptedDocumentTypes = _cameraViewConfiguration.acceptedDocumentFormats;
+    }
+    if (_cameraViewConfiguration.gs1DecodingEnabled) {
+        viewController.additionalDetectionParameters.enableGS1Decoding = [_cameraViewConfiguration.gs1DecodingEnabled boolValue];
+    }
+    if (_cameraViewConfiguration.maximumTextLength) {
+        viewController.additionalDetectionParameters.maximumTextLength = [_cameraViewConfiguration.maximumTextLength intValue];
+    }
+    if (_cameraViewConfiguration.minimumTextLength) {
+        viewController.additionalDetectionParameters.minimumTextLength = [_cameraViewConfiguration.minimumTextLength intValue];
+    }
+    if (_cameraViewConfiguration.msiPlesseyChecksumAlgorithm != -1) {
+        viewController.additionalDetectionParameters.msiPlesseyChecksumAlgorithm = _cameraViewConfiguration.msiPlesseyChecksumAlgorithm;
+    }
+    if (_cameraViewConfiguration.cameraZoomFactor) {
+        CGFloat value = [_cameraViewConfiguration.cameraZoomFactor floatValue];
+        if (value != _userDefinedCameraZoomFactor || _userDefinedCameraZoomFactor == -1) {
+            viewController.cameraZoomFactor = value;
+            _userDefinedCameraZoomFactor = value;
+        }
+    }
+    if (_cameraViewConfiguration.engineMode != -1) {
+        viewController.engineMode = _cameraViewConfiguration.engineMode;
+    }
+    if (_cameraViewConfiguration.flashEnabled) {
+        viewController.flashLightEnabled = [_cameraViewConfiguration.flashEnabled boolValue];
+    }
+}
+
+- (UIViewController* _Nullable)getParentViewController {
+    UIResponder* parentResponder = self;
+    while (parentResponder) {
+        parentResponder = parentResponder.nextResponder;
+        if (parentResponder && [parentResponder isKindOfClass:[UIViewController class]]) {
+            return (UIViewController*) parentResponder;
+        }
+    }
+    return NULL;
+}
+
+- (void)sendScanResults:(NSArray<SBSDKBarcodeScannerResult*>*) results {
+    if(!self.onBarcodeScannerResult) {
+        return;
+    }
+
+    if(!results || results.count == 0) {
+        return;
+    }
+    
+    NSMutableArray* jsonBarcodes = [[NSMutableArray alloc] init];
+    
+    for (SBSDKBarcodeScannerResult* result in results) {
+        [jsonBarcodes addObject:@{
+            @"text": result.rawTextString,
+            @"type": result.type.name
+        }];
+    }
+    
+    NSDictionary* outResult = @{
+        @"result": @{
+            @"status": @"OK",
+            @"barcodes": jsonBarcodes
+        }
+    };
+    
+    self.onBarcodeScannerResult(outResult);
+}
+
+// MARK: - SBSDKBarcodeScannerViewControllerDelegate
+
+- (void)barcodeScannerController:(SBSDKBarcodeScannerViewController *)controller
+               didDetectBarcodes:(NSArray<SBSDKBarcodeScannerResult *> *)codes {
+    [self sendScanResults:codes];
+}
+
+- (BOOL)barcodeScannerControllerShouldDetectBarcodes:(SBSDKBarcodeScannerViewController *)controller {
+    return true;
+}
+
+- (NSArray*)hashedBarcodes {
+    NSMutableArray* outArray = [[NSMutableArray alloc] init];
+    for (NSDictionary* barcode in self.barcodes) {
+        NSString* hash = [RNScanbotBarcodeCameraView hashFromBarcode:barcode];
+        [outArray addObject:hash];
+    }
+    return outArray;
+}
+
++ (NSString*)hashFromBarcode: (NSDictionary* _Nonnull)barcode {
+    NSString* text = [barcode objectForKey:@"barcode"];
+    NSString* type = [barcode objectForKey:@"type"];
+    return [[NSString stringWithFormat:@"%@_%@", text, type] lowercaseString];
+}
+
+@end
+
+@implementation RNScanbotCameraViewConfiguration
+
+- (instancetype)init
+{
+    self = [super init];
+    if (self) {
+        self.shouldUseFinderView = false;
+        self.finderLineWidth = 1.0;
+        self.finderLineColor = UIColor.whiteColor;
+        self.finderAspectRatio = [[SBSDKAspectRatio alloc] initWithWidth:1 andHeight:1];
+        self.finderBackgroundColor = UIColor.blackColor;
+        self.finderBackgroundOpacity = 0.6;
+        self.finderMinimumPadding = 32.0;
+        self.finderVerticalOffset = 0.0;
+        self.acceptedDocumentFormats = nil;
+        self.gs1DecodingEnabled = nil;
+        self.maximumTextLength = nil;
+        self.minimumTextLength = nil;
+        self.msiPlesseyChecksumAlgorithm = -1;
+        self.cameraZoomFactor = nil;
+        self.engineMode = -1;
+        self.flashEnabled = nil;
+    }
+    return self;
+}
+
+@end

package/ios/Components/BarcodeCameraView/RNScanbotBarcodeCameraViewManager.h

@@ -0,0 +1,16 @@
+//
+//  RNScanbotClassicComponents.h
+//  Pods
+//
+//  Created by Marco Saia on 17.05.21.
+//
+
+#ifndef RNScanbotClassicComponents_h
+#define RNScanbotClassicComponents_h
+
+#import <React/RCTViewManager.h>
+
+@interface RNScanbotBarcodeCameraViewManager: RCTViewManager
+@end
+
+#endif /* RNScanbotClassicComponents_h */

package/ios/Components/BarcodeCameraView/RNScanbotBarcodeCameraViewManager.m

@@ -0,0 +1,30 @@
+//
+//  RNScanbotClassicComponents.m
+//  RNScanbotSDK
+//
+//  Created by Marco Saia on 17.05.21.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNScanbotBarcodeCameraViewManager.h"
+#import "RNScanbotBarcodeCameraView.h"
+#import <React/RCTViewManager.h>
+
+@import UIKit;
+@import ScanbotBarcodeScannerSDK;
+
+@implementation RNScanbotBarcodeCameraViewManager
+
+RCT_EXPORT_MODULE(ScanbotBarcodeCameraView)
+
+RCT_EXPORT_VIEW_PROPERTY(onBarcodeScannerResult, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(requestComponentReload, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(shouldUseFinderView, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(configuration, NSDictionary*)
+
+- (UIView *) view
+{
+    return [[RNScanbotBarcodeCameraView alloc] init];
+}
+
+@end

package/ios/ScanbotBarcodeSdk.m

@@ -39,7 +39,7 @@ RCT_EXPORT_METHOD(initializeSdk:(NSDictionary *)configuration
     [ObjectMapper setEnumerationMapping:@{
         @"barcodeImageGenerationType": @{
                 @"NONE": @(SBSDKBarcodeImageGenerationTypeNone),
-                @"FROM_VIDEO_FRAME": @(SBSDKBarcodeImageGenerationTypeFromVideoFrame),
+                @"VIDEO_FRAME": @(SBSDKBarcodeImageGenerationTypeFromVideoFrame),
                 @"CAPTURED_IMAGE" :@(SBSDKBarcodeImageGenerationTypeCapturedImage),
         },
         @"engineMode": @{

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "react-native-scanbot-barcode-scanner-sdk",
   "title": "Scanbot Barcode Scanner SDK for React Native",
-  "version": "3.0.0-beta7",
+  "version": "3.1.0-alpha3",
   "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",

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

@@ -0,0 +1,115 @@
+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;
+}

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',
+);

package/src/configuration.ts

@@ -3,14 +3,14 @@
   Copyright (c) 2020 doo GmbH. All rights reserved.
   https://scanbot.io/sdk
  */
-import { FinderAspectRatio } from "./src/model";
+import { FinderAspectRatio } from "./model";
 import {
     BarcodeDocumentFormat,
     BarcodeFormat,
     BarcodeImageGenerationType,
     UIInterfaceOrientationMask,
     EngineMode
-} from "./src/enum";
+} from "./enum";
 import { MSIPlesseyChecksumAlgorithm } from "react-native-scanbot-barcode-scanner-sdk/src/enum";
 
 export interface BarcodeScannerConfiguration

package/src/enum.ts

@@ -31,7 +31,7 @@ export type UIInterfaceOrientationMask =
 
 export type BarcodeImageGenerationType =
     "NONE"
-    | "FROM_VIDEO_FRAME"
+    | "VIDEO_FRAME"
     | "CAPTURED_IMAGE";
 
 export type BarcodeDocumentFormat =