react-native-scanbot-barcode-scanner-sdk 4.0.4 → 4.2.0-beta.2

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/extensions/ReadableMap.kt

@@ -0,0 +1,53 @@
+package io.scanbot.barcodesdk.plugin.reactnative.extensions
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+
+
+@Throws(JSONException::class)
+fun ReadableMap.toJSON(): JSONObject {
+    val jsonResult = JSONObject()
+
+    val iterator = this.keySetIterator()
+
+    while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+
+        when (this.getType(key)) {
+            ReadableType.Boolean -> jsonResult.put(key, this.getBoolean(key))
+            ReadableType.Number -> jsonResult.put(key, this.getDouble(key))
+            ReadableType.String -> jsonResult.put(key, this.getString(key))
+            ReadableType.Map -> jsonResult.put(key, this.getMap(key)?.toJSON())
+            ReadableType.Array -> jsonResult.put(key, this.getArray(key)?.toJSONArray())
+            ReadableType.Null -> {
+                // NO-OP
+            }
+        }
+    }
+
+    return jsonResult
+}
+
+@Throws(JSONException::class)
+fun ReadableArray.toJSONArray(): JSONArray {
+    val jsonResult = JSONArray()
+
+    for (i in 0 until this.size()) {
+        when (this.getType(i)) {
+            ReadableType.Boolean -> jsonResult.put(this.getBoolean(i))
+            ReadableType.Number -> jsonResult.put(this.getDouble(i))
+            ReadableType.String -> jsonResult.put(this.getString(i))
+            ReadableType.Map -> jsonResult.put(this.getMap(i).toJSON())
+            ReadableType.Array -> jsonResult.put(this.getArray(i).toJSONArray())
+            ReadableType.Null -> {
+                // NO-OP
+            }
+        }
+    }
+
+    return jsonResult
+}

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/utils/JSONUtils.kt

@@ -0,0 +1,24 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2024 Scanbot SDK GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+package io.scanbot.barcodesdk.plugin.reactnative.utils
+
+import com.facebook.react.bridge.ReadableMap
+import io.scanbot.barcodesdk.plugin.reactnative.extensions.toJSON
+import io.scanbot.barcodesdk.plugin.reactnative.extensions.toWritableMap
+import org.json.JSONObject
+
+object JSONUtils {
+
+    @JvmStatic
+    fun jsonToWritableMap(jsonObject: JSONObject): ReadableMap {
+        return jsonObject.toWritableMap()
+    }
+
+    @JvmStatic
+    fun readableMapToJson(readableMap: ReadableMap): JSONObject {
+        return readableMap.toJSON()
+    }
+}

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/utils/ScanbotViewUtils.java

@@ -36,4 +36,8 @@ public class ScanbotViewUtils {
     public static int convertDpToPx(Resources resources, int dp) {
         return (int) Math.floor(dp * resources.getDisplayMetrics().density);
     }
+
+    public static int convertDpToPx(Resources resources, float dp) {
+        return (int) Math.floor(dp * resources.getDisplayMetrics().density);
+    }
 }

package/android/src/new-architecture/io/scanbot/barcodesdk/plugin/reactnative/components/barcodecameraview/ScanbotBarcodeCameraViewManager.java

@@ -1,7 +1,5 @@
 package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;
 
-import android.util.Log;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 

package/index.d.ts

