Flutter - barKoder SDK API Reference

                Future <BarkoderResolution> getBarkoderResolution
            

                BarkoderResolution resolution = await _barkoder.getBarkoderResolution;

            

                Future<BarkoderResolution>get getBarkoderResolutionasync {
if (_isBarkoderViewNotMounted) {
return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

returnawait _methodChannel
      .invokeMethod('getBarkoderResolution')
      .then((index) {
return BarkoderResolution.values[index];
  });
}

            

                Future<void> startScanning(resultsCallback)
            

                _barkoder.startScanning((result) {
  _updateState(result, false);
});
print('Scanning started');

            

                Future<void> startScanning(void Function(BarkoderResult) resultsCallback) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  _clearScanningResultsStreamSubscription();
  _scanningResultsStreamSubscription = _scanningResultsStream.listen(
      (result) =>
          resultsCallback.call(BarkoderResult.fromJsonString(result)));

  return _methodChannel.invokeMethod('startScanning');
}

            

                Future<void> stopScanning()
            

                await _barkoder.stopScanning();
print('Scanning stopped');

            

                Future<void> stopScanning() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  _clearScanningResultsStreamSubscription();
  return _methodChannel.invokeMethod('stopScanning');
}

            

                Future<void> pauseScanning()
            

                await _barkoder.pauseScanning();
print('Scanning paused');

            

                Future<void> pauseScanning() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  _clearScanningResultsStreamSubscription();
  return _methodChannel.invokeMethod('pauseScanning');
}

            

                Future<void> setFlashEnabled(bool enabled)
            

                bool flashEnabled =true;
await _barkoder.setFlashEnabled(flashEnabled);
print('Flash enabled:$flashEnabled');

            

                Future<void> setFlashEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setFlashEnabled', enabled);
}

            

                Future<void> setZoomFactor(double zoomFactor)
            

                double zoom = 2.0;
await setZoomFactor(zoom);
print('Zoom factor set to:$zoom');


            

                Future<void> setZoomFactor(double zoomFactor) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setZoomFactor', zoomFactor);
}

            

                Future<void> setRoiLineColor(String hexColor)
            

                String lineColor = '#00FF00';// Green color
_barkoder.setRoiLineColor(lineColor);
print('ROI line color set to:$lineColor');


            

                Future<void> setRoiLineColor(String hexColor) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setRoiLineColor', hexColor);
}

            

                Future<void> setRoiLineWidth(double lineWidth)
            

                double lineWidth = 2.0;
_barkoder.setRoiLineWidth(lineWidth);
print('ROI line width set to:$lineWidth');

            

                Future<void> setRoiLineWidth(double lineWidth) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setRoiLineWidth', lineWidth);
}

            

                Future<void> setRoiOverlayBackgroundColor(String hexColor)
            

                String backgroundColor = '#FFA500';// Orange color
_barkoder.setRoiOverlayBackgroundColor(backgroundColor);
print('ROI overlay background color set to:$backgroundColor');


            

                Future<void> setRoiOverlayBackgroundColor(String hexColor) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setRoiOverlayBackgroundColor', hexColor);
}

            

                Future<void> setCloseSessionOnResultEnabled(bool enabled)
            

                bool closeSessionEnabled =true;
_barkoder.setCloseSessionOnResultEnabled(closeSessionEnabled);
print('Close session on result enabled:$closeSessionEnabled');


            

                Future<void> setCloseSessionOnResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setCloseSessionOnResultEnabled', enabled);
}

            

                Future<void> setImageResultEnabled(bool enabled)
            

                bool imageResultEnabled =true;
_barkoder.setImageResultEnabled(imageResultEnabled);
print('Image result enabled:$imageResultEnabled');

            

                Future<void> setImageResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setImageResultEnabled', enabled);
}

            

                Future<void> setLocationInImageResultEnabled(bool enabled)
            

                bool locationInImageResultEnabled =true;
_barkoder.setLocationInImageResultEnabled(locationInImageResultEnabled);
print('Location in image result enabled:$locationInImageResultEnabled');


            

                Future<void> setLocationInImageResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setLocationInImageResultEnabled', enabled);
}

            

                Future<void> setLocationInPreviewEnabled( bool enabled)
            

                bool locationInPreviewEnabled =true;
_barkoder.setLocationInPreviewEnabled(locationInPreviewEnabled);
print('Location in preview enabled:$locationInPreviewEnabled');

            

                Future<void> setLocationInPreviewEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setLocationInPreviewEnabled', enabled);
}

            

                Future<void> setPinchToZoomEnabled(bool enabled)
            

                bool pinchToZoomEnabled =true;
_barkoder.setPinchToZoomEnabled(pinchToZoomEnabled);
print('Pinch to zoom enabled:$pinchToZoomEnabled');

            

                Future<void> setPinchToZoomEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setPinchToZoomEnabled', enabled);
}

            

                Future<void> setRegionOfInterestVisible(bool visible)
            

                bool roiVisible =true;
await _barkoder.setRegionOfInterestVisible(roiVisible);
print('Region of interest set to visible:$roiVisible');


            

                Future<void> setRegionOfInterestVisible(bool visible) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setRegionOfInterestVisible', visible);
}

            

                Future<void> setRegionOfInterest(double left, double top, double width, double height)
            

                double left = 10.0;
double top = 10.0;
double width = 80.0;
double height = 8.0;
_barkoder.setRegionOfInterest(left, top, width, height);
print('Region of interest set');

            

                Future<void> setRegionOfInterest(
    double left, double top, double width, double height) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setRegionOfInterest',
      {'left': left, 'top': top, 'width': width, 'height': height});
}

            

                Future<void> setBeepOnSuccessEnabled(bool enabled)
            

                bool beepOnSuccessEnabled =true;
