react-native-scanbot-barcode-scanner-sdk 3.6.1-alpha.1 → 3.6.1-alpha.2

package/RNScanbotBarcodeSDK.podspec

@@ -17,7 +17,7 @@ Pod::Spec.new do |s|
 
   
   s.source = { :http => 'https://download.scanbot.io/barcode-scanner-sdk/react-native/react-native-scanbot-barcode-scanner-sdk-' + package['version'] + '.tgz' }    
-  s.source_files = "ios/**/*.{h,m,swift}"
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
   s.requires_arc = true
 
   install_modules_dependencies(s)

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/components/barcodecameraview/ScanbotBarcodeCameraView.java

@@ -46,7 +46,7 @@ import kotlin.Unit;
 public class ScanbotBarcodeCameraView extends FrameLayout implements BarcodeDetectorFrameHandler.ResultHandler {
     // From Java to JavaScript
     public enum NativeEvents implements ScanbotEventEmitter.NativeEvent {
-        BARCODE_SCANNER_RESULT("onBarcodeScannerResult");
+        BARCODE_SCANNER_RESULT("onNativeBarcodeScannerResult");
 
         private final String name;
         NativeEvents(final String name) {

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

@@ -0,0 +1,46 @@
+//
+//  RTNScanbotBarcodeCameraView.h
+//  RTNScanbotSDK
+//
+//  Created by Marco Saia on 18.05.21.
+//
+
+// We use this compilation pragma to expose this implementation for the NEW ARCHITECTURE only
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#ifndef RTNScanbotCameraView_h
+#define RTNScanbotCameraView_h
+
+#import <React/RCTViewComponentView.h>
+#import <React/RCTView.h>
+#import <UIKit/UIKit.h>
+
+#import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
+#import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/Props.h>
+
+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;
+
+@property (nonatomic) facebook::react::RTNScanbotBarcodeCameraViewConfigurationStruct configuration;
+
+- (void) createCameraViewController;
+- (UIViewController* _Nullable) getParentViewController;
+
+- (void) componentDidMount;
+- (void) componentDidUpdate;
+- (void) componentWillUnmount;
+- (void) orientationChanged;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* RTNScanbotCameraView_h */
+#endif // ifdef RCT_NEW_ARCH_ENABLED

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

@@ -0,0 +1,364 @@
+//
+//  RTNScanbotBarcodeCameraView.mm
+//  RNScanbotSDK
+//
+//  Created by Marco Saia on 18.05.21.
+//
+
+// We use this compilation pragma to expose this implementation for the NEW ARCHITECTURE only
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/ComponentDescriptors.h>
+#import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/EventEmitters.h>
+#import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/Props.h>
+#import <react/renderer/components/RTNScanbotBarcodeCameraViewSpecs/RCTComponentViewHelpers.h>
+
+#import "RTNScanbotBarcodeCameraView.h"
+#import "ObjectMapper.h"
+#import "BarcodeMapping.h"
+#import "RCTFabricComponentsPlugins.h"
+
+#import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
+#import <Foundation/Foundation.h>
+
+using namespace facebook::react;
+
+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;
+}
+
+@interface RTNScanbotBarcodeCameraView () <RCTRTNScanbotBarcodeCameraViewViewProtocol>
+@end
+
+@implementation RTNScanbotBarcodeCameraView {
+    RTNScanbotBarcodeCameraViewConfigurationStruct _configuration;
+    SBSDKBarcodeScannerViewController* viewController;
+    SBSDKUIBarcodeFilter* _barcodeFilter;
+    CGFloat _userDefinedCameraZoomFactor;
+    BOOL _isFirstLaunch;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<RTNScanbotBarcodeCameraViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        _isFirstLaunch = true;
+        static const auto defaultProps = std::make_shared<const RTNScanbotBarcodeCameraViewProps>();
+        _props = defaultProps;
+
+        self.barcodes = [[NSMutableArray alloc] init];
+        _userDefinedCameraZoomFactor = -1;
+    }
+    return self;
+}
+
+- (void)layoutSubviews {
+    if (_cameraViewController) {
+        _cameraViewController.view.frame = [self bounds];
+        return;
+    }
+    
+    __weak RTNScanbotBarcodeCameraView* weakSelf = self;
+    
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [weakSelf createCameraViewController];
+    });
+}
+
+- (void)createCameraViewController {
+    UIViewController* parentViewController = [self getParentViewController];
+    if (!parentViewController) {
+        return;
+    }
+    
+    if (!_cameraViewController) {
+        viewController = [[SBSDKBarcodeScannerViewController alloc] initWithParentViewController:parentViewController
+                                                                                      parentView:self
+                                                                                        delegate:self];
+        
+        _cameraViewController = viewController;
+    }
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+    if ([commandName isEqualToString:@"componentDidMount"]) {
+        [self componentDidMount];
+    } else if ([commandName isEqualToString:@"componentDidUpdate"]) {
+        [self componentDidUpdate];
+    } else if ([commandName isEqualToString:@"componentWillUnmount"]) {
+        [self componentWillUnmount];
+    } else if ([commandName isEqualToString:@"orientationChanged"]) {
+        [self orientationChanged];
+    } else {
+        NSLog(@"Unhandled React Native Command: %@", commandName);
+    }
+}
+
+- (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 onImage:(UIImage*)image {
+    if (_eventEmitter == nullptr) {
+        return;
+    }
+    
+    if(!results || results.count == 0) {
+        return;
+    }
+    
+    if (_barcodeFilter != nil) {
+        results = filterBarcodeResults(results, _barcodeFilter);
+    }
+    
+    NSDictionary* outResult = @{
+        @"result": @{
+            @"status": @"OK",
+            @"barcodes": jsonFromBarcodeResults(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 = 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;
+}
+
+// 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);
+    
+    // -----------------------------------------
+    // START OF ViewFinderConfiguration MAPPING
+    // -----------------------------------------
+    
+    // In order for the mapping to work we need to alloc, init and set a new SBSDKBaseScannerViewFinderConfiguration object
+    // in the Scanbot SDK ViewController configuration. Applying hot changes on the existing object does not update
+    // the component.
+
+    SBSDKBaseScannerViewFinderConfiguration* viewFinderConfiguration = [SBSDKBaseScannerViewFinderConfiguration defaultConfiguration];
+
+    viewFinderConfiguration.viewFinderEnabled = newViewProps.configuration.shouldUseFinderView;
+        
+    if (!isUndefined(newViewProps.configuration.finderLineWidth)) {
+        viewFinderConfiguration.lineWidth = newViewProps.configuration.finderLineWidth;
+
+    }
+    
+    if (!newViewProps.configuration.finderLineColor.empty()) {
+        viewFinderConfiguration.lineColor = [UIColor colorFromHexString:toNSString(newViewProps.configuration.finderLineColor)];
+    }
+        
+    if (!newViewProps.configuration.finderBackgroundColor.empty()) {
+        viewFinderConfiguration.backgroundColor = [UIColor colorFromHexString:toNSString(newViewProps.configuration.finderBackgroundColor)];
+    }
+        
+    if (!isUndefined(newViewProps.configuration.finderBackgroundOpacity)) {
+        UIColor* bgColor = viewController.viewFinderConfiguration.backgroundColor;
+        viewFinderConfiguration.backgroundColor = [bgColor colorWithAlphaComponent:newViewProps.configuration.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 (!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);
+    }
+    
+    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)) {
+            viewController.additionalDetectionParameters.minimumTextLength = newViewProps.configuration.minimumTextLength;
+        }
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.maximumTextLength != newViewProps.configuration.maximumTextLength) {
+        if (!isUndefined(newViewProps.configuration.maximumTextLength)) {
+            viewController.additionalDetectionParameters.maximumTextLength = newViewProps.configuration.maximumTextLength;
+        }
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.minimum1DBarcodesQuietZone != newViewProps.configuration.minimum1DBarcodesQuietZone) {
+        if (!isUndefined(newViewProps.configuration.minimum1DBarcodesQuietZone)) {
+            viewController.additionalDetectionParameters.minimum1DBarcodesQuietZone = newViewProps.configuration.minimum1DBarcodesQuietZone;
+        }
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.stripCheckDigits != newViewProps.configuration.stripCheckDigits) {
+        viewController.additionalDetectionParameters.stripCheckDigits = newViewProps.configuration.stripCheckDigits;
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.gs1DecodingEnabled != newViewProps.configuration.gs1DecodingEnabled) {
+        viewController.additionalDetectionParameters.enableGS1Decoding = newViewProps.configuration.gs1DecodingEnabled;
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.msiPlesseyChecksumAlgorithm != newViewProps.configuration.msiPlesseyChecksumAlgorithm) {
+        viewController.additionalDetectionParameters.msiPlesseyChecksumAlgorithm = extractMsiPlesseyChecksumAlgorithm(toNSString(newViewProps.configuration.msiPlesseyChecksumAlgorithm));
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.codeDensity != newViewProps.configuration.codeDensity) {
+        viewController.additionalDetectionParameters.codeDensity = extractBarcodeDensity(toNSString(newViewProps.configuration.codeDensity));
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.flashEnabled != newViewProps.configuration.flashEnabled) {
+        viewController.flashLightEnabled = newViewProps.configuration.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];
+                }
+            }
+            viewController.acceptedBarcodeTypes = [barcodeFormats copy];
+        }
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.engineMode != newViewProps.configuration.engineMode) {
+        viewController.engineMode = extractEngineMode(toNSString(newViewProps.configuration.engineMode));
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.cameraZoomFactor != newViewProps.configuration.cameraZoomFactor) {
+        if (!isUndefined(newViewProps.configuration.cameraZoomFactor)) {
+            if (newViewProps.configuration.cameraZoomFactor != _userDefinedCameraZoomFactor || _userDefinedCameraZoomFactor == -1) {
+                viewController.cameraZoomFactor = newViewProps.configuration.cameraZoomFactor;
+                _userDefinedCameraZoomFactor = newViewProps.configuration.cameraZoomFactor;
+            }
+        }
+    }
+        
+    if (forceUpdate || oldViewProps.configuration.barcodeFilter != newViewProps.configuration.barcodeFilter) {
+        _barcodeFilter = extractBarcodeFilter(toNSString(newViewProps.configuration.barcodeFilter));
+    }
+}
+
+- (void)updateProps:(const facebook::react::Props::Shared &)props oldProps:(const facebook::react::Props::Shared &)oldProps {
+    const auto &newViewProps = *std::static_pointer_cast<RTNScanbotBarcodeCameraViewProps const>(props);
+    
+    _configuration = newViewProps.configuration;
+    
+    [self applyProps:props oldProps:oldProps forceUpdate:_isFirstLaunch];
+    _isFirstLaunch = false;
+    
+    [super updateProps:props oldProps:oldProps];
+}
+
+- (void)componentDidMount {
+    _isFirstLaunch = true;
+    [self applyProps:_props oldProps:_props forceUpdate:_isFirstLaunch];
+}
+- (void)componentDidUpdate {}
+- (void)componentWillUnmount {
+    [_cameraViewController removeFromParentViewController];
+    _cameraViewController = NULL;
+}
+- (void)orientationChanged {}
+
+// MARK: - SBSDKBarcodeScannerViewControllerDelegate
+
+- (void)barcodeScannerController:(SBSDKBarcodeScannerViewController *)controller
+               didDetectBarcodes:(NSArray<SBSDKBarcodeScannerResult *> *)codes
+                         onImage:(nonnull UIImage *)image {
+    
+    [self sendScanResults:codes onImage:image];
+}
+
+- (BOOL)barcodeScannerControllerShouldDetectBarcodes:(SBSDKBarcodeScannerViewController *)controller {
+    return true;
+}
+
+- (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];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> RTNScanbotBarcodeCameraViewCls(void)
+{
+  return RTNScanbotBarcodeCameraView.class;
+}
+
+#endif // ifdef RCT_NEW_ARCH_ENABLED
+

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

