scandit-datacapture-frameworks-core 8.0.0-beta.1 → 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,6 +5,25 @@ 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;
@@ -14,10 +33,15 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
     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;
@@ -36,6 +60,7 @@ export declare class Camera extends DefaultSerializeable implements FrameSource
     removeListener(listener: FrameSourceListener | null): void;
     applySettings(settings: CameraSettings): Promise<void>;
     private didChange;
+    private resetPhaseState;
 }
 export interface PrivateCamera {
     context: DataCaptureContext | null;

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

@@ -33,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/index.js

@@ -1716,16 +1716,73 @@ var TorchState;
     TorchState["Auto"] = "auto";
 })(TorchState || (TorchState = {}));
 
+/**
+ * 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
+ */
 class Camera extends DefaultSerializeable {
     static get coreDefaults() {
         return getCoreDefaults();
     }
     set context(newContext) {
         this._context = newContext;
+        if (newContext) {
+            // Phase 3: Native camera is ready, resolve the promise so waiting operations can proceed
+            if (this.nativeReadyTimeout) {
+                clearTimeout(this.nativeReadyTimeout);
+                this.nativeReadyTimeout = null;
+            }
+            if (this.nativeReadyResolver) {
+                this.nativeReadyResolver();
+                this.nativeReadyResolver = null;
+                this.nativeReadyRejecter = null;
+                this.nativeReadyPromise = null;
+            }
+        }
+        else {
+            // When context is removed, reset everything
+            if (this.nativeReadyTimeout) {
+                clearTimeout(this.nativeReadyTimeout);
+                this.nativeReadyTimeout = null;
+            }
+            this.nativeReadyResolver = null;
+            this.nativeReadyRejecter = null;
+            this.nativeReadyPromise = null;
+        }
     }
     get context() {
         return this._context;
     }
+    setNativeFrameSourceIsBeingCreated() {
+        this.nativeReadyPromise = new Promise((resolve, reject) => {
+            this.nativeReadyResolver = resolve;
+            this.nativeReadyRejecter = reject;
+            this.nativeReadyTimeout = setTimeout(() => {
+                this.nativeReadyTimeout = null;
+                if (this.nativeReadyRejecter) {
+                    this.nativeReadyRejecter(new Error('Camera native initialization timed out after 5 seconds'));
+                    this.nativeReadyResolver = null;
+                    this.nativeReadyRejecter = null;
+                    this.nativeReadyPromise = null;
+                }
+            }, 5000);
+        });
+    }
     get isActiveCamera() {
         return this._context !== null;
     }
@@ -1757,7 +1814,15 @@ class Camera extends DefaultSerializeable {
     }
     set desiredTorchState(desiredTorchState) {
         this._desiredTorchState = desiredTorchState;
-        this.didChange();
+        if (this.nativeReadyPromise) {
+            // Phase 2: Wait for native camera to be ready, then update
+            this.nativeReadyPromise.then(() => this.didChange());
+        }
+        else if (this.isActiveCamera) {
+            // Phase 3: Execute immediately
+            this.didChange();
+        }
+        // Phase 1: Just update the property, no action needed
     }
     get desiredTorchState() {
         return this._desiredTorchState;
@@ -1771,6 +1836,10 @@ class Camera extends DefaultSerializeable {
         this.currentCameraState = FrameSourceState.Off;
         this.listeners = [];
         this._context = null;
+        this.nativeReadyResolver = null;
+        this.nativeReadyRejecter = null;
+        this.nativeReadyPromise = null;
+        this.nativeReadyTimeout = null;
         this.position = position || Camera.coreDefaults.Camera.defaultPosition;
         this.settings = settings || null;
         this._desiredTorchState = desiredTorchState || TorchState.Off;
@@ -1784,6 +1853,7 @@ class Camera extends DefaultSerializeable {
         }
         const existingCamera = Camera._cameraInstances.get(cameraPosition);
         if (existingCamera) {
+            existingCamera.resetPhaseState();
             if (settings !== undefined) {
                 existingCamera.settings = settings;
             }
@@ -1806,14 +1876,20 @@ class Camera extends DefaultSerializeable {
     }
     switchToDesiredState(state) {
         return __awaiter(this, void 0, void 0, function* () {
+            this._desiredState = state;
+            if (this.nativeReadyPromise) {
+                // Phase 2: Wait for native camera to be ready, then switch state
+                yield this.nativeReadyPromise;
+                yield this.controller.switchCameraToDesiredState(state);
+                return;
+            }
             if (!this.isActiveCamera) {
+                // Phase 1: Not yet added to context
                 console.warn('The current camera is not added to the DataCaptureContext. Add camera to the DataCaptureContext first.');
                 return;
             }
-            if (state !== this.currentCameraState) {
-                this._desiredState = state;
-                return this.controller.switchCameraToDesiredState(state);
-            }
+            // Phase 3: Execute immediately
+            yield this.controller.switchCameraToDesiredState(state);
         });
     }
     getCurrentState() {
@@ -1826,9 +1902,6 @@ class Camera extends DefaultSerializeable {
         if (listener == null) {
             return;
         }
-        if (this.listeners.length === 0) {
-            this.controller.subscribeListener();
-        }
         if (this.listeners.includes(listener)) {
             return;
         }
@@ -1844,8 +1917,19 @@ class Camera extends DefaultSerializeable {
         this.listeners.splice(this.listeners.indexOf(listener), 1);
     }
     applySettings(settings) {
-        this.settings = settings;
-        return this.didChange();
+        return __awaiter(this, void 0, void 0, function* () {
+            this.settings = settings;
+            if (this.nativeReadyPromise) {
+                // Phase 2: Wait for native camera to be ready, then apply settings
+                yield this.nativeReadyPromise;
+                yield this.didChange();
+            }
+            else if (this.isActiveCamera) {
+                // Phase 3: Execute immediately
+                yield this.didChange();
+            }
+            // Phase 1: Just update the property, no action needed
+        });
     }
     didChange() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1854,6 +1938,15 @@ class Camera extends DefaultSerializeable {
             }
         });
     }
+    resetPhaseState() {
+        if (this.nativeReadyTimeout) {
+            clearTimeout(this.nativeReadyTimeout);
+            this.nativeReadyTimeout = null;
+        }
+        this.nativeReadyResolver = null;
+        this.nativeReadyRejecter = null;
+        this.nativeReadyPromise = null;
+    }
 }
 Camera._cameraInstances = new Map();
 __decorate([
@@ -1874,6 +1967,18 @@ __decorate([
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "_context", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "nativeReadyResolver", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "nativeReadyRejecter", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "nativeReadyPromise", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "nativeReadyTimeout", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "controller", void 0);
@@ -2536,14 +2641,21 @@ class DataCaptureContext extends DefaultSerializeable {
         }
     }
     setFrameSource(frameSource) {
-        if (this._frameSource) {
-            this._frameSource.context = null;
-        }
-        this._frameSource = frameSource;
-        if (frameSource) {
-            frameSource.context = this;
-        }
-        return this.update();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._frameSource) {
+                this._frameSource.context = null;
+            }
+            this._frameSource = frameSource;
+            if (frameSource) {
+                // Set the flag to indicate that the native frame source is being created
+                frameSource.setNativeFrameSourceIsBeingCreated();
+            }
+            yield this.update();
+            // Make camera active once the set on native side is complete
+            if (frameSource) {
+                frameSource.context = this;
+            }
+        });
     }
     addListener(listener) {
         if (this.listeners.length === 0) {
@@ -2564,30 +2676,40 @@ class DataCaptureContext extends DefaultSerializeable {
         }
     }
     addMode(mode) {
-        this.addModeInternal(mode);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.addModeInternal(mode);
+        });
     }
     setMode(mode) {
-        this.removeAllModes();
-        this.addModeInternal(mode);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.removeAllModes();
+            yield this.addModeInternal(mode);
+        });
     }
     addModeInternal(mode) {
-        if (!this.modes.includes(mode)) {
-            this.modes.push(mode);
-            this.controller.addModeToContext(mode);
-            mode._context = this;
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.modes.includes(mode)) {
+                this.modes.push(mode);
+                yield this.controller.addModeToContext(mode);
+                mode._context = this;
+            }
+        });
     }
     removeCurrentMode() {
-        if (this.modes.length === 0) {
-            return;
-        }
-        if (this.modes.length > 1) {
-            console.warn('removeCurrentMode() called with multiple modes active. Consider using removeMode() for specific mode removal. Only the first mode will be removed.');
-        }
-        this.removeModeInternal(this.modes[0]);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.modes.length === 0) {
+                return;
+            }
+            if (this.modes.length > 1) {
+                console.warn('removeCurrentMode() called with multiple modes active. Consider using removeMode() for specific mode removal. Only the first mode will be removed.');
+            }
+            yield this.removeModeInternal(this.modes[0]);
+        });
     }
     removeMode(mode) {
-        this.removeModeInternal(mode);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.removeModeInternal(mode);
+        });
     }
     removeModeInternal(mode) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2600,27 +2722,33 @@ class DataCaptureContext extends DefaultSerializeable {
         });
     }
     removeAllModes() {
-        if (this.modes.length === 0) {
-            return;
-        }
-        this.modes.forEach(mode => {
-            mode._context = null;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.modes.length === 0) {
+                return;
+            }
+            this.modes.forEach(mode => {
+                mode._context = null;
+            });
+            this.modes = [];
+            yield this.controller.removeAllModesFromContext();
         });
-        this.modes = [];
-        this.controller.removeAllModesFromContext();
     }
     dispose() {
-        var _a;
-        if (!this.controller) {
-            return;
-        }
-        (_a = this.view) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.removeAllModes();
-        this.controller.dispose();
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.controller) {
+                return;
+            }
+            (_a = this.view) === null || _a === void 0 ? void 0 : _a.dispose();
+            yield this.removeAllModes();
+            this.controller.dispose();
+        });
     }
     applySettings(settings) {
-        this.settings = settings;
-        return this.update();
+        return __awaiter(this, void 0, void 0, function* () {
+            this.settings = settings;
+            yield this.update();
+        });
     }
     static getOpenSourceSoftwareLicenseInfo() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -2628,10 +2756,12 @@ class DataCaptureContext extends DefaultSerializeable {
         });
     }
     update() {
-        if (!this.controller) {
-            return Promise.resolve();
-        }
-        return this.controller.updateContextFromJSON();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controller) {
+                return;
+            }
+            yield this.controller.updateContextFromJSON();
+        });
     }
 }
 __decorate([