scandit-datacapture-frameworks-core 7.6.2 → 8.0.0-beta.2

package/__mocks__/Defaults.ts

@@ -0,0 +1,64 @@
+import { FactoryMaker, loadCoreDefaults } from '../src';
+
+const mockCoreDefaultsData = {
+  "Camera": {
+    "defaultPosition": "worldFacing",
+    "Settings": {
+      "zoomFactor": 1,
+      "zoomGestureZoomFactor": 2,
+      "focusGestureStrategy": "manualUntilCapture",
+      "focusRange": "near",
+      "preferredResolution": "auto",
+      "shouldPreferSmoothAutoFocus": false,
+      "properties": {}
+    },
+    "availablePositions": ["worldFacing", "userFacing"]
+  },
+  "Version": "8.1.0-test",
+  "deviceID": "test-device-id",
+  "AimerViewfinder": {
+    "dotColor": "ffffffcc",
+    "frameColor": "ffffffff"
+  },
+  "RectangularViewfinder": {
+    "defaultStyle": "rounded",
+    "styles": {
+      "rounded": {
+        "color": "ffffffff",
+        "size": "{\"aspect\":1.0,\"shorterDimension\":{\"unit\":\"fraction\",\"value\":0.75}}",
+        "disabledDimming": 0,
+        "dimming": 0,
+        "animation": "{\"looping\":true}",
+        "style": "rounded",
+        "disabledColor": "00000000",
+        "lineStyle": "light"
+      }
+    }
+  },
+  "DataCaptureView": {
+    "zoomGesture": "{\"type\":\"swipeToZoom\"}",
+    "pointOfInterest": "{\"x\":{\"unit\":\"fraction\",\"value\":0.5},\"y\":{\"unit\":\"fraction\",\"value\":0.5}}",
+    "focusGesture": "{\"showUIIndicator\":true,\"type\":\"tapToFocus\"}",
+    "logoStyle": "extended",
+    "logoOffset": "{\"x\":{\"unit\":\"fraction\",\"value\":0.0},\"y\":{\"unit\":\"fraction\",\"value\":0.0}}",
+    "logoAnchor": "bottomRight",
+    "scanAreaMargins": "{\"bottom\":{\"unit\":\"fraction\",\"value\":0.0},\"left\":{\"unit\":\"fraction\",\"value\":0.0},\"right\":{\"unit\":\"fraction\",\"value\":0.0},\"top\":{\"unit\":\"fraction\",\"value\":0.0}}"
+  },
+  "Brush": {
+    "fillColor": "00000000",
+    "strokeColor": "00000000",
+    "strokeWidth": 0
+  },
+  "LaserlineViewfinder": {
+    "width": "{\"unit\":\"fraction\",\"value\":0.8}",
+    "enabledColor": "#FFFFFFFF",
+    "disabledColor": "#00000000"
+  }
+};
+
+export function loadMockDefaults() {
+  loadCoreDefaults(mockCoreDefaultsData);
+}
+
+loadMockDefaults();
+

package/__mocks__/ScanditDataCaptureCore.ts