await _barkoder.setBeepOnSuccessEnabled(beepOnSuccessEnabled);
print('Beep on success enabled:$beepOnSuccessEnabled');

            

                Future<void> setBeepOnSuccessEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setBeepOnSuccessEnabled', enabled);
}

            

                Future<void> setVibrateOnSuccessEnabled(bool enabled)
            

                bool vibrateOnSuccessEnabled =true;
await _barkoder.setVibrateOnSuccessEnabled(vibrateOnSuccessEnabled);
print('Vibrate on success enabled:$vibrateOnSuccessEnabled');

            

                Future<void> setVibrateOnSuccessEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setVibrateOnSuccessEnabled', enabled);
}

            

                Future<void> setLocationLineWidth(double lineWidth)
            

                double lineWidth = 2.0;
_barkoder.setLocationLineWidth(lineWidth);
print('Location line width set to:$lineWidth');

            

                Future<void> setLocationLineWidth(double lineWidth) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setLocationLineWidth', lineWidth);
}

            

                Future<void> setBarkoderResolution(BarkoderResolution resolution)
            

                BarkoderResolution resolution = BarkoderResolution.HIGH;
await _barkoder.setBarkoderResolution(resolution);
print('Barkoder resolution set to:$resolution');

            

                Future<void> setBarkoderResolution(BarkoderResolution resolution) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setBarkoderResolution', resolution.index);
}

            

                Future<void> setLocationLineColor(String hexColor)
            

                String lineColor = '#FF0000';// Red color
_barkoder.setLocationLineColor(lineColor);
print('Location line color set to:$lineColor');

            

                Future<void> setLocationLineColor(String hexColor) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setLocationLineColor', hexColor);
}

            

                Future<void> setEncodingCharacterSet(String characterSet)
            

                String characterSet = 'utf-8';
_barkoder.setEncodingCharacterSet(characterSet);
print('Encoding character set set to:$characterSet');

            

                Future<void> setEncodingCharacterSet(String characterSet) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setEncodingCharacterSet', characterSet);
}

            

                Future<void> setDecodingSpeed(DecodingSpeed decodingSpeed)
            

                DecodingSpeed speed = DecodingSpeed.fast;
_barkoder.setDecodingSpeed(speed);
print('Decoding speed set to:$speed');

            

                Future<void> setDecodingSpeed(DecodingSpeed decodingSpeed) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setDecodingSpeed', decodingSpeed.index);
}

            

                Future<double> getMaxZoomFactor()
            

                double maxZoom =await getMaxZoomFactor();
print('Maximum zoom factor:$maxZoom');

            

                Future<double> getMaxZoomFactor() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel
      .invokeMethod('getMaxZoomFactor')
      .then((zoomFactor) => zoomFactor as double);
}

            

                Future<String> getLocationLineColorHex
            

                String lineColor =await _barkoder.getLocationLineColorHex();
print('Location line color:$lineColor');

            

                Future<String> get getLocationLineColorHex async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getLocationLineColorHex');
}

            

                Future<double> getLocationLineWidth
            

                double lineWidth =await _barkoder.getLocationLineWidth();
print('Location line width:$lineWidth');

            

                Future<double> get getLocationLineWidth async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getLocationLineWidth');
}

            

                Future<String> getRoiLineColorHex
            

                String lineColor =await _barkoder.getRoiLineColorHex();
print('ROI line color:$lineColor');

            

                Future<String> get getRoiLineColorHex async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getRoiLineColorHex');
}

            

                Future<double> getRoiLineWidth
            

                double lineWidth =await _barkoder.getRoiLineWidth();
print('ROI line width:$lineWidth');

            

                Future<double> get getRoiLineWidth async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getRoiLineWidth');
}

            

                Future<String> getRoiOverlayBackgroundColorHex
            

                String backgroundColor =await _barkoder.getRoiOverlayBackgroundColorHex();
print('ROI overlay background color:$backgroundColor');


            

                Future<String> get getRoiOverlayBackgroundColorHex async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getRoiOverlayBackgroundColorHex');
}

            

                Future<List<double>> getRegionOfInterest
            

                List<double> roi =await _barkoder.getRegionOfInterest;
print('Region of interest:$roi');

            

                Future<List<double>> get getRegionOfInterest async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('getRegionOfInterest')
      .then((value) {
    return List.from(value);
  });
}

            

                Future<int> getThreadsLimit
            

                int threadsLimit =await _barkoder.getThreadsLimit;
print('Threads limit:$threadsLimit');

            

                Future<int> get getThreadsLimit async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getThreadsLimit');
}

            

                Future<void> setThreadsLimit(int threadsLimit)
            

                int threadsLimit = 2;
_barkoder.setThreadsLimit(threadsLimit);
print('Threads limit set to:$threadsLimit');

            

                Future<void> setThreadsLimit(int threadsLimit) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setThreadsLimit', threadsLimit);
}

            

                Future<String> getEncodingCharacterSet
            

                String characterSet =await _barkoder.getEncodingCharacterSet;
print('Encoding character set:$characterSet');

            

                Future<String> get getEncodingCharacterSet async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getEncodingCharacterSet');
}

            

                Future<DecodingSpeed> getDecodingSpeed
            

                DecodingSpeed speed =await _barkoder.getDecodingSpeed;
print('Decoding speed:$speed');

            

                Future<DecodingSpeed> get getDecodingSpeed async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getDecodingSpeed').then((index) {
    return DecodingSpeed.values[index];
  });
}

            

                Future<FormattingType> getFormattingType
            

                FormattingType type =await _barkoder.getFormattingType;
print('Formatting type:$type');

            

                Future<FormattingType> get getFormattingType async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getFormattingType').then((index) {
    return FormattingType.values[index];
  });
}

            

                Future<String> getVersion
            

                String version =await _barkoder.getVersion;
print('Barkoder library version:$version');

            

                Future<String> get getVersion async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getVersion');
}

            

                Future<MsiChecksumType> getMsiChecksumType
            

                MsiChecksumType checksumType =await _barkoder.getMsiChecksumType;