@@ -1,42 +1,30 @@
-import { InitializationOptions } from "./src/model";
-import { BarcodeScannerConfiguration, BatchBarcodeScannerConfiguration, DetectBarcodesOnImageArguments } from "./src/configuration";
-import { BarcodeDocumentFormat, BarcodeFormat, EngineMode } from "./src/enum";
-import { BarcodeResult, BarcodeScannerResult, BatchBarcodeScannerResult, GetLicenseInfoResult } from "./src/result";
-import { ScanbotBarcodeCameraView } from "./src/components/barcode-camera-view/scanbot-barcode-camera-view";
-import { ScanbotBarcodeCameraViewConfiguration} from "./src/components/barcode-camera-view/scanbot-barcode-camera-view-types";
-
-export {
-    BarcodeScannerConfiguration,
-    BatchBarcodeScannerConfiguration,
-    BarcodeDocumentFormat,
-    BarcodeFormat,
-    BarcodeResult,
-    BarcodeScannerResult,
-    BatchBarcodeScannerResult,
-    ScanbotBarcodeCameraView,
-    ScanbotBarcodeCameraViewConfiguration,
-    EngineMode,
-    GetLicenseInfoResult
-}
+import { BarcodeScannerConfiguration, BatchBarcodeScannerConfiguration, ScanbotBarcodeSdkConfiguration } from "./src/configurations";
+import { DetectBarcodesOnImageArguments, ExtractImagesFromPdfArguments } from "./src/customConfigurations";
+import { ResultWrapper } from "./src/customResults";
+import { BarcodeScannerResult, BatchBarcodeScannerResult, GetLicenseInfoResult } from "./src/results";
 
 export interface ScanbotBarcodeSdk {
     // SDK Internal
-    initializeSdk(options: InitializationOptions): Promise<{ result: string }>;
-    getLicenseInfo(): Promise<GetLicenseInfoResult>;
+    initializeSdk(config: ScanbotBarcodeSdkConfiguration): Promise<ResultWrapper<string>>;
+    getLicenseInfo(): Promise<ResultWrapper<GetLicenseInfoResult>>;
 
-    cleanup(): Promise<void>;
+    cleanup(): Promise<ResultWrapper<string>>;
 
     // RTU-UI Barcode Scanning
-    startBarcodeScanner(configuration: BarcodeScannerConfiguration): Promise<BarcodeScannerResult>;
-    closeBarcodeScanner(): Promise<void>;
+    startBarcodeScanner(config: BarcodeScannerConfiguration): Promise<ResultWrapper<BarcodeScannerResult>>;
+    closeBarcodeScanner(): Promise<ResultWrapper<undefined>>;
 
-    startBatchBarcodeScanner(configuration: BatchBarcodeScannerConfiguration): Promise<BatchBarcodeScannerResult>;
-    closeBatchBarcodeScanner(): Promise<void>;
+    startBatchBarcodeScanner(config: BatchBarcodeScannerConfiguration): Promise<ResultWrapper<BatchBarcodeScannerResult>>;
+    closeBatchBarcodeScanner(): Promise<ResultWrapper<undefined>>;
 
     // Other Barcode Scanning functionalities
     detectBarcodesOnImage(
         args: DetectBarcodesOnImageArguments
-    ): Promise<BarcodeResult>;
+    ): Promise<ResultWrapper<BarcodeScannerResult>>;
+
+    extractImagesFromPDF(
+        args: ExtractImagesFromPdfArguments
+    ): Promise<ResultWrapper<string[]>>;
 }
 
 declare var ScanbotBarcodeSDK: ScanbotBarcodeSdk;
@@ -44,4 +32,11 @@ declare var ScanbotBarcodeSDK: ScanbotBarcodeSdk;
 export default ScanbotBarcodeSDK;
 
 export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view';
-export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view-types';
+export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view-types';
+
+export * from './src/types'
+export * from './src/customTypes'
+export * from './src/results'
+export * from './src/customResults'
+export * from './src/configurations'
+export * from './src/customConfigurations'

package/index.js

@@ -1,6 +1,6 @@
 /*
   Scanbot Barcode Scanner SDK React Native Plugin
-  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
+  Copyright (c) 2024 Scanbot SDK GmbH. All rights reserved.
   https://scanbot.io/sdk
  */
 import { NativeModules } from 'react-native';
@@ -10,4 +10,11 @@ const { ScanbotBarcodeSdk } = NativeModules;
 export default ScanbotBarcodeSdk;
 
 export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view';
-export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view-types';
+export * from './src/components/barcode-camera-view/scanbot-barcode-camera-view-types';
+
+export * from './src/types'
+export * from './src/customTypes'
+export * from './src/results'
+export * from './src/customResults'
+export * from './src/configurations'
+export * from './src/customConfigurations'

package/ios/Components/BarcodeCameraView/NewArchitecture/RTNScanbotBarcodeCameraView.h

@@ -22,7 +22,6 @@ NS_ASSUME_NONNULL_BEGIN
 @interface RTNScanbotBarcodeCameraView: RCTViewComponentView<SBSDKBarcodeScannerViewControllerDelegate>
 
 @property SBSDKBarcodeScannerViewController* _Nullable cameraViewController;
-@property NSMutableArray* _Nonnull barcodes;
 
 // TODO: Check if required
 @property (nonatomic, copy) RCTBubblingEventBlock _Nullable requestComponentReload;

package/ios/Components/BarcodeCameraView/NewArchitecture/RTNScanbotBarcodeCameraView.mm

@@ -14,11 +14,10 @@
 #import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/RCTComponentViewHelpers.h>
 
 #import "RTNScanbotBarcodeCameraView.h"
-#import "ObjectMapper.h"
-#import "BarcodeMapping.h"
 #import "RCTFabricComponentsPlugins.h"
 
 #import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