@@ -0,0 +1,71 @@
+//
+//  RNScanbotBarcodeCameraViewManager.mm
+//  RNScanbotBarcodeSDK
+//
+//  Created by Marco Saia on 28.08.23.
+//
+
+// We use this compilation pragma to expose this implementation for the NEW ARCHITECTURE only
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+#import <Foundation/Foundation.h>
+#import "RTNScanbotBarcodeCameraView.h"
+
+typedef void (^NativeViewBlock)(RTNScanbotBarcodeCameraView* _Nonnull);
+
+@interface RTNScanbotBarcodeCameraViewManager : RCTViewManager
+@end
+
+@implementation RTNScanbotBarcodeCameraViewManager
+
+RCT_EXPORT_MODULE(RTNScanbotBarcodeCameraView)
+RCT_EXPORT_VIEW_PROPERTY(configuration, NSDictionary*)
+RCT_EXPORT_VIEW_PROPERTY(onNativeBarcodeScannerResult, RCTDirectEventBlock);
+
+// componentDidMount
+RCT_EXPORT_METHOD(componentDidMount:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RTNScanbotBarcodeCameraView* nativeView) {
+        [nativeView componentDidMount];
+    }];
+}
+
+// componentDidUpdate
+RCT_EXPORT_METHOD(componentDidUpdate:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RTNScanbotBarcodeCameraView* nativeView) {
+        [nativeView componentDidUpdate];
+    }];
+}
+
+// componentWillUnmount
+RCT_EXPORT_METHOD(componentWillUnmount:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RTNScanbotBarcodeCameraView* nativeView) {
+        [nativeView componentWillUnmount];
+    }];
+}
+
+// orientationChanged
+RCT_EXPORT_METHOD(orientationChanged:(nonnull NSNumber*) reactTag) {
+    [self callNativeMethodWithReactTag: reactTag andBlock: ^void (RTNScanbotBarcodeCameraView* nativeView) {
+        [nativeView orientationChanged];
+    }];
+}
+
+- (void) callNativeMethodWithReactTag:(nonnull NSNumber*) reactTag andBlock:(NativeViewBlock)block {
+    [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+        RTNScanbotBarcodeCameraView* view = (RTNScanbotBarcodeCameraView*) viewRegistry[reactTag];
+        if (!view || ![view isKindOfClass:[RTNScanbotBarcodeCameraView class]]) {
+            RCTLogError(@"Cannot find native view with tag #%@", reactTag);
+            return;
+        }
+        block(view);
+    }];
+}
+
+@end
+
+
+
+#endif

