react-native-scanbot-barcode-scanner-sdk 3.0.0-beta7 → 3.1.0-alpha3

package/android/.idea/workspace.xml

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="1c2fd6f3-9709-40d2-ad2e-188494e80ebf" name="Default Changelist" comment="">
+      <change beforePath="$PROJECT_DIR$/build.gradle" beforeDir="false" afterPath="$PROJECT_DIR$/build.gradle" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ExternalProjectsData">
+    <projectState path="$PROJECT_DIR$">
+      <ProjectState />
+    </projectState>
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/.." />
+  </component>
+  <component name="ProjectId" id="1vLzzU2l94lUfLDsbtvBItpPOV6" />
+  <component name="ProjectLevelVcsManager" settingsEditedManually="true" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">
+    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
+    <property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
+    <property name="android.sdk.path" value="$USER_HOME$/Library/Android/sdk" />
+    <property name="dart.analysis.tool.window.visible" value="false" />
+    <property name="settings.editor.selected.configurable" value="AndroidSdkUpdater" />
+    <property name="show.migrate.to.gradle.popup" value="false" />
+  </component>
+  <component name="RunManager">
+    <configuration default="true" type="AndroidJUnit" factoryName="Android JUnit">
+      <option name="TEST_OBJECT" value="class" />
+      <option name="WORKING_DIRECTORY" value="$MODULE_DIR$" />
+      <method v="2">
+        <option name="Android.Gradle.BeforeRunTask" enabled="true" />
+      </method>
+    </configuration>
+  </component>
+  <component name="SvnConfiguration">
+    <configuration />
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="1c2fd6f3-9709-40d2-ad2e-188494e80ebf" name="Default Changelist" comment="" />
+      <created>1626356419354</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1626356419354</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="WindowStateProjectService">
+    <state x="-1661" y="125" width="761" height="574" key="find.popup" timestamp="1626356429471">
+      <screen x="-2560" y="-295" width="2560" height="1415" />
+    </state>
+    <state x="-1661" y="125" width="761" height="574" key="find.popup/-5120.-390.2560.1330/-2560.-295.2560.1415/0.25.1792.1095@-2560.-295.2560.1415" timestamp="1626356429471" />
+  </component>
+</project>

package/android/build.gradle

@@ -15,7 +15,7 @@ def DEFAULT_BUILD_TOOLS_VERSION = '28.0.3'
 def DEFAULT_MIN_SDK_VERSION = 21
 def DEFAULT_TARGET_SDK_VERSION = 29
 
-def sdkVersion = '3.0.1'
+def sdkVersion = '3.0.5'
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback

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

@@ -7,6 +7,7 @@ package io.scanbot.barcodesdk.plugin.reactnative;
 
 import android.graphics.PointF;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Arguments;
@@ -14,6 +15,7 @@ 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.WritableNativeMap;
 
 import org.jetbrains.annotations.NotNull;
 
