react-native-scanbot-barcode-scanner-sdk 3.1.0-beta1 → 3.1.0-beta10

package/RNScanbotBarcodeSDK.podspec

@@ -2,7 +2,7 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 
-ScanbotBarcodeScannerSDKVersion = '3.0.2'
+ScanbotBarcodeScannerSDKVersion = '3.1.1'
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +1,2 @@
-#Thu Jul 15 15:40:35 CEST 2021
-gradle.version=6.1.1
+#Mon Jan 31 14:23:43 CET 2022
+gradle.version=7.1.1

package/android/.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>android</name>
+	<comment>Project android created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1637321714029</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,13 @@
+arguments=
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(7.1.1))
+connection.project.dir=
+eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/jdk-16.0.2.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

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.6'
+def sdkVersion = '3.1.0'
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback

package/android/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Tue Jan 18 13:44:25 CET 2022
+sdk.dir=/Users/rutkaybiyik/Library/Android/sdk

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

@@ -18,6 +18,7 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 
 import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
 
 import java.util.ArrayList;
 import java.util.EnumSet;
@@ -30,6 +31,7 @@ import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfig;
 import io.scanbot.sdk.barcode.entity.EngineMode;
 import io.scanbot.sdk.barcode.entity.MSIPlesseyChecksumAlgorithm;
 import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeScannerAdditionalConfiguration;
+import io.scanbot.sdk.ui.view.base.configuration.CameraOrientationMode;
 
 public final class JSONUtils {
 
@@ -116,6 +118,30 @@ public final class JSONUtils {
         return nativeBarcodeDocumentFormats;
     }
 
+    public static @Nullable CameraOrientationMode extractCameraOrientationMode(final ReadableMap configuration) {
+        if (configuration.hasKey("allowedInterfaceOrientations")) {
+            String orientation = configuration.getString("allowedInterfaceOrientations");
+            if (orientation == null) {
+                orientation = "NONE";
+            }
+            switch (orientation) {
+                case "NONE":
+                    break;
+                case "PORTRAIT":
+                case "PORTRAIT_UPSIDE_DOWN":
+                    return CameraOrientationMode.PORTRAIT;
+                case "LANDSCAPE_LEFT":
+                case "LANDSCAPE_RIGHT":
+                case "LANDSCAPE":
+                    return CameraOrientationMode.LANDSCAPE;
+                default:
+                    return null;
+            }
+        }
+
+        return null;
+    }
+
     public static @Nullable BarcodeScannerAdditionalConfig extractBarcodeScannerAdditionalConfig(final ReadableMap configuration) {
         boolean changed = false;
 
@@ -158,13 +184,20 @@ public final class JSONUtils {
             changed = true;
         }
 
+        boolean lowPowerMode = BarcodeScannerAdditionalConfig.DEFAULT_LOW_POWER_MODE;
+        if (configuration.hasKey("lowPowerMode")) {
+            lowPowerMode = configuration.getBoolean("lowPowerMode");
+            changed = true;
+        }
+
         return changed ? new BarcodeScannerAdditionalConfig(
                 minimumTextLength,
                 maximumTextLength,
                 minimum1DQuietZoneSize,
                 gs1DecodingEnabled,
                 msiPlesseyChecksumAlgorithms,
-                stripCheckDigits
+                stripCheckDigits,
+                lowPowerMode
         ) : null;
     }
 
@@ -176,7 +209,8 @@ public final class JSONUtils {
                 config.getMinimum1DQuietZoneSize(),
                 config.getGs1DecodingEnabled(),
                 config.getMsiPlesseyChecksumAlgorithms(),
-                config.getStripCheckDigits()
+                config.getStripCheckDigits(),
+                config.getLowPowerMode()
         ) : null;
     }
 

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

@@ -63,6 +63,11 @@ public final class ObjectMapper {
                 continue;
             }
 