package/ios/Components/BarcodeCameraView/{RNScanbotBarcodeCameraView.h → OldArchitecture/RNScanbotBarcodeCameraView.h}

@@ -1,10 +1,13 @@
 //
-//  RNScanbotCameraView.h
+//  RNScanbotBarcodeCameraView.h
 //  RNScanbotSDK
 //
 //  Created by Marco Saia on 18.05.21.
 //
 
+// We use this compilation pragma to expose this implementation for the OLD ARCHITECTURE only
+#ifndef RCT_NEW_ARCH_ENABLED
+
 #ifndef RNScanbotCameraView_h
 #define RNScanbotCameraView_h
 
@@ -15,7 +18,7 @@
 
 @property SBSDKBarcodeScannerViewController* _Nullable cameraViewController;
 @property NSMutableArray* _Nonnull barcodes;
-@property (nonatomic, copy) RCTBubblingEventBlock _Nullable onBarcodeScannerResult;
+@property (nonatomic, copy) RCTBubblingEventBlock _Nullable onNativeBarcodeScannerResult;
 @property (nonatomic, copy) RCTBubblingEventBlock _Nullable requestComponentReload;
 @property (nonatomic) BOOL shouldUseFinderView;
 @property (nonatomic, copy) NSDictionary* _Nullable configuration;