@@ -33,6 +35,50 @@ public final class JSONUtils {
 
     private JSONUtils() {}
 
+    public static class WritableMapBuilder {
+
+        private final WritableNativeMap _writableMap = new WritableNativeMap();
+
+        public WritableMapBuilder putBoolean(@NonNull String key, boolean value) {
+            _writableMap.putBoolean(key, value);
+            return this;
+        }
+
+        public WritableMapBuilder putDouble(@NonNull String key, double value) {
+            _writableMap.putDouble(key, value);
+            return this;
+        }
+
+        public WritableMapBuilder putInt(@NonNull String key, int value) {
+            _writableMap.putInt(key, value);
+            return this;
+        }
+
+        public WritableMapBuilder putNull(@NonNull String key) {
+            _writableMap.putNull(key);
+            return this;
+        }
+
+        public WritableMapBuilder putString(@NonNull String key, @Nullable String value) {
+            _writableMap.putString(key, value);
+            return this;
+        }
+
+        public WritableMapBuilder putMap(@NonNull String key, @Nullable ReadableMap value) {
+            _writableMap.putMap(key, value);
+            return this;
+        }
+
+        public WritableMapBuilder putArray(@NonNull String key, @Nullable ReadableArray value) {
+            _writableMap.putArray(key, value);
+            return this;
+        }
+
+        public WritableMap build() {
+            return this._writableMap;
+        }
+    }
+
     public static WritableArray sdkPolygonToWritableArray(final List<PointF> polygon) {
         WritableArray points = Arguments.createArray();
         if (polygon != null) {
@@ -70,15 +116,9 @@ public final class JSONUtils {
         return nativeBarcodeDocumentFormats;
     }
 
-    public static @Nullable BarcodeScannerAdditionalConfiguration extractBarcodeScannerAdditionalConfiguration(final ReadableMap configuration) {
+    public static @Nullable BarcodeScannerAdditionalConfig extractBarcodeScannerAdditionalConfig(final ReadableMap configuration) {
         boolean changed = false;
 
-        boolean gs1DecodingEnabled = BarcodeScannerAdditionalConfig.DEFAULT_GS1_DECODING_ENABLED;
-        if (configuration.hasKey("gs1DecodingEnabled")) {
-            gs1DecodingEnabled = configuration.getBoolean("gs1DecodingEnabled");
-            changed = true;
-        }
-
         int minimumTextLength = BarcodeScannerAdditionalConfig.DEFAULT_MIN_TEXT_LENGTH;
         if (configuration.hasKey("minimumTextLength")) {
             minimumTextLength = configuration.getInt("minimumTextLength");
@@ -97,6 +137,12 @@ public final class JSONUtils {
             changed = true;
         }
 
+        boolean gs1DecodingEnabled = BarcodeScannerAdditionalConfig.DEFAULT_GS1_DECODING_ENABLED;
+        if (configuration.hasKey("gs1DecodingEnabled")) {
+            gs1DecodingEnabled = configuration.getBoolean("gs1DecodingEnabled");
+            changed = true;
+        }
+
         EnumSet<MSIPlesseyChecksumAlgorithm> msiPlesseyChecksumAlgorithms =
                 BarcodeScannerAdditionalConfig.Companion.getDEFAULT_MSI_PLESSEY_CHECKSUM_ALGORITHMS();
         if (configuration.hasKey("msiPlesseyChecksumAlgorithm")) {
@@ -106,12 +152,31 @@ public final class JSONUtils {
             changed = true;
         }
 
-        return changed ? new BarcodeScannerAdditionalConfiguration(
+        boolean stripCheckDigits = BarcodeScannerAdditionalConfig.DEFAULT_STRIP_CHECK_DIGITS;
+        if (configuration.hasKey("stripCheckDigits")) {
+            stripCheckDigits = configuration.getBoolean("stripCheckDigits");
+            changed = true;
+        }
+
+        return changed ? new BarcodeScannerAdditionalConfig(
                 minimumTextLength,
                 maximumTextLength,
                 minimum1DQuietZoneSize,
                 gs1DecodingEnabled,
-                msiPlesseyChecksumAlgorithms
+                msiPlesseyChecksumAlgorithms,
+                stripCheckDigits
+        ) : null;
+    }
+
+    public static @Nullable BarcodeScannerAdditionalConfiguration extractBarcodeScannerAdditionalConfiguration(final ReadableMap configuration) {
+        final BarcodeScannerAdditionalConfig config = extractBarcodeScannerAdditionalConfig(configuration);
+        return config != null ? new BarcodeScannerAdditionalConfiguration(
+                config.getMinimumTextLength(),
+                config.getMaximumTextLength(),
+                config.getMinimum1DQuietZoneSize(),
+                config.getGs1DecodingEnabled(),
+                config.getMsiPlesseyChecksumAlgorithms(),
+                config.getStripCheckDigits()
         ) : null;
     }
 

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

@@ -181,7 +181,7 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
 
                     final Bitmap bitmap = MediaStore.Images.Media.getBitmap(getReactApplicationContext().getContentResolver(), Uri.parse(imageUri));
                     final ScanbotBarcodeScannerSDK sdk = new ScanbotBarcodeScannerSDK(getReactApplicationContext());
-                    final ScanbotBarcodeDetector detector = sdk.barcodeDetector();
+                    final ScanbotBarcodeDetector detector = sdk.createBarcodeDetector();
 
                     detector.modifyConfig(new Function1<BarcodeScannerConfigBuilder, Unit>() {
                         @Override
@@ -324,7 +324,7 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
 
                     debugLog("Cleaning Barcode SDK storage folder ...");
                     ScanbotBarcodeScannerSDK sdk = new ScanbotBarcodeScannerSDK(getReactApplicationContext());
-                    sdk.barcodeFileStorage().cleanupBarcodeImagesDirectory();
+                    sdk.createBarcodeFileStorage().cleanupBarcodeImagesDirectory();
 
                     debugLog("Cleaning plugin storage folder ...");
                     StorageUtils.cleanupPluginStorageDirectory(getReactApplicationContext());

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

@@ -14,6 +14,8 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 
+import io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview.ScanbotBarcodeCameraViewManager;
+
 public class ScanbotBarcodeSdkPackage implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
@@ -22,6 +24,8 @@ public class ScanbotBarcodeSdkPackage implements ReactPackage {
 
     @Override
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-        return Collections.emptyList();
+        return Arrays.asList(new ViewManager[]{
+                new ScanbotBarcodeCameraViewManager(reactContext)
+        });
     }
 }

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

@@ -0,0 +1,55 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components;
+
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import java.util.Map;
+
+public class EventEmitter {
+
+    public enum NativeEvent {
+        BARCODE_SCANNER_RESULT("onBarcodeScannerResult"),
+        REQUEST_COMPONENT_RELOAD("requestComponentReload");
+
+        private final String name;
+        NativeEvent(final String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    private final RCTEventEmitter jsEventEmitter;
+    private final ReactContext reactContext;
+    private final ViewGroup rootViewGroup;
+
+    public EventEmitter(final ReactContext reactContext, final ViewGroup rootViewGroup) {
+        this.reactContext = reactContext;
+        this.jsEventEmitter = reactContext.getJSModule(RCTEventEmitter.class);
+        this.rootViewGroup = rootViewGroup;
+    }
+
+    public void emitEvent(final NativeEvent event, final WritableMap data) {
+        assert reactContext != null;
+        jsEventEmitter.receiveEvent(
+                rootViewGroup.getId(),
+                event.getName(),
+                data);
+    }
+
+    public static Map<String, Object> getMapForNativeEvents(NativeEvent[] events) {
+        MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+
+        for (NativeEvent event: events) {
+            builder.put(event.getName(), MapBuilder.of("registrationName", event.getName()));
+        }
+
+        return builder.build();
+    }
+}

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

@@ -0,0 +1,113 @@
+package io.scanbot.barcodesdk.plugin.reactnative.components.barcodecameraview;
+
+import android.graphics.Color;
+
+import java.util.ArrayList;
+import java.util.List;
+
+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.sdk.ui.camera.FinderAspectRatio;
+
+@SuppressWarnings("unused")
+public class ScanbotBarcodeCameraViewConfiguration {
+
+    public List<BarcodeFormat> barcodeFormats = new ArrayList<>();
+    public List<BarcodeDocumentFormat> acceptedDocumentFormats = new ArrayList<>();
+    public EngineMode engineMode;
+    public BarcodeScannerAdditionalConfig additionalConfiguration;
+
+    // Automatically mapped properties
+    private boolean shouldUseFinderView = false;
+    private int finderLineWidth = 1;
+    private int finderLineColor = Color.WHITE;
+    private int finderBackgroundColor = Color.BLACK;
+    private int finderMinimumPadding = 32;
+    private int finderVerticalOffset = 0;
+    private float finderBackgroundOpacity = 0.66f;
+    private float cameraZoomFactor = -1;
+    private boolean flashEnabled = false;
+    private FinderAspectRatio finderAspectRatio = new FinderAspectRatio(1, 1);
+
+    public void setShouldUseFinderView(boolean shouldUseFinderView) {
+        this.shouldUseFinderView = shouldUseFinderView;
+    }
+
+    public void setFinderLineWidth(int viewFinderLineWidth) {
+        this.finderLineWidth = viewFinderLineWidth;
+    }
+
+    public void setFinderLineColor(@androidx.annotation.ColorInt int viewFinderLineColor) {
+        this.finderLineColor = viewFinderLineColor;
+    }
+
+    public void setFinderBackgroundColor(@androidx.annotation.ColorInt int viewFinderBackgroundColor) {
+        this.finderBackgroundColor = viewFinderBackgroundColor;
+    }
+
+    public void setFinderMinimumPadding(int finderMinimumPadding) {
+        this.finderMinimumPadding = finderMinimumPadding;
+    }
+
+    public void setFinderVerticalOffset(int finderVerticalOffset) {
+        this.finderVerticalOffset = finderVerticalOffset;
+    }
+
+    public void setFinderAspectRatio(FinderAspectRatio finderAspectRatio) {
+        this.finderAspectRatio = finderAspectRatio;
+    }
+
+    public void setFinderBackgroundOpacity(float finderBackgroundOpacity) {
+        this.finderBackgroundOpacity = finderBackgroundOpacity;
+    }
+
+    public void setCameraZoomFactor(float cameraZoomFactor) {
+        this.cameraZoomFactor = cameraZoomFactor;
+    }
+
+    public void setFlashEnabled(boolean flashEnabled) {
+        this.flashEnabled = flashEnabled;
+    }
+
+    public boolean shouldUseFinderView() {
+        return shouldUseFinderView;
+    }
+
+    public int getFinderLineWidth() {
+        return finderLineWidth;
+    }
+
+    public int getFinderLineColor() {
+        return finderLineColor;
+    }
+
+    public int getFinderBackgroundColor() {
+        return finderBackgroundColor;
+    }
+
+    public int getFinderMinimumPadding() {
+        return finderMinimumPadding;
+    }
+
+    public int getFinderVerticalOffset() {
+        return finderVerticalOffset;
+    }
+
+    public float getFinderBackgroundOpacity() {
+        return finderBackgroundOpacity;
+    }
+
+    public float getCameraZoomFactor() {
+        return cameraZoomFactor;
+    }
+
+    public boolean isFlashEnabled() {
+        return flashEnabled;
+    }
+
+    public FinderAspectRatio getFinderAspectRatio() {
+        return finderAspectRatio;
+    }
+}

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

@@ -0,0 +1,246 @@
+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.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.fragment.app.Fragment;
+
+import com.facebook.react.bridge.ReactContext;
+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.barcodesdk.plugin.reactnative.JSONUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.R;
+import io.scanbot.barcodesdk.plugin.reactnative.components.EventEmitter;
+import io.scanbot.barcodesdk.plugin.reactnative.components.common.ScanbotComponentFrameLayout;
+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.BarcodeScannerConfigBuilder;
+import io.scanbot.sdk.barcode.entity.BarcodeScanningResult;
+import io.scanbot.sdk.camera.CameraOpenCallback;
+import io.scanbot.sdk.camera.FrameHandlerResult;
+import io.scanbot.sdk.camera.ScanbotCameraView;
+import io.scanbot.sdk.ui.camera.FinderOverlayView;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+
+public class ScanbotBarcodeCameraViewFragment extends Fragment implements BarcodeDetectorFrameHandler.ResultHandler {
+
+    private static final int REQUEST_PERMISSION_CODE = 200;
+
+    private ReactContext callerContext;
+    private ViewGroup rootViewGroup;
+    private ScanbotComponentFrameLayout cameraLayout;
+    private ScanbotCameraView cameraView;
+    private FinderOverlayView finderOverlayView;
+    private ScanbotBarcodeDetector barcodeDetector;
+    private BarcodeDetectorFrameHandler frameHandler;
+    private ScanbotBarcodeCameraViewConfiguration configuration = new ScanbotBarcodeCameraViewConfiguration();
+    private boolean isInitialized = false;
+    private EventEmitter jsEventEmitter;
+    private float userDefinedCameraZoomFactor = -1;
+
+    public ScanbotBarcodeCameraViewFragment() {
+        super(R.layout.fragment_barcode_scanner);
+    }
+
+    public void instantiate(final ReactContext reactContext, final ViewGroup rootViewGroup) {
+        this.callerContext = reactContext;
+        this.rootViewGroup = rootViewGroup;
+        jsEventEmitter = new EventEmitter(reactContext, rootViewGroup);
+    }
+
+    @Override
+    public void onViewCreated(@NonNull final View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        final Activity activity = getActivity();
+        final View rootView = getView();
+        assert activity != null;
+        assert rootView != null;
+
+        cameraLayout = rootView.findViewById(R.id.barcode_camera_layout);
+        cameraView = rootView.findViewById(R.id.barcode_camera);
+        finderOverlayView = rootView.findViewById(R.id.barcode_finder_overlay);
+
+        cameraView.post(new Runnable() {
+            @Override
+            public void run() {
+                checkPermissions();
+            }
+        });
+
+        cameraView.onResume();
+
+        // Setup Frame Handler for Barcode Detection
+        barcodeDetector = new DefaultScanbotBarcodeDetector();
+
+        frameHandler = BarcodeDetectorFrameHandler.attach(cameraView, barcodeDetector);
+        frameHandler.setDetectionInterval(0);
+        frameHandler.addResultHandler(this);
+
+        cameraView.addFrameHandler(frameHandler);
+
+        cameraView.setCameraOpenCallback(new CameraOpenCallback() {
+            @Override
+            public void onCameraOpened() {
+                cameraView.continuousFocus();
+            }
+        });
+
+        applyConfiguration();
+
+        isInitialized = true;
+    }
+
+    private void applyConfiguration() {
+        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()));
+
+        cameraView.useFlash(configuration.isFlashEnabled());
+
+        if (configuration.getCameraZoomFactor() != -1) {
+            if (configuration.getCameraZoomFactor() != userDefinedCameraZoomFactor || userDefinedCameraZoomFactor == -1) {
+                cameraView.setOpticalZoomLevel(configuration.getCameraZoomFactor());
+                userDefinedCameraZoomFactor = configuration.getCameraZoomFactor();
+            }
+        }
+        barcodeDetector.modifyConfig(new Function1<BarcodeScannerConfigBuilder, Unit>() {
+            @Override
+            public Unit invoke(BarcodeScannerConfigBuilder 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.setAdditionalConfig(configuration.additionalConfiguration);
+                }
+                return Unit.INSTANCE;
+            }
+        });
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        if(cameraView != null) {
+            cameraView.onResume();
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (cameraView != null) {
+            cameraView.onResume();
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        if (cameraView != null) {
+            cameraView.onPause();
+        }
+    }
+
+    public void updateWithConfiguration(ScanbotBarcodeCameraViewConfiguration configuration) {
+        this.configuration = configuration;
+
+        if (isInitialized) {
+            applyConfiguration();
+        }
+    }
+
+    @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);
+    }
+
+    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())
+                    .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();
+
+        jsEventEmitter.emitEvent(EventEmitter.NativeEvent.BARCODE_SCANNER_RESULT, data);
+    }
+
+    @Override
+    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;
+        }
+
+        sendResult(result.getValue().getBarcodeItems());
+    }
+
+    private void checkPermissions() {
+        if (callerContext == null) { return; }
+        Activity activity = callerContext.getCurrentActivity();
+
+        if (activity != null && ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
+            ActivityCompat.requestPermissions(activity, new String[] { Manifest.permission.CAMERA }, REQUEST_PERMISSION_CODE);
+        }
+    }
+}