@@ -0,0 +1,148 @@
+import { jest } from '@jest/globals';
+import { NativeCaller } from '../src';
+import { EventEmitter } from "eventemitter3";
+
+export class MockDataCaptureView {
+  public get viewId(): number {
+    return 1;
+  }
+
+  addOverlay = jest.fn((overlay: any): Promise<void> => {
+    overlay.view = this as any;
+    return Promise.resolve();
+  });
+
+  removeOverlay = jest.fn((overlay: any): Promise<void> => {
+    overlay.view = null;
+    return Promise.resolve();
+  });
+}
+
+export class MockDataCaptureContext {
+  public controller: any = null;
+
+  constructor() {
+    this.controller = {
+      updateContextFromJSON: jest.fn(() => Promise.resolve())
+    };
+  }
+
+  addMode = jest.fn((mode: any): Promise<void> => {
+    mode._context = this;
+    return Promise.resolve();
+  });
+
+  setMode = jest.fn((mode: any): Promise<void> => {
+    mode._context = this;
+    return Promise.resolve();
+  });
+
+  setFrameSource = jest.fn(async (frameSource: any) => {
+    if (frameSource) {
+      if (typeof frameSource.setNativeFrameSourceIsBeingCreated === 'function') {
+        frameSource.setNativeFrameSourceIsBeingCreated();
+      }
+      await this.update();
+      frameSource.context = this;
+    }
+  });
+
+  update = jest.fn(async () => {
+    if (this.controller) {
+      await this.controller.updateContextFromJSON();
+    }
+    return Promise.resolve();
+  });
+
+  initializeAsync = jest.fn(() => Promise.resolve());
+}
+
+class MockEmitterSubscription {
+  constructor(
+    private emitter: EventEmitter,
+    private eventType: string,
+    private listener: (...args: any[]) => void
+  ) {}
+
+  remove(): void {
+    this.emitter.removeListener(this.eventType, this.listener);
+  }
+}
+
+export class MockNativeEventEmitter {
+  private emitter: EventEmitter;
+
+  constructor() {
+    this.emitter = new EventEmitter();
+  }
+
+  addListener(eventType: string, listener: (...args: any[]) => void): MockEmitterSubscription {
+    this.emitter.addListener(eventType, listener);
+    return new MockEmitterSubscription(this.emitter, eventType, listener);
+  }
+
+  removeAllListeners(eventType?: string): void {
+    this.emitter.removeAllListeners(eventType);
+  }
+
+  emit(eventType: string, ...args: any[]): boolean {
+    return this.emitter.emit(eventType, ...args);
+  }
+}
+
+export class MockCaller implements NativeCaller {
+  constructor(public nativeModule: any, public emitter: MockNativeEventEmitter) {}
+
+  eventHook(args: any) {
+    return args;
+  }
+
+  callFn(fnName: string, args: object | undefined | null): Promise<any> {
+    if (typeof this.nativeModule[fnName] === 'function') {
+      return this.nativeModule[fnName](args);
+    }
+    return Promise.resolve(undefined);
+  }
+
+  async registerEvent(evName: string, handler: (args: any) => Promise<void>): Promise<any> {
+    return this.emitter.addListener(evName, handler);
+  }
+
+  async unregisterEvent(evName: string, subscription: any): Promise<void> {
+    if (subscription && subscription.remove) {
+      await subscription.remove();
+    }
+  }
+}
+
+export function createMockCameraNativeModule() {
+  return {
+    $getCurrentCameraState: jest.fn(() => Promise.resolve({ data: 'off' })),
+    $switchCameraToDesiredState: jest.fn(() => Promise.resolve()),
+    $isTorchAvailable: jest.fn(() => Promise.resolve({ data: 'true' })),
+    $registerListenerForCameraEvents: jest.fn(() => Promise.resolve()),
+    $unregisterListenerForCameraEvents: jest.fn(() => Promise.resolve()),
+    $getFrame: jest.fn(() => Promise.resolve(null)),
+  };
+}
+
+export function createMockDataCaptureContextNativeModule() {
+  return {
+    $contextFromJSON: jest.fn(() => Promise.resolve({ data: '{}' })),
+    $updateContextFromJSON: jest.fn(() => Promise.resolve()),
+    $subscribeContextListener: jest.fn(),
+    $unsubscribeContextListener: jest.fn(() => Promise.resolve()),
+    $addModeToContext: jest.fn(() => Promise.resolve()),
+    $removeModeFromContext: jest.fn(() => Promise.resolve()),
+    $removeAllModes: jest.fn(() => Promise.resolve()),
+    $getOpenSourceSoftwareLicenseInfo: jest.fn(() => Promise.resolve({ data: '[]' })),
+    $disposeContext: jest.fn(() => Promise.resolve()),
+  };
+}
+
+export function createMockFeedbackNativeModule() {
+  return {
+    $emit: jest.fn(() => Promise.resolve()),
+  };
+}
+