print('MSI checksum type:$checksumType');


            

                Future<MsiChecksumType> get getMsiChecksumType async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('getMsiChecksumType')
      .then((index) {
    return MsiChecksumType.values[index];
  });
}

            

                Future<Code11ChecksumType> getCode11ChecksumType
            

                Code11ChecksumType checksumType =await _barkoder.getCode11ChecksumType;
print('Code11 checksum type:$checksumType');

            

                Future<Code11ChecksumType> get getCode11ChecksumType async {
    if (_isBarkoderViewNotMounted) {
      return Future.error(PlatformException(
          code: BarkoderErrors.barkoderViewNotMounted,
          message: BarkoderErrors.barkodeViewNotMountedDesc));
    }

    return await _methodChannel
        .invokeMethod('getCode11ChecksumType')
        .then((index) {
      return Code11ChecksumType.values[index];
    });
  }

            

                Future<Code39ChecksumType> getCode39ChecksumType
            

                Code39ChecksumType checksumType =await _barkoder.getCode39ChecksumType;
print('Code39 checksum type:$checksumType');

            

                Future<Code39ChecksumType> get getCode39ChecksumType async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('getCode39ChecksumType')
      .then((index) {
    return Code39ChecksumType.values[index];
  });
}

            

                Future<bool> isCloseSessionOnResultEnabled
            

                bool closeSessionEnabled =await _barkoder.isCloseSessionOnResultEnabled;
print('Close session on result enabled:$closeSessionEnabled');

            

                Future<bool> get isCloseSessionOnResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isCloseSessionOnResultEnabled');
}

            

                Future<bool> isBeepOnSuccessEnabled
            

                bool beepOnSuccessEnabled =await _barkoder.isBeepOnSuccessEnabled;
print('Beep on success enabled:$beepOnSuccessEnabled');


            

                Future<bool> get isBeepOnSuccessEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isBeepOnSuccessEnabled');
}

            

                Future<bool> isFlashAvailable()
            

                bool flashAvailable =await _barkoder.isFlashAvailable();
print('Flash available:$flashAvailable');

            

                Future<bool> isFlashAvailable() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel
      .invokeMethod('isFlashAvailable')
      .then((isAvailable) => isAvailable as bool);
}

            

                Future<bool> isImageResultEnabled
            

                bool imageResultEnabled =await _barkoder.isImageResultEnabled;
print('Image result enabled:$imageResultEnabled');

            

                Future<bool> get isImageResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isImageResultEnabled');
}

            

                Future<bool> isLocationInImageResultEnabled
            

                bool locationInImageResultEnabled =await _barkoder.isLocationInImageResultEnabled;
print('Location in image result enabled:$locationInImageResultEnabled');


            

                Future<bool> get isLocationInImageResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isLocationInImageResultEnabled');
}

            

                Future<bool> isLocationInPreviewEnabled
            

                bool locationInPreviewEnabled =await _barkoder.isLocationInPreviewEnabled;
print('Location in preview enabled:$locationInPreviewEnabled');

            

                Future<bool> get isLocationInPreviewEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isLocationInPreviewEnabled');
}

            

                Future<bool> isPinchToZoomEnabled
            

                bool pinchToZoomEnabled =await _barkoder.isPinchToZoomEnabled;
print('Pinch to zoom enabled:$pinchToZoomEnabled');

            

                Future<bool> get isPinchToZoomEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isPinchToZoomEnabled');
}

            

                Future<bool> isRegionOfInterestVisible
            

                bool roiVisible =await _barkoder.isRegionOfInterestVisible;
print('Region of interest visible:$roiVisible');

            

                Future<bool> get isRegionOfInterestVisible async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isRegionOfInterestVisible');
}

            

                Future<void> setFormattingType(FormattingType formattingType)
            

                FormattingType type = FormattingType.gs1;
_barkoder.setFormattingType(type);
print('Formatting type set to:$type');


            

                Future<void> setFormattingType(FormattingType formattingType) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setFormattingType', formattingType.index);
}

            

                Future<void> setMsiChecksumType(MsiChecksumType checksumType)
            

                MsiChecksumType checksumType = MsiChecksumType.mod10;
await _barkoder.setMsiChecksumType(checksumType);
print('MSI checksum type set to:$checksumType');


            

                Future<void> setMsiChecksumType(MsiChecksumType checksumType) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setMsiChecksumType', checksumType.index);
}

            

                Future<void> setCode39ChecksumType(Code39ChecksumType checksumType)
            

                Code39ChecksumType checksumType = Code39ChecksumType.enabled;
_barkoder.setCode39ChecksumType(checksumType);
print('Code39 checksum type set to:$checksumType');

            

                Future<void> setCode39ChecksumType(Code39ChecksumType checksumType) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setCode39ChecksumType', checksumType.index);
}

            

                Future<void> setThresholdBetweenDuplicatesScans(int thresholdBetweenDuplicatesScans)
            

                int threshold = 1;// 100 milliseconds
_barkoder.setThresholdBetweenDuplicatesScans(threshold);
print('Threshold between duplicate scans set to:$threshold milliseconds');

            

                Future<void> setThresholdBetweenDuplicatesScans(
    int thresholdBetweenDuplicatesScans) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setThresholdBetweenDuplicatesScans', thresholdBetweenDuplicatesScans);
}

            

                Future<int> getThresholdBetweenDuplicatesScans
            

                int threshold =await _barkoder.getThresholdBetweenDuplicatesScans;
print('Threshold between duplicate scans:$threshold milliseconds');

            

                Future<int> get getThresholdBetweenDuplicatesScans async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getThresholdBetweenDuplicatesScans');
}

            

                Future<void> setCode11ChecksumType(Code11ChecksumType checksumType)
            

                Code11ChecksumType checksumType = Code11ChecksumType.single;
await _barkoder.setCode11ChecksumType(checksumType);
print('Code11 checksum type set to:$checksumType');

            

                Future<void> setCode11ChecksumType(Code11ChecksumType checksumType) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setCode11ChecksumType', checksumType.index);
}

            

                Future<bool> isBarcodeTypeEnabled(BarcodeType type)
            

                BarcodeType type = BarcodeType.code128;
