react-native-scanbot-barcode-scanner-sdk 3.2.1-beta2 → 3.2.1-beta5

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;
     }
     
-    // UPC Extension filter
-    NSNumber* shouldApplyExtensionFilter = [configuration objectForKey:@"onlyAcceptCodesWithExtensions"];
-    if (shouldApplyExtensionFilter != nil && [shouldApplyExtensionFilter boolValue]) {
-        behaviorConfig.barcodeFilter = [[SBSDKUIBarcodeExtensionsFilter alloc] init];
-    }
-
-    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];
-    }
-    
-    // UPC Extension filter
-    NSNumber* shouldApplyExtensionFilter = [configuration objectForKey:@"onlyAcceptCodesWithExtensions"];
-    if (shouldApplyExtensionFilter != nil && [shouldApplyExtensionFilter boolValue]) {
-        behavior.barcodeFilter = [[SBSDKUIBarcodeExtensionsFilter alloc] init];
+        
+    // 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

@@ -8,6 +8,7 @@
 #define BarcodeMapping_h
 
 #include "ScanbotStorageUtils.h"
+#include "ReactBarcodeExtensionsFilter.h"
 @import ScanbotBarcodeScannerSDK;
 
 static inline SBSDKBarcodeType* barcodeTypeFromString(NSString* string) {
@@ -86,6 +87,54 @@ 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) {
+        return nil;
+    }
+    
+    if ([jsonFilterType isEqualToString:@"WithExtension"]) {
+        return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithExtension];
+    } else if ([jsonFilterType isEqualToString:@"WithEAN2Extension"]) {
+        return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithEAN2Extension];
+    } else if ([jsonFilterType isEqualToString:@"WithEAN5Extension"]) {
+        return [[ReactBarcodeExtensionsFilter alloc] init:ReactBarcodeExtensionsFilterWithEAN5Extension];
+    }
+    
+    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) {
@@ -126,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/ios/Utils/ReactBarcodeExtensionsFilter.h

@@ -0,0 +1,22 @@
+//
+//  ReactBarcodeExtensionsFilter.h
+//  RNScanbotBarcodeSDK
+//
+//  Created by Marco Saia on 13.07.22.
+//
+
+#import <Foundation/Foundation.h>
+@import ScanbotBarcodeScannerSDK;
+
+typedef enum BarcodeFilterType : NSUInteger {
+    ReactBarcodeExtensionsFilterWithExtension,
+    ReactBarcodeExtensionsFilterWithEAN2Extension,
+    ReactBarcodeExtensionsFilterWithEAN5Extension
+} BarcodeFilterType;
+
+@interface ReactBarcodeExtensionsFilter : SBSDKUIBarcodeFilter
+
+- (instancetype)init NS_UNAVAILABLE;
+- (id)init:(BarcodeFilterType)filterType;
+
+@end