@@ -58,3 +61,5 @@
 @end
 
 #endif /* RNScanbotCameraView_h */
+
+#endif // ifndef RCT_NEW_ARCH_ENABLED

package/ios/Components/BarcodeCameraView/{RNScanbotBarcodeCameraView.m → OldArchitecture/RNScanbotBarcodeCameraView.m}

@@ -5,6 +5,9 @@
 //  Created by Marco Saia on 18.05.21.
 //
 
+// We use this compilation pragma to expose this implementation for the OLD ARCHITECTURE only
+#ifndef RCT_NEW_ARCH_ENABLED
+
 #import "RNScanbotBarcodeCameraView.h"
 #import "ObjectMapper.h"
 #import "BarcodeMapping.h"
@@ -70,7 +73,7 @@
     }
     
     if ([config objectForKey:@"barcodeFilter"]) {
-        cameraViewConfiguration.barcodeFilter = extractBarcodeFilter(config);
+        cameraViewConfiguration.barcodeFilter = extractBarcodeFilterFromConfiguration(config);
         [config removeObjectForKey:@"barcodeFilter"];
     }
     
@@ -82,8 +85,8 @@
         }
         
         // We also need to manually extract the MSI-Plessey Checksum Algorithm since it can't be mapped automatically
-        cameraViewConfiguration.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
-        cameraViewConfiguration.codeDensity = extractBarcodeDensity(config);
+        cameraViewConfiguration.msiPlesseyChecksumAlgorithm = extractMsiPlesseyChecksumAlgorithmFromConfiguration(configuration);
+        cameraViewConfiguration.codeDensity = extractBarcodeDensityFromConfiguration(config);
         cameraViewConfiguration.finderInset = [self populateFinderInset:config];
         
         self.shouldUseFinderView = [[config objectForKey:@"shouldUseFinderView"] boolValue];
@@ -193,7 +196,7 @@
 }
 
 - (void)sendScanResults:(NSArray<SBSDKBarcodeScannerResult*>*) results onImage:(UIImage*)image {
-    if(!self.onBarcodeScannerResult) {
+    if(!self.onNativeBarcodeScannerResult) {
         return;
     }
     
@@ -212,7 +215,7 @@
         }
     };
     
-    self.onBarcodeScannerResult(outResult);
+    self.onNativeBarcodeScannerResult(outResult);
 }
 
 // MARK: - React Native Lifecycle
@@ -282,3 +285,6 @@
 }
 
 @end
+
+#endif // ifndef RCT_NEW_ARCH_ENABLED
+

package/ios/Components/BarcodeCameraView/{RNScanbotBarcodeCameraViewManager.h → OldArchitecture/RNScanbotBarcodeCameraViewManager.h}

@@ -1,10 +1,13 @@
 //
-//  RNScanbotClassicComponents.h
+//  RNScanbotBarcodeCameraViewManager.h
 //  Pods
 //
 //  Created by Marco Saia on 17.05.21.
 //
 
+// We use this compilation pragma to expose this implementation for the OLD ARCHITECTURE only
+#ifndef RCT_NEW_ARCH_ENABLED
+
 #ifndef RNScanbotClassicComponents_h
 #define RNScanbotClassicComponents_h
 
@@ -20,3 +23,5 @@ typedef void (^NativeViewBlock)(RNScanbotBarcodeCameraView* _Nonnull);
 @end
 
 #endif /* RNScanbotClassicComponents_h */
+
+#endif // ifndef RCT_NEW_ARCH_ENABLED

package/ios/Components/BarcodeCameraView/{RNScanbotBarcodeCameraViewManager.m → OldArchitecture/RNScanbotBarcodeCameraViewManager.m}

@@ -1,10 +1,13 @@
 //
-//  RNScanbotClassicComponents.m
+//  RNScanbotBarcodeCameraViewManager.m
 //  RNScanbotSDK
 //
 //  Created by Marco Saia on 17.05.21.
 //
 