bool isEnabled =await _barkoder.isBarcodeTypeEnabled(type);
print('Barcode type$type is enabled:$isEnabled');


            

                Future<bool> isBarcodeTypeEnabled(BarcodeType type) async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod(
      'isBarcodeTypeEnabled', type.index);
}

            

                Future<void> setBarcodeTypeEnabled(BarcodeType type, bool enabled)
            

                BarcodeType type = BarcodeType.code128;
bool isEnabled =true;
_barkoder.setBarcodeTypeEnabled(type, isEnabled);
print('Barcode type$type set to enabled:$isEnabled');


            

                Future<void> setBarcodeTypeEnabled(BarcodeType type, bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setBarcodeTypeEnabled', {'type': type.index, 'enabled': enabled});
}

            

                Future<List<int>> getBarcodeTypeLengthRange(BarcodeType type)
            

                BarcodeType type = BarcodeType.code128;
List<int> lengthRange =await _barkoder.getBarcodeTypeLengthRange(type);
print('Length range of barcode type$type:$lengthRange');


            

                Future<List<int>> getBarcodeTypeLengthRange(BarcodeType type) async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('getBarcodeTypeLengthRange', type.index)
      .then((value) {
    return List.from(value);
  });
}

            

                Future<void> setBarcodeTypeLengthRange(BarcodeType type, int min, int max)
            

                BarcodeType type = BarcodeType.code128;
int minLength = 6;
int maxLength = 20;
await _barkoder.setBarcodeTypeLengthRange(type, minLength, maxLength);
print('Length range set for barcode type$type: min=$minLength, max=$maxLength');

            

                Future<void> setBarcodeTypeLengthRange(BarcodeType type, int min, int max) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setBarcodeTypeLengthRange',
      {'type': type.index, 'min': min, 'max': max});
}

            

                Future<void> setMaximumResultsCount(int maximumResultsCount)
            

                int maxResults = 10;
await _barkoder.setMaximumResultsCount(maxResults);
print('Maximum results count set to:$maxResults');

            

                Future<void> setMaximumResultsCount(int maximumResultsCount) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setMaximumResultsCount', maximumResultsCount);
}

            

                Future<void> setMulticodeCachingDuration(int multicodeCachingDuration)
            

                int cachingDuration = 5000;// 5 secondsawait _barkoder.setMulticodeCachingDuration(cachingDuration);
print('Multicode caching duration set to:$cachingDuration');

            

                Future<void> setMulticodeCachingDuration(int multicodeCachingDuration) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setMulticodeCachingDuration', multicodeCachingDuration);
}

            

                Future<void> setMulticodeCachingEnabled(bool enabled)
            

                bool multicodeCachingEnabled =true;
await _barkoder.setMulticodeCachingEnabled(multicodeCachingEnabled);
print('Multicode caching enabled:$multicodeCachingEnabled');

            

                Future<void> setMulticodeCachingEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setMulticodeCachingEnabled', enabled);
}

            

                Future<double> getMaximumResultsCount
            

                double maxResults =await _barkoder.getMaximumResultsCount;
print('Maximum results count:$maxResults');


            

                Future<double> get getMaximumResultsCount async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getMaximumResultsCount');
}

            

                Future<void> setDatamatrixDpmModeEnabled(bool enabled)
            

                Future<void> setDatamatrixDpmModeEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setDatamatrixDpmModeEnabled', enabled);
}

            

                Future<void> setUpcEanDeblurEnabled(bool enabled)
            

                bool isEnabled =true;
await _barkoder.setUpcEanDeblurEnabled(isEnabled);
print('UPC/EAN deblur enabled set to:$isEnabled');

            

                Future<void> setUpcEanDeblurEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setUpcEanDeblurEnabled', enabled);
}

            

                Future<void> setEnableMisshaped1DEnabled(bool enabled)
            

                Future<void> setEnableMisshaped1DEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setEnableMisshaped1DEnabled', enabled);
}

            

                Future<void> setBarcodeThumbnailOnResultEnabled(bool enabled)
            

                bool thumbnailEnabled =true;
await _barkoder.setBarcodeThumbnailOnResultEnabled(thumbnailEnabled);
print('Barcode thumbnail on result enabled:$thumbnailEnabled');

            

                Future<void> setBarcodeThumbnailOnResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setBarcodeThumbnailOnResultEnabled', enabled);
}

            

                Future<bool> isBarcodeThumbnailOnResultEnabled
            

                bool thumbnailEnabled =await _barkoder.isBarcodeThumbnailOnResultEnabled;
print('Barcode thumbnail on result enabled:$thumbnailEnabled');

            

                Future<bool> get isBarcodeThumbnailOnResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isBarcodeThumbnailOnResultEnabled');
}

            

                Future<bool> getMulticodeCachingEnabled
            

                bool multicodeCachingEnabled =await _barkoder.getMulticodeCachingEnabled;
print('Multicode caching enabled:$multicodeCachingEnabled');

            

                Future<bool> get getMulticodeCachingEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getMulticodeCachingEnabled');
}

            

                Future<int> getMulticodeCachingDuration
            

                int cachingDuration =await _barkoder.getMulticodeCachingDuration;
print('Multicode caching duration:$cachingDuration');

            

                Future<int> get getMulticodeCachingDuration async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getMulticodeCachingDuration');
}

            

                Future<bool> isUpcEanDeblurEnabled
            

                bool isEnabled =await _barkoder.isUpcEanDeblurEnabled;
print('UPC/EAN deblur enabled:$isEnabled');


            

                Future<bool> get isUpcEanDeblurEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isUpcEanDeblurEnabled');
}

            

                Future<bool> isMisshaped1DEnabled
            

                bool isEnabled =await _barkoder.isMisshaped1DEnabled;
