react-native-scanbot-barcode-scanner-sdk 7.1.2-rc.2 → 8.0.0-rc.1

package/src/index.ts

@@ -1,180 +1,7 @@
-import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
-
-import { BarcodeItem, BarcodeScannerConfiguration, BarcodeScannerResult } from './barcode';
-import {
-  ExtractImagesFromPdfArguments,
-  LicenseInfoResult,
-  MockCameraParams,
-  ResultWrapper,
-  ScanbotBarcodeSdkConfiguration,
-} from './base';
-import {
-  BarcodeItemMapper,
-  BarcodeMappedData,
-  BarcodeScannerScreenConfiguration,
-  BarcodeScannerUiResult,
-  MultipleScanningMode,
-  SingleScanningMode,
-} from './ui_v2';
-import { DeepPartial, mapRTUUIResult } from './utils';
-
-const LINKING_ERROR =
-  `The package 'react-native-scanbot-barcode-scanner-sdk' doesn't seem to be linked. Make sure: \n\n` +
-  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
-  '- You rebuilt the app after installing the package\n' +
-  '- You are not using Expo Go\n';
-
-const ScanbotBarcodeSDKImpl = NativeModules.ScanbotBarcodeSdk
-  ? NativeModules.ScanbotBarcodeSdk
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
-
-const isIOS: boolean = Platform.OS === 'ios';
-
-const ScanbotBarcodeSDK = {
-  /**
-   * Initialize the Scanbot Barcode Scanner SDK with the preferred configuration.
-   *
-   * @param {ScanbotBarcodeSdkConfiguration} config
-   * @returns {Promise<LicenseInfoResult>}
-   */
-  initializeSdk: (config: ScanbotBarcodeSdkConfiguration): Promise<LicenseInfoResult> => {
-    return ScanbotBarcodeSDKImpl.initializeSdk(config);
-  },
-  /**
-   * Provides complete information about the current license status.
-   *
-   * @returns {Promise<LicenseInfoResult>}
-   */
-  getLicenseInfo: (): Promise<LicenseInfoResult> => {
-    return ScanbotBarcodeSDKImpl.getLicenseInfo();
-  },
-  /**
-   * Remove all files generated by this plugin.
-   *
-   * @returns {Promise<string>}
-   */
-  cleanup: (): Promise<string> => {
-    return ScanbotBarcodeSDKImpl.cleanup();
-  },
-  /**
-   * Opens the Ready-To-Use UI screen for scanning barcodes with the desired configuration.
-   *
-   * @param {BarcodeScannerScreenConfiguration} config
-   * @returns {Promise<ResultWrapper<BarcodeScannerUiResult>>}
-   */
-  startBarcodeScanner: async (
-    config: BarcodeScannerScreenConfiguration
-  ): Promise<ResultWrapper<BarcodeScannerUiResult>> => {
-    const barcodeItemMapperEventName: string = 'barcodeItemMapperEvent';
-    let barcodeItemMapperCallback: BarcodeItemMapper | null = null;
-    let barcodeItemMapperEventEmitter: NativeEventEmitter | null = null;
-
-    if (
-      config.useCase instanceof SingleScanningMode ||
-      config.useCase instanceof MultipleScanningMode
-    ) {
-      barcodeItemMapperCallback = config.useCase.barcodeInfoMapping.barcodeItemMapper;
-
-      if (barcodeItemMapperCallback) {
-        barcodeItemMapperEventEmitter = new NativeEventEmitter(ScanbotBarcodeSDKImpl);
-        barcodeItemMapperEventEmitter.removeAllListeners(barcodeItemMapperEventName);
-
-        barcodeItemMapperEventEmitter.addListener(
-          barcodeItemMapperEventName,
-          (barcodeItem: BarcodeItem) => {
-            const barcodeItemUuid = `${barcodeItem.text}${barcodeItem.upcEanExtension}_${barcodeItem.format}`;
-
-            barcodeItemMapperCallback!(
-              barcodeItem,
-              (barcodeMappedData: BarcodeMappedData) =>
-                ScanbotBarcodeSDKImpl.onBarcodeItemMapper(barcodeItemUuid, barcodeMappedData),
-              () => ScanbotBarcodeSDKImpl.onBarcodeItemMapper(barcodeItemUuid, null)
-            );
-          }
-        );
-
-        // On iOS, the communication with the native part is throwing an error (startBarcodeScannerV2) because of the barcodeItemMapper
-        // callback in the configuration class (not parsable), that's why we need to remove it before executing startBarcodeScannerV2 method
-        config.useCase.barcodeInfoMapping.barcodeItemMapper = null;
-
-        return new Promise<ResultWrapper<BarcodeScannerUiResult>>((resolve, reject) => {
-          ScanbotBarcodeSDKImpl.startBarcodeScanner(isIOS ? JSON.stringify(config) : config, true)
-            .then((result: ResultWrapper<DeepPartial<BarcodeScannerUiResult>>) => {
-              barcodeItemMapperEventEmitter?.removeAllListeners(barcodeItemMapperEventName);
-              barcodeItemMapperEventEmitter = null;
-
-              resolve(mapRTUUIResult(result, BarcodeScannerUiResult));
-            })
-            .catch((error: any) => {
-              barcodeItemMapperEventEmitter?.removeAllListeners(barcodeItemMapperEventName);
-              barcodeItemMapperEventEmitter = null;
-
-              reject(error);
-            });
-        });
-      }
-    }
-
-    return ScanbotBarcodeSDKImpl.startBarcodeScanner(
-      isIOS ? JSON.stringify(config) : config,
-      false
-    ).then((result: ResultWrapper<DeepPartial<BarcodeScannerUiResult>>) =>
-      mapRTUUIResult(result, BarcodeScannerUiResult)
-    );
-  },
-  /**
-   * Detect barcodes on the image represented by the file URL. The image file URL is part of the input parameters.
-   *
-   * @param {{imageFileUri: string, configuration: BarcodeScannerConfiguration}} params
-   * @returns {Promise<BarcodeScannerResult>}
-   */
-  detectBarcodesOnImage: async (params: {
-    imageFileUri: string;
-    configuration: BarcodeScannerConfiguration;
-  }): Promise<BarcodeScannerResult> => {
-    return ScanbotBarcodeSDKImpl.detectBarcodesOnImage(params).then(
-      (result: DeepPartial<BarcodeScannerResult>) => new BarcodeScannerResult(result)
-    );
-  },
-  /**
-   * Extract images from a PDF represented by the file URL. The PDF file URL is part of the input parameters.
-   *
-   * @param {ExtractImagesFromPdfArguments} params
-   * @returns {Promise<string[]>}
-   */
-  extractImagesFromPDF: (params: ExtractImagesFromPdfArguments): Promise<string[]> => {
-    return ScanbotBarcodeSDKImpl.extractImagesFromPDF(params);
-  },
-  /**
-   * Returns the Base 64 encoded representation of the image data.
-   *
-   * @returns {Promise<string>}
-   */
-  getImageData(imageUri: string): Promise<string> {
-    return ScanbotBarcodeSDKImpl.getImageData(imageUri);
-  },
-  /**
-   * Mock camera preview by using static images as a frame source.
-   * This is useful for testing purposes.
-   */
-  mockCamera(params: MockCameraParams): Promise<void> {
-    return ScanbotBarcodeSDKImpl.mockCamera(params);
-  },
-};
+import { ScanbotBarcodeSdk as ScanbotBarcodeSDK } from './Sdk';
 
 export default ScanbotBarcodeSDK;
