simple-dynamsoft-mcp 1.0.0

package/code-snippet/android/FoundationalAPISamples/GeneralSettings/src/main/java/com/dynamsoft/dbr/generalsettings/models/DecodeSettings.java

@@ -0,0 +1,279 @@
+package com.dynamsoft.dbr.generalsettings.models;
+
+import android.util.Range;
+
+import androidx.databinding.BaseObservable;
+import androidx.databinding.Bindable;
+
+import com.dynamsoft.core.basic_structures.EnumErrorCode;
+import com.dynamsoft.cvr.CaptureVisionRouter;
+import com.dynamsoft.cvr.CaptureVisionRouterException;
+import com.dynamsoft.cvr.EnumPresetTemplate;
+import com.dynamsoft.cvr.SimplifiedCaptureVisionSettings;
+import com.dynamsoft.dbr.EnumBarcodeFormat;
+import com.dynamsoft.dbr.EnumDeblurMode;
+import com.dynamsoft.dbr.EnumLocalizationMode;
+import com.dynamsoft.dbr.generalsettings.BR;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+public class DecodeSettings extends BaseObservable {
+    public static final Range<Integer> expectedBarcodesCountRange = new Range<>(0, 99999);
+    public static final Range<Integer> minResultConfidenceRange = new Range<>(0, 100);
+    public static final Range<Integer> scaleDownThresholdRange = new Range<>(512, Integer.MAX_VALUE);
+    public static final Range<Integer> minBarcodeTextLengthRange = new Range<>(0, 999);
+    public static final Range<Integer> timeoutRange = new Range<>(0, 100000);
+    public static final Range<Integer> minDecodeIntervalRange = new Range<>(0, 100000);
+
+    @Bindable
+    private String selectedPresetTemplateName = EnumPresetTemplate.PT_READ_BARCODES_SPEED_FIRST;
+    @Bindable
+    private String importedTemplateContent = null;
+    @Bindable
+    public boolean ifUseImportedTemplate;
+    @Bindable
+    public boolean ifImportedTemplateIsComplex;
+    private int timeout;
+    private int minDecodeInterval;
+    private long barcodeFormat;
+    private int expectedBarcodesCount;
+    @EnumLocalizationMode
+    private int[] localizationModes;
+    @EnumDeblurMode
+    private int[] deblurModes;
+    private int[] grayscaleEnhancementModes;
+    private int[] grayscaleTransformationModes;
+    private int minResultConfidence;
+    private int scaleDownThreshold;
+    private String barcodeTextRegExPattern;
+    private int minBarcodeTextLength;
+
+    public DecodeSettings() {
+        init();
+    }
+
+    public void init() {
+        try {
+            CaptureVisionRouter router = new CaptureVisionRouter();
+            if (ifUseImportedTemplate) {
+                router.initSettings(importedTemplateContent);
+            }
+            SimplifiedCaptureVisionSettings settings = router.getSimplifiedSettings(selectedPresetTemplateName);
+            assert settings.barcodeSettings != null;
+            timeout = settings.timeout;
+            minDecodeInterval = settings.minImageCaptureInterval;
+            barcodeFormat = settings.barcodeSettings.barcodeFormatIds;
+            expectedBarcodesCount = settings.barcodeSettings.expectedBarcodesCount;
+            localizationModes = settings.barcodeSettings.localizationModes;
+            deblurModes = settings.barcodeSettings.deblurModes;
+            grayscaleEnhancementModes = settings.barcodeSettings.grayscaleEnhancementModes;
+            grayscaleTransformationModes = settings.barcodeSettings.grayscaleTransformationModes;
+            minResultConfidence = settings.barcodeSettings.minResultConfidence;
+            scaleDownThreshold = settings.barcodeSettings.scaleDownThreshold;
+            barcodeTextRegExPattern = settings.barcodeSettings.barcodeTextRegExPattern;
+            minBarcodeTextLength = settings.barcodeSettings.minBarcodeTextLength;
+            setImportedTemplateIsComplex(false);
+        } catch (CaptureVisionRouterException e) {
+            if(e.getErrorCode() == EnumErrorCode.EC_CONVERT_COMPLEX_TEMPLATE_ERROR) {
+                setImportedTemplateIsComplex(true);
+            }
+        }
+    }
+
+    public String getSelectedPresetTemplateName() {
+        return selectedPresetTemplateName;
+    }
+
+    public void setSelectedPresetTemplateName(String selectedPresetTemplate) {
+        if(!this.selectedPresetTemplateName.equals(selectedPresetTemplate)) {
+            this.selectedPresetTemplateName = selectedPresetTemplate;
+            init();
+            notifyPropertyChanged(BR.selectedPresetTemplateName);
+        }
+    }
+
+    public String getImportedTemplateContent() {
+        return importedTemplateContent;
+    }
+
+    public void setImportedTemplateContent(String importedTemplateContent) {
+        if (importedTemplateContent != null) {
+            setUseImportedTemplate(true);
+        }
+        this.importedTemplateContent = importedTemplateContent;
+    }
+
+    @Bindable
+    public boolean isUseImportedTemplate() {
+        return ifUseImportedTemplate;
+    }
+
+    @Bindable
+    public void setUseImportedTemplate(boolean useImportedTemplate) {
+        this.ifUseImportedTemplate = useImportedTemplate;
+        notifyPropertyChanged(BR.useImportedTemplate);
+    }
+
+    @Bindable
+    public boolean isImportedTemplateIsComplex() {
+        return ifImportedTemplateIsComplex;
+    }
+
+    @Bindable
+    public void setImportedTemplateIsComplex(boolean importedTemplateIsComplex) {
+        this.ifImportedTemplateIsComplex = importedTemplateIsComplex;
+        notifyPropertyChanged(BR.importedTemplateIsComplex);
+    }
+
+    @EnumBarcodeFormat
+    public long getBarcodeFormat() {
+        return barcodeFormat;
+    }
+
+    public void setBarcodeFormat(long barcodeFormat) {
+        this.barcodeFormat = barcodeFormat;
+    }
+
+    public int getExpectedBarcodesCount() {
+        return expectedBarcodesCount;
+    }
+
+    public void setExpectedBarcodesCount(int expectedBarcodesCount) {
+        this.expectedBarcodesCount = expectedBarcodesCount;
+    }
+
+    @EnumLocalizationMode
+    public int[] getLocalizationModes() {
+        return localizationModes;
+    }
+
+    public void setLocalizationModes(@EnumLocalizationMode int[] localizationModes) {
+        this.localizationModes = localizationModes;
+    }
+
+    @EnumDeblurMode
+    public int[] getDeblurModes() {
+        return deblurModes;
+    }
+
+    public void setDeblurModes(@EnumDeblurMode int[] deblurModes) {
+        this.deblurModes = deblurModes;
+    }
+
+    public int[] getGrayscaleEnhancementModes() {
+        return grayscaleEnhancementModes;
+    }
+
+    public void setGrayscaleEnhancementModes(int[] grayscaleEnhancementModes) {
+        this.grayscaleEnhancementModes = grayscaleEnhancementModes;
+    }
+
+    public int[] getGrayscaleTransformationModes() {
+        return grayscaleTransformationModes;
+    }
+
+    public void setGrayscaleTransformationModes(int[] grayscaleTransformationModes) {
+        this.grayscaleTransformationModes = grayscaleTransformationModes;
+    }
+
+    public int getMinResultConfidence() {
+        return minResultConfidence;
+    }
+
+    public void setMinResultConfidence(int minResultConfidence) {
+        this.minResultConfidence = minResultConfidence;
+    }
+
+    public int getScaleDownThreshold() {
+        return scaleDownThreshold;
+    }
+
+    public void setScaleDownThreshold(int scaleDownThreshold) {
+        this.scaleDownThreshold = scaleDownThreshold;
+    }
+
+    public String getBarcodeTextRegExPattern() {
+        return barcodeTextRegExPattern;
+    }
+
+    public void setBarcodeTextRegExPattern(String barcodeTextRegExPattern) {
+        this.barcodeTextRegExPattern = barcodeTextRegExPattern;
+    }
+
+    public int getMinBarcodeTextLength() {
+        return minBarcodeTextLength;
+    }
+
+    public void setMinBarcodeTextLength(int minBarcodeTextLength) {
+        this.minBarcodeTextLength = minBarcodeTextLength;
+    }
+
+    public int getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+
+    public int getMinDecodeInterval() {
+        return minDecodeInterval;
+    }
+
+    public void setMinDecodeInterval(int minDecodeInterval) {
+        this.minDecodeInterval = minDecodeInterval;
+    }
+
+    //For export
+    public void updateToCvr(CaptureVisionRouter router) {
+        if (ifUseImportedTemplate) {
+            try {
+                router.initSettings(importedTemplateContent);
+            } catch (CaptureVisionRouterException e) {
+                //no-op
+                e.printStackTrace();
+            }
+        }
+        if (ifUseImportedTemplate) {
+            return;
+        }
+        try {
+            SimplifiedCaptureVisionSettings settings = router.getSimplifiedSettings(selectedPresetTemplateName);
+            settings.timeout = timeout;
+            settings.minImageCaptureInterval = minDecodeInterval;
+            assert settings.barcodeSettings != null;
+            settings.barcodeSettings.barcodeFormatIds = barcodeFormat;
+            settings.barcodeSettings.expectedBarcodesCount = expectedBarcodesCount;
+            settings.barcodeSettings.localizationModes = localizationModes;
+            settings.barcodeSettings.deblurModes = deblurModes;
+            settings.barcodeSettings.grayscaleEnhancementModes = grayscaleEnhancementModes;
+            settings.barcodeSettings.grayscaleTransformationModes = grayscaleTransformationModes;
+            settings.barcodeSettings.minResultConfidence = minResultConfidence;
+            settings.barcodeSettings.scaleDownThreshold = scaleDownThreshold;
+            settings.barcodeSettings.barcodeTextRegExPattern = barcodeTextRegExPattern;
+            settings.barcodeSettings.minBarcodeTextLength = minBarcodeTextLength;
+
+            router.updateSettings(selectedPresetTemplateName, settings);
+        } catch (CaptureVisionRouterException e) {
+            //no-op
+            e.printStackTrace();
+        }
+    }
+
+    public void reset() {
+        DecodeSettings newSettings = new DecodeSettings();
+        for (Field declaredField : getClass().getDeclaredFields()) {
+            try {
+                if(!Modifier.isFinal(declaredField.getModifiers())) {
+                    Object newValue = declaredField.get(newSettings);
+                    declaredField.set(this, newValue);
+                }
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+        notifyChange();
+    }
+
+}

package/code-snippet/android/FoundationalAPISamples/GeneralSettings/src/main/java/com/dynamsoft/dbr/generalsettings/models/MultiFrameCrossFilterSettings.java

@@ -0,0 +1,59 @@
+package com.dynamsoft.dbr.generalsettings.models;
+
+
+import android.util.Range;
+
+import androidx.databinding.BaseObservable;
+import androidx.databinding.Bindable;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+
+public class MultiFrameCrossFilterSettings extends BaseObservable {
+    @Bindable
+    public boolean isMultiFrameVerificationEnabled = true;
+    @Bindable
+    public boolean isResultDeduplicationEnabled;
+    @Bindable
+    public int duplicationForgetTime = 3000;
+    public static final Range<Integer> duplicationForgetTimeRange = new Range<>(0, Integer.MAX_VALUE);
+    @Bindable
+    public boolean isLatestOverlappingEnabled;
+
+    @Bindable
+    public int maxOverlappingFramesCount = 5;
+    public static final Range<Integer> maxOverlappingFramesCountRange = new Range<>(0, Integer.MAX_VALUE);
+
+
+    public int getDuplicationForgetTime() {
+        return duplicationForgetTime;
+    }
+
+    public void setDuplicationForgetTime(int duplicationForgetTime) {
+        this.duplicationForgetTime = duplicationForgetTime;
+    }
+
+    public int getMaxOverlappingFramesCount() {
+        return maxOverlappingFramesCount;
+    }
+
+    public void setMaxOverlappingFramesCount(int maxOverlappingFramesCount) {
+        this.maxOverlappingFramesCount = maxOverlappingFramesCount;
+    }
+
+    public void reset() {
+        MultiFrameCrossFilterSettings newSettings = new MultiFrameCrossFilterSettings();
+        for (Field declaredField : getClass().getDeclaredFields()) {
+            try {
+                if(!Modifier.isFinal(declaredField.getModifiers())) {
+                    Object newValue = declaredField.get(newSettings);
+                    declaredField.set(this, newValue);
+                }
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+        notifyChange();
+    }
+}

package/code-snippet/android/FoundationalAPISamples/GeneralSettings/src/main/java/com/dynamsoft/dbr/generalsettings/models/ResultFeedbackSettings.java

@@ -0,0 +1,31 @@
+package com.dynamsoft.dbr.generalsettings.models;
+
+import androidx.databinding.BaseObservable;
+import androidx.databinding.Bindable;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+
+public class ResultFeedbackSettings extends BaseObservable {
+    @Bindable
+    public boolean isBeepEnabled = true;
+
+    @Bindable
+    public boolean isVibrationEnabled = true;
+
+
+    public void reset() {
+        ResultFeedbackSettings newSettings = new ResultFeedbackSettings();
+        for (Field declaredField : getClass().getDeclaredFields()) {
+            try {
+                if(!Modifier.isFinal(declaredField.getModifiers())) {
+                    Object newValue = declaredField.get(newSettings);
+                    declaredField.set(this, newValue);
+                }
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+        notifyChange();
+    }
+}

package/code-snippet/android/FoundationalAPISamples/GeneralSettings/src/main/java/com/dynamsoft/dbr/generalsettings/models/SettingsCache.java

@@ -0,0 +1,49 @@
+package com.dynamsoft.dbr.generalsettings.models;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import com.google.gson.Gson;
+
+public class SettingsCache {
+    private static final SettingsCache CURRENT = new SettingsCache();
+    private static final String PREF_NAME = "SettingsCache";
+    private static final String KEY_SETTINGS = "settings";
+    private static final Gson GSON = new Gson();
+
+    public DecodeSettings decodeSettings = new DecodeSettings();
+    public CameraSettings cameraSettings = new CameraSettings();
+    public MultiFrameCrossFilterSettings multiFrameCrossFilterSettings = new MultiFrameCrossFilterSettings();
+    public ResultFeedbackSettings resultFeedbackSettings = new ResultFeedbackSettings();
+
+    public static SettingsCache getCurrentSettings() {
+        return CURRENT;
+    }
+
+    public void reset() {
+        cameraSettings.reset();
+        decodeSettings.reset();
+        multiFrameCrossFilterSettings.reset();
+        resultFeedbackSettings.reset();
+    }
+
+    public void saveToPreferences(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = prefs.edit();
+        editor.putString(KEY_SETTINGS, GSON.toJson(this));
+        editor.apply();
+    }
+
+    public void loadFromPreferences(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
+        String json = prefs.getString(KEY_SETTINGS, null);
+        if (json != null) {
+            SettingsCache loadedSettings = GSON.fromJson(json, SettingsCache.class);
+            this.decodeSettings = loadedSettings.decodeSettings;
+            this.cameraSettings = loadedSettings.cameraSettings;
+            this.multiFrameCrossFilterSettings = loadedSettings.multiFrameCrossFilterSettings;
+            this.resultFeedbackSettings = loadedSettings.resultFeedbackSettings;
+        }
+    }
+
+}

package/code-snippet/android/FoundationalAPISamples/GeneralSettings/src/main/java/com/dynamsoft/dbr/generalsettings/scanner/ScannerActivity.java

@@ -0,0 +1,225 @@
+package com.dynamsoft.dbr.generalsettings.scanner;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.ViewModelProvider;
+
+import com.dynamsoft.core.basic_structures.DSRect;
+import com.dynamsoft.core.basic_structures.EnumCapturedResultItemType;
+import com.dynamsoft.cvr.CaptureVisionRouter;
+import com.dynamsoft.cvr.CaptureVisionRouterException;
+import com.dynamsoft.cvr.SimplifiedCaptureVisionSettings;
+import com.dynamsoft.dbr.DecodedBarcodesResult;
+import com.dynamsoft.dbr.SimplifiedBarcodeReaderSettings;
+import com.dynamsoft.dbr.generalsettings.R;
+import com.dynamsoft.dbr.generalsettings.models.CameraSettings;
+import com.dynamsoft.dbr.generalsettings.models.DecodeSettings;
+import com.dynamsoft.dbr.generalsettings.models.MultiFrameCrossFilterSettings;
+import com.dynamsoft.dbr.generalsettings.models.SettingsCache;
+import com.dynamsoft.dbr.generalsettings.settings.SettingsActivity;
+import com.dynamsoft.dbr.generalsettings.ui.CustomResultDisplayView;
+import com.dynamsoft.dce.CameraEnhancer;
+import com.dynamsoft.dce.CameraEnhancerException;
+import com.dynamsoft.dce.CameraView;
+import com.dynamsoft.dce.EnumEnhancerFeatures;
+import com.dynamsoft.dce.EnumResolution;
+import com.dynamsoft.dce.utils.PermissionUtil;
+import com.dynamsoft.utility.MultiFrameResultCrossFilter;
+import com.google.android.material.appbar.MaterialToolbar;
+
+import java.util.Objects;
+
+public class ScannerActivity extends AppCompatActivity implements ScannerViewModel.Listener {
+    private CaptureVisionRouter router;
+    private CameraEnhancer camera;
+    private final MultiFrameResultCrossFilter filter = new MultiFrameResultCrossFilter();
+    private ScannerViewModel viewModel;
+    private SettingsCache settingsCache;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        PermissionUtil.requestCameraPermission(this);
+
+        viewModel = new ViewModelProvider(this).get(ScannerViewModel.class);
+        settingsCache = viewModel.settingsCache;
+
+        viewModel.setListener(this);
+
+        initActionBar();
+        initCameraAndCaptureVisionRouter();
+    }
+
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.menu_main, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        if (item.getItemId() == R.id.action_settings) {
+            findViewById(R.id.results_view).setVisibility(View.GONE);
+            startActivity(new Intent(this, SettingsActivity.class));
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void initCameraAndCaptureVisionRouter() {
+        CameraView cameraView = findViewById(R.id.camera_view);
+        camera = new CameraEnhancer(cameraView, this);
+
+        router = new CaptureVisionRouter();
+        try {
+            router.setInput(camera);
+            router.addResultReceiver(viewModel);
+        } catch (CaptureVisionRouterException e) {
+            //no-op
+        }
+        router.addResultFilter(filter);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+
+        //ResultFeedbackSettings take effect in CapturedResultReceiver callback. See ScannerViewModel.onDecodedBarcodesReceived
+        setupDecodeSettings();
+        setupMultiFrameResultCrossFilterSettings();
+        setupCameraSettings();
+
+        camera.open();
+
+        router.startCapturing(settingsCache.decodeSettings.getSelectedPresetTemplateName(), viewModel);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        camera.close();
+
+        router.stopCapturing();
+    }
+
+    //interface ScannerViewModel.Listener
+    @Override
+    public void showResult(@NonNull DecodedBarcodesResult result) {
+        runOnUiThread(() -> {
+            if (result.getItems().length > 0) {
+                CustomResultDisplayView resultView = findViewById(R.id.results_view);
+                resultView.setVisibility(View.VISIBLE);
+                resultView.updateResults(result.getItems());
+            }
+        });
+    }
+
+    //interface ScannerViewModel.Listener
+    @Override
+    public void showError(int errorCode, String errorString, String title) {
+        runOnUiThread(() -> ((TextView) findViewById(R.id.tv_start_capturing_error))
+                .setText("StartCapturing failed: errorCode=" + errorCode + ", errorString=" + errorString));
+    }
+
+    private void initActionBar() {
+        MaterialToolbar toolbar = findViewById(R.id.toolbar);
+        setSupportActionBar(toolbar);
+        toolbar.setNavigationOnClickListener(v -> getOnBackPressedDispatcher().onBackPressed());
+    }
+
+    private void setupDecodeSettings() {
+        DecodeSettings decodeSettings = settingsCache.decodeSettings;
+
+        try {
+            if (decodeSettings.ifUseImportedTemplate) {
+                router.initSettings(decodeSettings.getImportedTemplateContent());
+            } else {
+                router.resetSettings();
+            }
+        } catch (CaptureVisionRouterException e) {
+            e.printStackTrace();
+        }
+
+        if (decodeSettings.ifUseImportedTemplate && decodeSettings.ifImportedTemplateIsComplex) {
+            return;
+        }
+
+        String selectedTemplateName = decodeSettings.getSelectedPresetTemplateName();
+        try {
+            SimplifiedCaptureVisionSettings simplifiedCaptureVisionSettings = router.getSimplifiedSettings(selectedTemplateName);
+            simplifiedCaptureVisionSettings.timeout = decodeSettings.getTimeout();
+            simplifiedCaptureVisionSettings.minImageCaptureInterval = decodeSettings.getMinDecodeInterval();
+
+            SimplifiedBarcodeReaderSettings barcodeSettings = simplifiedCaptureVisionSettings.barcodeSettings;
+            assert barcodeSettings != null;
+            barcodeSettings.barcodeFormatIds = decodeSettings.getBarcodeFormat();
+            barcodeSettings.expectedBarcodesCount = decodeSettings.getExpectedBarcodesCount();
+            barcodeSettings.localizationModes = decodeSettings.getLocalizationModes();
+            barcodeSettings.deblurModes = decodeSettings.getDeblurModes();
+            barcodeSettings.grayscaleEnhancementModes = decodeSettings.getGrayscaleEnhancementModes();
+            barcodeSettings.grayscaleTransformationModes = decodeSettings.getGrayscaleTransformationModes();
+            barcodeSettings.minResultConfidence = decodeSettings.getMinResultConfidence();
+            barcodeSettings.scaleDownThreshold = decodeSettings.getScaleDownThreshold();
+            barcodeSettings.barcodeTextRegExPattern = decodeSettings.getBarcodeTextRegExPattern();
+            barcodeSettings.minBarcodeTextLength = decodeSettings.getMinBarcodeTextLength();
+
+            router.updateSettings(selectedTemplateName, simplifiedCaptureVisionSettings);
+        } catch (CaptureVisionRouterException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private void setupMultiFrameResultCrossFilterSettings() {
+        //Filter should be added to the router via CaptureVisionRouter.addFilter() in advance,
+        // so setting the filter will take effect.
+        MultiFrameCrossFilterSettings filterSettings = settingsCache.multiFrameCrossFilterSettings;
+        filter.enableResultCrossVerification(EnumCapturedResultItemType.CRIT_BARCODE, filterSettings.isMultiFrameVerificationEnabled);
+        filter.enableResultDeduplication(EnumCapturedResultItemType.CRIT_BARCODE, filterSettings.isResultDeduplicationEnabled);
+        filter.setDuplicateForgetTime(EnumCapturedResultItemType.CRIT_BARCODE, filterSettings.duplicationForgetTime);
+        filter.enableLatestOverlapping(EnumCapturedResultItemType.CRIT_BARCODE, filterSettings.isLatestOverlappingEnabled);
+        filter.setMaxOverlappingFrames(EnumCapturedResultItemType.CRIT_BARCODE, filterSettings.maxOverlappingFramesCount);
+    }
+
+    private void setupCameraSettings() {
+        CameraSettings cameraSettings = settingsCache.cameraSettings;
+
+        try {
+            if (cameraSettings.autoZoomEnabled) {
+                camera.enableEnhancedFeatures(EnumEnhancerFeatures.EF_AUTO_ZOOM);
+            } else {
+                camera.disableEnhancedFeatures(EnumEnhancerFeatures.EF_AUTO_ZOOM);
+            }
+
+            if (Objects.equals(cameraSettings.resolution, CameraSettings.Resolution.FULL_HD)) {
+                camera.setResolution(EnumResolution.RESOLUTION_1080P);
+            } else { //cameraSettings.resolution.equals(CameraSettings.Resolution.HD)
+                camera.setResolution(EnumResolution.RESOLUTION_720P);
+            }
+
+
+            switch (cameraSettings.scanRegion) {
+                case CameraSettings.ScanRegion.FULL_IMAGE:
+                    camera.setScanRegion(null);
+                    break;
+                case CameraSettings.ScanRegion.SQUARE:
+                    camera.setScanRegion(new DSRect(.15f, .3f, .85f, .7f, true));
+                    break;
+                case CameraSettings.ScanRegion.RECTANGLE:
+                    camera.setScanRegion(new DSRect(.05f, .3f, .95f, .55f, true));
+                    break;
+            }
+        } catch (CameraEnhancerException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}