print('Misshaped 1D barcodes enabled:$isEnabled');


            

                Future<bool> get isMisshaped1DEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isMisshaped1DEnabled');
}

            

                Future<bool> isVINRestrictionsEnabled
            

                bool isEnabled =await _barkoder.isVINRestrictionsEnabled;
print('VIN restrictions enabled:$isEnabled');


            

                Future<bool> get isVINRestrictionsEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isVINRestrictionsEnabled');
}

            

                Future<void> setEnableVINRestrictions(bool enabled)
            

                bool isEnabled =true;
_barkoder.setEnableVINRestrictions(isEnabled);
print('VIN restrictions enabled set to:$isEnabled');


            

                Future<void> setEnableVINRestrictions(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setEnableVINRestrictions', enabled);
}

            

                Future<void> configureBarkoder(BarkoderConfig barkoderConfig)
            

                BarkoderConfig config = BarkoderConfig(
  pinchToZoomEnabled:true,
  beepOnSuccessEnabled:true,
// Add other configuration settings here
);
_barkoder.configureBarkoder(config);
print('Barkoder configured successfully.');


            

                Future<void> configureBarkoder(BarkoderConfig barkoderConfig) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'configureBarkoder', jsonEncode(barkoderConfig));
}

            

                double currentZoom = await getCurrentZoomFactor();
print('Current zoom factor: $currentZoom');
            

                Future<double> getCurrentZoomFactor() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel
      .invokeMethod('getCurrentZoomFactor')
      .then((zoomFactor) => zoomFactor as double);
}
            

                await _barkoder.startCamera();
print('Camera started successfully');
            

                Future<void> startCamera() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('startCamera');
}
            

                await _barkoder.freezeScanning();
print('Scanning frozen');
            

                Future<void> freezeScanning() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('freezeScanning');
}
            

                await _barkoder.unfreezeScanning();
print('Scanning unfrozen');
            

                Future<void> unfreezeScanning() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('unfreezeScanning');
}
            

                await _barkoder.captureImage();
print('Image captured');
            

                Future<void> captureImage() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('captureImage');
}
            

                _barkoder.scanImage((result) {
  _updateState(result, false);
}, base64ImageString);
print('Scan image called');
            

                Future<void> scanImage(
  void Function(BarkoderResult) resultsCallback,
  String base64image,
) async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  _clearScanningResultsStreamSubscription();
  _scanningResultsStreamSubscription =
      _scanningResultsStream.listen((result) {
    BarkoderResult barkoderResult =
        BarkoderResult.fromJson(json.decode(result));
    resultsCallback(
        barkoderResult); // Pass the BarkoderResult to the callback
  });

  await _methodChannel.invokeMethod('scanImage', base64image);
}
            

                _barkoder.onCloseButtonTapped(() {
  print('Close button tapped');
});
            

                void onCloseButtonTapped(VoidCallback handler) {
  _uiEventsSubscription?.cancel();
  _uiEventsSubscription = _uiEventsStream.listen((event) {
    if (event == 'closeButtonTapped') {
      handler();
    }
  });
}
            

                String libVersion = await _barkoder.getLibVersion;
print('Barkoder library version: $libVersion');
            

                Future<String> get getLibVersion async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getLibVersion');
}
            

                bool isEnabled = true;
_barkoder.setMisshaped1DEnabled(isEnabled);
print('Misshaped 1D barcodes enabled set to: $isEnabled');
            

                Future<void> setMisshaped1DEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setMisshaped1DEnabled', enabled);
}
            

                bool isEnabled = await _barkoder.isDatamatrixDpmModeEnabled;
print('DPM mode for Datamatrix barcodes enabled: $isEnabled');
            

                Future<bool> get isDatamatrixDpmModeEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isDatamatrixDpmModeEnabled');
}
            

                bool isEnabled = await _barkoder.isQrDpmModeEnabled;
print('DPM mode for QR barcodes enabled: $isEnabled');
            

                Future<bool> get isQrDpmModeEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isQrDpmModeEnabled');
}
            

                bool isEnabled = true;
_barkoder.setQrDpmModeEnabled(isEnabled);
print('QR DPM mode enabled set to: $isEnabled');
            

                Future<void> setQrDpmModeEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setQrDpmModeEnabled', enabled);
}
            

                bool isEnabled = await _barkoder.isQrMultiPartMergeEnabled;
print('QR multi-part merge mode enabled: $isEnabled');
            

                Future<bool> get isQrMultiPartMergeEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isQrMultiPartMergeEnabled');
}
            

                bool isEnabled = true;
_barkoder.setQrMultiPartMergeEnabled(isEnabled);
print('QR multi-part merge mode enabled set to: $isEnabled');
            

                Future<void> setQrMultiPartMergeEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setQrMultiPartMergeEnabled', enabled);
}
            

                bool isEnabled = await _barkoder.isQrMicroDpmModeEnabled;
print('DPM mode for QR Micro barcodes enabled: $isEnabled');
            

                Future<bool> get isQrMicroDpmModeEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isQrMicroDpmModeEnabled');
}
            

                bool isEnabled = true;
_barkoder.setQrMicroDpmModeEnabled(isEnabled);
print('QR Micro DPM mode enabled set to: $isEnabled');
            

                Future<void> setQrMicroDpmModeEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setQrMicroDpmModeEnabled', enabled);
}
            

                bool isEnabled = await _barkoder.isIdDocumentMasterChecksumEnabled;
print('ID Documents master checksum is required(enabled): $isEnabled');
            

                Future<bool> get isIdDocumentMasterChecksumEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('isIdDocumentMasterChecksumEnabled');
}
            

                bool isEnabled = true;
_barkoder.setIdDocumentMasterChecksumEnabled(isEnabled);
print('Master checksum enabled set to: $isEnabled');
            

                Future<void> setIdDocumentMasterChecksumEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setIdDocumentMasterChecksumEnabled', enabled);
}
            

                bool expandToUPCA = true;
