react-native-scanbot-barcode-scanner-sdk 4.2.0 → 4.3.0-beta.1

package/ios/Components/BarcodeScannerView/RNScanbotBarcodeScannerViewControllerWrapper.m

@@ -0,0 +1,196 @@
+//
+//  RNScanbotBarcodeScannerViewHandler.m
+//  RNScanbotBarcodeSDK
+//
+//  Created by Stefan Krzhovski on 27.05.24.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNScanbotBarcodeScannerViewControllerWrapper.h"
+
+
+@implementation RNScanbotBarcodeScannerViewControllerWrapper
+
++ hexStringToColor:(NSString *)hexString
+{
+    
+    if ([hexString hasPrefix:@"#"]) {
+        hexString = [hexString substringFromIndex:1];
+    } else {
+        return nil;
+    }
+    
+    NSUInteger length = [hexString length];
+    if (length != 6 && length != 8) {
+        return nil;
+    }
+    
+    unsigned int red, green, blue, alpha = 255;
+    NSString *redString = [hexString substringWithRange:NSMakeRange(0, 2)];
+    NSString *greenString = [hexString substringWithRange:NSMakeRange(2, 2)];
+    NSString *blueString = [hexString substringWithRange:NSMakeRange(4, 2)];
+    
+    if (length == 8) {
+        NSString *alphaString = [hexString substringWithRange:NSMakeRange(6, 2)];
+        [[NSScanner scannerWithString:alphaString] scanHexInt:&alpha];
+    }
+    
+    [[NSScanner scannerWithString:redString] scanHexInt:&red];
+    [[NSScanner scannerWithString:greenString] scanHexInt:&green];
+    [[NSScanner scannerWithString:blueString] scanHexInt:&blue];
+    
+    return [UIColor colorWithRed:(CGFloat)red/255.0
+                           green:(CGFloat)green/255.0
+                            blue:(CGFloat)blue/255.0
+                           alpha:(CGFloat)alpha/255.0];
+}
+
++ (SBSDKBarcodeScannerViewController *)initController {
+    
+    SBSDKBarcodeScannerViewController *scannerViewController = [[SBSDKBarcodeScannerViewController alloc] init];
+    scannerViewController.viewFinderConfiguration = [SBSDKBaseScannerViewFinderConfiguration defaultConfiguration];
+    scannerViewController.generalConfiguration = [SBSDKBaseScannerGeneralConfiguration defaultConfiguration];
+    scannerViewController.zoomConfiguration = [SBSDKBaseScannerZoomConfiguration defaultConfiguration];
+    scannerViewController.energyConfiguration = [SBSDKBaseScannerEnergyConfiguration defaultConfiguration];
+    
+    return scannerViewController;
+}
+
++ (void)setFlashEnabled:(SBSDKBarcodeScannerViewController *)controller value:(BOOL)value {
+    controller.flashLightEnabled = value;
+}
+
++ (void)setFinderEnabled:(SBSDKBaseScannerViewFinderConfiguration *)config value:(BOOL)value {
+    config.viewFinderEnabled = value;
+}
+
++ (void)setFinderStrokeWidth:(SBSDKBaseScannerViewFinderConfiguration *)config value:(int)value {
+    config.lineWidth = value;
+}
+
++ (void)setFinderStrokeColor:(SBSDKBaseScannerViewFinderConfiguration *)config value:(UIColor *)value {
+    config.lineColor = value;
+    
+}
+
++ (void)setFinderOverlayColor:(SBSDKBaseScannerViewFinderConfiguration *)config value:(UIColor *)value {
+    config.backgroundColor = value;
+}
+
++ (void)setFinderInset:(SBSDKBaseScannerViewFinderConfiguration *)config
+                   top:(float)top
+                  left:(float)left
+                bottom:(float)bottom
+                 right:(float)right {
+    config.minimumInset = UIEdgeInsetsMake(top, left, bottom, right);
+}
+
++ (void)setFinderRequiredAspectRatios:(SBSDKBaseScannerViewFinderConfiguration *)config
+                                width:(double)width
+                               height:(double)height {
+    config.aspectRatio = [[SBSDKAspectRatio alloc] initWithWidth:width andHeight:height];
+}
+
++ (void)setCameraZoomFactor:(SBSDKBarcodeScannerViewController *)controller value:(float)value {
+    controller.cameraZoomFactor = value;
+}
+
++ (void)setCameraZoomRange:(SBSDKBaseScannerZoomConfiguration *)config minZoom:(float)minZoom maxZoom:(float)maxZoom{
+    config.zoomRange =  [[SBSDKZoomRange alloc] initWithMinZoom:minZoom andMaxZoom:maxZoom];
+}
+
++ (void)setCameraDevice:(SBSDKBarcodeScannerViewController *)controller value:(NSString *)value {
+    SBSDKCameraDevice *cameraConfig = controller.cameraDevice;
+    if([value isEqualToString:@"BACK_WIDEST"]){
+        cameraConfig = [SBSDKCameraDevice widestAvailableBackFacingCamera];
+    } else if ([value isEqualToString:@"FRONT"]){
+        cameraConfig = [SBSDKCameraDevice defaultFrontFacingCamera];
+    } else {
+        cameraConfig = [SBSDKCameraDevice defaultBackFacingCamera];
+    }
+    controller.cameraDevice = cameraConfig;
+}
+
++ (void)setMinFocusDistanceLock:(SBSDKBarcodeScannerViewController *)controller value:(BOOL)value {
+    if(value){
+        if(!controller.isFocusLockEnabled) [controller beginFocusLockAtLensPosition:0.0f];
+    } else {
+        if(controller.isFocusLockEnabled) [controller endFocusLock];
+    }
+}
+
++ (void)setLowPowerMode:(SBSDKBarcodeScannerViewController *)controller value:(BOOL)value {
+    if(value){
+        if(!controller.isEnergySavingActive) [controller startEnergySaving];
+    } else {
+        if(controller.isEnergySavingActive) [controller endEnergySaving];
+    }
+}
+
++ (void)setMaximumTextLenght:(SBSDKBarcodeAdditionalParameters *)config value:(int)value {
+    config.minimumTextLength = value;
+}
+
++ (void)setMinimumTextLenght:(SBSDKBarcodeAdditionalParameters *)config value:(int)value {
+    config.maximumTextLength = value;
+}
+
++ (void)setMinimum1DBarcodesQuietZone:(SBSDKBarcodeAdditionalParameters *)config value:(int)value {
+    config.minimum1DBarcodesQuietZone = value;
+}
+
++ (void)setStripCheckDigits:(SBSDKBarcodeAdditionalParameters *)config value:(BOOL)value {
+    config.stripCheckDigits = value;
+}
+
++ (void)setBarcodeFormats:(SBSDKBarcodeScannerViewController *)controller acceptedBarcodeTypes:(NSArray<SBSDKBarcodeType *> *)acceptedBarcodeTypes {
+    controller.acceptedBarcodeTypes = acceptedBarcodeTypes;
+}
+
++ (void)setDocumentFormats:(SBSDKBarcodeScannerViewController *)controller acceptedDocumentTypes:(NSArray<SBSDKBarcodeDocumentType *> *)acceptedDocumentTypes {
+    controller.acceptedDocumentTypes = acceptedDocumentTypes;
+}
+
++ (void)setEngineMode:(SBSDKBarcodeScannerViewController *)controller engineMode:(SBSDKBarcodeEngineMode)engineMode {
+    controller.engineMode = engineMode;
+}
+
++ (void)setBarcodeExtensionFilter:(SBSDKBarcodeScannerViewController *)controller filter:(SBSDKBarcodesExtensionFilter)filter {
+    controller.extensionFilter = filter;
+}
+
++ (void)setGS1HandlingMode:(SBSDKBarcodeAdditionalParameters *)config gs1HandlingMode:(SBSDKGS1Handling)gs1HandlingMode {
+    config.gs1Handling = gs1HandlingMode;
+}
+
++ (void)setMsiPlesseyChecksumAlgorithm:(SBSDKBarcodeAdditionalParameters *)config msiPlesseyChecksumAlgorithm:(SBSDKBarcodeMSIPlesseyChecksumAlgorithm)msiPlesseyChecksumAlgorithm {
+    config.msiPlesseyChecksumAlgorithm = msiPlesseyChecksumAlgorithm;
+}
+
++ (void)setCodeDensity:(SBSDKBarcodeAdditionalParameters *)config codeDencity:(SBSDKBarcodeDensity)codeDencity {
+    config.codeDensity = codeDencity;
+}
+
++ (void)freezeCamera:(SBSDKBarcodeScannerViewController *)controller {
+    [controller freezeCamera];
+}
+
++ (void)unfreezeCamera:(SBSDKBarcodeScannerViewController *)controller {
+    [controller unfreezeCamera];
+}
+
++ (NSString *) jsonFromResultOrNil:(NSArray<SBSDKBarcodeScannerResult *> *)codes {
+    if(!codes || codes.count == 0) return nil;
+    
+    NSDictionary* _Nullable result = [SBBWrapperBarcodeScannerResult nativeResultsToDictionary:codes];
+    if(result != NULL) {
+        NSData *data = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingFragmentsAllowed error:nil];
+        return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    }
+    
+    return nil;
+}
+
+
+
+@end

