react-native-scanbot-barcode-scanner-sdk 3.7.0 → 3.7.1-beta.2

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

@@ -0,0 +1,127 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.facebook.react.viewmanagers.RTNScanbotBarcodeCameraViewManagerInterface;
+
+import java.util.Map;
+
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.ScanbotEventEmitter;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.ScanbotEventEmitter.NativeEvent;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.ScanbotEventReceiver;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.ScanbotEventReceiver.CommonEvents;
+
+@ReactModule(name = ScanbotBarcodeCameraViewManager.NAME)
+public class ScanbotBarcodeCameraViewManager
+        extends ViewGroupManager<ScanbotBarcodeCameraView>
+        implements RTNScanbotBarcodeCameraViewManagerInterface<ScanbotBarcodeCameraView>, ScanbotEventReceiver.IEventHandler
+{
+    static final String NAME = "RTNScanbotBarcodeCameraView";
+    @NonNull @Override public String getName() { return NAME; }
+
+    private ScanbotBarcodeCameraView barcodeCameraView;
+    private final ScanbotEventReceiver eventReceiver;
+    private boolean shouldRefreshConfig = false;
+
+    public ScanbotBarcodeCameraViewManager() {
+        super();
+        this.eventReceiver = new ScanbotEventReceiver(this, new ScanbotEventReceiver.JavaScriptEvent[] {});
+    }
+
+    @NonNull
+    @Override
+    protected ScanbotBarcodeCameraView createViewInstance(@NonNull ThemedReactContext context) {
+        this.barcodeCameraView = new ScanbotBarcodeCameraView(context);
+        return this.barcodeCameraView;
+    }
+
+    /*-----------------------*
+    *   Component Lifecycle
+    *------------------------*/
+    @Override
+    public void componentDidUpdate(ScanbotBarcodeCameraView view) {
+        if (shouldRefreshConfig) {
+            this.barcodeCameraView.refreshConfiguration();
+            shouldRefreshConfig = false;
+        }
+    }
+    @Override
+    public void orientationChanged(ScanbotBarcodeCameraView view) {
+        shouldRefreshConfig = true;
+    }
+
+    @Override
+    public void componentDidMount(ScanbotBarcodeCameraView view) {
+    }
+
+    @Override
+    public void componentWillUnmount(ScanbotBarcodeCameraView view) {
+    }
+
+    /*-----------------------*
+    *     Events Handling
+    *------------------------*/
+    @Override
+    public void receiveCommand(@NonNull ScanbotBarcodeCameraView root, String commandId, @Nullable ReadableArray args) {
+        super.receiveCommand(root, commandId, args);
+        eventReceiver.receiveCommand(commandId, args);
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        final NativeEvent[] commonEvents = ScanbotEventEmitter.CommonEvents.values();
+        final NativeEvent[] customEvents = ScanbotBarcodeCameraView.getNativeEvents();
+        final NativeEvent[] allEvents = ScanbotEventEmitter.concatEvents(commonEvents, customEvents);
+        return ScanbotEventEmitter.getMapForNativeEvents(allEvents);
+    }
+
+    @Override
+    public void eventHandler_eventReceived(ScanbotEventReceiver.JavaScriptEvent event, @Nullable ReadableArray args) {
+        CommonEvents commonEvent = eventReceiver.getCommonEventFromName(event.getName());
+        if (commonEvent == null) {
+            return;
+        }
+        this.handleCommonEvent(commonEvent, args);
+    }
+
+    private void handleCommonEvent(CommonEvents commonEvent, @Nullable ReadableArray ignoredArgs) {
+        switch (commonEvent) {
+            case COMPONENT_DID_UPDATE:
+                componentDidUpdate(null);
+                break;
+            case COMPONENT_DID_MOUNT:
+                componentDidMount(null);
+                break;
+            case COMPONENT_WILL_UNMOUNT:
+                componentWillUnmount(null);
+                break;
+            case ORIENTATION_CHANGED:
+                orientationChanged(null);
+                break;
+        }
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return eventReceiver.getCommandsMap();
+    }
+
+    @Override
+    @ReactProp(name = "configuration")
+    public void setConfiguration(ScanbotBarcodeCameraView view, @Nullable ReadableMap value) {
+        if (barcodeCameraView == null) { return; }
+        if (value == null) { return; }
+        barcodeCameraView.applyConfiguration(value);
+    }
+}

package/android/src/{main/java → old-architecture}/io/scanbot/barcodesdk/plugin/reactnative/components/barcodecameraview/ScanbotBarcodeCameraViewManager.java

@@ -19,7 +19,7 @@ import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.Sc
 import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.ScanbotEventReceiver.CommonEvents;
 
 public class ScanbotBarcodeCameraViewManager extends ViewGroupManager<ScanbotBarcodeCameraView> implements ScanbotEventReceiver.IEventHandler {
-    private static final String TAG = "ScanbotBarcodeCameraView";
+    private static final String TAG = "RTNScanbotBarcodeCameraView";
     @NonNull @Override public String getName() { return TAG; }
 
     private ScanbotBarcodeCameraView barcodeCameraView;

package/index.js

@@ -1,6 +1,6 @@
 /*
   Scanbot Barcode Scanner SDK React Native Plugin
-  Copyright (c) 2020 doo GmbH. All rights reserved.
+  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
   https://scanbot.io/sdk
  */
 import { NativeModules } from 'react-native';

package/ios/Categories/SBSDKPolygon+JSON.h

@@ -1,7 +1,7 @@
 //
 //  Scanbot Barcode Scanner SDK React Native Plugin
 //
-//  Copyright (c) 2020 doo GmbH. All rights reserved.
+//  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
 //  https://scanbot.io/sdk
 //
 

package/ios/Categories/SBSDKPolygon+JSON.m

@@ -1,7 +1,7 @@
 //
 //  Scanbot Barcode Scanner SDK React Native Plugin
 //
-//  Copyright (c) 2020 doo GmbH. All rights reserved.
+//  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
 //  https://scanbot.io/sdk
 //
 #import "SBSDKPolygon+JSON.h"

package/ios/Categories/UIColor+JSON.h

@@ -1,7 +1,7 @@
 //
 //  Scanbot Barcode Scanner SDK React Native Plugin
 //
-//  Copyright (c) 2020 doo GmbH. All rights reserved.
+//  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
 //  https://scanbot.io/sdk
 //
 

package/ios/Categories/UIColor+JSON.m

@@ -1,7 +1,7 @@
 //
 //  Scanbot Barcode Scanner SDK React Native Plugin
 //
-//  Copyright (c) 2020 doo GmbH. All rights reserved.
+//  Copyright (c) 2023 Scanbot SDK GmbH. All rights reserved.
 //  https://scanbot.io/sdk
 //
 

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

@@ -0,0 +1,45 @@
+//
+//  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