_barkoder.setUPCEexpandToUPCA(expandToUPCA);
print('UPC-E expansion to UPC-A enabled: $expandToUPCA');
            

                Future<void> setUPCEexpandToUPCA(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setUPCEexpandToUPCA', enabled);
}
            

                bool expandToUPCA = true;
_barkoder.setUPCE1expandToUPCA(expandToUPCA);
print('UPC-E1 expansion to UPC-A enabled: $expandToUPCA');
            

                Future<void> setUPCE1expandToUPCA(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setUPCE1expandToUPCA', enabled);
}
            

                _barkoder.setCustomOption('optionKey', 1);
print('Custom option set.');
            

                Future<void> setCustomOption(String option, int value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel
      .invokeMethod('setCustomOption', {'option': option, 'value': value});
}
            

                String indicatorColor = await _barkoder.getScanningIndicatorColorHex();
print('Scanning indicator color: $indicatorColor');
            

                Future<String> get getScanningIndicatorColorHex async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getScanningIndicatorColorHex');
}
            

                String indicatorColor = '#FF0000'; // Red color
_barkoder.setScanningIndicatorColor(indicatorColor);
print('Scanning indicator color set to: $indicatorColor');
            

                Future<void> setScanningIndicatorColor(String hexColor) async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod(
      'setScanningIndicatorColor', hexColor);
}
            

                double indicatorWidth = await _barkoder.getScanningIndicatorWidth();
print('Scanning indicator width: $indicatorWidth');
            

                Future<double> get getScanningIndicatorWidth async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getScanningIndicatorWidth');
}
            

                double indicatorWidth = 3.0;
_barkoder.setScanningIndicatorWidth(indicatorWidth);
print('Scanning indicator width set to: $indicatorWidth');
            

                Future<void> setScanningIndicatorWidth(double lineWidth) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setScanningIndicatorWidth', lineWidth);
}
            

                int animation = await _barkoder.getScanningIndicatorAnimation();
print('Scanning indicator animation: $animation');
            

                Future<int> get getScanningIndicatorAnimation async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('getScanningIndicatorAnimation');
}
            

                int animation = 1;
_barkoder.setScanningIndicatorAnimation(animation);
print('Scanning indicator animation set to: $animation');
            

                Future<void> setScanningIndicatorAnimation(int animation) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setScanningIndicatorAnimation', animation);
}
            

                bool alwaysVisible = await _barkoder.isScanningIndicatorAlwaysVisible;
print('Scanning indicator always visible: $alwaysVisible');
            

                Future<bool> get isScanningIndicatorAlwaysVisible async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('isScanningIndicatorAlwaysVisible');
}
            

                bool alwaysVisible = true;
_barkoder.setScanningIndicatorAlwaysVisible(alwaysVisible);
print('Scanning indicator always visible: $alwaysVisible');
            

                Future<void> setScanningIndicatorAlwaysVisible(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setScanningIndicatorAlwaysVisible', value);
}
            

                int dynamicExposure = 4;
_barkoder.setDynamicExposure(dynamicExposure);
print('Camera dynamic exposure: $dynamicExposure');
            

                Future<void> setDynamicExposure(int dynamicExposure) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setDynamicExposure', dynamicExposure);
}
            

                bool value = true;
_barkoder.setCentricFocusAndExposure(value);
print('Centric focus and exposure: $value');
            

                Future<void> setCentricFocusAndExposure(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setCentricFocusAndExposure', value);
}
            

                int value = 1;
_barkoder.setEnableComposite(value);
print('Enable composite: $value');
            

                Future<void> setEnableComposite(int value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setEnableComposite', value);
}
            

                bool value = true;
_barkoder.setVideoStabilization(value);
print('Video stabilization: $value');
            

                Future<void> setVideoStabilization(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setVideoStabilization', value);
}
            

                BarkoderCameraPosition cameraPosition = BarkoderCameraPosition.BACK;
_barkoder.setCamera(cameraPosition);
print('Barkoder camera position set to: $cameraPosition');
            

                Future<void> setCamera(BarkoderCameraPosition value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setCamera', value.index);
}
            

                _barkoder.setShowDuplicatesLocations(true);
            

                Future<void> setShowDuplicatesLocations(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setShowDuplicatesLocations', value);
}
            

                _barkoder.setARMode(BarkoderARMode.interactive);
            

                Future<void> setARMode(BarkoderARMode value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARMode', value.index);
}
            

                _barkoder.setARResultDisappearanceDelayMs(800);
            

                Future<void> setARResultDisappearanceDelayMs(int value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARResultDisappearanceDelayMs', value);
}
            

                _barkoder.setARLocationTransitionSpeed(0.3);
            

                Future<void> setARLocationTransitionSpeed(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARLocationTransitionSpeed', value);
}
            

                _barkoder.setAROverlayRefresh(BarkoderAROverlayRefresh.smooth);
            

                Future<void> setAROverlayRefresh(BarkoderAROverlayRefresh value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setAROverlayRefresh', value.index);
}
            

                _barkoder.setARSelectedLocationColor('#00FF00');
            

                Future<void> setARSelectedLocationColor(String value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARSelectedLocationColor', value);
}
            

                _barkoder.setARNonSelectedLocationColor('#FF0000');
            

                Future<void> setARNonSelectedLocationColor(String value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARNonSelectedLocationColor', value);
}
            

                _barkoder.setARSelectedLocationLineWidth(2.0);
            

                Future<void> setARSelectedLocationLineWidth(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARSelectedLocationLineWidth', value);
}
            

                _barkoder.setARNonSelectedLocationLineWidth(1.0);
            

                Future<void> setARNonSelectedLocationLineWidth(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARNonSelectedLocationLineWidth', value);
}
            

                _barkoder.setARLocationType(BarkoderARLocationType.tight);
            

                Future<void> setARLocationType(BarkoderARLocationType value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARLocationType', value.index);
}
            

                _barkoder.setARDoubleTapToFreezeEnabled(true);
            

                Future<void> setARDoubleTapToFreezeEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARDoubleTapToFreezeEnabled', enabled);
}
            

                bool arImageResultEnabled = true;
