react-native-scanbot-barcode-scanner-sdk 3.2.1-beta8 → 3.2.1-beta9

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

@@ -0,0 +1,292 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.view.View;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeArray;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.scanbot.sdk.SdkLicenseError;
+import io.scanbot.sdk.barcode.BarcodeDetectorFrameHandler;
+import io.scanbot.sdk.barcode.DefaultScanbotBarcodeDetector;
+import io.scanbot.sdk.barcode.ScanbotBarcodeDetector;
+import io.scanbot.sdk.barcode.entity.BarcodeItem;
+import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfig;
+import io.scanbot.sdk.barcode.entity.BarcodeScanningResult;
+import io.scanbot.sdk.camera.FrameHandlerResult;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventEmitter;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventReceiver;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.RNScanbotNativeComponent;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.RNScanbotNativeComponentUi;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.views.RNScanbotNativeComponentRootView;
+import io.scanbot.sdk.ui.camera.FinderOverlayView;
+import io.scanbot.sdk.ui.camera.ScanbotCameraXView;
+import kotlin.Unit;
+
+/*
+ * The core logic of the ScanbotBarcodeCameraView Component
+ */
+public class RNScanbotBarcodeCameraComponent extends RNScanbotNativeComponent implements BarcodeDetectorFrameHandler.ResultHandler {
+
+    private static final int REQUEST_PERMISSION_CODE = 200;
+
+    // From Java to JavaScript
+    public enum NativeEvents implements RNScanbotEventEmitter.NativeEvent {
+        BARCODE_SCANNER_RESULT("onBarcodeScannerResult");
+
+        private final String name;
+        NativeEvents(final String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    // UI
+    private RNScanbotBarcodeCameraUi barcodeCameraUi;
+    private ScanbotBarcodeDetector barcodeDetector;
+    private BarcodeDetectorFrameHandler frameHandler;
+
+    // Communication
+    private RNScanbotEventEmitter eventEmitter;
+
+    // Configuration
+    private RNScanbotBarcodeCameraConfiguration configuration = new RNScanbotBarcodeCameraConfiguration();
+    private float userDefinedCameraZoomFactor = -1;
+
+    // Dependencies
+    private final ReactContext reactContext;
+
+    // State handling
+    private boolean isInitialized = false;
+
+    public RNScanbotBarcodeCameraComponent(@NonNull final ReactContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+        this.barcodeCameraUi = new RNScanbotBarcodeCameraUi(reactContext);
+    }
+
+    // ---------------------
+    //  Component Lifecycle
+    // ---------------------
+    @Override
+    public void onComponentWillUnmount() {
+        super.onComponentWillUnmount();
+        final ScanbotCameraXView cameraView = this.barcodeCameraUi.getCameraView();
+        cameraView.stopPreview();
+    }
+
+    @Override
+    public void onOrientationChanged() {
+        super.onOrientationChanged();
+    }
+    // ---------------------
+
+    @Override
+    public void initializeComponent() {
+        final ScanbotCameraXView cameraView = this.barcodeCameraUi.getCameraView();
+        cameraView.startPreview();
+
+        this.barcodeDetector = new DefaultScanbotBarcodeDetector();
+
+        this.frameHandler = BarcodeDetectorFrameHandler.attach(cameraView, barcodeDetector);
+        this.frameHandler.setDetectionInterval(0);
+        this.frameHandler.addResultHandler(this);
+
+        cameraView.addFrameHandler(frameHandler);
+        cameraView.setCameraOpenCallback(cameraView::continuousFocus);
+
+        cameraView.post(this::checkPermissions);
+
+        this.eventEmitter = new RNScanbotEventEmitter(this.reactContext, this.barcodeCameraUi.getRootView());
+
+        applyConfiguration();
+
+        reactContext.runOnUiQueueThread(() -> isInitialized = true);
+    }
+
+    private void applyConfiguration() {
+        reactContext.runOnUiQueueThread(() -> {
+            final FinderOverlayView finderOverlayView = barcodeCameraUi.getFinderOverlayView();
+            final ScanbotCameraXView cameraView = barcodeCameraUi.getCameraView();
+
+            finderOverlayView.setVisibility(configuration.shouldUseFinderView() ? View.VISIBLE : View.INVISIBLE);
+            finderOverlayView.setStrokeWidth(configuration.getFinderLineWidth());
+            finderOverlayView.setStrokeColor(configuration.getFinderLineColor());
+            finderOverlayView.setOverlayColor(colorWithAlpha(
+                    configuration.getFinderBackgroundColor(),
+                    configuration.getFinderBackgroundOpacity()));
+            finderOverlayView.setMinFinderPadding(configuration.getFinderMinimumPadding());
+            finderOverlayView.setVerticalOffset(configuration.getFinderVerticalOffset());
+            finderOverlayView.setRequiredAspectRatios(Collections.singletonList(configuration.getFinderAspectRatio()));
+            finderOverlayView.requestLayout();
+
+            cameraView.useFlash(configuration.isFlashEnabled());
+
+            if (configuration.getCameraZoomFactor() != -1) {
+                if (configuration.getCameraZoomFactor() != userDefinedCameraZoomFactor || userDefinedCameraZoomFactor == -1) {
+                    cameraView.setOpticalZoomLevel(configuration.getCameraZoomFactor());
+                    userDefinedCameraZoomFactor = configuration.getCameraZoomFactor();
+                }
+            }
+            barcodeDetector.modifyConfig(b -> {
+                if(!configuration.barcodeFormats.isEmpty()) {
+                    b.setBarcodeFormats(configuration.barcodeFormats);
+                }
+                if(!configuration.acceptedDocumentFormats.isEmpty()) {
+                    b.setAcceptedDocumentFormats(configuration.acceptedDocumentFormats);
+                }
+                b.setEngineMode(configuration.engineMode);
+
+                if(configuration.additionalConfiguration != null) {
+                    b.modifyAdditionalConfig(ab -> {
+                        final BarcodeScannerAdditionalConfig config = configuration.additionalConfiguration;
+                        ab.setMinimumTextLength(config.getMinimumTextLength());
+                        ab.setMaximumTextLength(config.getMaximumTextLength());
+                        ab.setMsiPlesseyChecksumAlgorithms(config.getMsiPlesseyChecksumAlgorithms());
+                        ab.setStripCheckDigits(config.getStripCheckDigits());
+                        ab.setGs1DecodingEnabled(config.getGs1DecodingEnabled());
+                        ab.setMinimum1DQuietZoneSize(config.getMinimum1DQuietZoneSize());
+                        return Unit.INSTANCE;
+                    });
+                }
+                return Unit.INSTANCE;
+            });
+        });
+
+    }
+
+    // Barcode Detector Frame Handler - Result Handler
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean handle(@NotNull FrameHandlerResult<? extends BarcodeScanningResult, ? extends SdkLicenseError> frameHandlerResult) {
+        if (frameHandlerResult instanceof FrameHandlerResult.Success) {
+            handleSuccess((FrameHandlerResult.Success<BarcodeScanningResult>) frameHandlerResult);
+        }
+        return false;
+    }
+
+    private void handleSuccess(final FrameHandlerResult.Success<BarcodeScanningResult> result) {
+        if (result == null || result.getValue() == null) {
+            return;
+        }
+
+        List<BarcodeItem> barcodeItems;
+        if (configuration.barcodeFilter != null) {
+            barcodeItems = JSONUtils.getBarcodeItemsFromItemListWithFilter(result.getValue().getBarcodeItems(), configuration.barcodeFilter);
+        } else {
+            barcodeItems = result.getValue().getBarcodeItems();
+        }
+
+        sendResult(barcodeItems);
+    }
+
+    private void sendResult(final List<BarcodeItem> barcodeItems) {
+        if (barcodeItems == null || barcodeItems.size() == 0) {
+            return;
+        }
+
+        final WritableArray barcodes = new WritableNativeArray();
+
+        for (BarcodeItem item: barcodeItems) {
+            final WritableMap barcode = new JSONUtils.WritableMapBuilder()
+                    .putString("text", item.getText())
+                    .putString("type", item.getBarcodeFormat().name())
+                    .putString("textWithExtension", item.getTextWithExtension())
+                    .build();
+            barcodes.pushMap(barcode);
+        }
+
+        final WritableMap result = new JSONUtils.WritableMapBuilder()
+                .putString("status", "OK")
+                .putArray("barcodes", barcodes)
+                .build();
+
+        final WritableMap data = new JSONUtils.WritableMapBuilder()
+                .putMap("result", result)
+                .build();
+
+        eventEmitter.emitEvent(NativeEvents.BARCODE_SCANNER_RESULT, data);
+    }
+
+    @Override
+    public RNScanbotNativeComponentUi createNativeComponentUi(@NonNull ReactContext reactContext) {
+        this.barcodeCameraUi = new RNScanbotBarcodeCameraUi(reactContext);
+        return this.barcodeCameraUi;
+    }
+
+    /*
+     * Creates the root view for the component
+     */
+    @Override
+    public RNScanbotNativeComponentRootView getRootView() { return this.barcodeCameraUi.getRootView(); }
+
+    /*
+    * Returns the list of native events
+    */
+    @Override
+    public RNScanbotEventEmitter.NativeEvent[] getNativeEvents() { return NativeEvents.values(); }
+
+    @Override
+    public RNScanbotEventReceiver.JavaScriptEvent[] getJavascriptEvents() {
+        return new RNScanbotEventReceiver.JavaScriptEvent[] {};
+    }
+
+    /*
+     * Applies the given configuration to the component (JSON Configuration)
+     */
+    @Override
+    public void applyConfiguration(@NonNull final ReadableMap configuration) {
+        applyConfiguration(RNScanbotBarcodeCameraConfiguration.fromJsonMap(configuration));
+    }
+
+    /*
+     * Applies the given configuration to the component (Native Configuration)
+     */
+    public void applyConfiguration(@NonNull final RNScanbotBarcodeCameraConfiguration configuration) {
+        this.configuration = configuration;
+        if (isInitialized) {
+            applyConfiguration();
+        }
+    }
+
+    private void checkPermissions() {
+        if (this.reactContext == null) { return; }
+        Activity activity = reactContext.getCurrentActivity();
+
+        if (activity != null && ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+            ActivityCompat.requestPermissions(activity, new String[] { Manifest.permission.CAMERA }, REQUEST_PERMISSION_CODE);
+        }
+    }
+
+    @ColorInt
+    public static int colorWithAlpha(@ColorInt int color, float factor) {
+        int alpha = Math.round(Color.alpha(color) * factor);
+        int red = Color.red(color);
+        int green = Color.green(color);
+        int blue = Color.blue(color);
+        return Color.argb(alpha, red, green, blue);
+    }
+
+}

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/components/barcodecameraview/{ScanbotBarcodeCameraViewConfiguration.java → RNScanbotBarcodeCameraConfiguration.java}

@@ -1,7 +1,11 @@
-package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;;
 
 import android.graphics.Color;
 
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReadableMap;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -9,19 +13,21 @@ import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat;
 import io.scanbot.sdk.barcode.entity.BarcodeFormat;
 import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfig;
 import io.scanbot.sdk.barcode.entity.EngineMode;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.ObjectMapper;
 import io.scanbot.sdk.ui.camera.FinderAspectRatio;
 import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeFilter;
 
 @SuppressWarnings("unused")
-public class ScanbotBarcodeCameraViewConfiguration {
-
+public class RNScanbotBarcodeCameraConfiguration {
+    // Manually mapped properties (must NOT have a getter and setter)
     public List<BarcodeFormat> barcodeFormats = new ArrayList<>();
     public List<BarcodeDocumentFormat> acceptedDocumentFormats = new ArrayList<>();
     public EngineMode engineMode;
     public BarcodeScannerAdditionalConfig additionalConfiguration;
     public BarcodeFilter barcodeFilter;
 
-    // Automatically mapped properties
+    // Automatically mapped properties (must have a getter and a setter with the same name)
     private boolean shouldUseFinderView = false;
     private int finderLineWidth = 1;
     private int finderLineColor = Color.WHITE;
@@ -112,4 +118,46 @@ public class ScanbotBarcodeCameraViewConfiguration {
     public FinderAspectRatio getFinderAspectRatio() {
         return finderAspectRatio;
     }
+
+    @NonNull
+    public static RNScanbotBarcodeCameraConfiguration fromJsonMap(ReadableMap jsonConfig) {
+        final RNScanbotBarcodeCameraConfiguration nativeConfig = new RNScanbotBarcodeCameraConfiguration();
+
+        // Automatic Mapping
+        try {
+            ObjectMapper.map(jsonConfig, nativeConfig);
+        } catch (Exception e) {
+            final String msg = "Unexpected ERROR while parsing the given JSON configuration: " + e.getMessage();
+            throw new ObjectMapper.InvalidJSONException(msg);
+        }
+
+        // Custom Mapping
+        if (jsonConfig.hasKey("barcodeFormats")) {
+            nativeConfig.barcodeFormats = JSONUtils.extractBarcodeFormats(jsonConfig);
+        }
+
+        if (jsonConfig.hasKey("acceptedDocumentFormats")) {
+            nativeConfig.acceptedDocumentFormats = JSONUtils.extractBarcodeDocumentFormats(jsonConfig);
+        }
+
+        if (jsonConfig.hasKey("cameraZoomFactor")) {
+            float value = (float) jsonConfig.getDouble("cameraZoomFactor");
+            if (value != -1) {
+                nativeConfig.setCameraZoomFactor(value);
+            }
+        }
+
+        if (jsonConfig.hasKey("flashEnabled")) {
+            nativeConfig.setFlashEnabled(jsonConfig.getBoolean("flashEnabled"));
+        }
+
+        if (jsonConfig.hasKey("barcodeFilter")) {
+            nativeConfig.barcodeFilter = JSONUtils.extractBarcodeFilter(jsonConfig);
+        }
+
+        nativeConfig.additionalConfiguration = JSONUtils.extractBarcodeScannerAdditionalConfig(jsonConfig);
+        nativeConfig.engineMode = JSONUtils.extractEngineMode(jsonConfig);
+
+        return nativeConfig;
+    }
 }

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

@@ -0,0 +1,81 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;
+
+import android.app.Activity;
+import android.util.Size;
+import android.view.LayoutInflater;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactContext;
+
+import io.scanbot.barcodesdk.plugin.reactnative.R;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.RNScanbotNativeComponentUi;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.views.RNScanbotNativeComponentFrameLayout;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.views.RNScanbotNativeComponentRootView;
+import io.scanbot.sdk.ui.camera.FinderOverlayView;
+import io.scanbot.sdk.ui.camera.ScanbotCameraXView;
+
+public class RNScanbotBarcodeCameraUi extends RNScanbotNativeComponentUi {
+
+    private FinderOverlayView finderOverlayView;
+    private ScanbotCameraXView cameraView;
+    private RNScanbotNativeComponentFrameLayout cameraLayout;
+
+    public RNScanbotBarcodeCameraUi(@NonNull final ReactContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    protected RNScanbotNativeComponentRootView createRootView(@NonNull final ReactContext reactContext) {
+        final Activity activity = reactContext.getCurrentActivity();
+        if (activity == null) {
+            throw new IllegalStateException("ERROR: Cannot retrieve current activity");
+        }
+        return setupUIAndGetRootView(activity);
+    }
+
+    public FinderOverlayView getFinderOverlayView() {
+        return this.finderOverlayView;
+    }
+    public ScanbotCameraXView getCameraView() {
+        return this.cameraView;
+    }
+
+    /*
+     * Takes care of inflating the XML layout, retrieving the views and configuring them (UI)
+     */
+    private RNScanbotNativeComponentRootView setupUIAndGetRootView(@NonNull final Activity activity) {
+        // Retrieves Root View from XML layout
+        final RNScanbotNativeComponentRootView rootView = (RNScanbotNativeComponentRootView) LayoutInflater
+                .from(activity)
+                .inflate(R.layout.component_barcode_camera_view, null, false);
+
+        // Retrieves the inner Camera Layout and configures it
+        cameraLayout = rootView.findViewById(R.id.barcode_camera_layout);
+        cameraLayout.setZ(-1.0f);
+        cameraLayout.setLayoutParams(new FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT));
+
+        finderOverlayView = rootView.findViewById(R.id.barcode_finder_overlay);
+        cameraView = rootView.findViewById(R.id.barcode_camera);
+
+        return rootView;
+    }
+
+    @Override
+    protected void onViewsRemeasured() {
+        cameraView.stopPreview();
+
+        final Size cameraViewSize = new Size(
+            cameraLayout.getWidth(),
+            cameraLayout.getHeight()
+        );
+
+        cameraView.setPreviewFrameSize(cameraViewSize);
+        cameraView.setAnalyzerFrameSize(cameraViewSize);
+
+        cameraView.startPreview();
+    }
+}

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/components/base/RNScanbotNativeComponent.java

@@ -0,0 +1,90 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.base;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventEmitter;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventReceiver;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.views.RNScanbotNativeComponentRootView;
+import kotlin.NotImplementedError;
+
+public abstract class RNScanbotNativeComponent {
+    // The UI layer of the native component
+    private RNScanbotNativeComponentUi nativeComponentUi;
+    // Internally set to true when the UI root view is recreated
+    private boolean isDirty;
+
+    public RNScanbotNativeComponent(@NonNull final ReactContext reactContext) {
+        this.nativeComponentUi = createNativeComponentUi(reactContext);
+    }
+    /*
+     * Every native component must have a UI component of type RNScanbotNativeComponentUi.
+     * You must override this method to provide your own custom implementation for it.
+     */
+    public RNScanbotNativeComponentUi createNativeComponentUi(@NonNull final ReactContext reactContext) {
+        throw new NotImplementedError("You must override createNativeComponentUi() in your Native Component implementation");
+    }
+    /*
+     * Initialize the component
+     */
+    public abstract void initializeComponent();
+    /*
+     * You must override this method to write your implementation mapping the JSON configuration
+     * that is passed to the component from the React Native JavaScript layer
+     */
+    public abstract void applyConfiguration(@NonNull final ReadableMap configuration);
+    /*
+     * This is called when a new view instance is requested to the ViewManager.
+     * It mostly disposes listeners and callbacks, and the .dispose() function of
+     * the UI Component can be overridden to add custom disposal methods.
+     */
+    public void recreateWithContext(final ReactContext reactContext) {
+        this.nativeComponentUi.dispose();
+        this.nativeComponentUi = createNativeComponentUi(reactContext);
+        this.nativeComponentUi._setOnViewRecreatedListener(() -> this.isDirty = true);
+    }
+
+    /*
+    * Called on componentDidMount
+    */
+    public void onComponentDidMount() {
+        this.initializeComponent();
+    }
+    /*
+     * Called on componentWillUnmount
+    */
+    public void onComponentWillUnmount() {}
+    /*
+     * Called on componentDidUpdate
+     */
+    public void onComponentDidUpdate() {
+        if (this.isDirty) {
+            initializeComponent();
+            this.isDirty = false;
+        }
+    }
+    /*
+     * Called on orientationChanged
+     */
+    public void onOrientationChanged() {}
+    /*
+     * Creates the root view for the component
+     */
+    public RNScanbotNativeComponentRootView getRootView() { return this.nativeComponentUi.getRootView(); }
+    /*
+     * Returns the list of Native events (from Native to JavaScript); default: empty
+     */
+    public RNScanbotEventEmitter.NativeEvent[] getNativeEvents() { return new RNScanbotEventEmitter.NativeEvent[] {}; }
+    /*
+     * Returns the list of JavaScript events (from JavaScript to Native); default: empty
+     */
+    public RNScanbotEventReceiver.JavaScriptEvent[] getJavascriptEvents() { return new RNScanbotEventReceiver.JavaScriptEvent[] {}; }
+    /*
+     * Override this to handle events defined in the getJavascriptEvents method; default: empty
+     */
+    public void handleJavascriptEvent(RNScanbotEventReceiver.JavaScriptEvent event, @Nullable ReadableArray args) {}
+}

package/android/src/main/java/io/scanbot/barcodesdk/plugin/reactnative/components/base/RNScanbotNativeComponentManager.java

@@ -0,0 +1,133 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.base;
+
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.ReactRootView;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventEmitter;
+import io.scanbot.barcodesdk.plugin.reactnative.components.base.communication.RNScanbotEventReceiver;
+
+/**
+ * This class takes care of setting up a ViewManager that:
+ * - Returns the correct name for registering the view in React Native
+ * - Accepts a JSON configuration under the prop name 'configuration' and passes it to the native component
+ * - Sets up events (both JS -> Java and Java -> JS) and it handles common core events
+ *   automatically (like componentDidMount, orientationChanged etc.)
+ * - Takes care of creating (and recreating) the root view and passing it to the React Native View Manager
+ * @param <T> Your custom type that extends RNScanbotNativeComponent
+ */
+public abstract class RNScanbotNativeComponentManager<T extends RNScanbotNativeComponent> extends ViewGroupManager<ReactRootView> implements RNScanbotEventReceiver.IEventHandler {
+    protected final ReactContext reactContext;
+    protected final T nativeComponent;
+    protected RNScanbotEventReceiver eventReceiver;
+    private boolean isInitialized = false;
+
+    public RNScanbotNativeComponentManager(
+        @NonNull final ReactContext reactContext,
+        @NonNull final T nativeComponent
+    ) {
+        super();
+        this.reactContext = reactContext;
+        this.nativeComponent = nativeComponent;
+        this.eventReceiver = new RNScanbotEventReceiver(this, nativeComponent.getJavascriptEvents());
+    }
+
+    @ReactProp(name = "configuration")
+    public void setConfiguration(FrameLayout frameLayout, ReadableMap configuration) {
+        final RNScanbotNativeComponent component = nativeComponent;
+        if (component == null) {
+            return;
+        }
+        component.applyConfiguration(configuration);
+    }
+
+    protected void componentDidMount() { this.nativeComponent.onComponentDidMount(); }
+    protected void componentWillUnmount() { this.nativeComponent.onComponentWillUnmount(); }
+    protected void componentDidUpdate() { this.nativeComponent.onComponentDidUpdate(); }
+    protected void orientationChanged() { this.nativeComponent.onOrientationChanged(); }
+
+    /* --------------------------------------------------*/
+    /* Internal stuff you probably shouldn't worry about */
+    /* --------------------------------------------------*/
+
+    // Maps native events (from Native to JS)
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        final RNScanbotEventEmitter.NativeEvent[] commonEvents = RNScanbotEventEmitter.CommonEvents.values();
+        final RNScanbotEventEmitter.NativeEvent[] customEvents = nativeComponent.getNativeEvents();
+        final RNScanbotEventEmitter.NativeEvent[] allEvents = RNScanbotEventEmitter.concatEvents(commonEvents, customEvents);
+        return RNScanbotEventEmitter.getMapForNativeEvents(allEvents);
+    }
+
+    // Creates the view instance when requested from the RN layer
+    @NonNull
+    @Override
+    protected ReactRootView createViewInstance(@NonNull final ThemedReactContext reactContext) {
+        if (isInitialized) {
+            this.nativeComponent.recreateWithContext(reactContext);
+        }
+        isInitialized = true;
+        return this.nativeComponent.getRootView();
+    }
+
+    // Parses notifications from the EventReceiver:
+    // - It handles common events and stops them from getting to the inheriting class
+    // - It sends non-common events to the handleJavascriptEvent delegate method in the inheriting class
+    @Override
+    public void eventHandler_eventReceived(RNScanbotEventReceiver.JavaScriptEvent event, @Nullable ReadableArray args) {
+        List<RNScanbotEventReceiver.JavaScriptEvent> handledEvents = new ArrayList<>();
+        RNScanbotEventReceiver.CommonEvents commonEvent = eventReceiver.getCommonEventFromName(event.getName());
+        if (commonEvent == null) {
+            this.nativeComponent.handleJavascriptEvent(event, args);
+            return;
+        }
+
+        this.handleCommonEvent(commonEvent, args);
+    }
+
+    // Calls the common events handlers
+    private void handleCommonEvent(RNScanbotEventReceiver.CommonEvents commonEvent, @Nullable ReadableArray args) {
+        switch (commonEvent) {
+            case COMPONENT_DID_UPDATE:
+                componentDidUpdate();
+                break;
+            case COMPONENT_DID_MOUNT:
+                componentDidMount();
+                break;
+            case COMPONENT_WILL_UNMOUNT:
+                componentWillUnmount();
+                break;
+            case ORIENTATION_CHANGED:
+                orientationChanged();
+                break;
+        }
+    }
+
+    // Maps JavaScript events (from JavaScript to Native)
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return eventReceiver.getCommandsMap();
+    }
+
+    // Hands over JavaScript events to our beatufiul event receiver
+    @Override
+    public void receiveCommand(@NonNull ReactRootView root, String commandId, @Nullable ReadableArray args) {
+        super.receiveCommand(root, commandId, args);
+        eventReceiver.receiveCommand(commandId, args);
+    }
+}