-
-export * from './barcode';
-export * from './base';
-export * from './component/barcode-camera-view';
-export * from './documents';
-export * from './imageRef';
-export * from './ui_v2';
-export * from './utils';
+export * from './Barcode';
+export * from './ImageProcessor';
+export * from './components';
+export * from './types';

package/src/types/base/SdkConfiguration.ts

@@ -0,0 +1,120 @@
+/// Auto-generated with ScanbotSDKCodegenV3. Modifications will be overwritten.
+/// Generated from xplatforms/schemas/barcode_scanner/SdkConfiguration.yaml
+
+import { DeepPartial } from '../core/utils/utils';
+
+/**
+Initialize configuration for the Scanbot SDK.
+*/
+export class SdkConfiguration {
+  /**
+    Your license key for the Scanbot SDK. See the "License Key" section below.
+    */
+  public licenseKey: string;
+  /**
+    Optional boolean flag to enable logging. See the "Logging" section below.
+    
+    Default is false
+    */
+  public loggingEnabled: boolean = false;
+  /**
+    Optional boolean flag that enables Scanbot SDK Core native logging (default is false, Android only).
+    
+    Default is false
+    */
+  public enableNativeLogging: boolean = false;
+  /**
+    Optional directory as file URI to override the default storage base directory of the Scanbot SDK. Refer to the section "Storage" for more details.
+    */
+  public storageBaseDirectory: string | null = null;
+  /**
+    Optional file encryption mode, 'AES128' or 'AES256'.
+    */
+  public fileEncryptionMode: FileEncryptionMode | null = null;
+  /**
+    Optional file encryption password. Refer to the section "Storage Encryption" for more details.
+    */
+  public fileEncryptionPassword: string | null = null;
+  /**
+    If set to `true`, PerformanceHintApi is enabled, which lead to increase of performance due of increased use of top CPU cores (Android only), also increase battery usage.
+    
+    Default is true
+    */
+  public performanceHintApi: boolean = true;
+  /**
+    If set to `true`, GPU Acceleration will be enabled for Barcode Scanner, Document Scanner and Generic Document Recognizer (Android only).
+    
+    Default is true
+    */
+  public allowGpuAcceleration: boolean = true;
+  /**
+    Enables/disables XNNPACK acceleration for TensorFlow ML models, which provides highly optimized implementations of floating-point neural network operators (Android only).
+    
+    Default is true
+    */
+  public allowXnnpackAcceleration: boolean = true;
+
+  /** @param source {@displayType `DeepPartial<SdkConfiguration>`} */
+  public constructor(source: DeepPartial<SdkConfiguration> = {}) {
+    if (source.licenseKey !== undefined) {
+      this.licenseKey = source.licenseKey;
+    } else {
+      throw new Error('licenseKey must be present in constructor argument');
+    }
+    if (source.loggingEnabled !== undefined) {
+      this.loggingEnabled = source.loggingEnabled;
+    }
+    if (source.enableNativeLogging !== undefined) {
+      this.enableNativeLogging = source.enableNativeLogging;
+    }
+    if (source.storageBaseDirectory !== undefined) {
+      this.storageBaseDirectory =
+        source.storageBaseDirectory != null ? source.storageBaseDirectory : null;
+    }
+    if (source.fileEncryptionMode !== undefined) {
+      this.fileEncryptionMode =
+        source.fileEncryptionMode != null
+          ? FileEncryptionModeValues.includes(source.fileEncryptionMode)
+            ? source.fileEncryptionMode
+            : null
+          : null;
+    }
+    if (source.fileEncryptionPassword !== undefined) {
+      this.fileEncryptionPassword =
+        source.fileEncryptionPassword != null ? source.fileEncryptionPassword : null;
+    }
+    if (source.performanceHintApi !== undefined) {
+      this.performanceHintApi = source.performanceHintApi;
+    }
+    if (source.allowGpuAcceleration !== undefined) {
+      this.allowGpuAcceleration = source.allowGpuAcceleration;
+    }
+    if (source.allowXnnpackAcceleration !== undefined) {
+      this.allowXnnpackAcceleration = source.allowXnnpackAcceleration;
+    }
+  }
+}
+
+/**
+File encryption mode.
+
+- `AES128`:
+   AES 128-bit encryption.
+- `AES256`:
+   AES 256-bit encryption.
+*/
+export type FileEncryptionMode =
+  /**
+    AES 128-bit encryption.
+    */
+  | 'AES128'
+  /**
+    AES 256-bit encryption.
+    */
+  | 'AES256';
+
+/** @hidden */
+export const FileEncryptionModeValues: ReadonlyArray<FileEncryptionMode> = [
+  'AES128',
+  'AES256',
+] as const;