_barkoder.setARImageResultEnabled(arImageResultEnabled);
print('AR Image result enabled: $arImageResultEnabled');
            

                Future<void> setARImageResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('setARImageResultEnabled', enabled);
}
            

                bool arThumbnailEnabled = true;
_barkoder.setARBarcodeThumbnailOnResultEnabled(arThumbnailEnabled);
print('AR Barcode thumbnail on result enabled: $arThumbnailEnabled');
            

                Future<void> setARBarcodeThumbnailOnResultEnabled(bool enabled) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod(
      'setARBarcodeThumbnailOnResultEnabled', enabled);
}
            

                _barkoder.setARResultLimit(5);
            

                Future<void> setARResultLimit(int value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARResultLimit', value);
}
            

                _barkoder.setARContinueScanningOnLimit(true);
            

                Future<void> setARContinueScanningOnLimit(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARContinueScanningOnLimit', value);
}
            

                _barkoder.setAREmitResultsAtSessionEndOnly(true);
            

                Future<void> setAREmitResultsAtSessionEndOnly(bool value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setAREmitResultsAtSessionEndOnly', value);
}
            

                _barkoder.setARHeaderHeight(24.0);
            

                Future<void> setARHeaderHeight(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderHeight', value);
}
            

                _barkoder.setARHeaderShowMode(BarkoderARHeaderShowMode.onSelected);
            

                Future<void> setARHeaderShowMode(BarkoderARHeaderShowMode value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderShowMode', value.index);
}
            

                _barkoder.setARHeaderMaxTextHeight(22.0);
            

                Future<void> setARHeaderMaxTextHeight(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderMaxTextHeight', value);
}
            

                _barkoder.setARHeaderMinTextHeight(12.0);
            

                Future<void> setARHeaderMinTextHeight(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderMinTextHeight', value);
}
            

                _barkoder.setARHeaderTextColorSelected('#FFFFFF');
            

                Future<void> setARHeaderTextColorSelected(String value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderTextColorSelected', value);
}
            

                _barkoder.setARHeaderTextColorNonSelected('#AAAAAA');
            

                Future<void> setARHeaderTextColorNonSelected(String value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderTextColorNonSelected', value);
}
            

                _barkoder.setARHeaderHorizontalTextMargin(8.0);
            

                Future<void> setARHeaderHorizontalTextMargin(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderHorizontalTextMargin', value);
}
            

                _barkoder.setARHeaderVerticalTextMargin(4.0);
            

                Future<void> setARHeaderVerticalTextMargin(double value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderVerticalTextMargin', value);
}
            

                _barkoder.setARHeaderTextFormat('[barcode_text] - [barcode_type]');
            

                Future<void> setARHeaderTextFormat(String value) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('setARHeaderTextFormat', value);
}
            

                Future<void> configureCloseButton({
  required bool visible,
  required double positionX,
  required double positionY,
  required double iconSize,
  required String tintColor,
  required String backgroundColor,
  required double cornerRadius,
  required double padding,
  required bool useCustomIcon,
  required String customIcon, // base64 string
}) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('configureCloseButton', {
    'visible': visible,
    'positionX': positionX,
    'positionY': positionY,
    'iconSize': iconSize,
    'tintColor': tintColor,
    'backgroundColor': backgroundColor,
    'cornerRadius': cornerRadius,
    'padding': padding,
    'useCustomIcon': useCustomIcon,
    'customIcon': customIcon,
  });
}
            

                Future<void> configureFlashButton({
  required bool visible,
  required double positionX,
  required double positionY,
  required double iconSize,
  required String tintColor,
  required String backgroundColor,
  required double cornerRadius,
  required double padding,
  required bool useCustomIcon,
  required String customIconFlashOn,  // base64
  required String customIconFlashOff, // base64
}) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('configureFlashButton', {
    'visible': visible,
    'positionX': positionX,
    'positionY': positionY,
    'iconSize': iconSize,
    'tintColor': tintColor,
    'backgroundColor': backgroundColor,
    'cornerRadius': cornerRadius,
    'padding': padding,
    'useCustomIcon': useCustomIcon,
    'customIconFlashOn': customIconFlashOn,
    'customIconFlashOff': customIconFlashOff,
  });
}
            

                Future<void> configureZoomButton({
  required bool visible,
  required double positionX,
  required double positionY,
  required double iconSize,
  required String tintColor,
  required String backgroundColor,
  required double cornerRadius,
  required double padding,
  required bool useCustomIcon,
  required String customIconZoomedIn,   // base64
  required String customIconZoomedOut,  // base64
  required double zoomedInFactor,
  required double zoomedOutFactor,
}) {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return _methodChannel.invokeMethod('configureZoomButton', {
    'visible': visible,
    'positionX': positionX,
    'positionY': positionY,
    'iconSize': iconSize,
    'tintColor': tintColor,
    'backgroundColor': backgroundColor,
    'cornerRadius': cornerRadius,
    'padding': padding,
    'useCustomIcon': useCustomIcon,
    'customIconZoomedIn': customIconZoomedIn,
    'customIconZoomedOut': customIconZoomedOut,
    'zoomedInFactor': zoomedInFactor,
    'zoomedOutFactor': zoomedOutFactor,
  });
}
            

                _barkoder.selectVisibleBarcodes();
print('Selected visible barcodes');
            

                Future<void> selectVisibleBarcodes() {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return _methodChannel.invokeMethod('selectVisibleBarcodes');
}
            

                bool showDuplicates = await _barkoder.getShowDuplicatesLocations();
print('Show duplicates locations: $showDuplicates');
            

                Future<bool> getShowDuplicatesLocations() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getShowDuplicatesLocations');
}
            

                BarkoderARMode mode = await _barkoder.getARMode();