+            // The default FRONT camera module should be FRONT_MIRRORED on Android
+            if ("cameraModule".equals(prop) && "FRONT".equals(value)) {
+                value = "FRONT_MIRRORED";
+            }
+
             final String setterName = "set" + prop.substring(0, 1).toUpperCase() + prop.substring(1);
 
             if (methodMap.containsKey(setterName)) {

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

@@ -7,8 +7,11 @@ package io.scanbot.barcodesdk.plugin.reactnative;
 
 public class ScanbotBarcodeSdkConfiguration {
     private boolean loggingEnabled = false;
+    private boolean enableNativeLogging = false;
     private String licenseKey;
     private String storageBaseDirectory = null;
+    private boolean useCameraX = false;
+    private boolean allowXnnpackAcceleration = true;
     private boolean allowGpuAcceleration = true;
 
     public boolean isLoggingEnabled() {
@@ -42,4 +45,28 @@ public class ScanbotBarcodeSdkConfiguration {
     public void setAllowGpuAcceleration(boolean allowGpuAcceleration) {
         this.allowGpuAcceleration = allowGpuAcceleration;
     }
-}
+
+    public boolean getUseCameraX() {
+        return useCameraX;
+    }
+
+    public void setUseCameraX(boolean useCameraX) {
+        this.useCameraX = useCameraX;
+    }
+
+    public boolean getAllowXnnpackAcceleration() {
+        return allowXnnpackAcceleration;
+    }
+
+    public void setAllowXnnpackAcceleration(boolean allowXnnpackAcceleration) {
+        this.allowXnnpackAcceleration = allowXnnpackAcceleration;
+    }
+
+    public boolean getEnableNativeLogging() {
+        return enableNativeLogging;
+    }
+
+    public void setEnableNativeLogging(boolean enableNativeLogging) {
+        this.enableNativeLogging = enableNativeLogging;
+    }
+}

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

@@ -5,31 +5,23 @@
  */
 package io.scanbot.barcodesdk.plugin.reactnative;
 
-import android.app.Activity;
 import android.app.Application;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.net.Uri;
 import android.provider.MediaStore;
-
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.BaseActivityEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.Callback;
-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.Contract;
 import org.jetbrains.annotations.NotNull;
-
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -37,9 +29,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-
 import io.scanbot.sap.SdkLicenseInfo;
-import io.scanbot.sap.Status;
 import io.scanbot.sdk.barcode.ScanbotBarcodeDetector;
 import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat;
 import io.scanbot.sdk.barcode.entity.BarcodeFormat;
@@ -47,20 +37,18 @@ import io.scanbot.sdk.barcode.entity.BarcodeItem;
 import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfigBuilder;
 import io.scanbot.sdk.barcode.entity.BarcodeScannerConfigBuilder;
 import io.scanbot.sdk.barcode.entity.BarcodeScanningResult;
-import io.scanbot.sdk.barcode.entity.EngineMode;
 import io.scanbot.sdk.barcode_scanner.ScanbotBarcodeScannerSDK;
 import io.scanbot.sdk.barcode_scanner.ScanbotBarcodeScannerSDKInitializer;
 import io.scanbot.sdk.ui.barcode_scanner.view.barcode.BarcodeScannerActivity;
 import io.scanbot.sdk.ui.barcode_scanner.view.barcode.batch.BatchBarcodeScannerActivity;
 import io.scanbot.sdk.ui.view.barcode.batch.configuration.BatchBarcodeScannerConfiguration;
-import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeImageGenerationType;
 import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeScannerAdditionalConfiguration;
 import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeScannerConfiguration;
+import io.scanbot.sdk.ui.view.base.configuration.CameraOrientationMode;
 import kotlin.Unit;
 import kotlin.jvm.functions.Function1;
-import okhttp3.Response;
+import android.app.Activity;
 
-import static io.scanbot.barcodesdk.plugin.reactnative.LogUtils.debugLog;
 
 public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implements ActivityEventListener {
 
@@ -108,10 +96,12 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
                     final String callbackMessage;
 
                     final ScanbotBarcodeScannerSDKInitializer initializer = new ScanbotBarcodeScannerSDKInitializer();
-                    initializer.withLogging(configuration.isLoggingEnabled());
+                    initializer.withLogging(configuration.isLoggingEnabled(), configuration.getEnableNativeLogging());
                     LogUtils.setLoggingEnabled(configuration.isLoggingEnabled());
 
                     initializer.allowGpuAcceleration(configuration.getAllowGpuAcceleration());
+                    initializer.allowXnnpackAcceleration(configuration.getAllowXnnpackAcceleration());
+                    initializer.useCameraXRtuUi(configuration.getUseCameraX());
 
                     if (configuration.getStorageBaseDirectory() != null && !"".equals(configuration.getStorageBaseDirectory())) {
                         final Uri uri = Uri.parse(configuration.getStorageBaseDirectory());
@@ -247,6 +237,11 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
 
             safeMap(options, configuration, promise);
 
+            CameraOrientationMode orientationMode = JSONUtils.extractCameraOrientationMode(options);
+            if (orientationMode != null) {
+                configuration.setOrientationLockMode(orientationMode);
+            }
+
             final ArrayList<BarcodeFormat> formats = JSONUtils.extractBarcodeFormats(options);
             if (!formats.isEmpty()) {
                 configuration.setBarcodeFormatsFilter(formats);
@@ -275,6 +270,13 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
         }
     }
 
+    @ReactMethod
+    public void closeBarcodeScanner(final Promise promise) {
+        final ReactContext context = getReactApplicationContext();
+        BarcodeScannerActivity.forceClose(context);
+        promise.resolve(null);
+    }
+
     @ReactMethod
     public void startBatchBarcodeScanner(ReadableMap configuration, final Promise promise) {
         final ReactContext context = getReactApplicationContext();
@@ -291,6 +293,11 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
                 nativeConfig.setAdditionalDetectionParameters(additionalConfiguration);
             }
 
+            CameraOrientationMode orientationMode = JSONUtils.extractCameraOrientationMode(configuration);
+            if (orientationMode != null) {
+                nativeConfig.setOrientationLockMode(orientationMode);
+            }
+
             // Barcode Format Filters
             ArrayList<BarcodeFormat> formats = JSONUtils.extractBarcodeFormats(configuration);
             if (!formats.isEmpty()) {
@@ -315,6 +322,13 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
         }
     }
 
+    @ReactMethod
+    public void closeBatchBarcodeScanner(final Promise promise) {
+        final ReactContext context = getReactApplicationContext();
+        BatchBarcodeScannerActivity.forceClose(context, false);
+        promise.resolve(null);
+    }
+
     @ReactMethod
     public void cleanup(final Promise promise) {
         if (rejectIfUninitialized(promise)) {
@@ -345,7 +359,7 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
 
         switch (requestCode) {
             case REQUEST_SB_BARCODE_SCANNER:
-                this.handleBarcodeScannerActivityCompletion(intent, (resultCode != Activity.RESULT_OK));
+                this.handleBarcodeScannerActivityCompletion(intent, resultCode);
                 return;
 
             default:
@@ -357,13 +371,14 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
     public void onNewIntent(Intent intent) {
     }
 
-    private void handleBarcodeScannerActivityCompletion(final Intent intent, boolean canceled) {
+    private void handleBarcodeScannerActivityCompletion(final Intent intent, final int resultCode) {
         Promise promise = this.activityCallbackPromise;
         this.activityCallbackPromise = null;
 
-        if (!canceled) {
-            final BarcodeScanningResult barcodeResult = intent.getParcelableExtra(BarcodeScannerActivity.SCANNED_BARCODE_EXTRA);
-            final WritableMap result = jsonResultFromBarcodeScannerResult(barcodeResult);
+        final BarcodeScannerActivity.Result barcodeResult = BarcodeScannerActivity.extractResult(resultCode, intent);
+
+        if (barcodeResult.getResultOk()) {
+            final WritableMap result = jsonResultFromBarcodeScannerResult(barcodeResult.getResult());
 
             String imagePath = intent.getStringExtra(BarcodeScannerActivity.SCANNED_BARCODE_IMAGE_PATH_EXTRA);
             if (imagePath == null) {

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

@@ -34,6 +34,8 @@ 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.BarcodeScannerAdditionalConfigBuilder;
 import io.scanbot.sdk.barcode.entity.BarcodeScannerConfigBuilder;
 import io.scanbot.sdk.barcode.entity.BarcodeScanningResult;
 import io.scanbot.sdk.camera.CameraOpenCallback;
@@ -143,7 +145,19 @@ public class ScanbotBarcodeCameraViewFragment extends Fragment implements Barcod
                 b.setEngineMode(configuration.engineMode);
 
                 if(configuration.additionalConfiguration != null) {
-                    b.setAdditionalConfig(configuration.additionalConfiguration);
+                    b.modifyAdditionalConfig(new Function1<BarcodeScannerAdditionalConfigBuilder, Unit>() {
+                        @Override
+                        public Unit invoke(BarcodeScannerAdditionalConfigBuilder 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;
             }

package/index.d.ts

@@ -1,4 +1,5 @@
-import { BarcodeScannerConfiguration, BatchBarcodeScannerConfiguration } from "./src/configuration";
+import { InitializationOptions } from "react-native-scanbot-barcode-scanner-sdk/src/model";
+import { BarcodeScannerConfiguration, BatchBarcodeScannerConfiguration, DetectBarcodesOnImageArguments } from "./src/configuration";
 import { BarcodeDocumentFormat, BarcodeFormat, EngineMode } from "./src/enum";
 import { BarcodeResult, BarcodeScannerResult, BatchBarcodeScannerResult } from "./src/result";
 
@@ -16,24 +17,20 @@ export {
 
 export interface ScanbotBarcodeSdk {
     // SDK Internal
-    initializeSdk(options: any): Promise<{result: string}>;
+    initializeSdk(options: InitializationOptions): Promise<{result: string}>;
     getLicenseInfo(): Promise<any>;
     cleanup(): Promise<void>;
 
     // RTU-UI Barcode Scanning
     startBarcodeScanner(configuration: BarcodeScannerConfiguration): Promise<BarcodeScannerResult>;
+    closeBarcodeScanner(): Promise<void>;
+
     startBatchBarcodeScanner(configuration: BatchBarcodeScannerConfiguration): Promise<BatchBarcodeScannerResult>;
+    closeBatchBarcodeScanner(): Promise<void>;
 
     // Other Barcode Scanning functionalities
     detectBarcodesOnImage(
-        args: {
-            imageFileUri: string,
-            barcodeFormats?: BarcodeFormat[],
-            acceptedDocumentFormats?: BarcodeDocumentFormat[],
-            minimumTextLength?: number, // NOTE: This feature works on ITF barcodes only.
-            maximumTextLength?: number, // NOTE: This feature works on ITF barcodes only.
-            minimum1DBarcodesQuietZone?: number //NOTE: This feature works on ITF barcodes only.
-        }
+        args: DetectBarcodesOnImageArguments
     ): Promise<BarcodeResult>;
 }
 

package/ios/Components/BarcodeCameraView/RNScanbotBarcodeCameraView.h

@@ -44,6 +44,7 @@
 @property (nonatomic, copy) NSNumber* _Nullable gs1DecodingEnabled;
 @property (nonatomic, copy) NSNumber* _Nullable minimumTextLength;
 @property (nonatomic, copy) NSNumber* _Nullable maximumTextLength;
+@property (nonatomic, copy) NSNumber* _Nullable stripCheckDigits;
 @property (nonatomic, copy) NSArray<SBSDKBarcodeType *>* _Nullable barcodeFormats;
 @property (nonatomic, copy) NSArray<SBSDKBarcodeDocumentType *>* _Nullable acceptedDocumentFormats;
 @property (nonatomic) SBSDKBarcodeMSIPlesseyChecksumAlgorithm msiPlesseyChecksumAlgorithm;

package/ios/Components/BarcodeCameraView/RNScanbotBarcodeCameraView.m

@@ -112,18 +112,28 @@
     if (_cameraViewConfiguration.acceptedDocumentFormats) {
         viewController.acceptedDocumentTypes = _cameraViewConfiguration.acceptedDocumentFormats;
     }
+    
+    // Map Additional Parameters
+    SBSDKBarcodeAdditionalParameters* additionalParameters = [[SBSDKBarcodeAdditionalParameters alloc] init];
+    
     if (_cameraViewConfiguration.gs1DecodingEnabled) {
-        viewController.additionalDetectionParameters.enableGS1Decoding = [_cameraViewConfiguration.gs1DecodingEnabled boolValue];
+        additionalParameters.enableGS1Decoding = [_cameraViewConfiguration.gs1DecodingEnabled boolValue];
     }
     if (_cameraViewConfiguration.maximumTextLength) {
-        viewController.additionalDetectionParameters.maximumTextLength = [_cameraViewConfiguration.maximumTextLength intValue];
+        additionalParameters.maximumTextLength = [_cameraViewConfiguration.maximumTextLength intValue];
     }
     if (_cameraViewConfiguration.minimumTextLength) {
-        viewController.additionalDetectionParameters.minimumTextLength = [_cameraViewConfiguration.minimumTextLength intValue];
+        additionalParameters.minimumTextLength = [_cameraViewConfiguration.minimumTextLength intValue];
     }
     if (_cameraViewConfiguration.msiPlesseyChecksumAlgorithm != -1) {
-        viewController.additionalDetectionParameters.msiPlesseyChecksumAlgorithm = _cameraViewConfiguration.msiPlesseyChecksumAlgorithm;
+        additionalParameters.msiPlesseyChecksumAlgorithm = _cameraViewConfiguration.msiPlesseyChecksumAlgorithm;
+    }
+    if (_cameraViewConfiguration.stripCheckDigits) {
+        additionalParameters.stripCheckDigits = [_cameraViewConfiguration.stripCheckDigits boolValue];
     }
+    
+    viewController.additionalDetectionParameters = additionalParameters;
+    
     if (_cameraViewConfiguration.cameraZoomFactor) {
         CGFloat value = [_cameraViewConfiguration.cameraZoomFactor floatValue];
         if (value != _userDefinedCameraZoomFactor || _userDefinedCameraZoomFactor == -1) {