+// We use this compilation pragma to expose this implementation for the OLD ARCHITECTURE only
+#ifndef RCT_NEW_ARCH_ENABLED
+
 #import <Foundation/Foundation.h>
 #import "RNScanbotBarcodeCameraViewManager.h"
 #import "RNScanbotBarcodeCameraView.h"
@@ -16,9 +19,9 @@
 
 @implementation RNScanbotBarcodeCameraViewManager
 
-RCT_EXPORT_MODULE(ScanbotBarcodeCameraView)
+RCT_EXPORT_MODULE(RTNScanbotBarcodeCameraView)
 
-RCT_EXPORT_VIEW_PROPERTY(onBarcodeScannerResult, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onNativeBarcodeScannerResult, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(requestComponentReload, RCTBubblingEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(shouldUseFinderView, BOOL)
 RCT_EXPORT_VIEW_PROPERTY(configuration, NSDictionary*)
@@ -69,3 +72,5 @@ RCT_EXPORT_METHOD(orientationChanged:(nonnull NSNumber*) reactTag) {
 }
 
 @end
+
+#endif // ifndef RCT_NEW_ARCH_ENABLED

package/ios/ScanbotBarcodeSdk.h

@@ -5,7 +5,7 @@
 //  https://scanbot.io/sdk
 //
 #import <React/RCTBridgeModule.h>
-@import ScanbotBarcodeScannerSDK;
+#import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
 
 @interface ScanbotBarcodeSdk : NSObject <RCTBridgeModule>
 

package/ios/ScanbotBarcodeSdk.m

@@ -136,7 +136,7 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
     }
     
     // Barcode Filter (at the moment used for UPC Extension filters)
-    SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
+    SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilterFromConfiguration(configuration);
     if (barcodeFilter != nil) {
         behaviorConfig.barcodeFilter = barcodeFilter;
     }
@@ -144,7 +144,7 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
     behaviorConfig.additionalParameters = extractAdditionalParameters(configuration);
     behaviorConfig.acceptedDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
     behaviorConfig.acceptedMachineCodeTypes = extractBarcodeTypesFromConfiguration(configuration);
-    behaviorConfig.engineMode = extractEngineMode(configuration);
+    behaviorConfig.engineMode = extractEngineModeFromConfiguration(configuration);
     
     uiConfig.orientationLockMode = [ObjectMapper extractOrientationLockMode:configuration];
     
@@ -194,7 +194,7 @@ RCT_EXPORT_METHOD(startBatchBarcodeScanner:(NSDictionary*)configuration
     }
         
     // Barcode Filter (at the moment used for UPC Extension filters)
-    SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
+    SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilterFromConfiguration(configuration);
     if (barcodeFilter != nil) {
         behaviorConfig.barcodeFilter = barcodeFilter;
     }
@@ -202,7 +202,7 @@ RCT_EXPORT_METHOD(startBatchBarcodeScanner:(NSDictionary*)configuration
     behaviorConfig.additionalDetectionParameters = extractAdditionalParameters(configuration);
     behaviorConfig.acceptedDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);;
     behaviorConfig.acceptedMachineCodeTypes = extractBarcodeTypesFromConfiguration(configuration);
-    behaviorConfig.engineMode = extractEngineMode(configuration);
+    behaviorConfig.engineMode = extractEngineModeFromConfiguration(configuration);
     
     uiConfig.orientationLockMode = [ObjectMapper extractOrientationLockMode:configuration];
 
@@ -253,7 +253,7 @@ RCT_EXPORT_METHOD(detectBarcodesOnImage:(NSDictionary *)configuration
         NSArray* barcodeDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
         [barcodeScanner setAcceptedDocumentTypes: barcodeDocumentTypes];
         
-        SBSDKBarcodeEngineMode engineMode = extractEngineMode(configuration);
+        SBSDKBarcodeEngineMode engineMode = extractEngineModeFromConfiguration(configuration);
         [barcodeScanner setEngineMode:engineMode];
         
         SBSDKBarcodeAdditionalParameters* additionalParameters = extractAdditionalParameters(configuration);
@@ -267,7 +267,7 @@ RCT_EXPORT_METHOD(detectBarcodesOnImage:(NSDictionary *)configuration
         NSArray<SBSDKBarcodeScannerResult *> *barcodeResults = [barcodeScanner detectBarCodesOnImage:image];
         
         if (barcodeResults) {
-            SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
+            SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilterFromConfiguration(configuration);
             if (barcodeFilter != nil) {
                 barcodeResults = filterBarcodeResults(barcodeResults, barcodeFilter);
             }

package/ios/Utils/BarcodeMapping.h

@@ -9,7 +9,7 @@
 #import "UIColor+JSON.h"
 #include "ScanbotStorageUtils.h"
 #include "ReactBarcodeExtensionsFilter.h"
-@import ScanbotBarcodeScannerSDK;
+#import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
 
 static inline SBSDKBarcodeType* barcodeTypeFromString(NSString* string) {
     if ([string isEqualToString:@"AZTEC"]) return SBSDKBarcodeTypeAztec;
@@ -101,9 +101,7 @@ static inline NSArray<NSDictionary<NSString*, NSObject*>*>* jsonFromMappedBarcod
     return [jsonResults copy];
 }
 
-static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgorithmFromConfiguration(NSDictionary* configuration) {
-    NSString* algorithm = [configuration objectForKey:@"msiPlesseyChecksumAlgorithm"];
-    
+static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractMsiPlesseyChecksumAlgorithm(NSString* algorithm) {
     if (algorithm != nil) {
         if ([algorithm isEqualToString:@"None"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmNone;
         if ([algorithm isEqualToString:@"Mod10"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
@@ -113,27 +111,35 @@ static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgo
         if ([algorithm isEqualToString:@"Mod1110IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110IBM;
         if ([algorithm isEqualToString:@"Mod1110NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110NCR;
     }
-    
+
     return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
 }
 
-static inline SBSDKUIBarcodeFilter* extractBarcodeFilter(NSDictionary* configuration) {
-    NSString* jsonFilterType = [configuration objectForKey:@"barcodeFilter"];
-    if (jsonFilterType == nil) {
-        return nil;
-    }
-    
-    if ([jsonFilterType isEqualToString:@"WithExtension"]) {
+static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractMsiPlesseyChecksumAlgorithmFromConfiguration(NSDictionary* configuration) {
+    return extractMsiPlesseyChecksumAlgorithm((NSString*)[configuration objectForKey:@"msiPlesseyChecksumAlgorithm"]);
+}
+
+static inline SBSDKUIBarcodeFilter* extractBarcodeFilter(NSString* barcodeFilter) {
+    if ([barcodeFilter isEqualToString:@"WithExtension"]) {
         return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithExtension];
-    } else if ([jsonFilterType isEqualToString:@"WithEAN2Extension"]) {
+    } else if ([barcodeFilter isEqualToString:@"WithEAN2Extension"]) {
         return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithEAN2Extension];
-    } else if ([jsonFilterType isEqualToString:@"WithEAN5Extension"]) {
+    } else if ([barcodeFilter isEqualToString:@"WithEAN5Extension"]) {
         return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithEAN5Extension];
     }
     
     return nil;
 }
 
+static inline SBSDKUIBarcodeFilter* extractBarcodeFilterFromConfiguration(NSDictionary* configuration) {
+    NSString* jsonFilterType = [configuration objectForKey:@"barcodeFilter"];
+    if (jsonFilterType == nil) {
+        return nil;
+    }
+    
+    return extractBarcodeFilter(jsonFilterType);
+}
+
 static inline NSArray* filterBarcodeResults(NSArray<SBSDKBarcodeScannerResult *>* barcodeResults, SBSDKUIBarcodeFilter* filter) {
     NSMutableArray<SBSDKBarcodeScannerResult *>* outResults = [[NSMutableArray alloc] init];
     
@@ -181,29 +187,30 @@ static inline NSArray* extractBarcodeDocumentTypesFromConfiguration(NSDictionary
     return nil;
 }
 
-static inline SBSDKBarcodeDensity extractBarcodeDensity(NSDictionary* configuration) {
-    SBSDKBarcodeDensity barcodeDensity = SBSDKBarcodeDensityLow;
-    
-    NSString* codeDensity = [configuration objectForKey:@"codeDensity"];
-    if (codeDensity != nil) {
-        if([codeDensity isEqualToString:@"HIGH"]) {
-            barcodeDensity = SBSDKBarcodeDensityHigh;
-        }
+static inline SBSDKBarcodeDensity extractBarcodeDensity(NSString* value) {
+    if (value != nil && [value isEqualToString:@"HIGH"]) {
+        return SBSDKBarcodeDensityHigh;
     }
-    
-    return barcodeDensity;
+
+    return SBSDKBarcodeDensityLow;
 }
 
-static inline SBSDKBarcodeEngineMode extractEngineMode(NSDictionary* configuration) {
-    NSString* mode = [configuration objectForKey:@"engineMode"];
-    
-    if (mode && [@"LEGACY" isEqualToString:mode]) {
+static inline SBSDKBarcodeDensity extractBarcodeDensityFromConfiguration(NSDictionary* configuration) {
+    return extractBarcodeDensity((NSString*)[configuration objectForKey:@"codeDensity"]);
+}
+
+static inline SBSDKBarcodeEngineMode extractEngineMode(NSString* value) {
+    if (value && [@"LEGACY" isEqualToString:value]) {
         return SBSDKBarcodeEngineModeLegacy;
     }
     
     return SBSDKBarcodeEngineModeNextGen;
 }
 
+static inline SBSDKBarcodeEngineMode extractEngineModeFromConfiguration(NSDictionary* configuration) {
+    return extractEngineMode((NSString*)[configuration objectForKey:@"engineMode"]);
+}
+
 static inline SBSDKBarcodeAdditionalParameters* extractAdditionalParameters(NSDictionary* configuration) {
     SBSDKBarcodeAdditionalParameters* additionalParameters = [[SBSDKBarcodeAdditionalParameters alloc] init];
     @try {
@@ -221,9 +228,9 @@ static inline SBSDKBarcodeAdditionalParameters* extractAdditionalParameters(NSDi
     }
     
     // We also need to manually extract the MSI-Plessey Checksum Algorithm since it can't be mapped automatically
-    additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
+    additionalParameters.msiPlesseyChecksumAlgorithm = extractMsiPlesseyChecksumAlgorithmFromConfiguration(configuration);
     
-    additionalParameters.codeDensity = extractBarcodeDensity(configuration);
+    additionalParameters.codeDensity = extractBarcodeDensityFromConfiguration(configuration);
     
     return additionalParameters;
 }

package/ios/Utils/ReactBarcodeExtensionsFilter.h

@@ -6,7 +6,7 @@
 //
 
 #import <Foundation/Foundation.h>
-@import ScanbotBarcodeScannerSDK;
+#import <ScanbotBarcodeScannerSDK/ScanbotBarcodeScannerSDK.h>
 
 typedef enum BarcodeFilterType : NSUInteger {
     ReactBarcodeExtensionsFilterWithExtension,

package/js/RTNScanbotBarcodeCameraViewNativeComponent.tsx

@@ -1,9 +1,34 @@
 import { ComponentType } from 'react';
 import type {HostComponent, ViewProps} from 'react-native';
-import { DirectEventHandler, Float, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
+import { BubblingEventHandler, DirectEventHandler, Float, Int32 } from 'react-native/Libraries/Types/CodegenTypes';
 import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
 import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
 
+export interface NativeBarcodeResult {
+  status: string;
+  barcodes: Readonly<{
+    /*
+    * The barcode format.
+    */
+    type: string;
+
+    /**
+      * The raw text encoded in the barcode.
+      */
+    text: string;
+
+    /**
+      * The raw text encoded in the barcode that also includes the extension, if detected
+      */
+    textWithExtension: string;
+
+    /**
+     * The array of raw bytes contained in the barcode.
+     */
+    rawBytes: Int32[]; 
+  }[]>;
+}
+
 export interface NativeProps extends ViewProps {
   configuration?: ScanbotBarcodeCameraViewConfiguration;
   // Lifecycle methods
@@ -11,6 +36,7 @@ export interface NativeProps extends ViewProps {
   onComponentDidMount: DirectEventHandler<Readonly<{}>>;
   onComponentWillUnmount: DirectEventHandler<Readonly<{}>>;
   onOrientationChanged: DirectEventHandler<Readonly<{}>>;
+  onNativeBarcodeScannerResult: BubblingEventHandler<Readonly<{jsonResult: string}>>;
 }
 
 export default codegenNativeComponent<NativeProps>(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-scanbot-barcode-scanner-sdk",
   "title": "Scanbot Barcode Scanner SDK for React Native",
-  "version": "3.6.1-alpha.1",
+  "version": "3.6.1-alpha.2",
   "scanbot": {
     "iosVersion": "3.6.0"
   },
@@ -71,11 +71,11 @@
   ],
   "react-native": "index",
   "codegenConfig": {
-    "name": "RTNScanbotBarcodeSdkSpec",
-    "type": "modules",
+    "name": "RTNScanbotBarcodeCameraViewSpecs",
+    "type": "components",
     "jsSrcsDir": "js",
     "android": {
       "javaPackageName": "io.scanbot.barcodesdk.plugin.reactnative"
     }
-}
+  }
 }

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

@@ -12,10 +12,17 @@ import { BarcodeAdditionalParameters } from '../../configuration';
 
 export interface ScanbotBarcodeCameraViewProperties {
   onBarcodeScannerResult?: (result: BarcodeResult) => void;
+  configuration?: ScanbotBarcodeCameraViewConfiguration;
+  style: StyleProp<ViewStyle>;
+  children?: React.ReactNode;
+}
+
+export interface ScanbotBarcodeCameraNativeViewProperties {
+  onNativeBarcodeScannerResult?: (result: BarcodeResult) => void;
   requestComponentReload?: () => void;
   configuration?: ScanbotBarcodeCameraViewConfiguration;
   style: StyleProp<ViewStyle>;
-  children: React.ReactNode;
+  children?: React.ReactNode;
 }
 
 export interface ScanbotBarcodeCameraViewBarcode {

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

@@ -1,8 +1,9 @@
 import React from 'react';
 import { EmitterSubscription, findNodeHandle, NativeMethods, Platform, UIManager } from 'react-native';
 import { Dimensions } from 'react-native';
-import { ScanbotBarcodeCameraViewProperties } from './scanbot-barcode-camera-view-types';
+import { ScanbotBarcodeCameraNativeViewProperties, ScanbotBarcodeCameraViewConfiguration, ScanbotBarcodeCameraViewProperties } from './scanbot-barcode-camera-view-types';
 import ScanbotNativeBarcodeCameraView, { Commands } from './scanbot-native-barcode-camera-view';
+import { BarcodeResult } from 'react-native-scanbot-barcode-scanner-sdk/src/result';
 
 const Device = {
   isPortrait: () => {
@@ -23,7 +24,7 @@ type Properties = ScanbotBarcodeCameraViewProperties;
 export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
 
   // Camera View Reference
-  cameraViewReference: React.RefObject<React.Component<ScanbotBarcodeCameraViewProperties> & Readonly<NativeMethods>>
+  cameraViewReference: React.RefObject<React.Component<ScanbotBarcodeCameraNativeViewProperties> & Readonly<NativeMethods>>
 
   // String length of auto-generated component key
   static UNIQUE_VIEW_KEY_LENGTH = 6;
@@ -93,13 +94,30 @@ export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
     });
   };
 
+  receiveEvent(event: any) {}
+
   // Maps the native bridge callback event from the Barcode Scanner
   _onBarcodeScannerResult = (event: any) => {
     if (!this.props.onBarcodeScannerResult) {
       return;
     }
 
-    this.props.onBarcodeScannerResult(event.nativeEvent.result);
+    let outResult: BarcodeResult | undefined = undefined;
+    if (Platform.OS === 'ios') {
+      // The new-architecture Fabric Component callback returns a JSON string as a result
+      if (event.nativeEvent.jsonResult) {
+        outResult = JSON.parse(event.nativeEvent.jsonResult)?.result;
+      } else {
+        // Support for the old architecture
+        outResult = event.nativeEvent.result;
+      }
+    } else {
+      outResult = event.nativeEvent.result;
+    }
+
+    if (outResult) {
+      this.props.onBarcodeScannerResult(outResult);
+    }
   };
 
   render() {
@@ -115,7 +133,7 @@ export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
         style={style}
         key={this.cameraKey}
         ref={this.cameraViewReference}
-        onBarcodeScannerResult={this._onBarcodeScannerResult}
+        onNativeBarcodeScannerResult={this._onBarcodeScannerResult}
       />
     );
   }
@@ -170,10 +188,28 @@ export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
     return newStyle;
   };
 
+  sanitizeNumbers = (obj: ScanbotBarcodeCameraViewConfiguration) => {
+    const outObj = {...obj};
+    outObj.cameraZoomFactor = obj.cameraZoomFactor ?? -1;
+    outObj.finderAspectRatio = obj.finderAspectRatio ?? { width: -1, height: -1 };
+    outObj.finderBackgroundOpacity = obj.finderBackgroundOpacity ?? -1;
+    outObj.finderInset = obj.finderInset ?? { left: -1, top: -1, right: -1, bottom: -1};
+    outObj.finderLineWidth = obj.finderLineWidth ?? -1;
+    outObj.maximumTextLength = obj.maximumTextLength ?? -1;
+    outObj.minimumTextLength = obj.minimumTextLength ?? -1;
+    outObj.minimum1DBarcodesQuietZone = obj.minimum1DBarcodesQuietZone ?? -1;
+    return outObj;
+  }
+
   preprocessProps = () => {
     const props = { ...this.props };
     delete props.style;
 
+    const config = props.configuration;
+    if (config != undefined && config != null) {
+      props.configuration = this.sanitizeNumbers(config as any);
+    }
+    
     return props;
   };
 
@@ -216,16 +252,9 @@ export class ScanbotBarcodeCameraView extends React.Component<Properties, {}> {
   }
 
   sendCommandToViewId = (viewId: number, command: string, args: any = []) => {
-    let commandId: number
-    if (Platform.OS == 'android') {
-      const cameraView = this.cameraViewReference?.current;
-      if (cameraView) {
-        Commands[command](cameraView);
-      }      
-      return;
-    } else {
-      commandId = UIManager.getViewManagerConfig('ScanbotBarcodeCameraView').Commands[command];
-    }
-    UIManager.dispatchViewManagerCommand(viewId, commandId, args);
+    const cameraView = this.cameraViewReference?.current;
+    if (cameraView) {
+      Commands[command](cameraView);
+    }          
   }
 }

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

@@ -1,8 +1,8 @@
 import { HostComponent } from "react-native";
-import { ScanbotBarcodeCameraViewProperties } from "./scanbot-barcode-camera-view-types";
+import { ScanbotBarcodeCameraNativeViewProperties } from "./scanbot-barcode-camera-view-types";
 
 const nativeBarcodeCameraView = require('../../../js/RTNScanbotBarcodeCameraViewNativeComponent').default;
 const nativeBarcodeCameraViewCommands = require('../../../js/RTNScanbotBarcodeCameraViewNativeComponent').Commands;
 
-export default (nativeBarcodeCameraView as HostComponent<ScanbotBarcodeCameraViewProperties>);
+export default (nativeBarcodeCameraView as HostComponent<ScanbotBarcodeCameraNativeViewProperties>);
 export const Commands = nativeBarcodeCameraViewCommands;