print('Current AR Mode: $mode');
            

                Future<BarkoderARMode> getARMode() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  final index = await _methodChannel.invokeMethod('getARMode');
  return BarkoderARMode.values[index];
}
            

                int delay = await _barkoder.getARResultDisappearanceDelayMs();
print('AR result disappearance delay: $delay ms');
            

                Future<int> getARResultDisappearanceDelayMs() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARResultDisappearanceDelayMs');
}
            

                double speed = await _barkoder.getARLocationTransitionSpeed();
print('AR transition speed: $speed');
            

                Future<double> getARLocationTransitionSpeed() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARLocationTransitionSpeed');
}
            

                var mode = await _barkoder.getAROverlayRefresh();
print('AR overlay refresh mode: $mode');
            

                Future<BarkoderAROverlayRefresh> getAROverlayRefresh() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  final index = await _methodChannel.invokeMethod('getAROverlayRefresh');
  return BarkoderAROverlayRefresh.values[index];
}
            

                String color = await _barkoder.getARSelectedLocationColor();
print('Selected location color: $color');
            

                Future<String> getARSelectedLocationColor() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARSelectedLocationColor');
}
            

                String color = await _barkoder.getARNonSelectedLocationColor();
print('Non-selected location color: $color');
            

                Future<String> getARNonSelectedLocationColor() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARNonSelectedLocationColor');
}
            

                double width = await _barkoder.getARSelectedLocationLineWidth();
print('Selected line width: $width');
            

                Future<double> getARSelectedLocationLineWidth() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARSelectedLocationLineWidth');
}
            

                double width = await _barkoder.getARNonSelectedLocationLineWidth();
print('Non-selected line width: $width');
            

                Future<double> getARNonSelectedLocationLineWidth() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARNonSelectedLocationLineWidth');
}
            

                var type = await _barkoder.getARLocationType();
print('AR location type: $type');
            

                Future<BarkoderARLocationType> getARLocationType() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  final index = await _methodChannel.invokeMethod('getARLocationType');
  return BarkoderARLocationType.values[index];
}
            

                bool enabled = await _barkoder.isARDoubleTapToFreezeEnabled();
print('Double tap to freeze: $enabled');
            

                Future<bool> isARDoubleTapToFreezeEnabled() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('isARDoubleTapToFreezeEnabled');
}
            

                bool arImageResultEnabled = await _barkoder.isARImageResultEnabled;
print('AR Image result enabled: $arImageResultEnabled');
            

                Future<bool> get isARImageResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel.invokeMethod('isARImageResultEnabled');
}
            

                bool arThumbnailEnabled = await _barkoder.isARBarcodeThumbnailOnResultEnabled;
print('AR Barcode thumbnail on result enabled: $arThumbnailEnabled');
            

                Future<bool> get isARBarcodeThumbnailOnResultEnabled async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
        code: BarkoderErrors.barkoderViewNotMounted,
        message: BarkoderErrors.barkodeViewNotMountedDesc));
  }

  return await _methodChannel
      .invokeMethod('isARBarcodeThumbnailOnResultEnabled');
}
            

                int resultLimit = await _barkoder.getARResultLimit;
            

                Future<int> get getARResultLimit async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return await _methodChannel.invokeMethod('getARResultLimit');
}
            

                bool continueScanning = await _barkoder.getARContinueScanningOnLimit;
            

                Future<bool> get getARContinueScanningOnLimit async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return await _methodChannel.invokeMethod('getARContinueScanningOnLimit');
}
            

                bool emitAtEnd = await _barkoder.getAREmitResultsAtSessionEndOnly;
            

                Future<bool> get getAREmitResultsAtSessionEndOnly async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc,
    ));
  }

  return await _methodChannel.invokeMethod('getAREmitResultsAtSessionEndOnly');
}
            

                double height = await _barkoder.getARHeaderHeight();
print('AR header height: $height');
            

                Future<double> getARHeaderHeight() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderHeight');
}
            

                var mode = await _barkoder.getARHeaderShowMode();
print('AR header show mode: $mode');
            

                Future<BarkoderARHeaderShowMode> getARHeaderShowMode() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  final index = await _methodChannel.invokeMethod('getARHeaderShowMode');
  return BarkoderARHeaderShowMode.values[index];
}
            

                double maxHeight = await _barkoder.getARHeaderMaxTextHeight();
print('Max text height: $maxHeight');
            

                Future<double> getARHeaderMaxTextHeight() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderMaxTextHeight');
}
            

                double minHeight = await _barkoder.getARHeaderMinTextHeight();
print('Min text height: $minHeight');
            

                Future<double> getARHeaderMinTextHeight() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderMinTextHeight');
}
            

                String color = await _barkoder.getARHeaderTextColorSelected();
print('Header selected text color: $color');
            

                Future<String> getARHeaderTextColorSelected() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderTextColorSelected');
}
            

                String color = await _barkoder.getARHeaderTextColorNonSelected();
print('Header non-selected text color: $color');
            

                Future<String> getARHeaderTextColorNonSelected() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderTextColorNonSelected');
}
            

                double margin = await _barkoder.getARHeaderHorizontalTextMargin();
print('Header horizontal margin: $margin');
            

                Future<double> getARHeaderHorizontalTextMargin() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderHorizontalTextMargin');
}
            

                double margin = await _barkoder.getARHeaderVerticalTextMargin();
print('Header vertical margin: $margin');
            

                Future<double> getARHeaderVerticalTextMargin() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderVerticalTextMargin');
}
            

                String format = await _barkoder.getARHeaderTextFormat();
print('Header text format: $format');
            

                Future<String> getARHeaderTextFormat() async {
  if (_isBarkoderViewNotMounted) {
    return Future.error(PlatformException(
      code: BarkoderErrors.barkoderViewNotMounted,
      message: BarkoderErrors.barkodeViewNotMountedDesc));
  }
  return await _methodChannel.invokeMethod('getARHeaderTextFormat');
}