package/src/types/base/customTypes.ts

@@ -0,0 +1,14 @@
+import { ImageRef } from '../core';
+
+export type ResultWrapper<T> = { status: 'CANCELED' } | { status: 'OK'; data: T };
+
+export type ImageInput = string | ImageRef;
+
+/**
+ * @hidden
+ */
+export type SerializedImageInput =
+  | {
+      imageFileUri: string;
+    }
+  | Awaited<ReturnType<ImageRef['serialize']>>;

package/src/types/base/errors.ts

@@ -0,0 +1,158 @@
+export type SBErrorType =
+  | 'InvalidLicense'
+  | 'NullPointer'
+  | 'InvalidArgument'
+  | 'InvalidImageRef'
+  | 'ComponentUnavailable'
+  | 'IllegalState'
+  | 'IOError'
+  | 'InvalidData'
+  | 'OutOfMemory'
+  | 'Timeout'
+  | 'ProcessError'
+  | 'Unknown';
+
+export abstract class SBError extends Error {
+  public abstract readonly type: SBErrorType;
+
+  protected constructor(message: string) {
+    super(message);
+  }
+}
+
+export class InvalidLicenseError extends SBError {
+  public readonly type: SBErrorType = 'InvalidLicense';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class NullPointerError extends SBError {
+  public readonly type: SBErrorType = 'NullPointer';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class InvalidArgumentError extends SBError {
+  public readonly type: SBErrorType = 'InvalidArgument';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class InvalidImageRefError extends SBError {
+  public readonly type: SBErrorType = 'InvalidImageRef';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class ComponentUnavailableError extends SBError {
+  public readonly type: SBErrorType = 'ComponentUnavailable';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class IllegalStateError extends SBError {
+  public readonly type: SBErrorType = 'IllegalState';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class IOError extends SBError {
+  public readonly type: SBErrorType = 'IOError';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class InvalidDataError extends SBError {
+  public readonly type: SBErrorType = 'InvalidData';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class OutOfMemoryError extends SBError {
+  public readonly type: SBErrorType = 'OutOfMemory';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class TimeoutError extends SBError {
+  public readonly type: SBErrorType = 'Timeout';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class UnknownError extends SBError {
+  public readonly type: SBErrorType = 'Unknown';
+
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class ProcessError extends SBError {
+  public readonly type: SBErrorType = 'ProcessError';
+  public readonly code: number;
+
+  constructor(message: string, code: number) {
+    super(message);
+    this.code = code;
+  }
+}
+
+/**
+ * @internal
+ * @hidden
+ */
+export function createSBError(err: any): SBError {
+  const code = Number(err.code);
+  const message = err.message || err.errorMessage || 'An unknown error occurred';
+  switch (code) {
+    case 1:
+      return new UnknownError(message);
+    case 2:
+      return new InvalidLicenseError(message);
+    case 3:
+      return new NullPointerError(message);
+    case 4:
+      return new InvalidArgumentError(message);
+    case 5:
+      return new InvalidImageRefError(message);
+    case 6:
+      return new ComponentUnavailableError(message);
+    case 7:
+      return new IllegalStateError(message);
+    case 8:
+      return new IOError(message);
+    case 9:
+      return new InvalidDataError(message);
+    case 11:
+      return new OutOfMemoryError(message);
+    case 12:
+      return new TimeoutError(message);
+    default: {
+      if (code >= 100) {
+        return new ProcessError(message, code);
+      }
+      return new UnknownError(message);
+    }
+  }
+}

package/src/types/base/index.ts

@@ -0,0 +1,4 @@
+export * from './SdkConfiguration';
+export * from './customTypes';
+export * from './errors';
+export * from './utils';

package/src/types/base/utils.ts

@@ -0,0 +1,53 @@
+import { DeepPartial, ImageRef } from '../core';
+import { ImageInput, ResultWrapper, SerializedImageInput } from './customTypes';
+import { createSBError } from './errors';
+
+/**
+ * @internal
+ * @hidden
+ */
+export function mapRTUUIResult<T>(
+  result: ResultWrapper<DeepPartial<T>>,
+  LClass: new (source: DeepPartial<T>) => T
+): ResultWrapper<T> {
+  if (result.status === 'OK') {
+    return {
+      ...result,
+      data: new LClass(result.data),
+    };
+  } else {
+    return result;
+  }
+}
+
+/**
+ * @internal
+ * @hidden
+ */
+export function handleImageInput(image: ImageInput): SerializedImageInput;
+export function handleImageInput(image: ImageInput[]): SerializedImageInput[];
+export function handleImageInput(
+  image: ImageInput | ImageInput[]
+): SerializedImageInput | SerializedImageInput[] {
+  const handleInput = (input: ImageInput): SerializedImageInput => {
+    if (input instanceof ImageRef) {
+      return input.uniqueId ? { uniqueId: input.uniqueId } : { buffer: input.buffer };
+    } else {
+      return { imageFileUri: input };
+    }
+  };
+
+  return Array.isArray(image) ? image.map(handleInput) : handleInput(image);
+}
+
+/**
+ * @internal
+ * @hidden
+ */
+export async function withSBErrorHandling<T>(fn: () => Promise<T>): Promise<T> {
+  try {
+    return await fn();
+  } catch (error: any) {
+    throw createSBError(error);
+  }
+}