package/dist/dts/camera/Camera.d.ts

@@ -5,17 +5,44 @@ import { CameraController } from "./CameraController";
 import { TorchState } from "./TorchState";
 import { CameraPosition } from "../camerahelpers/CameraPosition";
 import { CameraSettings } from "./CameraSettings";
+/**
+ * Camera lifecycle and operation handling:
+ *
+ * Phase 1 - Initial State (before native creation starts):
+ *   - Camera object exists in TypeScript but not yet being created on native side
+ *   - State changes (torch, desired state, settings) only update TypeScript properties
+ *   - No native calls are triggered
+ *
+ * Phase 2 - Native Creation In Progress (after setFrameSource, before context set):
+ *   - setFrameSource() called on DataCaptureContext, triggering setNativeFrameSourceIsBeingCreated()
+ *   - A promise is created that will resolve when the native camera is ready
+ *   - State changes during this phase await the native ready promise before executing
+ *   - Native camera is created asynchronously
+ *
+ * Phase 3 - Active State (after context set):
+ *   - Native camera is ready and available
+ *   - The native ready promise is resolved
+ *   - All state changes execute immediately on native side
+ */
 export declare class Camera extends DefaultSerializeable implements FrameSource {
     private type;
     private settings;
     private position;
     private _desiredTorchState;
     private _desiredState;
+    private currentCameraState;
     private listeners;
     private _context;
+    private nativeReadyResolver;
+    private nativeReadyRejecter;
+    private nativeReadyPromise;
+    private nativeReadyTimeout;
+    private static readonly _cameraInstances;
     private static get coreDefaults();
     private set context(value);
     private get context();
+    private setNativeFrameSourceIsBeingCreated;
+    private get isActiveCamera();
     private controller;
     static get default(): Camera | null;
     static withSettings(settings: CameraSettings): Camera | null;
@@ -25,26 +52,26 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
     set desiredTorchState(desiredTorchState: TorchState);
     get desiredTorchState(): TorchState;
     private constructor();
+    static create(position?: CameraPosition, settings?: CameraSettings | null, desiredTorchState?: TorchState, desiredState?: FrameSourceState): Camera | null;
     switchToDesiredState(state: FrameSourceState): Promise<void>;
     getCurrentState(): Promise<FrameSourceState>;
     getIsTorchAvailable(): Promise<boolean>;
-    /**
-     * @deprecated
-     */
-    get isTorchAvailable(): boolean;
     addListener(listener: FrameSourceListener | null): void;
     removeListener(listener: FrameSourceListener | null): void;
     applySettings(settings: CameraSettings): Promise<void>;
     private didChange;
+    private resetPhaseState;
 }
 export interface PrivateCamera {
     context: DataCaptureContext | null;
     position: CameraPosition;
     _desiredState: FrameSourceState;
+    currentCameraState: FrameSourceState;
     desiredTorchState: TorchState;
-    settings: CameraSettings;
+    settings: CameraSettings | null;
     listeners: FrameSourceListener[];
     controller: CameraController;
+    get isActiveCamera(): boolean;
     initialize: () => void;
     didChange: () => Promise<void>;
 }

package/dist/dts/camera/CameraController.d.ts

