react-native-scanbot-barcode-scanner-sdk 3.2.1-beta3 → 3.2.1-beta4

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

@@ -21,6 +21,14 @@ public final class ObjectMapper {
 
     private static Map<String, Map<String, String>> enumMappings;
 
+    /*
+    *  Properties listed here will be skipped by the Object Mapper
+    */
+    private final static String[] kIgnoredProperties = new String[] {
+        "engineMode",
+        "barcodeFilter"
+    };
+
     public static void map(ReadableMap source, Object target)
             throws IllegalAccessException, InvocationTargetException {
         map(source.toHashMap(), target);
@@ -30,7 +38,7 @@ public final class ObjectMapper {
         ObjectMapper.enumMappings = enumMappings;
     }
 
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings({"unchecked", "SuspiciousMethodCalls", "rawtypes", "ConstantConditions"})
     private static void map(final Map<String, Object> source, final Object target)
             throws IllegalAccessException, InvocationTargetException {
         final Class cls = target.getClass();
@@ -59,11 +67,7 @@ public final class ObjectMapper {
                 continue;
             }
 
-            if ("engineMode".equals(prop)) {
-                continue;
-            }
-
-            if ("barcodeFilter".equals(prop)) {
+            if (shouldIgnoreProperty(prop)) {
                 continue;
             }
 
@@ -104,10 +108,13 @@ public final class ObjectMapper {
                     if (setterName.contains("Color")) {
                         value = Color.parseColor((String) value);
                     } else if (paramType == int.class) {
+                        assert value instanceof Number;
                         value = ((Number)value).intValue();
                     } else if (paramType == float.class) {
+                        assert value instanceof Number;
                         value = ((Number) value).floatValue();
                     } else if (paramType == double.class) {
+                        assert value instanceof Number;
                         value = ((Number) value).doubleValue();
                     } else if (paramType.isEnum()) {
                         value = Enum.valueOf(paramType, (String) value);
@@ -118,4 +125,13 @@ public final class ObjectMapper {
             }
         }
     }
+
+    private static boolean shouldIgnoreProperty(final String propertyKey) {
+        for(String property: kIgnoredProperties) {
+           if (property.equals(propertyKey)) {
+               return true;
+           }
+        }
+        return false;
+    }
 }

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

@@ -29,33 +29,34 @@ import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import io.scanbot.barcodesdk.plugin.reactnative.barcode.ScanbotBarcodeDetectorConfigBuilder;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.LogUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.ResponseUtils;
 import io.scanbot.sap.SdkLicenseInfo;
 import io.scanbot.sdk.barcode.ScanbotBarcodeDetector;
 import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat;
 import io.scanbot.sdk.barcode.entity.BarcodeFormat;
 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.BarcodeExtensionsFilter;
 import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeFilter;
 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 android.app.Activity;
-import android.util.Log;
 
 
 public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implements ActivityEventListener {
@@ -170,62 +171,37 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
         if (rejectIfUninitialized(promise)) {
             return;
         }
-        this.threadPool.execute(new Runnable() {
-            public void run() {
-                try {
-                    String imageUri = options.getString("imageFileUri");
-                    final ArrayList<BarcodeFormat> barcodeFormats = JSONUtils.extractBarcodeFormats(options);
-                    final ArrayList<BarcodeDocumentFormat> barcodeDocumentFormats = JSONUtils.extractBarcodeDocumentFormats(options);
-
-                    final Bitmap bitmap = MediaStore.Images.Media.getBitmap(getReactApplicationContext().getContentResolver(), Uri.parse(imageUri));
-                    final ScanbotBarcodeScannerSDK sdk = new ScanbotBarcodeScannerSDK(getReactApplicationContext());
-                    final ScanbotBarcodeDetector detector = sdk.createBarcodeDetector();
-
-                    detector.modifyConfig(new Function1<BarcodeScannerConfigBuilder, Unit>() {
-                        @Override
-                        public Unit invoke(BarcodeScannerConfigBuilder barcodeScannerConfigBuilder) {
-                            if (!barcodeFormats.isEmpty()) {
-                                barcodeScannerConfigBuilder.setBarcodeFormats(barcodeFormats);
-                            }
-
-                            if (!barcodeDocumentFormats.isEmpty()) {
-                                barcodeScannerConfigBuilder.setAcceptedDocumentFormats(barcodeDocumentFormats);
-                            }
-
-                            // Additional Configuration
-                            barcodeScannerConfigBuilder.modifyAdditionalConfig(new Function1<BarcodeScannerAdditionalConfigBuilder, Unit>() {
-                                @Override
-                                public Unit invoke(BarcodeScannerAdditionalConfigBuilder barcodeScannerAdditionalConfigBuilder) {
-
-                                    if (options.hasKey("minimumTextLength")) {
-                                        barcodeScannerAdditionalConfigBuilder.setMinimumTextLength(options.getInt("minimumTextLength"));
-                                    }
-
-                                    if (options.hasKey("maximumTextLength")) {
-                                        barcodeScannerAdditionalConfigBuilder.setMaximumTextLength(options.getInt("maximumTextLength"));
-                                    }
-
-                                    if (options.hasKey("minimum1DBarcodesQuietZone")) {
-                                        barcodeScannerAdditionalConfigBuilder.setMinimum1DQuietZoneSize(options.getInt("minimum1DBarcodesQuietZone"));
-                                    }
-
-                                    return Unit.INSTANCE;
-                                }
-                            });
-
-                            return Unit.INSTANCE;
-                        }
-                    });
+        this.threadPool.execute(() -> {
+            try {
+                final String imageUri = options.getString("imageFileUri");
 
-                    BarcodeScanningResult result = detector.detectFromBitmap(bitmap, 0);
+                final Bitmap bitmap = MediaStore.Images.Media.getBitmap(getReactApplicationContext().getContentResolver(), Uri.parse(imageUri));
+                final ScanbotBarcodeScannerSDK sdk = new ScanbotBarcodeScannerSDK(getReactApplicationContext());
 
-                    WritableMap jsonResult = jsonResultFromBarcodeScannerResult(result);
-                    jsonResult.putString("imageFileUri", imageUri);
-                    promise.resolve(jsonResult);
+                final ScanbotBarcodeDetector detector = sdk.createBarcodeDetector();
 
-                } catch (Exception ex) {
-                    promise.reject(ex);
+                detector.modifyConfig(new ScanbotBarcodeDetectorConfigBuilder(options));
+
+                final BarcodeScanningResult result = detector.detectFromBitmap(bitmap, 0);
+                WritableMap jsonResult;
+
+                final boolean shouldFilterBarcodes = options.hasKey("barcodeFilter");
+                if (shouldFilterBarcodes) {
+                    final BarcodeFilter barcodeFilter = JSONUtils.extractBarcodeFilter(options);
+                    if (barcodeFilter == null) {
+                        throw new IllegalArgumentException("Invalid Barcode Filter specified in JSON configuration: " + options.getString("barcodeFilter"));
+                    }
+                    final List<BarcodeItem> barcodeItems = JSONUtils.getBarcodeItemsFromResultWithFilter(result, barcodeFilter);
+                    jsonResult = jsonResultFromBarcodeScannerResult(barcodeItems);
+                } else {
+                    jsonResult = jsonResultFromBarcodeScannerResult(result);
                 }
+
+                jsonResult.putString("imageFileUri", imageUri);
+                promise.resolve(jsonResult);
+
+            } catch (Exception ex) {
+                promise.reject(ex);
             }
         });
     }
@@ -402,25 +378,27 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
         }
     }
 
-    private static WritableMap jsonResultFromBarcodeScannerResult(BarcodeScanningResult barcodeResult) {
+    private static WritableMap jsonResultFromBarcodeScannerResult(List<BarcodeItem> barcodeItems) {
         final WritableArray barcodes = Arguments.createArray();
-
-        if (barcodeResult != null) {
-            for (BarcodeItem barcodeItem : barcodeResult.getBarcodeItems()) {
-                final WritableMap barcode = Arguments.createMap();
-                barcode.putString("type", barcodeItem.getBarcodeFormat().name());
-                barcode.putString("text", barcodeItem.getText());
-                barcode.putString("textWithExtension", barcodeItem.getTextWithExtension());
-                barcodes.pushMap(barcode);
-            }
+        for (BarcodeItem barcodeItem : barcodeItems) {
+            final WritableMap barcode = Arguments.createMap();
+            barcode.putString("type", barcodeItem.getBarcodeFormat().name());
+            barcode.putString("text", barcodeItem.getText());
+            barcode.putString("textWithExtension", barcodeItem.getTextWithExtension());
+            barcodes.pushMap(barcode);
         }
-
         final WritableMap result = Arguments.createMap();
         result.putString("status", "OK");
         result.putArray("barcodes", barcodes);
         return result;
     }
 
+    private static WritableMap jsonResultFromBarcodeScannerResult(BarcodeScanningResult barcodeResult) {
+        return jsonResultFromBarcodeScannerResult(
+            barcodeResult != null ? barcodeResult.getBarcodeItems() : new ArrayList<>()
+        );
+    }
+
     @NotNull
     @Contract(pure = true)
     private static String descriptionFromLicenseStatus(@NotNull io.scanbot.sap.Status status) {

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

@@ -0,0 +1,36 @@
+package io.scanbot.barcodesdk.plugin.reactnative.barcode;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
+import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfig;
+import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfigBuilder;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+
+class ScanbotBarcodeDetectorAdditionalConfigBuilder implements Function1<BarcodeScannerAdditionalConfigBuilder, Unit> {
+
+    final ReadableMap options;
+
+    public ScanbotBarcodeDetectorAdditionalConfigBuilder(final ReadableMap options) {
+        this.options = options;
+    }
+
+    @Override
+    public Unit invoke(BarcodeScannerAdditionalConfigBuilder builder) {
+        final BarcodeScannerAdditionalConfig config = JSONUtils.extractBarcodeScannerAdditionalConfig(options);
+        if (config == null) {
+            return Unit.INSTANCE;
+        }
+
+        builder.setLowPowerMode(config.getLowPowerMode());
+        builder.setMinimumTextLength(config.getMinimumTextLength());
+        builder.setMaximumTextLength(config.getMaximumTextLength());
+        builder.setMinimum1DQuietZoneSize(config.getMinimum1DQuietZoneSize());
+        builder.setStripCheckDigits(config.getStripCheckDigits());
+        builder.setGs1DecodingEnabled(config.getGs1DecodingEnabled());
+        builder.setMsiPlesseyChecksumAlgorithms(config.getMsiPlesseyChecksumAlgorithms());
+
+        return Unit.INSTANCE;
+    }
+}

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

@@ -0,0 +1,45 @@
+package io.scanbot.barcodesdk.plugin.reactnative.barcode;
+
+import com.facebook.react.bridge.ReadableMap;
+
+import java.util.ArrayList;
+
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
+import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat;
+import io.scanbot.sdk.barcode.entity.BarcodeFormat;
+import io.scanbot.sdk.barcode.entity.BarcodeScannerConfigBuilder;
+import io.scanbot.sdk.barcode.entity.EngineMode;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+
+public class ScanbotBarcodeDetectorConfigBuilder implements Function1<BarcodeScannerConfigBuilder, Unit> {
+
+    final ReadableMap options;
+
+    public ScanbotBarcodeDetectorConfigBuilder(final ReadableMap options) {
+        this.options = options;
+    }
+
+    @Override
+    public Unit invoke(BarcodeScannerConfigBuilder barcodeScannerConfigBuilder) {
+        final ArrayList<BarcodeFormat> barcodeFormats = JSONUtils.extractBarcodeFormats(options);
+        final ArrayList<BarcodeDocumentFormat> barcodeDocumentFormats = JSONUtils.extractBarcodeDocumentFormats(options);
+
+        if (!barcodeFormats.isEmpty()) {
+            barcodeScannerConfigBuilder.setBarcodeFormats(barcodeFormats);
+        }
+
+        if (!barcodeDocumentFormats.isEmpty()) {
+            barcodeScannerConfigBuilder.setAcceptedDocumentFormats(barcodeDocumentFormats);
+        }
+
+        // Engine Mode
+        final EngineMode engineMode = JSONUtils.extractEngineMode(options);
+        barcodeScannerConfigBuilder.setEngineMode(engineMode);
+
+        // Additional Configuration
+        barcodeScannerConfigBuilder.modifyAdditionalConfig(new ScanbotBarcodeDetectorAdditionalConfigBuilder(options));
+
+        return Unit.INSTANCE;
+    }
+}

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

@@ -25,7 +25,8 @@ 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.barcode.ScanbotBarcodeDetectorConfigBuilder;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.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;
@@ -133,34 +134,28 @@ public class ScanbotBarcodeCameraViewFragment extends Fragment implements Barcod
                 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.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;
+        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;
         });
     }
 

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

@@ -20,7 +20,7 @@ import com.facebook.react.uimanager.annotations.ReactProp;
 
 import java.util.Map;
 
-import io.scanbot.barcodesdk.plugin.reactnative.JSONUtils;
+import io.scanbot.barcodesdk.plugin.reactnative.utils.JSONUtils;
 import io.scanbot.barcodesdk.plugin.reactnative.ObjectMapper;
 import io.scanbot.barcodesdk.plugin.reactnative.R;
 import io.scanbot.barcodesdk.plugin.reactnative.components.EventEmitter;

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

@@ -0,0 +1,59 @@
+package io.scanbot.barcodesdk.plugin.reactnative.filters;
+
+import androidx.annotation.NonNull;
+
+import java.util.Map;
+
+import io.scanbot.sdk.barcode.entity.BarcodeItem;
+import io.scanbot.sdk.barcode.entity.BarcodeMetadataKey;
+import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeFilter;
+
+public class ReactBarcodeExtensionsFilter extends BarcodeFilter {
+
+    public enum Type {
+        WithExtension,
+        WithEAN2Extension,
+        WithEAN5Extension
+    }
+
+    private final Type filterType;
+
+    public ReactBarcodeExtensionsFilter(Type filterType) {
+        this.filterType = filterType;
+    }
+
+    @Override
+    public boolean acceptsBarcode(@NonNull BarcodeItem barcodeItem) {
+        if (!super.acceptsBarcode(barcodeItem)) {
+            return false;
+        }
+
+        final String extension = getExtensionOrEmpty(barcodeItem);
+        if(extension.equals("")) {
+            return false;
+        }
+
+        switch(this.filterType) {
+            case WithExtension:
+                return true;
+            case WithEAN2Extension:
+                return extension.trim().length() == 2;
+            case WithEAN5Extension:
+                return extension.trim().length() == 5;
+            default:
+                return false;
+        }
+    }
+
+    private static String getExtensionOrEmpty(final BarcodeItem barcodeItem)
+    {
+        final Map<BarcodeMetadataKey, String> metadata = barcodeItem.getMetadata();
+
+        if (!metadata.containsKey(BarcodeMetadataKey.UpcEanExtension)
+        ) {
+            return "";
+        }
+
+        return metadata.get(BarcodeMetadataKey.UpcEanExtension);
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2020 doo GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+package io.scanbot.barcodesdk.plugin.reactnative.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.net.Uri;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import io.scanbot.barcodesdk.plugin.reactnative.StorageUtils;
+
+public class BitmapHelper {
+    public static File storeImageAsFile(final Bitmap image, final int quality, final Context context) throws IOException {
+        final File pictureFile = StorageUtils.generateRandomPluginStorageFile("jpg", context);
+        final FileOutputStream fos = new FileOutputStream(pictureFile);
+        image.compress(Bitmap.CompressFormat.JPEG, quality, fos);
+        fos.close();
+        return pictureFile;
+    }
+
+    public static Uri storeImage(final Bitmap image, final int quality, final Context context) throws IOException {
+        return Uri.fromFile(storeImageAsFile(image, quality, context));
+    }
+}

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

@@ -0,0 +1,286 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2020 doo GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+package io.scanbot.barcodesdk.plugin.reactnative.utils;
+
+import android.graphics.PointF;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+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;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Objects;
+
+import io.scanbot.barcodesdk.plugin.reactnative.filters.ReactBarcodeExtensionsFilter;
+import io.scanbot.sdk.barcode.entity.BarcodeDocumentFormat;
+import io.scanbot.sdk.barcode.entity.BarcodeFormat;
+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.barcode.entity.EngineMode;
+import io.scanbot.sdk.barcode.entity.MSIPlesseyChecksumAlgorithm;
+import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeFilter;
+import io.scanbot.sdk.ui.view.barcode.configuration.BarcodeScannerAdditionalConfiguration;
+import io.scanbot.sdk.ui.view.base.configuration.CameraOrientationMode;
+
+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) {
+            for (final PointF p: polygon) {
+                WritableMap pointRecord = Arguments.createMap();
+                pointRecord.putDouble("x", p.x);
+                pointRecord.putDouble("y", p.y);
+                points.pushMap(pointRecord);
+            }
+        }
+        return points;
+    }
+
+    public static ArrayList<BarcodeFormat> extractBarcodeFormats(@NotNull ReadableMap configuration) {
+        ArrayList<BarcodeFormat> nativeBarcodeFormats = new ArrayList<>();
+        if (configuration.hasKey("barcodeFormats")) {
+            ReadableArray barcodeFormats = configuration.getArray("barcodeFormats");
+            if (barcodeFormats != null) {
+                for (int i = 0; i < barcodeFormats.size(); ++i) {
+                    nativeBarcodeFormats.add(BarcodeFormat.valueOf(barcodeFormats.getString(i)));
+                }
+            }
+        }
+        return nativeBarcodeFormats;
+    }
+
+    public static ArrayList<BarcodeDocumentFormat> extractBarcodeDocumentFormats(final ReadableMap configuration) {
+        ArrayList<BarcodeDocumentFormat> nativeBarcodeDocumentFormats = new ArrayList<>();
+        ArrayList<String> barcodeDocumentFormats = JSONUtils.getStringArrayListFromMap(configuration, "acceptedDocumentFormats");
+
+        for (String format : barcodeDocumentFormats) {
+            nativeBarcodeDocumentFormats.add(BarcodeDocumentFormat.valueOf(format));
+        }
+
+        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;
+
+        int minimumTextLength = BarcodeScannerAdditionalConfig.DEFAULT_MIN_TEXT_LENGTH;
+        if (configuration.hasKey("minimumTextLength")) {
+            minimumTextLength = configuration.getInt("minimumTextLength");
+            changed = true;
+        }
+
+        int maximumTextLength = BarcodeScannerAdditionalConfig.DEFAULT_MAX_TEXT_LENGTH;
+        if (configuration.hasKey("maximumTextLength")) {
+            maximumTextLength = configuration.getInt("maximumTextLength");
+            changed = true;
+        }
+
+        int minimum1DQuietZoneSize = BarcodeScannerAdditionalConfig.DEFAULT_MIN_1D_QUIET_ZONE_SIZE;
+        if (configuration.hasKey("minimum1DBarcodesQuietZone")) {
+            minimum1DQuietZoneSize  = configuration.getInt("minimum1DBarcodesQuietZone");
+            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")) {
+            msiPlesseyChecksumAlgorithms.clear();
+            String algorithm = configuration.getString("msiPlesseyChecksumAlgorithm");
+            msiPlesseyChecksumAlgorithms.add(MSIPlesseyChecksumAlgorithm.valueOf(algorithm));
+            changed = true;
+        }
+
+        boolean stripCheckDigits = BarcodeScannerAdditionalConfig.DEFAULT_STRIP_CHECK_DIGITS;
+        if (configuration.hasKey("stripCheckDigits")) {
+            stripCheckDigits = configuration.getBoolean("stripCheckDigits");
+            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,
+                lowPowerMode
+        ) : 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(),
+                config.getLowPowerMode()
+        ) : null;
+    }
+
+    public static BarcodeFilter extractBarcodeFilter(final ReadableMap options) {
+        if (!options.hasKey("barcodeFilter")) {
+            return null;
+        }
+        final String filterType = options.getString("barcodeFilter");
+        try {
+            final ReactBarcodeExtensionsFilter.Type type =
+                    ReactBarcodeExtensionsFilter.Type.valueOf(filterType);
+            return new ReactBarcodeExtensionsFilter(type);
+        }
+        catch (IllegalArgumentException exception) {
+            final String errMsg = String.format("The value passed in 'barcodeFilter' (%s) does not exist", filterType);
+            Log.e("SCANBOT_SDK", errMsg);
+        }
+
+        return null;
+    }
+
+    public static List<BarcodeItem> getBarcodeItemsFromResultWithFilter(BarcodeScanningResult result, BarcodeFilter filter) {
+        if (result == null) {
+            return new ArrayList<>();
+        }
+
+        final List<BarcodeItem> filteredBarcodeItems = new ArrayList<>();
+        for (BarcodeItem barcodeItem : result.getBarcodeItems()) {
+            if (!filter.acceptsBarcode(barcodeItem)) { continue; }
+            filteredBarcodeItems.add(barcodeItem);
+        }
+        return filteredBarcodeItems;
+    }
+
+    public static ArrayList<String> getStringArrayListFromMap(final ReadableMap configuration, final String key) {
+        ArrayList<String> out = new ArrayList<>();
+        if(!configuration.hasKey(key)) {
+            return out;
+        }
+        ReadableArray nullable = configuration.getArray(key);
+        if (nullable != null) {
+            ArrayList<Object> objects = nullable.toArrayList();
+            for (Object obj : objects) {
+                try { out.add(Objects.toString(obj)); }
+                catch (ClassCastException ignored) {}
+            }
+        }
+        return out;
+    }
+
+    public static EngineMode extractEngineMode(ReadableMap configuration) {
+        if (!configuration.hasKey("engineMode")) {
+            return EngineMode.NextGen;
+        }
+
+        String mode = configuration.getString("engineMode");
+        if ("LEGACY".equals(mode)) {
+            return EngineMode.Legacy;
+        }
+        return EngineMode.NextGen;
+    }
+
+    public static boolean getBoolOrFalse(final ReadableMap map, final String key) {
+        if (!map.hasKey(key)) {
+            return false;
+        }
+        return map.getBoolean(key);
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2020 doo GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+package io.scanbot.barcodesdk.plugin.reactnative.utils;
+
+
+import android.util.Log;
+
+public final class LogUtils {
+
+    // global static loggingEnabled flag (set on ScanbotSdkPlugin.initializeSdk(..))
+    private static boolean loggingEnabled = false;
+
+    private LogUtils() {}
+
+    public static synchronized void setLoggingEnabled(final boolean flag) {
+        loggingEnabled = flag;
+    }
+
+    public static synchronized boolean isLoggingEnabled() {
+        return loggingEnabled;
+    }
+
+    public static void debugLog(final String logTag, final String msg) {
+        if (loggingEnabled) {
+            Log.d(logTag, msg);
+        }
+    }
+
+    public static void errorLog(final String logTag, final String msg) {
+        Log.e(logTag, msg);
+    }
+
+    public static void errorLog(final String logTag, final String msg, final Throwable e) {
+        Log.e(logTag, msg, e);
+    }
+
+}

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

@@ -0,0 +1,41 @@
+/*
+  Scanbot Barcode Scanner SDK React Native Plugin
+  Copyright (c) 2020 doo GmbH. All rights reserved.
+  https://scanbot.io/sdk
+ */
+package io.scanbot.barcodesdk.plugin.reactnative.utils;
+
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+public class ResponseUtils {
+
+    public static void successMessageJson(final String msg, final Promise promise) {
+        final WritableMap response = Arguments.createMap();
+        response.putString("status", "OK");
+        response.putString("message", msg);
+        promise.resolve(response);
+    }
+
+    public static void successCanceled(final Promise promise) {
+        final WritableMap response = Arguments.createMap();
+        response.putString("status", "CANCELED");
+        promise.resolve(response);
+    }
+
+    public static void errorMessageJson(final String msg, final Promise promise) {
+        final WritableMap response = Arguments.createMap();
+        response.putString("error", msg);
+        promise.reject(msg);
+    }
+
+    public static void sendReactEvent(String eventName, WritableMap event, View view) {
+        final ReactContext reactContext = (ReactContext)view.getContext();
+        reactContext.getJSModule(RCTEventEmitter.class).receiveEvent(view.getId(), eventName, event);
+    }
+}

package/ios/ScanbotBarcodeSdk.m

@@ -40,13 +40,13 @@ RCT_EXPORT_METHOD(initializeSdk:(NSDictionary *)configuration
 {
     [ObjectMapper setEnumerationMapping:@{
         @"barcodeImageGenerationType": @{
-                @"NONE": @(SBSDKBarcodeImageGenerationTypeNone),
-                @"VIDEO_FRAME": @(SBSDKBarcodeImageGenerationTypeFromVideoFrame),
-                @"CAPTURED_IMAGE" :@(SBSDKBarcodeImageGenerationTypeCapturedImage),
+            @"NONE": @(SBSDKBarcodeImageGenerationTypeNone),
+            @"VIDEO_FRAME": @(SBSDKBarcodeImageGenerationTypeFromVideoFrame),
+            @"CAPTURED_IMAGE" :@(SBSDKBarcodeImageGenerationTypeCapturedImage),
         },
         @"engineMode": @{
-                @"LEGACY": @(SBSDKBarcodeEngineModeLegacy),
-                @"NEXT_GEN": @(SBSDKBarcodeEngineModeNextGen)
+            @"LEGACY": @(SBSDKBarcodeEngineModeLegacy),
+            @"NEXT_GEN": @(SBSDKBarcodeEngineModeNextGen)
         },
         @"allowedInterfaceOrientations": @{
             @"NONE": @(UIInterfaceOrientationMaskAll),
@@ -120,35 +120,24 @@ RCT_EXPORT_METHOD(startBarcodeScanner:(NSDictionary*)configuration
     SBSDKUIBarcodeScannerUIConfiguration* uiConfig = [[SBSDKUIBarcodeScannerUIConfiguration alloc] init];
     SBSDKUIBarcodeScannerBehaviorConfiguration* behaviorConfig = [[SBSDKUIBarcodeScannerBehaviorConfiguration alloc] init];
     SBSDKUIBarcodeScannerTextConfiguration* textConfig = [[SBSDKUIBarcodeScannerTextConfiguration alloc] init];
-    SBSDKBarcodeAdditionalParameters* additionalParameters = [[SBSDKBarcodeAdditionalParameters alloc] init];
     
     @try {
         [ObjectMapper populateInstance:uiConfig fromDictionary:configuration];
         [ObjectMapper populateInstance:behaviorConfig fromDictionary:configuration];
         [ObjectMapper populateInstance:textConfig fromDictionary:configuration];
-        [ObjectMapper populateInstance:additionalParameters fromDictionary:configuration];
     }
     @catch (NSException* ex) {
         reject(@"Property error", [ex reason], nil);
         return;
     }
     
-    // Need to manually extract because of naming disparity between iOS and Android
-    // Also, it is nullable, 'true' by default, so we wrap it in an NSNumber
-    NSNumber* gs1Decoding = [configuration objectForKey:@"gs1DecodingEnabled"];
-    if (gs1Decoding != nil) {
-       additionalParameters.enableGS1Decoding = [gs1Decoding boolValue];
-    }
-    
     // Barcode Filter (at the moment used for UPC Extension filters)
     SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
     if (barcodeFilter != nil) {
         behaviorConfig.barcodeFilter = barcodeFilter;
     }
     
-    additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
-    
-    behaviorConfig.additionalParameters = additionalParameters;
+    behaviorConfig.additionalParameters = extractAdditionalParameters(configuration);
 
     NSArray* machineCodeTypes = extractBarcodeTypesFromConfiguration(configuration);
     NSArray* acceptedDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
@@ -184,47 +173,34 @@ RCT_EXPORT_METHOD(closeBarcodeScanner:(RCTPromiseResolveBlock)resolve
 RCT_EXPORT_METHOD(startBatchBarcodeScanner:(NSDictionary*)configuration
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject) {
-    SBSDKUIBarcodesBatchScannerUIConfiguration *ui =
-                [[SBSDKUIBarcodesBatchScannerUIConfiguration alloc] init];
-    SBSDKUIBarcodesBatchScannerTextConfiguration *text =
-                [[SBSDKUIBarcodesBatchScannerTextConfiguration alloc] init];
-    SBSDKUIBarcodesBatchScannerBehaviorConfiguration *behavior =
-                [[SBSDKUIBarcodesBatchScannerBehaviorConfiguration alloc] init];
-    SBSDKBarcodeAdditionalParameters* additionalParameters = [[SBSDKBarcodeAdditionalParameters alloc] init];
-    
+
+    SBSDKUIBarcodesBatchScannerUIConfiguration *ui = [[SBSDKUIBarcodesBatchScannerUIConfiguration alloc] init];
+    SBSDKUIBarcodesBatchScannerTextConfiguration *text = [[SBSDKUIBarcodesBatchScannerTextConfiguration alloc] init];
+    SBSDKUIBarcodesBatchScannerBehaviorConfiguration *behavior = [[SBSDKUIBarcodesBatchScannerBehaviorConfiguration alloc] init];
+
     @try {
         [ObjectMapper populateInstance:ui fromDictionary:configuration];
         [ObjectMapper populateInstance:behavior fromDictionary:configuration];
         [ObjectMapper populateInstance:text fromDictionary:configuration];
-        [ObjectMapper populateInstance:additionalParameters fromDictionary:configuration];
     }
     @catch (NSException* ex) {
         reject(@"Property error", [ex reason], nil);
         return;
     }
-    
-    // Need to manully extract because of naming disparity between iOS and Android
-    // Also, it is nullable, 'true' by default, so we wrap it in an NSNumber
-    NSNumber* gs1Decoding = [configuration objectForKey:@"gs1DecodingEnabled"];
-    if (gs1Decoding != nil) {
-       additionalParameters.enableGS1Decoding = [gs1Decoding boolValue];
-    }
-    
+        
     // Barcode Filter (at the moment used for UPC Extension filters)
     SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
     if (barcodeFilter != nil) {
         behavior.barcodeFilter = barcodeFilter;
     }
 
-    additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
-    
-    behavior.additionalDetectionParameters = additionalParameters;
-    
+    behavior.additionalDetectionParameters = extractAdditionalParameters(configuration);
+
     SBSDKUIBarcodesBatchScannerConfiguration *config = [[SBSDKUIBarcodesBatchScannerConfiguration alloc]
                                                         initWithUIConfiguration:ui
                                                         textConfiguration:text
                                                         behaviorConfiguration:behavior];
-    
+
     NSArray* machineCodeTypes = extractBarcodeTypesFromConfiguration(configuration);
     NSArray* acceptedDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
 
@@ -270,16 +246,32 @@ RCT_EXPORT_METHOD(detectBarcodesOnImage:(NSDictionary *)configuration
         return;
     }
     
-    NSArray* barcodeTypes = [ScanbotBarcodeSdk extractBarcodeTypesFromConfiguration:configuration];
-
     runInBackground(^{
+        
+        NSArray* barcodeTypes = [ScanbotBarcodeSdk extractBarcodeTypesFromConfiguration:configuration];
         SBSDKBarcodeScanner* barcodeScanner = [[SBSDKBarcodeScanner alloc] initWithTypes:barcodeTypes];
+    
+        NSArray* barcodeDocumentTypes = extractBarcodeDocumentTypesFromConfiguration(configuration);
+        [barcodeScanner setAcceptedDocumentTypes: barcodeDocumentTypes];
+        
+        SBSDKBarcodeEngineMode engineMode = extractEngineMode(configuration);
+        [barcodeScanner setEngineMode:engineMode];
+        
+        SBSDKBarcodeAdditionalParameters* additionalParameters = extractAdditionalParameters(configuration);
+        [barcodeScanner setAdditionalParameters:additionalParameters];
+        
         UIImage* image = [ScanbotStorageUtils loadImage:imageUri];
         if (!image) {
             [self reportErrorWithMessage:@"Image could not be loaded." reject:reject];
             return;
         }
         NSArray<SBSDKBarcodeScannerResult *> *barcodeResults = [barcodeScanner detectBarCodesOnImage:image];
+        
+        SBSDKUIBarcodeFilter* barcodeFilter = extractBarcodeFilter(configuration);
+        if (barcodeFilter != nil) {
+            barcodeResults = filterBarcodeResults(barcodeResults, barcodeFilter);
+        }
+        
         resolve(@{
            @"status": @"OK",
            @"barcodes": jsonFromBarcodeResults(barcodeResults),

package/ios/Utils/BarcodeMapping.h

@@ -87,6 +87,22 @@ static inline NSArray<NSDictionary<NSString*, NSObject*>*>* jsonFromMappedBarcod
     return [jsonResults copy];
 }
 
+static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgorithmFromConfiguration(NSDictionary* configuration) {
+    NSString* algorithm = [configuration objectForKey:@"msiPlesseyChecksumAlgorithm"];
+
+    if (algorithm != nil) {
+        if ([algorithm isEqualToString:@"None"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmNone;
+        if ([algorithm isEqualToString:@"Mod10"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
+        if ([algorithm isEqualToString:@"Mod1010"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1010;
+        if ([algorithm isEqualToString:@"Mod11IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11IBM;
+        if ([algorithm isEqualToString:@"Mod11NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11NCR;
+        if ([algorithm isEqualToString:@"Mod1110IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110IBM;
+        if ([algorithm isEqualToString:@"Mod1110NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110NCR;
+    }
+
+    return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
+}
+
 static inline SBSDKUIBarcodeFilter* extractBarcodeFilter(NSDictionary* configuration) {
     NSString* jsonFilterType = [configuration objectForKey:@"barcodeFilter"];
     if (jsonFilterType == nil) {
@@ -104,6 +120,21 @@ static inline SBSDKUIBarcodeFilter* extractBarcodeFilter(NSDictionary* configura
     return nil;
 }
 
+static inline NSArray* filterBarcodeResults(NSArray<SBSDKBarcodeScannerResult *>* barcodeResults, SBSDKUIBarcodeFilter* filter) {
+    NSMutableArray<SBSDKBarcodeScannerResult *>* outResults = [[NSMutableArray alloc] init];
+
+    if (barcodeResults == nil) {
+        return outResults;
+    }
+
+    for (SBSDKBarcodeScannerResult* result in barcodeResults) {
+        if (![filter acceptsBarcode:result]) { continue; }
+        [outResults addObject:result];
+    }
+
+    return outResults;
+}
+
 static inline NSArray* extractBarcodeTypesFromConfiguration(NSDictionary* configuration) {
     NSArray* barcodeFormats = [configuration objectForKey:@"barcodeFormats"];
     if (barcodeFormats && [barcodeFormats indexOfObject:@"ALL_FORMATS"] == NSNotFound) {
@@ -144,20 +175,26 @@ static inline SBSDKBarcodeEngineMode extractEngineMode(NSDictionary* configurati
     return SBSDKBarcodeEngineModeNextGen;
 }
 
-static inline SBSDKBarcodeMSIPlesseyChecksumAlgorithm extractPlesseyChecksumAlgorithmFromConfiguration(NSDictionary* configuration) {
-    NSString* algorithm = [configuration objectForKey:@"msiPlesseyChecksumAlgorithm"];
-
-    if (algorithm != nil) {
-        if ([algorithm isEqualToString:@"None"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmNone;
-        if ([algorithm isEqualToString:@"Mod10"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
-        if ([algorithm isEqualToString:@"Mod1010"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1010;
-        if ([algorithm isEqualToString:@"Mod11IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11IBM;
-        if ([algorithm isEqualToString:@"Mod11NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod11NCR;
-        if ([algorithm isEqualToString:@"Mod1110IBM"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110IBM;
-        if ([algorithm isEqualToString:@"Mod1110NCR"]) return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod1110NCR;
+static inline SBSDKBarcodeAdditionalParameters* extractAdditionalParameters(NSDictionary* configuration) {
+    SBSDKBarcodeAdditionalParameters* additionalParameters = [[SBSDKBarcodeAdditionalParameters alloc] init];
+    @try {
+        [ObjectMapper populateInstance:additionalParameters fromDictionary:configuration];
     }
-
-    return SBSDKBarcodeMSIPlesseyChecksumAlgorithmMod10;
+    @catch (NSException* ex) {
+        return nil;
+    }
+    
+    // Need to manually extract because of naming disparity between iOS and Android
+    // Also, it is nullable, 'true' by default, so we wrap it in an NSNumber
+    NSNumber* gs1Decoding = [configuration objectForKey:@"gs1DecodingEnabled"];
+    if (gs1Decoding != nil) {
+        additionalParameters.enableGS1Decoding = [gs1Decoding boolValue];
+    }
+    
+    // We also need to manually extract the MSI-Plessey Checksum Algorithm since it can't be mapped automatically
+    additionalParameters.msiPlesseyChecksumAlgorithm = extractPlesseyChecksumAlgorithmFromConfiguration(configuration);
+    
+    return additionalParameters;
 }
 
 static inline SBSDKUICameraConfiguration* extractCameraConfiguration(NSDictionary* configuration) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-scanbot-barcode-scanner-sdk",
   "title": "Scanbot Barcode Scanner SDK for React Native",
-  "version": "3.2.1-beta3",
+  "version": "3.2.1-beta4",
   "description": "Scanbot Barcode Scanner SDK React Native Plugin for Android and iOS",
   "main": "index.js",
   "files": [