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

package/test/Camera.test.ts

@@ -0,0 +1,294 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { Camera, CameraSettings, FrameSourceState, TorchState, CameraPosition, createNativeProxy, FactoryMaker } from '../src';
+import { MockCaller, MockNativeEventEmitter, MockDataCaptureContext, createMockCameraNativeModule, createMockDataCaptureContextNativeModule, createMockFeedbackNativeModule } from '../__mocks__/ScanditDataCaptureCore';
+import { CameraProxy } from '../src/camera/CameraController';
+import { DataCaptureContextProxy } from '../src/context/controller/DataCaptureContextController';
+import { FeedbackProxy } from '../src/feedback/FeedbackController';
+import { loadMockDefaults } from '../__mocks__/Defaults';
+
+describe('Camera Lifecycle with Promise-based Waiting', () => {
+  let nativeEventEmitter: MockNativeEventEmitter;
+  let mockContext: MockDataCaptureContext;
+  let mockCameraNativeModule: any;
+  let mockContextNativeModule: any;
+  let mockFeedbackNativeModule: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    (Camera as any)._cameraInstances.clear();
+    FactoryMaker.instances.delete('CameraProxy');
+    FactoryMaker.instances.delete('DataCaptureContextProxy');
+    FactoryMaker.instances.delete('FeedbackProxy');
+
+    mockCameraNativeModule = createMockCameraNativeModule();
+    mockContextNativeModule = createMockDataCaptureContextNativeModule();
+    mockFeedbackNativeModule = createMockFeedbackNativeModule();
+    nativeEventEmitter = new MockNativeEventEmitter();
+    
+    loadMockDefaults();
+
+    FactoryMaker.bindLazyInstance('CameraProxy', () => {
+      const caller = new MockCaller(mockCameraNativeModule, nativeEventEmitter);
+      return createNativeProxy<CameraProxy>(caller);
+    });
+
+    FactoryMaker.bindLazyInstance('DataCaptureContextProxy', () => {
+      const caller = new MockCaller(mockContextNativeModule, nativeEventEmitter);
+      return createNativeProxy<DataCaptureContextProxy>(caller);
+    });
+
+    FactoryMaker.bindLazyInstance('FeedbackProxy', () => {
+      const caller = new MockCaller(mockFeedbackNativeModule, nativeEventEmitter);
+      return createNativeProxy<FeedbackProxy>(caller);
+    });
+
+    mockContext = new MockDataCaptureContext();
+  });
+
+  describe('Phase 1: Initial State', () => {
+    it('operations only update properties, no native calls', () => {
+      const camera = Camera.default!;
+      const settings = new CameraSettings();
+      
+      camera.desiredTorchState = TorchState.On;
+      camera.applySettings(settings);
+      
+      expect(camera.desiredTorchState).toBe(TorchState.On);
+      expect((camera as any).settings).toBe(settings);
+      expect(mockContext.update).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Phase 2: Native Creation In Progress', () => {
+    it('operations wait for native camera to be ready', async () => {
+      const camera = Camera.default!;
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      
+      camera.desiredTorchState = TorchState.On;
+      
+      await setFrameSourcePromise;
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+    });
+
+    it('switchToDesiredState waits for native camera', async () => {
+      const camera = Camera.default!;
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      const switchPromise = camera.switchToDesiredState(FrameSourceState.On);
+      
+      const controllerSpy = jest.spyOn((camera as any).controller, 'switchCameraToDesiredState');
+      
+      await setFrameSourcePromise;
+      await switchPromise;
+      
+      expect(controllerSpy).toHaveBeenCalledWith(FrameSourceState.On);
+    });
+
+    it('applySettings waits for native camera', async () => {
+      const camera = Camera.default!;
+      const settings = new CameraSettings();
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      const applyPromise = camera.applySettings(settings);
+      
+      await setFrameSourcePromise;
+      await applyPromise;
+      
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+    });
+  });
+
+  describe('Phase 3: Active State', () => {
+    it('operations execute immediately', async () => {
+      const camera = Camera.default!;
+      
+      await mockContext.setFrameSource(camera);
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      mockContext.controller.updateContextFromJSON.mockClear();
+      
+      camera.desiredTorchState = TorchState.On;
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+    });
+  });
+
+  describe('Phase transitions', () => {
+    it('transitions from Phase 1 → Phase 2 → Phase 3 correctly', async () => {
+      const camera = Camera.default!;
+      
+      camera.desiredTorchState = TorchState.On;
+      expect(mockContext.controller.updateContextFromJSON).not.toHaveBeenCalled();
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      expect((camera as any).nativeReadyPromise).not.toBeNull();
+      
+      camera.desiredTorchState = TorchState.Off;
+      
+      await setFrameSourcePromise;
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect((camera as any).nativeReadyPromise).toBeNull();
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+    });
+
+    it('context set to null clears native ready promise', async () => {
+      const camera = Camera.default!;
+      
+      mockContext.setFrameSource(camera);
+      expect((camera as any).nativeReadyPromise).not.toBeNull();
+      
+      (camera as any).context = null;
+      
+      expect((camera as any).nativeReadyPromise).toBeNull();
+    });
+  });
+
+  describe('Multiple operations in Phase 2', () => {
+    it('multiple operations all wait and execute after native is ready', async () => {
+      const camera = Camera.default!;
+      const settings = new CameraSettings();
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      
+      camera.desiredTorchState = TorchState.On;
+      const switchPromise = camera.switchToDesiredState(FrameSourceState.On);
+      const applyPromise = camera.applySettings(settings);
+      
+      const controllerSpy = jest.spyOn((camera as any).controller, 'switchCameraToDesiredState');
+      
+      await setFrameSourcePromise;
+      await Promise.all([switchPromise, applyPromise]);
+      
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+      expect(controllerSpy).toHaveBeenCalledWith(FrameSourceState.On);
+    });
+
+    it('property updates are preserved even when operations are waiting', async () => {
+      const camera = Camera.default!;
+      const settings = new CameraSettings();
+      
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      
+      camera.desiredTorchState = TorchState.On;
+      camera.desiredTorchState = TorchState.Off;
+      
+      expect(camera.desiredTorchState).toBe(TorchState.Off);
+      
+      await setFrameSourcePromise;
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(camera.desiredTorchState).toBe(TorchState.Off);
+    });
+  });
+
+  describe('Camera singleton behavior', () => {
+    it('returns same camera instance for same position', () => {
+      const camera1 = Camera.atPosition(CameraPosition.WorldFacing);
+      const camera2 = Camera.atPosition(CameraPosition.WorldFacing);
+      
+      expect(camera1).toBe(camera2);
+    });
+
+    it('resetPhaseState clears promise when camera is retrieved from cache', () => {
+      const camera1 = Camera.atPosition(CameraPosition.WorldFacing)!;
+      
+      mockContext.setFrameSource(camera1);
+      expect((camera1 as any).nativeReadyPromise).not.toBeNull();
+      
+      const camera2 = Camera.create(CameraPosition.WorldFacing);
+      
+      expect(camera2).toBe(camera1);
+      expect((camera2 as any).nativeReadyPromise).toBeNull();
+    });
+
+    it('different camera positions are independent instances', () => {
+      const worldCamera = Camera.atPosition(CameraPosition.WorldFacing);
+      const userCamera = Camera.atPosition(CameraPosition.UserFacing);
+      
+      expect(worldCamera).not.toBe(userCamera);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('switchToDesiredState in Phase 1 shows warning', async () => {
+      const camera = Camera.default!;
+      const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      
+      await camera.switchToDesiredState(FrameSourceState.On);
+      
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('not added to the DataCaptureContext')
+      );
+      
+      consoleWarnSpy.mockRestore();
+    });
+
+    it('multiple property changes in Phase 1 only update TS properties', () => {
+      const camera = Camera.default!;
+      
+      camera.desiredTorchState = TorchState.On;
+      camera.desiredTorchState = TorchState.Off;
+      camera.desiredTorchState = TorchState.On;
+      
+      expect(camera.desiredTorchState).toBe(TorchState.On);
+      expect(mockContext.controller.updateContextFromJSON).not.toHaveBeenCalled();
+    });
+
+    it('handles operations during rapid phase transitions', async () => {
+      const camera = Camera.default!;
+      
+      camera.desiredTorchState = TorchState.On;
+      const setFrameSourcePromise = mockContext.setFrameSource(camera);
+      camera.desiredTorchState = TorchState.Off;
+      
+      await setFrameSourcePromise;
+      await new Promise(resolve => setTimeout(resolve, 50));
+      
+      expect(camera.desiredTorchState).toBe(TorchState.Off);
+      expect(mockContext.controller.updateContextFromJSON).toHaveBeenCalled();
+    });
+
+    it('times out if native camera is not ready after 5 seconds', async () => {
+      jest.useFakeTimers();
+      const camera = Camera.default!;
+      
+      (camera as any).setNativeFrameSourceIsBeingCreated();
+      
+      const switchPromise = camera.switchToDesiredState(FrameSourceState.On);
+      
+      jest.advanceTimersByTime(5000);
+      
+      await expect(switchPromise).rejects.toThrow('Camera native initialization timed out after 5 seconds');
+      
+      jest.useRealTimers();
+    });
+
+    it('timeout is cleared when context is set', async () => {
+      jest.useFakeTimers();
+      const camera = Camera.default!;
+      
+      mockContext.setFrameSource(camera);
+      
+      const switchPromise = camera.switchToDesiredState(FrameSourceState.On);
+      
+      jest.advanceTimersByTime(1000);
+      
+      (camera as any).context = mockContext;
+      
+      await switchPromise;
+      
+      jest.advanceTimersByTime(5000);
+      
+      jest.useRealTimers();
+    });
+  });
+});
+
+
+

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

@@ -1,8 +0,0 @@
-export declare class ScreenStateManager {
-    private static instance;
-    private activeScreenId;
-    private constructor();
-    static getInstance(): ScreenStateManager;
-    setActiveScreen(screenId: number): void;
-    isScreenActive(screenId: number): boolean;
-}