@@ -27,8 +27,7 @@ export interface CameraProxy {
 export declare class CameraController extends BaseNewController<CameraProxy> {
     private camera;
     private static get _proxy();
-    static forCamera(camera: Camera): CameraController;
-    private constructor();
+    constructor(camera: Camera);
     private get privateCamera();
     static getFrame(frameId: string): Promise<FrameData>;
     static getFrameOrNull(frameId: string): Promise<FrameData | null>;
@@ -39,4 +38,5 @@ export declare class CameraController extends BaseNewController<CameraProxy> {
     unsubscribeListener(): Promise<void>;
     dispose(): void;
     private handleDidChangeStateEvent;
+    private handleDidChangeStateEventWrapper;
 }

package/dist/dts/camera/VideoResolution.d.ts

@@ -1,4 +1,5 @@
 export declare enum VideoResolution {
+    /** @deprecated Auto is deprecated. Please use the capture mode's recommendedCameraSettings for the best results. */
     Auto = "auto",
     HD = "hd",
     FullHD = "fullHd",

package/dist/dts/camerahelpers/CameraOwner.d.ts

@@ -0,0 +1,3 @@
+export interface CameraOwner {
+    readonly id: string;
+}

package/dist/dts/camerahelpers/CameraOwnershipHelper.d.ts

@@ -0,0 +1,42 @@
+import { Camera } from "../camera/Camera";
+import { CameraPosition } from "./CameraPosition";
+import { CameraOwner } from "./CameraOwner";
+export declare class CameraOwnershipHelper {
+    private static ownershipManager;
+    /**
+     * Get camera instance for the owner (only works if you own it)
+     */
+    static getCamera(position: CameraPosition, owner: CameraOwner): Camera | null;
+    /**
+     * Safely execute camera operations (only works if you own the camera)
+     */
+    static withCamera<T>(position: CameraPosition, owner: CameraOwner, operation: (camera: Camera) => Promise<T> | T): Promise<T | null>;
+    /**
+     * Execute camera operations, waiting for ownership if necessary
+     */
+    static withCameraWhenAvailable<T>(position: CameraPosition, owner: CameraOwner, operation: (camera: Camera) => Promise<T> | T, timeoutMs?: number): Promise<T | null>;
+    /**
+     * Request ownership and wait if necessary
+     */
+    static requestOwnership(position: CameraPosition, owner: CameraOwner, timeoutMs?: number): Promise<boolean>;
+    /**
+     * Release ownership
+     */
+    static releaseOwnership(position: CameraPosition, owner: CameraOwner): boolean;
+    /**
+     * Check if owner has ownership
+     */
+    static hasOwnership(position: CameraPosition, owner: CameraOwner): boolean;
+    /**
+     * Get the camera position currently owned by the owner (if any)
+     */
+    static getOwnedPosition(owner: CameraOwner): CameraPosition | null;
+    /**
+     * Get all camera positions currently owned by the owner
+     */
+    static getAllOwnedPositions(owner: CameraOwner): CameraPosition[];
+    /**
+     * Release ownership of all cameras owned by the owner
+     */
+    static releaseAllOwnerships(owner: CameraOwner): void;
+}

package/dist/dts/camerahelpers/CameraOwnershipManager.d.ts

@@ -0,0 +1,24 @@
+import { CameraPosition } from "./CameraPosition";
+import { CameraOwner } from "./CameraOwner";
+export declare class CameraOwnershipManager {
+    private static instance;
+    private readonly owners;
+    private readonly waitingQueue;
+    private readonly protectedCameras;
+    private constructor();
+    static getInstance(): CameraOwnershipManager;
+    requestOwnership(position: CameraPosition, owner: CameraOwner): boolean;
+    requestOwnershipAsync(position: CameraPosition, owner: CameraOwner, timeoutMs?: number): Promise<boolean>;
+    releaseOwnership(position: CameraPosition, owner: CameraOwner): boolean;
+    isOwner(position: CameraPosition, owner: CameraOwner): boolean;
+    getCurrentOwner(position: CameraPosition): CameraOwner | null;
+    checkOwnership(position: CameraPosition, owner: CameraOwner): boolean;
+    getOwnedPosition(owner: CameraOwner): CameraPosition | null;
+    getAllOwnedPositions(owner: CameraOwner): CameraPosition[];
+    private enableProtectionForOwner;
+    private disableProtectionForPosition;
+    private processWaitingQueue;
+    private removeFromQueue;
+    private protectCameraForOwner;
+    private unprotectCamera;
+}

package/dist/dts/camerahelpers/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./CameraPosition";
 export * from "./FrameSourceListenerEvents";
+export * from "./CameraOwner";
+export * from "./CameraOwnershipManager";
+export * from "./CameraOwnershipHelper";

package/dist/dts/common/Payload.d.ts

@@ -1,3 +1,4 @@
+import { CameraPosition } from "../camerahelpers/CameraPosition";
 import { FrameSourceState } from "../frame/FrameSourceState";
 import { SizeJSON } from "./Size";
 export interface DidChangeSizeEventPayload {
@@ -23,4 +24,5 @@ export interface NativeCallResult {
 }
 export interface FrameSourceDidChangeStateEventPayload {
     state: FrameSourceState;
+    cameraPosition: CameraPosition;
 }

package/dist/dts/context/DataCaptureContext.d.ts

@@ -24,10 +24,6 @@ export declare class DataCaptureContext extends DefaultSerializeable {
     private static get coreDefaults();
     get frameSource(): FrameSource | null;
     static get deviceID(): string | null;
-    /**
-     * @deprecated
-     */
-    get deviceID(): string | null;
     static forLicenseKey(licenseKey: string): DataCaptureContext;
     static forLicenseKeyWithSettings(licenseKey: string, settings: DataCaptureContextSettings | null): DataCaptureContext;
     static forLicenseKeyWithOptions(licenseKey: string, options: DataCaptureContextCreationOptions | null): DataCaptureContext;
@@ -37,14 +33,14 @@ export declare class DataCaptureContext extends DefaultSerializeable {
     setFrameSource(frameSource: FrameSource | null): Promise<void>;
     addListener(listener: DataCaptureContextListener): void;
     removeListener(listener: DataCaptureContextListener): void;
-    addMode(mode: DataCaptureMode): void;
-    setMode(mode: DataCaptureMode): void;
+    addMode(mode: DataCaptureMode): Promise<void>;
+    setMode(mode: DataCaptureMode): Promise<void>;
     private addModeInternal;
-    removeCurrentMode(): void;
-    removeMode(mode: DataCaptureMode): void;
+    removeCurrentMode(): Promise<void>;
+    removeMode(mode: DataCaptureMode): Promise<void>;
     private removeModeInternal;
-    removeAllModes(): void;
-    dispose(): void;
+    removeAllModes(): Promise<void>;
+    dispose(): Promise<void>;
     applySettings(settings: DataCaptureContextSettings): Promise<void>;
     static getOpenSourceSoftwareLicenseInfo(): Promise<OpenSourceSoftwareLicenseInfo>;
     private update;

package/dist/dts/frame/FrameSource.d.ts

@@ -4,6 +4,7 @@ import { FrameSourceListener } from "./FrameSourceListener";
 import { DataCaptureContext } from "../context/DataCaptureContext";
 export interface PrivateFrameSource {
     context: DataCaptureContext | null;
+    setNativeFrameSourceIsBeingCreated(): void;
 }
 export interface FrameSource extends Serializeable {
     readonly desiredState: FrameSourceState;

package/dist/dts/view/DataCaptureView.d.ts

@@ -48,8 +48,8 @@ export declare class BaseDataCaptureView extends DefaultSerializeable {
     private get privateContext();
     static forContext(context: DataCaptureContext | null): BaseDataCaptureView;
     constructor(context: DataCaptureContext | null);
-    addOverlay(overlay: DataCaptureOverlay): void;
-    removeOverlay(overlay: DataCaptureOverlay): void;
+    addOverlay(overlay: DataCaptureOverlay): Promise<void>;
+    removeOverlay(overlay: DataCaptureOverlay): Promise<void>;
     removeAllOverlays(): void;
     addListener(listener: DataCaptureViewListener): void;
     removeListener(listener: DataCaptureViewListener): void;

package/dist/dts/view/index.d.ts

@@ -4,4 +4,4 @@ export * from "./DataCaptureOverlay";
 export * from "./DataCaptureViewListener";
 export * from "./DataCaptureView";
 export * from "./DataCaptureViewController";
-export * from "./ScreenStateManager";
+export * from "../camerahelpers/CameraOwner";