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

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

@@ -6,6 +6,7 @@
 package io.scanbot.barcodesdk.plugin.reactnative;
 
 import android.graphics.PointF;
+import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -30,6 +31,7 @@ import io.scanbot.sdk.barcode.entity.BarcodeFormat;
 import io.scanbot.sdk.barcode.entity.BarcodeScannerAdditionalConfig;
 import io.scanbot.sdk.barcode.entity.EngineMode;
 import io.scanbot.sdk.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;
 
@@ -214,6 +216,25 @@ public final class JSONUtils {
         ) : 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) {
+            exception.printStackTrace();
+            final String errMsg = String.format("The value passed in 'barcodeFilter' (%s) does not exist", filterType);
+            Log.e("SCANBOT_SDK", errMsg);
+        }
+
+        return null;
+    }
+
     public static ArrayList<String> getStringArrayListFromMap(final ReadableMap configuration, final String key) {
         ArrayList<String> out = new ArrayList<>();
         if(!configuration.hasKey(key)) {

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 ("onlyAcceptCodesWithExtensions".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/ReactBarcodeExtensionsFilter.java

@@ -0,0 +1,61 @@
+package io.scanbot.barcodesdk.plugin.reactnative;
+
+import androidx.annotation.NonNull;
+
+import java.util.List;
+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;
+import io.scanbot.sdk.ui.view.barcode.configuration.IBarcodeFilter;
+
+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/ScanbotBarcodeSdkModule.java

@@ -29,28 +29,32 @@ 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.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;
 
@@ -167,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);
             }
         });
     }
@@ -306,6 +285,13 @@ public class ScanbotBarcodeSdkModule extends ReactContextBaseJavaModule implemen
         if (options.hasKey("replaceCancelButtonWithIcon") && options.getBoolean("replaceCancelButtonWithIcon")) {
             configuration.setCancelButtonIcon(R.drawable.ic_baseline_arrow_back_24);
         }
+
+        if (options.hasKey("barcodeFilter")) {
+            final BarcodeFilter barcodeFilter = JSONUtils.extractBarcodeFilter(options);
+            if (barcodeFilter != null) {
+                configuration.setBarcodeFilter(barcodeFilter);
+            }
+        }
     }
 
     @ReactMethod
@@ -392,24 +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());
-                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));
+    }
+}