+#import <ScanbotBarcodeSDKWrapper/ScanbotBarcodeSDKWrapper-Swift.h>
 #import <Foundation/Foundation.h>
 
 using namespace facebook::react;
@@ -27,14 +26,18 @@ static inline NSString* toNSString(std::string value) {
     return [[NSString alloc] initWithCString:value.c_str() encoding:NSUTF8StringEncoding];
 }
 
-static inline bool isUndefined(facebook::react::Float value) {
-    return isnan(value) || value == -1;
+static inline bool isFloatDefined(facebook::react::Float value) {
+    // If value is not set from the typescript, by default -1 is allocated from the props
+    return !(isnan(value) || value == -1);
+}
+
+static inline bool isIntDefined(int value) {
+    // If value is not set from the typescript, by default -1 is allocated from the props
+    return !(isnan(value) || value == -1);
 }
 
 @interface RTNScanbotBarcodeCameraView () <RCTRTNScanbotBarcodeCameraViewViewProtocol>
     @property(nonatomic, strong) SBSDKBarcodeScannerViewController *viewController;
-    @property(nonatomic, strong) SBSDKUIBarcodeFilter *barcodeFilter;
-    @property(nonatomic) CGFloat userDefinedCameraZoomFactor;
     @property(nonatomic) BOOL isFirstLaunch;
     @property(nonatomic) BOOL scanningEnabled;
 @end
@@ -53,8 +56,6 @@ static inline bool isUndefined(facebook::react::Float value) {
         static const auto defaultProps = std::make_shared<const RTNScanbotBarcodeCameraViewProps>();
         _props = defaultProps;
 
-        self.barcodes = [[NSMutableArray alloc] init];
-        _userDefinedCameraZoomFactor = -1;
         _scanningEnabled = true;
     }
     return self;
@@ -113,7 +114,7 @@ static inline bool isUndefined(facebook::react::Float value) {
     return NULL;
 }
 
-- (void)sendScanResults:(NSArray<SBSDKBarcodeScannerResult*>*) results onImage:(UIImage*)image {
+- (void)sendScanResults:(NSArray<SBSDKBarcodeScannerResult*>*) results {
     if (_eventEmitter == nullptr) {
         return;
     }
@@ -122,54 +123,42 @@ static inline bool isUndefined(facebook::react::Float value) {
         return;
     }
     
-    if (self.barcodeFilter != nil) {
-        results = filterBarcodeResults(results, _barcodeFilter);
-    }
-    
-    NSDictionary* outResult = @{
-        @"result": @{
-            @"status": @"OK",
-            @"barcodes": jsonFromBarcodeResults(results)
-        }
-    };
+    NSDictionary* _Nullable result = [SBBWrapperBarcodeScannerResult nativeResultsToDictionary:results];
     
-    NSData *data = [NSJSONSerialization dataWithJSONObject:outResult options:NSJSONWritingFragmentsAllowed error:nil];
-    NSString *jsonResult = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-    
-    const auto &eventEmitter = std::dynamic_pointer_cast<const facebook::react::RTNScanbotBarcodeCameraViewEventEmitter>(_eventEmitter);
-    eventEmitter->onNativeBarcodeScannerResult(facebook::react::RTNScanbotBarcodeCameraViewEventEmitter::OnNativeBarcodeScannerResult{.jsonResult = std::string([jsonResult UTF8String])});
-}
-
-// MARK: - Utility View Configuration Methods
-
-/* TODO: A single property change requires us to create a new ViewFinder configuration */
-- (SBSDKBaseScannerViewFinderConfiguration*)createViewFinderConfigurationCopy
-{
-    SBSDKBaseScannerViewFinderConfiguration* oldConfig = self.viewController.viewFinderConfiguration;
-    SBSDKBaseScannerViewFinderConfiguration* newConfig = [SBSDKBaseScannerViewFinderConfiguration defaultConfiguration];
-    
-    newConfig.viewFinderEnabled = oldConfig.viewFinderEnabled;
-    newConfig.aspectRatio = oldConfig.aspectRatio;
-    newConfig.minimumInset = oldConfig.minimumInset;
-    newConfig.preferredHeight = oldConfig.preferredHeight;
-    newConfig.ignoresSafeAreaInsets = oldConfig.ignoresSafeAreaInsets;
-    newConfig.secondaryAspectRatio = oldConfig.secondaryAspectRatio;
-    newConfig.secondaryMinimumInset = oldConfig.secondaryMinimumInset;
-    newConfig.lineColor = oldConfig.lineColor;
-    newConfig.backgroundColor = oldConfig.backgroundColor;
-    newConfig.lineCornerRadius = oldConfig.lineCornerRadius;
-    newConfig.lineWidth = oldConfig.lineWidth;
-    newConfig.animateChanges = oldConfig.animateChanges;
-    newConfig.backgroundEffect = oldConfig.backgroundEffect;
-    
-    return newConfig;
+    if(result != NULL) {
+        NSDictionary* outResult = @{
+            @"result": result
+        };
+        
+        NSData *data = [NSJSONSerialization dataWithJSONObject:outResult options:NSJSONWritingFragmentsAllowed error:nil];
+        NSString *jsonResult = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+        
+        const auto &eventEmitter = std::dynamic_pointer_cast<const facebook::react::RTNScanbotBarcodeCameraViewEventEmitter>(_eventEmitter);
+        
+        eventEmitter->onNativeBarcodeScannerResult(facebook::react::RTNScanbotBarcodeCameraViewEventEmitter::OnNativeBarcodeScannerResult{.jsonResult = std::string([jsonResult UTF8String])});
+    }
 }
 
 // MARK: - React Native Lifecycle
 - (void)applyProps:(const facebook::react::Props::Shared &)props oldProps:(const facebook::react::Props::Shared &)oldProps forceUpdate:(bool)forceUpdate {
+    
     const auto &oldViewProps = *std::static_pointer_cast<RTNScanbotBarcodeCameraViewProps const>(_props);
     const auto &newViewProps = *std::static_pointer_cast<RTNScanbotBarcodeCameraViewProps const>(props);
     
+    NSDictionary *oldViewPropsAsDictionary = [[NSDictionary alloc] init];
+    oldViewPropsAsDictionary = [self barcodeCameraViewConfigurationStructToDictionary:oldViewProps.configuration];
+    
+    SBBWrapperBarcodeCameraViewConfiguration* oldBarcodeCameraViewConfiguration = [SBBWrapperBarcodeCameraViewConfiguration fromDicitonary:oldViewPropsAsDictionary];
+    
+    NSDictionary *newViewPropsAsDictionary = [[NSDictionary alloc] init];
+    newViewPropsAsDictionary = [self barcodeCameraViewConfigurationStructToDictionary:newViewProps.configuration];
+    
+    SBBWrapperBarcodeCameraViewConfiguration* newBarcodeCameraViewConfiguration = [SBBWrapperBarcodeCameraViewConfiguration fromDicitonary:newViewPropsAsDictionary];
+    
+    if(newBarcodeCameraViewConfiguration == NULL || oldBarcodeCameraViewConfiguration == NULL) {
+        return;
+    }
+    
     // -----------------------------------------
     // START OF ViewFinderConfiguration MAPPING
     // -----------------------------------------
@@ -180,124 +169,86 @@ static inline bool isUndefined(facebook::react::Float value) {
 
     SBSDKBaseScannerViewFinderConfiguration* viewFinderConfiguration = [SBSDKBaseScannerViewFinderConfiguration defaultConfiguration];
 
-    viewFinderConfiguration.viewFinderEnabled = newViewProps.configuration.shouldUseFinderView;
-        
-    if (!isUndefined(newViewProps.configuration.finderLineWidth)) {
-        viewFinderConfiguration.lineWidth = newViewProps.configuration.finderLineWidth;
-
-    }
+    viewFinderConfiguration.viewFinderEnabled = newBarcodeCameraViewConfiguration.shouldUseFinderView;
     
-    if (!newViewProps.configuration.finderLineColor.empty()) {
-        viewFinderConfiguration.lineColor = [UIColor colorFromHexString:toNSString(newViewProps.configuration.finderLineColor)];
+    if (isIntDefined(newBarcodeCameraViewConfiguration.finderLineWidth)) {
+        viewFinderConfiguration.lineWidth = newBarcodeCameraViewConfiguration.finderLineWidth;
     }
-        
-    if (!newViewProps.configuration.finderBackgroundColor.empty()) {
-        viewFinderConfiguration.backgroundColor = [UIColor colorFromHexString:toNSString(newViewProps.configuration.finderBackgroundColor)];
+    
+    if(![newBarcodeCameraViewConfiguration.finderLineColor isEqual: @""]) {
+        viewFinderConfiguration.lineColor = newBarcodeCameraViewConfiguration.finderLineColorAsUIColor;
     }
-        
-    if (!isUndefined(newViewProps.configuration.finderBackgroundOpacity)) {
-        UIColor* bgColor = self.viewController.viewFinderConfiguration.backgroundColor;
-        viewFinderConfiguration.backgroundColor = [bgColor colorWithAlphaComponent:newViewProps.configuration.finderBackgroundOpacity];
+    
+    if(![newBarcodeCameraViewConfiguration.finderBackgroundColor isEqual: @""] && isFloatDefined(newBarcodeCameraViewConfiguration.finderBackgroundOpacity)) {
+        viewFinderConfiguration.backgroundColor = [newBarcodeCameraViewConfiguration.finderBackgroundColorAsUIColor colorWithAlphaComponent:newBarcodeCameraViewConfiguration.finderBackgroundOpacity];
     }
     
-    if (
-        !isUndefined(newViewProps.configuration.finderAspectRatio.width) &&
-        !isUndefined(newViewProps.configuration.finderAspectRatio.height)
-    ) {
-        viewFinderConfiguration.aspectRatio = [[SBSDKAspectRatio alloc] initWithWidth:newViewProps.configuration.finderAspectRatio.width
-                                                                            andHeight:newViewProps.configuration.finderAspectRatio.height];
+    if (isIntDefined(newBarcodeCameraViewConfiguration.finderAspectRatio.width) && isIntDefined(newBarcodeCameraViewConfiguration.finderAspectRatio.height)) {
+        viewFinderConfiguration.aspectRatio = [[SBSDKAspectRatio alloc] initWithWidth:newBarcodeCameraViewConfiguration.finderAspectRatio.width andHeight:newBarcodeCameraViewConfiguration.finderAspectRatio.height];
     }
-        
 
-    if (!isUndefined(newViewProps.configuration.finderInset.left) &&
-        !isUndefined(newViewProps.configuration.finderInset.top) &&
-        !isUndefined(newViewProps.configuration.finderInset.right) &&
-        !isUndefined(newViewProps.configuration.finderInset.bottom)
-    ) {
-        viewFinderConfiguration.minimumInset = UIEdgeInsetsMake(newViewProps.configuration.finderInset.top,
-                                                                               newViewProps.configuration.finderInset.left,
-                                                                               newViewProps.configuration.finderInset.bottom,
-                                                                               newViewProps.configuration.finderInset.right);
+    if (newBarcodeCameraViewConfiguration.finderInset.insetsAreSet) {
+        viewFinderConfiguration.minimumInset = newBarcodeCameraViewConfiguration.finderInset.insets;
     }
     
     self.viewController.viewFinderConfiguration = viewFinderConfiguration;
     // ---------------------------------------
     // END OF ViewFinderConfiguration MAPPING
     // ---------------------------------------
-    
-    if (forceUpdate || oldViewProps.configuration.lowPowerMode != newViewProps.configuration.lowPowerMode) {
-        // TODO: verify behavior
-    }
         
-    if (forceUpdate || oldViewProps.configuration.minimumTextLength != newViewProps.configuration.minimumTextLength) {
-        if (!isUndefined(newViewProps.configuration.minimumTextLength)) {
-            self.viewController.additionalDetectionParameters.minimumTextLength = newViewProps.configuration.minimumTextLength;
-        }
+    if (isIntDefined(newBarcodeCameraViewConfiguration.minimumTextLength) && (forceUpdate || oldBarcodeCameraViewConfiguration.minimumTextLength != newBarcodeCameraViewConfiguration.minimumTextLength)) {
+            self.viewController.additionalDetectionParameters.minimumTextLength = newBarcodeCameraViewConfiguration.minimumTextLength;
     }
         
-    if (forceUpdate || oldViewProps.configuration.maximumTextLength != newViewProps.configuration.maximumTextLength) {
-        if (!isUndefined(newViewProps.configuration.maximumTextLength)) {
-            self.viewController.additionalDetectionParameters.maximumTextLength = newViewProps.configuration.maximumTextLength;
-        }
+    if (isIntDefined(newBarcodeCameraViewConfiguration.maximumTextLength) && (forceUpdate || oldBarcodeCameraViewConfiguration.maximumTextLength != newBarcodeCameraViewConfiguration.maximumTextLength)) {
+            self.viewController.additionalDetectionParameters.maximumTextLength = newBarcodeCameraViewConfiguration.maximumTextLength;
     }
         
-    if (forceUpdate || oldViewProps.configuration.minimum1DBarcodesQuietZone != newViewProps.configuration.minimum1DBarcodesQuietZone) {
-        if (!isUndefined(newViewProps.configuration.minimum1DBarcodesQuietZone)) {
-            self.viewController.additionalDetectionParameters.minimum1DBarcodesQuietZone = newViewProps.configuration.minimum1DBarcodesQuietZone;
-        }
+    if (isIntDefined(newBarcodeCameraViewConfiguration.minimum1DBarcodesQuietZone) && (forceUpdate || oldBarcodeCameraViewConfiguration.minimum1DBarcodesQuietZone != newBarcodeCameraViewConfiguration.minimum1DBarcodesQuietZone)) {
+            self.viewController.additionalDetectionParameters.minimum1DBarcodesQuietZone = newBarcodeCameraViewConfiguration.minimum1DBarcodesQuietZone;
     }
         
-    if (forceUpdate || oldViewProps.configuration.stripCheckDigits != newViewProps.configuration.stripCheckDigits) {
-        self.viewController.additionalDetectionParameters.stripCheckDigits = newViewProps.configuration.stripCheckDigits;
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.stripCheckDigits != newBarcodeCameraViewConfiguration.stripCheckDigits) {
+        self.viewController.additionalDetectionParameters.stripCheckDigits = newBarcodeCameraViewConfiguration.stripCheckDigits;
     }
         
-    if (forceUpdate || oldViewProps.configuration.gs1DecodingEnabled != newViewProps.configuration.gs1DecodingEnabled) {
-        self.viewController.additionalDetectionParameters.enableGS1Decoding = newViewProps.configuration.gs1DecodingEnabled;
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.gs1Handling != newBarcodeCameraViewConfiguration.gs1Handling) {
+        self.viewController.additionalDetectionParameters.gs1Handling = newBarcodeCameraViewConfiguration.gs1Handling;
     }
         
-    if (forceUpdate || oldViewProps.configuration.msiPlesseyChecksumAlgorithm != newViewProps.configuration.msiPlesseyChecksumAlgorithm) {
-        self.viewController.additionalDetectionParameters.msiPlesseyChecksumAlgorithm = extractMsiPlesseyChecksumAlgorithm(toNSString(newViewProps.configuration.msiPlesseyChecksumAlgorithm));
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.msiPlesseyChecksumAlgorithm != newBarcodeCameraViewConfiguration.msiPlesseyChecksumAlgorithm) {
+        self.viewController.additionalDetectionParameters.msiPlesseyChecksumAlgorithm = newBarcodeCameraViewConfiguration.msiPlesseyChecksumAlgorithm;
     }
         
-    if (forceUpdate || oldViewProps.configuration.codeDensity != newViewProps.configuration.codeDensity) {
-        self.viewController.additionalDetectionParameters.codeDensity = extractBarcodeDensity(toNSString(newViewProps.configuration.codeDensity));
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.codeDensity != newBarcodeCameraViewConfiguration.codeDensity) {
+        self.viewController.additionalDetectionParameters.codeDensity = newBarcodeCameraViewConfiguration.codeDensity;
     }
         
-    if (forceUpdate || oldViewProps.configuration.flashEnabled != newViewProps.configuration.flashEnabled) {
-        self.viewController.flashLightEnabled = newViewProps.configuration.flashEnabled;
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.flashEnabled != newBarcodeCameraViewConfiguration.flashEnabled) {
+        self.viewController.flashLightEnabled = newBarcodeCameraViewConfiguration.flashEnabled;
     }
         
-    if (forceUpdate || oldViewProps.configuration.barcodeFormats != newViewProps.configuration.barcodeFormats) {
-        if (!newViewProps.configuration.barcodeFormats.empty()) {
-            NSMutableArray* barcodeFormats = [NSMutableArray array];
-            for (auto const& format : newViewProps.configuration.barcodeFormats) {
-                SBSDKBarcodeType* type = barcodeTypeFromString(toNSString(format));
-                if (type != nil) {
-                    [barcodeFormats addObject:type];
-                }
-            }
-            self.viewController.acceptedBarcodeTypes = [barcodeFormats copy];
-        }
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.acceptedBarcodeTypes != newBarcodeCameraViewConfiguration.acceptedBarcodeTypes) {
+        self.viewController.acceptedBarcodeTypes = newBarcodeCameraViewConfiguration.acceptedBarcodeTypes;
     }
-        
-    if (forceUpdate || oldViewProps.configuration.engineMode != newViewProps.configuration.engineMode) {
-        self.viewController.engineMode = extractEngineMode(toNSString(newViewProps.configuration.engineMode));
+
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.acceptedDocumentTypes != newBarcodeCameraViewConfiguration.acceptedDocumentTypes) {
+        self.viewController.acceptedDocumentTypes = newBarcodeCameraViewConfiguration.acceptedDocumentTypes;
+    }
+    
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.engineMode != newBarcodeCameraViewConfiguration.engineMode) {
+        self.viewController.engineMode = newBarcodeCameraViewConfiguration.engineMode;
     }
         
-    if (forceUpdate || oldViewProps.configuration.cameraZoomFactor != newViewProps.configuration.cameraZoomFactor) {
-        if (!isUndefined(newViewProps.configuration.cameraZoomFactor)) {
-            if (newViewProps.configuration.cameraZoomFactor != _userDefinedCameraZoomFactor || _userDefinedCameraZoomFactor == -1) {
-                self.viewController.cameraZoomFactor = newViewProps.configuration.cameraZoomFactor;
-                _userDefinedCameraZoomFactor = newViewProps.configuration.cameraZoomFactor;
-            }
-        }
+    if (isFloatDefined(newBarcodeCameraViewConfiguration.cameraZoomFactor) && (forceUpdate || oldBarcodeCameraViewConfiguration.cameraZoomFactor != newBarcodeCameraViewConfiguration.cameraZoomFactor)) {
+        self.viewController.cameraZoomFactor = newBarcodeCameraViewConfiguration.cameraZoomFactor;
     }
         
-    if (forceUpdate || oldViewProps.configuration.barcodeFilter != newViewProps.configuration.barcodeFilter) {
-        _barcodeFilter = extractBarcodeFilter(toNSString(newViewProps.configuration.barcodeFilter));
+    if (forceUpdate || oldBarcodeCameraViewConfiguration.barcodesExtensionFilter != newBarcodeCameraViewConfiguration.barcodesExtensionFilter) {
+        self.viewController.extensionFilter = newBarcodeCameraViewConfiguration.barcodesExtensionFilter;
     }
 
-    _scanningEnabled = newViewProps.configuration.scanningEnabled;
+    _scanningEnabled = newBarcodeCameraViewConfiguration.scanningEnabled;
 }
 
 - (void)updateProps:(const facebook::react::Props::Shared &)props oldProps:(const facebook::react::Props::Shared &)oldProps {
@@ -311,6 +262,43 @@ static inline bool isUndefined(facebook::react::Float value) {
     [super updateProps:props oldProps:oldProps];
 }
 
+- barcodeCameraViewConfigurationStructToDictionary:(facebook::react::RTNScanbotBarcodeCameraViewConfigurationStruct) configurationStruct
+{
+    return @{
+        @"flashEnabled": @(configurationStruct.flashEnabled),
+        @"barcodeFormats": [self vectorStringToNSArray:configurationStruct.barcodeFormats],
+        @"acceptedDocumentFormats": [self vectorStringToNSArray:configurationStruct.acceptedDocumentFormats],
+        @"engineMode": toNSString(configurationStruct.engineMode),
+        @"cameraZoomFactor": @(configurationStruct.cameraZoomFactor),
+        @"barcodesExtensionFilter": toNSString(configurationStruct.barcodesExtensionFilter),
+        @"scanningEnabled": @(configurationStruct.scanningEnabled),
+        @"minimumTextLength": @(configurationStruct.minimumTextLength),
+        @"maximumTextLength": @(configurationStruct.maximumTextLength),
+        @"minimum1DBarcodesQuietZone": @(configurationStruct.minimum1DBarcodesQuietZone),
+        @"stripCheckDigits": @(configurationStruct.stripCheckDigits),
+        @"gs1HandlingMode": toNSString(configurationStruct.gs1HandlingMode),
+        @"msiPlesseyChecksumAlgorithm": toNSString(configurationStruct.msiPlesseyChecksumAlgorithm),
+        @"codeDensity": toNSString(configurationStruct.codeDensity),
+        @"shouldUseFinderView": @(configurationStruct.shouldUseFinderView),
+        @"finderLineWidth": @(configurationStruct.finderLineWidth),
+        @"finderLineColor": toNSString(configurationStruct.finderLineColor),
+        @"finderBackgroundColor": toNSString(configurationStruct.finderBackgroundColor),
+        @"finderBackgroundOpacity": @(configurationStruct.finderBackgroundOpacity),
+        @"finderAspectRatio": @{@"width": @(configurationStruct.finderAspectRatio.width), @"height": @(configurationStruct.finderAspectRatio.height)},
+        @"finderInset": @{@"left": @(configurationStruct.finderInset.left), @"top": @(configurationStruct.finderInset.top), @"bottom": @(configurationStruct.finderInset.bottom), @"right": @(configurationStruct.finderInset.right)}
+    };
+}
+
+- (NSArray*)vectorStringToNSArray:(std::vector<std::string>) vector {
+    NSMutableArray* nsArray = [NSMutableArray array];
+    
+    for (auto const& value : vector) {
+        [nsArray addObject: toNSString(value)];
+    }
+    
+    return nsArray;
+}
+
 - (void)componentDidMount {
     _isFirstLaunch = true;
     [self applyProps:_props oldProps:_props forceUpdate:_isFirstLaunch];
@@ -328,7 +316,7 @@ static inline bool isUndefined(facebook::react::Float value) {
                didDetectBarcodes:(NSArray<SBSDKBarcodeScannerResult *> *)codes
                          onImage:(nonnull UIImage *)image {
     
-    [self sendScanResults:codes onImage:image];
+    [self sendScanResults:codes];
 }
 
 - (BOOL)barcodeScannerControllerShouldDetectBarcodes:(SBSDKBarcodeScannerViewController *)controller {
@@ -336,23 +324,7 @@ static inline bool isUndefined(facebook::react::Float value) {
 }
 
 - (void)barcodeScannerController:(nonnull SBSDKBarcodeScannerViewController *)controller didDetectBarcodes:(nonnull NSArray<SBSDKBarcodeScannerResult *> *)codes {
-    [self sendScanResults:codes onImage:nil];
-}
-
-
-- (NSArray*)hashedBarcodes {
-    NSMutableArray* outArray = [[NSMutableArray alloc] init];
-    for (NSDictionary* barcode in self.barcodes) {
-        NSString* hash = [RTNScanbotBarcodeCameraView 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];
+    [self sendScanResults:codes];
 }
 
 @end

package/ios/Components/BarcodeCameraView/OldArchitecture/RNScanbotBarcodeCameraView.h

@@ -18,12 +18,8 @@
 @interface RNScanbotBarcodeCameraView: UIView<SBSDKBarcodeScannerViewControllerDelegate>
 
 @property SBSDKBarcodeScannerViewController* _Nullable cameraViewController;
-@property NSMutableArray* _Nonnull barcodes;
 @property (nonatomic, copy) RCTBubblingEventBlock _Nullable onNativeBarcodeScannerResult;
 @property (nonatomic, copy) RCTBubblingEventBlock _Nullable requestComponentReload;
-@property (nonatomic) BOOL shouldUseFinderView;
-@property (nonatomic, copy) NSDictionary* _Nullable configuration;
-@property (nonatomic) BOOL finderInsetAvailable;
 
 - (void) createCameraViewController;
 - (UIViewController* _Nullable) getParentViewController;
@@ -35,33 +31,6 @@
 
 @end
 
-@interface RNScanbotCameraViewConfiguration: NSObject
-
-// Non-Nullable Properties
-@property (nonatomic) CGFloat finderLineWidth;
-@property (nonatomic) UIColor* _Nonnull finderLineColor;
-@property (nonatomic) UIColor* _Nonnull finderBackgroundColor;
-@property (nonatomic) CGFloat finderBackgroundOpacity;
-@property (nonatomic) SBSDKAspectRatio* _Nonnull finderAspectRatio;
-@property (nonatomic) BOOL scanningEnabled;
-
-// Nullable Properties (-1 for enums)
-@property (nonatomic, copy) NSNumber* _Nullable shouldUseFinderView;
-@property (nonatomic, copy) NSNumber* _Nullable flashEnabled;
-@property (nonatomic, copy) NSNumber* _Nullable cameraZoomFactor;
-@property (nonatomic, copy) NSNumber* _Nullable gs1DecodingEnabled;
-@property (nonatomic, copy) NSNumber* _Nullable minimumTextLength;
-@property (nonatomic, copy) NSNumber* _Nullable maximumTextLength;
-@property (nonatomic, copy) NSNumber* _Nullable stripCheckDigits;
-@property (nonatomic, copy) NSArray<SBSDKBarcodeType *>* _Nullable barcodeFormats;
-@property (nonatomic, copy) NSArray<SBSDKBarcodeDocumentType *>* _Nullable acceptedDocumentFormats;
-@property (nonatomic) SBSDKBarcodeMSIPlesseyChecksumAlgorithm msiPlesseyChecksumAlgorithm;
-@property (nonatomic) SBSDKBarcodeEngineMode engineMode;
-@property (nonatomic) SBSDKUIBarcodeFilter* _Nullable barcodeFilter;
-@property (nonatomic) SBSDKBarcodeDensity codeDensity;
-@property (nonatomic) UIEdgeInsets finderInset;
-@end
-
 #endif /* RNScanbotCameraView_h */
 
 #endif // ifdef RCT_NEW_ARCH_ENABLED