package/ios/Components/BarcodeScannerView/RNScanbotBarcodeScannerViewManager.mm

@@ -0,0 +1,73 @@
+//
+//  RNScanbotBarcodeScannerViewManager.m
+//  RNScanbotBarcodeSDK
+//
+//  Created by Stefan Krzhovski on 21.05.24.
+//
+
+#if !defined(RCT_NEW_ARCH_ENABLED)
+#import <Foundation/Foundation.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+#import <UIKit/UIKit.h>
+#import "RNScanbotBarcodeScannerLegacyView.h"
+
+typedef void (^NativeViewBlock)(RNScanbotBarcodeScannerLegacyView* _Nonnull);
+
+@interface RNScanbotBarcodeScannerViewManager: RCTViewManager
+@end
+
+@implementation RNScanbotBarcodeScannerViewManager
+
+RCT_EXPORT_MODULE(ScanbotBarcodeScannerView)
+
+- (UIView *)view {
+    return [[RNScanbotBarcodeScannerLegacyView alloc] init];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(onBarcodeScannerResult, RCTDirectEventBlock)
+
+RCT_EXPORT_VIEW_PROPERTY(flashEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(finderEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(finderStrokeWidth, int)
+RCT_EXPORT_VIEW_PROPERTY(finderStrokeColor, UIColor)
+RCT_EXPORT_VIEW_PROPERTY(finderOverlayColor, UIColor)
+//RCT_EXPORT_VIEW_PROPERTY(finderMinPadding, int)
+RCT_EXPORT_VIEW_PROPERTY(finderInset, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(finderRequiredAspectRatios, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(cameraZoomFactor, float)
+RCT_EXPORT_VIEW_PROPERTY(cameraZoomRange, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(cameraModule, NSString)
+RCT_EXPORT_VIEW_PROPERTY(minFocusDistanceLock, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(detectorConfig, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(scanningEnabled, BOOL)
+
+//Commands
+
+RCT_EXPORT_METHOD(freezeCamera:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RNScanbotBarcodeScannerLegacyView *nativeView) {
+        [nativeView freezeCamera];
+    }];
+}
+
+RCT_EXPORT_METHOD(unfreezeCamera:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RNScanbotBarcodeScannerLegacyView *nativeView) {
+        [nativeView unfreezeCamera];
+    }];
+}
+
+- (void) callNativeMethodWithReactTag:(nonnull NSNumber*) reactTag andBlock:(NativeViewBlock)block {
+    [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+        RNScanbotBarcodeScannerLegacyView *view = (RNScanbotBarcodeScannerLegacyView *) viewRegistry[reactTag];
+        if (!view || ![view isKindOfClass:[RNScanbotBarcodeScannerLegacyView class]]) {
+            RCTLogError(@"Cannot find native view with tag #%@", reactTag);
+            return;
+        }
+        block(view);
+    }];
+}
+
+@end
+
+#endif

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "react-native-scanbot-barcode-scanner-sdk",
   "title": "Scanbot Barcode Scanner SDK for React Native",
-  "version": "4.2.0",
-  "scanbot": {
-    "iosWrapperVersion": "4.2.2.0"
-  },
+  "version": "4.3.0-beta.1",
+  "packageManager": "yarn@3.8.1",
+  "react-native": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "description": "Scanbot Barcode Scanner SDK React Native Plugin for Android and iOS",
-  "main": "index.js",
   "scripts": {
-    "prepack": "node prepare-podspec.js"
+    "prepack": "npm run typescript:build",
+    "typescript:build": "tsc",
+    "typescript:check": "tsc --noEmit"
   },
   "files": [
+    "dist",
     "src/*.js",
     "src/*.ts",
     "src/components/**/*.ts",
@@ -18,9 +21,6 @@
     "src/components/**/*.js",
     "android/**",
     "ios/**",
-    "js/**",
-    "index.d.ts",
-    "index.js",
     "README.md",
     "Libraries.txt",
     "RNScanbotBarcodeSDK.podspec",
@@ -55,18 +55,14 @@
   "readmeFilename": "README.md",
   "homepage": "https://scanbot.io/developer/react-native-barcode-scanner",
   "peerDependencies": {
-    "react": ">=16.8.1",
-    "react-native": ">=0.60 <1.0.x"
+    "react": "*",
+    "react-native": "*"
   },
   "devDependencies": {
-    "@types/react": "^18.2.6",
-    "@types/react-native": "^0.72.0",
-    "chalk": "^5.3.0",
-    "cli-spinner": "^0.2.10",
-    "log-update": "^5.0.1",
-    "nunjucks": "^3.2.4",
+    "@types/react": "^18.2.79",
     "react": "^18.2.0",
-    "react-native": "^0.71.8"
+    "react-native": "0.74.0",
+    "typescript": "^5.4.5"
   },
   "contributors": [
     {
@@ -75,11 +71,10 @@
       "url": "https://scanbot.io"
     }
   ],
-  "react-native": "index",
   "codegenConfig": {
-    "name": "RTNScanbotBarcodeCameraViewSpecs",
+    "name": "RNScanbotBarcodeScannerViewSpec",
     "type": "components",
-    "jsSrcsDir": "js",
+    "jsSrcsDir": "src/components",
     "android": {
       "javaPackageName": "io.scanbot.barcodesdk.plugin.reactnative"
     }

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

@@ -0,0 +1,112 @@
+import React, { forwardRef, useCallback, useImperativeHandle, useRef } from 'react';
+import NativeBarcodeCameraView, {Commands} from '../spec/ScanbotBarcodeScannerViewNativeComponent';
+import { ScanbotBarcodeCameraViewHandle, ScanbotBarcodeCameraViewProperties } from './ScanbotBarcodeCameraViewProperties';
+import { NativeSyntheticEvent, Platform } from 'react-native';
+import { BarcodeScannerResult } from '../../results';
+
+export const ScanbotBarcodeCameraView = forwardRef<ScanbotBarcodeCameraViewHandle, ScanbotBarcodeCameraViewProperties>((
+    {
+      flashEnabled = false,
+      scanningEnabled = true,
+      ...props
+    },
+    forwardedRef,
+  ) => {
+
+    const finderConfig = {
+      ...{
+        viewFinderEnabled: true,
+        finderLineWidth: 2,
+        finderLineColor: '#ffffffff',
+        overlayColor: '#000000A9',
+        finderInset: {
+          bottom: 20,
+          top: 20,
+          left: 20,
+          right: 20,
+        },
+        requiredAspectRatio: {
+          height: 3,
+          width: 4,
+        },
+        minPadding: 60,
+      }, ...props.finderConfig,
+    };
+
+    const cameraConfig = {
+      ...{
+        cameraZoomRange: {
+          minZoom: 1,
+          maxZoom: 12,
+        },
+        cameraZoomFactor: 0.0,
+        minFocusDistanceLock: false,
+      }, ...props.cameraConfig,
+    };
+
+    const viewRef = useRef(null);
+
+    useImperativeHandle(forwardedRef, () => {
+      return {
+        freezeCamera() {
+          if (viewRef.current) {
+            //@ts-ignore
+            Commands.freezeCamera(viewRef.current);
+          }
+        },
+
+        unfreezeCamera() {
+          if (viewRef.current) {
+            //@ts-ignore
+            Commands.unfreezeCamera(viewRef.current);
+          }
+        },
+      };
+    }, []);
+
+    const _onBarcodeScannerResult = useCallback((event: NativeSyntheticEvent<any>) => {
+      const result = Platform.select({
+        ios: JSON.parse(event.nativeEvent.result),
+        android: event.nativeEvent.result
+      }) as (BarcodeScannerResult | undefined)
+      if(props.onBarcodeScannerResult && result){
+        props.onBarcodeScannerResult(result);
+      }
+    }, [props.onBarcodeScannerResult]);
+
+    return <NativeBarcodeCameraView
+      //FinderConfigs
+      finderEnabled={finderConfig.viewFinderEnabled}
+      finderStrokeWidth={finderConfig.finderLineWidth}
+      finderMinPadding={finderConfig.minPadding}
+      finderStrokeColor={finderConfig.finderLineColor}
+      finderOverlayColor={finderConfig.overlayColor}
+      finderInset={finderConfig.finderInset}
+      finderRequiredAspectRatios={finderConfig.requiredAspectRatio}
+
+      //CameraConfigs
+      cameraZoomFactor={Platform.select({
+        ios: parseFloat(cameraConfig.cameraZoomFactor.toFixed(2)),
+        android: cameraConfig.cameraZoomRange.minZoom +
+          (cameraConfig.cameraZoomRange.maxZoom - cameraConfig.cameraZoomRange.minZoom) * cameraConfig.cameraZoomFactor,
+      })}
+      cameraZoomRange={cameraConfig.cameraZoomRange}
+      minFocusDistanceLock={cameraConfig.minFocusDistanceLock}
+      cameraModule={cameraConfig.cameraModule}
+
+      //DetectorConfigs
+      detectorConfig={props.detectorConfig}
+
+      //Other
+      flashEnabled={flashEnabled}
+      scanningEnabled={scanningEnabled}
+
+      //View
+      style={[{ flex: 1 }, props.style]}
+      ref={viewRef}
+
+      //Result
+      onBarcodeScannerResult={_onBarcodeScannerResult}
+    />;
+  },
+);

package/src/components/barcode-camera-view/ScanbotBarcodeCameraViewProperties.ts

@@ -0,0 +1,106 @@
+import { ColorValue, ViewStyle } from 'react-native';
+import { BarcodeScannerResult } from '../../results';
+import {
+    AspectRatio,
+    BarcodeDocumentFormat,
+    BarcodeFormat,
+    BarcodesExtensionFilter,
+    CameraModule,
+    CodeDensity,
+    EngineMode,
+    Gs1HandlingMode,
+    MSIPlesseyChecksumAlgorithm,
+    ZoomRange,
+} from '../../types';
+import { StyleProp } from 'react-native/Libraries/StyleSheet/StyleSheet';
+
+export interface ScanbotBarcodeCameraViewProperties {
+    /** Configuration properties of the finder overlay */
+    finderConfig?: FinderConfig
+    /** Configuration properties of the camera device */
+    cameraConfig?: CameraConfig
+    /** An interface that defines parameters for barcodes detection and filtering */
+    detectorConfig?: DetectorConfig
+    /** Whether flash is toggled on or off. */
+    flashEnabled?: boolean
+    /**
+     * Enable or disable barcode detection.
+     * If disabled, the camera preview is active but no barcodes will be detected.
+     * Default is enabled.
+     */
+    scanningEnabled?: boolean;
+    /* The result of the barcode scanner */
+    onBarcodeScannerResult: (result: BarcodeScannerResult) => void;
+    style?: StyleProp<ViewStyle>
+}
+/** Configuration properties of the finder overlay */
+export interface FinderConfig {
+    /** Display the region of interest. The default value is TRUE. */
+    viewFinderEnabled?: boolean;
+    /** Width of finder frame border. */
+    finderLineWidth?: number;
+    /** Color of finder frame border. */
+    finderLineColor?: ColorValue;
+    /** Background color of the detection overlay. */
+    overlayColor?: ColorValue;
+    /** The minimum space from view finders outer edges to the view edges. */
+    finderInset?: FinderInset;
+    /** Initial padding for insets. Android only. */
+    minPadding?: number;
+    /** Aspect ratio of finder frame (width \ height), which is used to build actual finder frame. */
+    requiredAspectRatio?: AspectRatio;
+}
+
+/** Configuration properties of the camera device */
+export interface CameraConfig {
+    /** The relative initial zoom level of the camera in the range (0,1), where 0 is zoomed out and 1 is zoomed in. Default value is 0.0. */
+    cameraZoomFactor?: number
+    /** The range of valid camera zoom factors. Default value is (1.0; 12.0). */
+    cameraZoomRange?: ZoomRange;
+    /** The camera module to be used for barcode scanning */
+    cameraModule?: CameraModule;
+    /** Lock focus distance withing minimum possible range */
+    minFocusDistanceLock?: boolean;
+}
+
+/** An interface that defines parameters for barcodes detection and filtering */
+export interface DetectorConfig {
+    /** Accepted barcode formats */
+    barcodeFormats?: BarcodeFormat[];
+    /** An optional array of barcode document formats that act as a detection filter. By default all supported document formats will be detected. */
+    acceptedDocumentFormats?: BarcodeDocumentFormat[];
+    /** The engine mode to be used for barcode scanning. The default value is NEXT_GEN. */
+    engineMode?: EngineMode;
+    /** The extension filter for EAN and UPC barcodes. */
+    barcodesExtensionFilter?: BarcodesExtensionFilter;
+    /** If `true`, enabled the mode which slightly decreases the scanning quality and the energy consumption, and increases the scanning speed. If `false` - mode is disabled. The default is `false` */
+    lowPowerMode?: 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 text length of the detected barcode. The default is 0 (setting is turned off). NOTE - This feature works on ITF barcodes only. */
+    maximumTextLength?: number;
+    /** Optional minimum required quiet zone on the barcode. Measured in modules (the size of minimal bar on the barcode). The default is 10. NOTE - This feature works on ITF barcodes only. */
+    minimum1DBarcodesQuietZone?: 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;
+    /** The GS1 handling mode. The default value is PARSE. */
+    gs1HandlingMode?: Gs1HandlingMode;
+    /** The checksum algorithm for MSI Plessey barcodes. The default value is MOD_10. */
+    msiPlesseyChecksumAlgorithm?: MSIPlesseyChecksumAlgorithm;
+    /** The expected density of QR codes in an image. */
+    codeDensity?: CodeDensity;
+}
+
+export interface FinderInset {
+    left: number;
+    top: number;
+    bottom: number;
+    right: number;
+}
+
+export interface ScanbotBarcodeCameraViewHandle {
+    /** Freezes the cameras preview */
+    freezeCamera(): void
+    /** Unfreezes the previously frozen cameras preview */
+    unfreezeCamera(): void
+}

package/src/components/spec/ScanbotBarcodeScannerViewNativeComponent.ts

@@ -0,0 +1,59 @@
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type { ColorValue, ViewProps } from 'react-native';
+import type { DirectEventHandler, Double, Float, Int32, WithDefault } from 'react-native/Libraries/Types/CodegenTypes';
+import { ComponentType } from 'react';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+
+export interface NativeProps extends ViewProps {
+  onBarcodeScannerResult?: DirectEventHandler<Readonly<{result: string}>>;
+  flashEnabled?: WithDefault<boolean, false>;
+  finderEnabled?: WithDefault<boolean, false>;
+  finderStrokeWidth?: WithDefault<Int32, 2>;
+  finderStrokeColor?: ColorValue;
+  finderOverlayColor?: ColorValue;
+  finderMinPadding?: WithDefault<Int32, 0>;
+  finderInset?: {
+    left?: WithDefault<Int32, 10>;
+    top?: WithDefault<Int32, 10>;
+    bottom?: WithDefault<Int32, 10>;
+    right?: WithDefault<Int32, 10>;
+  };
+  finderRequiredAspectRatios?: {
+    width?: WithDefault<Double, 4>,
+    height?: WithDefault<Double, 3>
+  };
+  cameraZoomFactor?: WithDefault<Float, 0.0>;
+  cameraZoomRange?: {
+    minZoom?: WithDefault<Float, 1.0>,
+    maxZoom?: WithDefault<Float, 12.0>,
+  };
+  cameraModule?: WithDefault<string, 'BACK'>;
+  scanningEnabled?: WithDefault<boolean, true>;
+  detectorConfig?: {
+    barcodeFormats?: ReadonlyArray<string>;
+    acceptedDocumentFormats?: ReadonlyArray<string>;
+    engineMode?: WithDefault<string, 'NEXT_GEN'>;
+    barcodesExtensionFilter?: WithDefault<string, 'NO_FILTER'>;
+    lowPowerMode?: WithDefault<boolean, false>;
+    minimumTextLength?: WithDefault<Int32, 0>;
+    maximumTextLength?: WithDefault<Int32, 0>;
+    minimum1DBarcodesQuietZone?: WithDefault<Int32, 10>;
+    stripCheckDigits?: WithDefault<boolean, false>;
+    gs1HandlingMode?: WithDefault<string, 'PARSE'>;
+    msiPlesseyChecksumAlgorithm?: WithDefault<string, 'MOD_10'>;
+    codeDensity?: WithDefault<string, 'LOW'>;
+  };
+  minFocusDistanceLock?: WithDefault<boolean, false>;
+}
+
+export default codegenNativeComponent<NativeProps>('ScanbotBarcodeScannerView');
+
+interface NativeCommands {
+  freezeCamera: (viewRef: React.ElementRef<ComponentType>) => void;
+  unfreezeCamera: (viewRef: React.ElementRef<ComponentType>) => void;
+}
+
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['freezeCamera', 'unfreezeCamera'],
+});

package/src/index.ts

@@ -0,0 +1,58 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2024 Scanbot SDK GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+import {NativeModules} from 'react-native';
+import {
+    BarcodeScannerConfiguration,
+    BatchBarcodeScannerConfiguration,
+    ScanbotBarcodeSdkConfiguration
+} from "./configurations";
+import {ResultWrapper} from "./customResults";
+import {BarcodeScannerResult, BatchBarcodeScannerResult, GetLicenseInfoResult} from "./results";
+import {DetectBarcodesOnImageArguments, ExtractImagesFromPdfArguments} from "./customConfigurations";
+import {ScanbotBarcodeCameraView} from './components/barcode-camera-view/ScanbotBarcodeCameraView';
+import {ScanbotBarcodeCameraViewProperties, ScanbotBarcodeCameraViewHandle} from './components/barcode-camera-view/ScanbotBarcodeCameraViewProperties';
+
+const {ScanbotBarcodeSdk} = NativeModules;
+
+export interface ScanbotBarcodeSdk {
+    // SDK Internal
+    initializeSdk(config: ScanbotBarcodeSdkConfiguration): Promise<ResultWrapper<string>>;
+
+    getLicenseInfo(): Promise<ResultWrapper<GetLicenseInfoResult>>;
+
+    cleanup(): Promise<ResultWrapper<string>>;
+
+    // RTU-UI Barcode Scanning
+    startBarcodeScanner(config: BarcodeScannerConfiguration): Promise<ResultWrapper<BarcodeScannerResult>>;
+
+    closeBarcodeScanner(): Promise<ResultWrapper<undefined>>;
+
+    startBatchBarcodeScanner(config: BatchBarcodeScannerConfiguration): Promise<ResultWrapper<BatchBarcodeScannerResult>>;
+
+    closeBatchBarcodeScanner(): Promise<ResultWrapper<undefined>>;
+
+    // Other Barcode Scanning functionalities
+    detectBarcodesOnImage(
+        args: DetectBarcodesOnImageArguments
+    ): Promise<ResultWrapper<BarcodeScannerResult>>;
+
+    extractImagesFromPDF(
+        args: ExtractImagesFromPdfArguments
+    ): Promise<ResultWrapper<string[]>>;
+}
+
+const ScanbotBarcodeSDK: ScanbotBarcodeSdk = ScanbotBarcodeSdk
+
+export default ScanbotBarcodeSDK;
+
+export * from './types'
+export * from './customTypes'
+export * from './results'
+export * from './customResults'
+export * from './configurations'
+export * from './customConfigurations'
+
+export {ScanbotBarcodeCameraView, ScanbotBarcodeCameraViewProperties, ScanbotBarcodeCameraViewHandle}