scandit-datacapture-frameworks-core 7.6.1 → 8.0.0-beta.1

package/dist/index.js

@@ -778,13 +778,6 @@ class FrameDataSettingsBuilder {
     }
 }
 
-var CameraPosition;
-(function (CameraPosition) {
-    CameraPosition["WorldFacing"] = "worldFacing";
-    CameraPosition["UserFacing"] = "userFacing";
-    CameraPosition["Unspecified"] = "unspecified";
-})(CameraPosition || (CameraPosition = {}));
-
 var FrameSourceListenerEvents;
 (function (FrameSourceListenerEvents) {
     FrameSourceListenerEvents["didChangeState"] = "FrameSourceListener.onStateChanged";
@@ -1532,19 +1525,30 @@ class HTMLElementState {
     }
 }
 
-class ImageFrameSourceController {
-    static forImage(imageFrameSource) {
-        const controller = new ImageFrameSourceController();
-        controller.imageFrameSource = imageFrameSource;
-        return controller;
+class BaseNewController {
+    get _proxy() {
+        return this._cachedProxy;
     }
-    constructor() {
-        this.eventEmitter = FactoryMaker.getInstance('EventEmitter');
-        this._proxy = FactoryMaker.getInstance('ImageFrameSourceProxy');
+    constructor(proxyName) {
+        this._cachedProxy = FactoryMaker.createInstance(proxyName);
+    }
+}
+
+class ImageFrameSourceController extends BaseNewController {
+    constructor(imageFrameSource) {
+        super('ImageFrameSourceProxy');
+        this.handleDidChangeStateEventWrapper = (ev) => {
+            return this.handleDidChangeStateEvent(ev);
+        };
+        this.imageFrameSource = imageFrameSource;
+        this.subscribeListener();
+    }
+    get privateImageFrameSource() {
+        return this.imageFrameSource;
     }
     getCurrentState() {
         return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._proxy.getCurrentCameraState(this.imageFrameSource.position);
+            const result = yield this._proxy.$getCurrentCameraState({ position: this.privateImageFrameSource.position });
             if (result == null) {
                 return FrameSourceState.Off;
             }
@@ -1552,29 +1556,38 @@ class ImageFrameSourceController {
         });
     }
     switchCameraToDesiredState(desiredStateJson) {
-        return this._proxy.switchCameraToDesiredState(desiredStateJson);
+        return this._proxy.$switchCameraToDesiredState({ desiredStateJson });
     }
     subscribeListener() {
-        var _a, _b;
-        this._proxy.registerListenerForEvents();
-        (_b = (_a = this._proxy).subscribeDidChangeState) === null || _b === void 0 ? void 0 : _b.call(_a);
-        this.eventEmitter.on(FrameSourceListenerEvents.didChangeState, (data) => {
-            const event = EventDataParser.parse(data);
-            if (event === null) {
-                console.error('ImageFrameSourceController didChangeState payload is null');
-                return;
-            }
-            const newState = event.state;
-            this.imageFrameSource.listeners.forEach(listener => {
-                if (listener.didChangeState) {
-                    listener.didChangeState(this.imageFrameSource, newState);
-                }
-            });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._proxy.$registerListenerForCameraEvents();
+            this._proxy.subscribeForEvents([FrameSourceListenerEvents.didChangeState]);
+            this._proxy.eventEmitter.on(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEventWrapper);
         });
     }
     unsubscribeListener() {
-        this._proxy.unregisterListenerForEvents();
-        this.eventEmitter.removeAllListeners(FrameSourceListenerEvents.didChangeState);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._proxy.$unregisterListenerForCameraEvents();
+            this._proxy.unsubscribeFromEvents([FrameSourceListenerEvents.didChangeState]);
+            this._proxy.eventEmitter.off(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEventWrapper);
+        });
+    }
+    dispose() {
+        this.unsubscribeListener();
+        this._proxy.dispose();
+    }
+    handleDidChangeStateEvent(ev) {
+        const event = EventDataParser.parse(ev.data);
+        if (event === null) {
+            console.error('ImageFrameSourceController didChangeState payload is null');
+            return;
+        }
+        const newState = event.state;
+        this.privateImageFrameSource.listeners.forEach(listener => {
+            if (listener.didChangeState) {
+                listener.didChangeState(this.imageFrameSource, newState);
+            }
+        });
     }
 }
 
@@ -1610,7 +1623,7 @@ class ImageFrameSource extends DefaultSerializeable {
         this._desiredState = FrameSourceState.Off;
         this.listeners = [];
         this._context = null;
-        this.controller = ImageFrameSourceController.forImage(this);
+        this.controller = new ImageFrameSourceController(this);
     }
     didChange() {
         if (this.context) {
@@ -1689,95 +1702,12 @@ class PrivateFrameData {
     }
 }
 
-class BaseNewController {
-    get _proxy() {
-        return this._cachedProxy;
-    }
-    constructor(proxyName) {
-        this._cachedProxy = FactoryMaker.createInstance(proxyName);
-    }
-}
-
-class CameraController extends BaseNewController {
-    static get _proxy() {
-        return FactoryMaker.getInstance('CameraProxy');
-    }
-    static forCamera(camera) {
-        const controller = new CameraController();
-        controller.camera = camera;
-        return controller;
-    }
-    constructor() {
-        super('CameraProxy');
-    }
-    get privateCamera() {
-        return this.camera;
-    }
-    static getFrame(frameId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield CameraController._proxy.$getFrame({ frameId });
-            if (result == null) {
-                return PrivateFrameData.empty();
-            }
-            const frameDataJSON = JSON.parse(result.data);
-            return PrivateFrameData.fromJSON(frameDataJSON);
-        });
-    }
-    static getFrameOrNull(frameId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield CameraController._proxy.$getFrame({ frameId });
-            if (result == null) {
-                return null;
-            }
-            const frameDataJSON = JSON.parse(result.data);
-            return PrivateFrameData.fromJSON(frameDataJSON);
-        });
-    }
-    getCurrentState() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._proxy.$getCurrentCameraState({ position: this.privateCamera.position });
-            if (result == null) {
-                return FrameSourceState.Off;
-            }
-            return result.data;
-        });
-    }
-    getIsTorchAvailable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this._proxy.$isTorchAvailable({ position: this.privateCamera.position });
-            if (result == null) {
-                return false;
-            }
-            return result.data === 'true';
-        });
-    }
-    switchCameraToDesiredState(desiredState) {
-        return this._proxy.$switchCameraToDesiredState({ desiredStateJson: desiredState.toString() });
-    }
-    subscribeListener() {
-        this._proxy.$registerListenerForCameraEvents();
-        this._proxy.subscribeForEvents([FrameSourceListenerEvents.didChangeState]);
-        this._proxy.eventEmitter.on(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEvent.bind(this));
-    }
-    unsubscribeListener() {
-        this._proxy.$unregisterListenerForCameraEvents();
-        this._proxy.unsubscribeFromEvents([FrameSourceListenerEvents.didChangeState]);
-        this._proxy.eventEmitter.off(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEvent.bind(this));
-    }
-    dispose() {
-        this.unsubscribeListener();
-        this._proxy.dispose();
-    }
-    handleDidChangeStateEvent(ev) {
-        const event = EventDataParser.parse(ev.data);
-        if (event) {
-            this.privateCamera.listeners.forEach(listener => {
-                var _a;
-                (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeState) === null || _a === void 0 ? void 0 : _a.call(listener, this.camera, event.state);
-            });
-        }
-    }
-}
+var CameraPosition;
+(function (CameraPosition) {
+    CameraPosition["WorldFacing"] = "worldFacing";
+    CameraPosition["UserFacing"] = "userFacing";
+    CameraPosition["Unspecified"] = "unspecified";
+})(CameraPosition || (CameraPosition = {}));
 
 var TorchState;
 (function (TorchState) {
@@ -1796,43 +1726,31 @@ class Camera extends DefaultSerializeable {
     get context() {
         return this._context;
     }
+    get isActiveCamera() {
+        return this._context !== null;
+    }
     static get default() {
-        if (Camera.coreDefaults.Camera.defaultPosition) {
-            const camera = new Camera();
-            camera.position = Camera.coreDefaults.Camera.defaultPosition;
-            return camera;
-        }
-        else {
+        const defaultPosition = Camera.coreDefaults.Camera.defaultPosition;
+        if (!defaultPosition) {
             return null;
         }
+        return Camera.atPosition(defaultPosition);
     }
     static withSettings(settings) {
-        const camera = Camera.default;
-        if (camera) {
-            camera.settings = settings;
-        }
-        return camera;
+        return Camera.create(undefined, settings);
     }
     static asPositionWithSettings(cameraPosition, settings) {
-        if (Camera.coreDefaults.Camera.availablePositions.includes(cameraPosition)) {
-            const camera = new Camera();
-            camera.settings = settings;
-            camera.position = cameraPosition;
-            return camera;
-        }
-        else {
-            return null;
-        }
+        return Camera.create(cameraPosition, settings);
     }
     static atPosition(cameraPosition) {
-        if (Camera.coreDefaults.Camera.availablePositions.includes(cameraPosition)) {
-            const camera = new Camera();
-            camera.position = cameraPosition;
-            return camera;
-        }
-        else {
+        if (!Camera.coreDefaults.Camera.availablePositions.includes(cameraPosition)) {
             return null;
         }
+        const existingCamera = Camera._cameraInstances.get(cameraPosition);
+        if (existingCamera) {
+            return existingCamera;
+        }
+        return Camera.create(cameraPosition);
     }
     get desiredState() {
         return this._desiredState;
@@ -1844,33 +1762,66 @@ class Camera extends DefaultSerializeable {
     get desiredTorchState() {
         return this._desiredTorchState;
     }
-    constructor() {
+    constructor(position, settings, desiredTorchState, desiredState) {
         super();
         this.type = 'camera';
         this.settings = null;
         this._desiredTorchState = TorchState.Off;
         this._desiredState = FrameSourceState.Off;
+        this.currentCameraState = FrameSourceState.Off;
         this.listeners = [];
         this._context = null;
-        this.controller = CameraController.forCamera(this);
+        this.position = position || Camera.coreDefaults.Camera.defaultPosition;
+        this.settings = settings || null;
+        this._desiredTorchState = desiredTorchState || TorchState.Off;
+        this._desiredState = desiredState || FrameSourceState.Off;
+        this.controller = new CameraController(this);
+    }
+    static create(position, settings, desiredTorchState, desiredState) {
+        const cameraPosition = position || Camera.coreDefaults.Camera.defaultPosition;
+        if (!cameraPosition) {
+            return null;
+        }
+        const existingCamera = Camera._cameraInstances.get(cameraPosition);
+        if (existingCamera) {
+            if (settings !== undefined) {
+                existingCamera.settings = settings;
+            }
+            if (desiredTorchState !== undefined) {
+                existingCamera._desiredTorchState = desiredTorchState;
+                existingCamera.didChange();
+            }
+            if (desiredState !== undefined) {
+                existingCamera._desiredState = desiredState;
+                existingCamera.controller.switchCameraToDesiredState(desiredState);
+            }
+            return existingCamera;
+        }
+        if (!Camera.coreDefaults.Camera.availablePositions.includes(cameraPosition)) {
+            return null;
+        }
+        const camera = new Camera(cameraPosition, settings, desiredTorchState, desiredState);
+        Camera._cameraInstances.set(cameraPosition, camera);
+        return camera;
     }
     switchToDesiredState(state) {
-        this._desiredState = state;
-        return this.controller.switchCameraToDesiredState(state);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isActiveCamera) {
+                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);
+            }
+        });
     }
     getCurrentState() {
-        return this.controller.getCurrentState();
+        return Promise.resolve(this.currentCameraState);
     }
     getIsTorchAvailable() {
         return this.controller.getIsTorchAvailable();
     }
-    /**
-     * @deprecated
-     */
-    get isTorchAvailable() {
-        console.warn('isTorchAvailable is deprecated. Use getIsTorchAvailable instead.');
-        return false;
-    }
     addListener(listener) {
         if (listener == null) {
             return;
@@ -1891,9 +1842,6 @@ class Camera extends DefaultSerializeable {
             return;
         }
         this.listeners.splice(this.listeners.indexOf(listener), 1);
-        if (this.listeners.length === 0) {
-            this.controller.unsubscribeListener();
-        }
     }
     applySettings(settings) {
         this.settings = settings;
@@ -1907,6 +1855,7 @@ class Camera extends DefaultSerializeable {
         });
     }
 }
+Camera._cameraInstances = new Map();
 __decorate([
     serializationDefault({})
 ], Camera.prototype, "settings", void 0);
@@ -1914,8 +1863,11 @@ __decorate([
     nameForSerialization('desiredTorchState')
 ], Camera.prototype, "_desiredTorchState", void 0);
 __decorate([
-    ignoreFromSerialization
+    nameForSerialization('desiredState')
 ], Camera.prototype, "_desiredState", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera.prototype, "currentCameraState", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "listeners", void 0);
@@ -1925,10 +1877,390 @@ __decorate([
 __decorate([
     ignoreFromSerialization
 ], Camera.prototype, "controller", void 0);
+__decorate([
+    ignoreFromSerialization
+], Camera, "_cameraInstances", void 0);
 __decorate([
     ignoreFromSerialization
 ], Camera, "coreDefaults", null);
 
+class CameraOwnershipManager {
+    constructor() {
+        this.owners = new Map();
+        this.waitingQueue = new Map();
+        this.protectedCameras = new Set();
+    }
+    static getInstance() {
+        if (!CameraOwnershipManager.instance) {
+            CameraOwnershipManager.instance = new CameraOwnershipManager();
+        }
+        return CameraOwnershipManager.instance;
+    }
+    requestOwnership(position, owner) {
+        const currentOwner = this.owners.get(position);
+        if (currentOwner && currentOwner.id !== owner.id) {
+            return false; // Already owned by someone else
+        }
+        this.owners.set(position, owner);
+        this.enableProtectionForOwner(position, owner);
+        return true;
+    }
+    requestOwnershipAsync(position, owner, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Try immediate acquisition first
+            if (this.requestOwnership(position, owner)) {
+                return true;
+            }
+            // If not available, wait in queue
+            return new Promise((resolve) => {
+                const request = { owner, resolve };
+                if (!this.waitingQueue.has(position)) {
+                    this.waitingQueue.set(position, []);
+                }
+                this.waitingQueue.get(position).push(request);
+                // Optional timeout
+                if (timeoutMs && timeoutMs > 0) {
+                    setTimeout(() => {
+                        this.removeFromQueue(position, request);
+                        resolve(false); // Timeout - ownership not acquired
+                    }, timeoutMs);
+                }
+            });
+        });
+    }
+    releaseOwnership(position, owner) {
+        const currentOwner = this.owners.get(position);
+        if (!currentOwner || currentOwner.id !== owner.id) {
+            return false; // Not the owner
+        }
+        this.owners.delete(position);
+        this.disableProtectionForPosition(position);
+        this.processWaitingQueue(position);
+        return true;
+    }
+    isOwner(position, owner) {
+        const currentOwner = this.owners.get(position);
+        return (currentOwner === null || currentOwner === void 0 ? void 0 : currentOwner.id) === owner.id;
+    }
+    getCurrentOwner(position) {
+        return this.owners.get(position) || null;
+    }
+    checkOwnership(position, owner) {
+        return this.isOwner(position, owner);
+    }
+    getOwnedPosition(owner) {
+        for (const [position, currentOwner] of this.owners.entries()) {
+            if (currentOwner.id === owner.id) {
+                return position;
+            }
+        }
+        return null;
+    }
+    getAllOwnedPositions(owner) {
+        const positions = [];
+        for (const [position, currentOwner] of this.owners.entries()) {
+            if (currentOwner.id === owner.id) {
+                positions.push(position);
+            }
+        }
+        return positions;
+    }
+    enableProtectionForOwner(position, owner) {
+        const camera = Camera.atPosition(position);
+        if (!camera || this.protectedCameras.has(camera)) {
+            return; // Camera not available or already protected
+        }
+        this.protectCameraForOwner(camera, position, owner);
+        this.protectedCameras.add(camera);
+    }
+    disableProtectionForPosition(position) {
+        const camera = Camera.atPosition(position);
+        if (!camera || !this.protectedCameras.has(camera)) {
+            return;
+        }
+        this.unprotectCamera(camera);
+        this.protectedCameras.delete(camera);
+    }
+    processWaitingQueue(position) {
+        const queue = this.waitingQueue.get(position);
+        if (!queue || queue.length === 0) {
+            return;
+        }
+        // Give ownership to the first in queue
+        const nextRequest = queue.shift();
+        this.owners.set(position, nextRequest.owner);
+        this.enableProtectionForOwner(position, nextRequest.owner);
+        nextRequest.resolve(true);
+        // Clean up empty queue
+        if (queue.length === 0) {
+            this.waitingQueue.delete(position);
+        }
+    }
+    removeFromQueue(position, requestToRemove) {
+        const queue = this.waitingQueue.get(position);
+        if (!queue)
+            return;
+        const index = queue.indexOf(requestToRemove);
+        if (index > -1) {
+            queue.splice(index, 1);
+        }
+        if (queue.length === 0) {
+            this.waitingQueue.delete(position);
+        }
+    }
+    protectCameraForOwner(camera, position, _owner) {
+        var _a, _b, _c;
+        const originalSwitchToDesiredState = camera.switchToDesiredState.bind(camera);
+        const originalApplySettings = camera.applySettings.bind(camera);
+        const originalSetDesiredTorchState = (_b = (_a = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(camera), 'desiredTorchState')) === null || _a === void 0 ? void 0 : _a.set) === null || _b === void 0 ? void 0 : _b.bind(camera);
+        // Protect switchToDesiredState - only owner can call it
+        camera.switchToDesiredState = (state) => __awaiter(this, void 0, void 0, function* () {
+            const currentOwner = this.getCurrentOwner(position);
+            if (!currentOwner) {
+                throw new Error(`Camera operation denied: No owner for camera at ${position}`);
+            }
+            // Allow operation - the owner is the only one who should have access to this camera instance
+            return originalSwitchToDesiredState(state);
+        });
+        // Protect applySettings - only owner can call it
+        camera.applySettings = (settings) => __awaiter(this, void 0, void 0, function* () {
+            const currentOwner = this.getCurrentOwner(position);
+            if (!currentOwner) {
+                throw new Error(`Camera operation denied: No owner for camera at ${position}`);
+            }
+            return originalApplySettings(settings);
+        });
+        // Protect desiredTorchState setter - only owner can set it
+        if (originalSetDesiredTorchState) {
+            Object.defineProperty(camera, 'desiredTorchState', {
+                set: (value) => {
+                    const currentOwner = this.getCurrentOwner(position);
+                    if (!currentOwner) {
+                        throw new Error(`Camera operation denied: No owner for camera at ${position}`);
+                    }
+                    originalSetDesiredTorchState(value);
+                },
+                get: (_c = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(camera), 'desiredTorchState')) === null || _c === void 0 ? void 0 : _c.get,
+                configurable: true
+            });
+        }
+        // Store originals for restoration
+        camera.__originalMethods = {
+            switchToDesiredState: originalSwitchToDesiredState,
+            applySettings: originalApplySettings,
+            setDesiredTorchState: originalSetDesiredTorchState
+        };
+    }
+    unprotectCamera(camera) {
+        var _a;
+        const originals = camera.__originalMethods;
+        if (!originals)
+            return;
+        // Restore original methods
+        camera.switchToDesiredState = originals.switchToDesiredState;
+        camera.applySettings = originals.applySettings;
+        if (originals.setDesiredTorchState) {
+            Object.defineProperty(camera, 'desiredTorchState', {
+                set: originals.setDesiredTorchState,
+                get: (_a = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(camera), 'desiredTorchState')) === null || _a === void 0 ? void 0 : _a.get,
+                configurable: true
+            });
+        }
+        delete camera.__originalMethods;
+    }
+}
+
+class CameraOwnershipHelper {
+    /**
+     * Get camera instance for the owner (only works if you own it)
+     */
+    static getCamera(position, owner) {
+        // Check ownership
+        if (!this.ownershipManager.checkOwnership(position, owner)) {
+            console.warn(`Camera access denied: ${owner.id} does not own camera at ${position}`);
+            return null;
+        }
+        return Camera.atPosition(position);
+    }
+    /**
+     * Safely execute camera operations (only works if you own the camera)
+     */
+    static withCamera(position, owner, operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const camera = this.getCamera(position, owner);
+            if (!camera) {
+                return null;
+            }
+            try {
+                const result = yield operation(camera);
+                return result;
+            }
+            catch (error) {
+                console.error(`Camera operation failed for ${owner.id}:`, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Execute camera operations, waiting for ownership if necessary
+     */
+    static withCameraWhenAvailable(position, owner, operation, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Try to get ownership, wait if necessary
+            const acquired = yield this.requestOwnership(position, owner, timeoutMs);
+            if (!acquired) {
+                console.warn(`Could not acquire camera ownership for ${owner.id} within timeout`);
+                return null;
+            }
+            const camera = Camera.atPosition(position);
+            if (!camera) {
+                console.warn(`Camera not available at position ${position}`);
+                return null;
+            }
+            try {
+                const result = yield operation(camera);
+                return result;
+            }
+            catch (error) {
+                console.error(`Camera operation failed for ${owner.id}:`, error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Request ownership and wait if necessary
+     */
+    static requestOwnership(position, owner, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.ownershipManager.requestOwnershipAsync(position, owner, timeoutMs);
+        });
+    }
+    /**
+     * Release ownership
+     */
+    static releaseOwnership(position, owner) {
+        return this.ownershipManager.releaseOwnership(position, owner);
+    }
+    /**
+     * Check if owner has ownership
+     */
+    static hasOwnership(position, owner) {
+        return this.ownershipManager.checkOwnership(position, owner);
+    }
+    /**
+     * Get the camera position currently owned by the owner (if any)
+     */
+    static getOwnedPosition(owner) {
+        return this.ownershipManager.getOwnedPosition(owner);
+    }
+    /**
+     * Get all camera positions currently owned by the owner
+     */
+    static getAllOwnedPositions(owner) {
+        return this.ownershipManager.getAllOwnedPositions(owner);
+    }
+    /**
+     * Release ownership of all cameras owned by the owner
+     */
+    static releaseAllOwnerships(owner) {
+        const ownedPositions = this.getAllOwnedPositions(owner);
+        for (const position of ownedPositions) {
+            this.releaseOwnership(position, owner);
+        }
+    }
+}
+CameraOwnershipHelper.ownershipManager = CameraOwnershipManager.getInstance();
+
+class CameraController extends BaseNewController {
+    static get _proxy() {
+        return FactoryMaker.getInstance('CameraProxy');
+    }
+    constructor(camera) {
+        super('CameraProxy');
+        // Arrow function wrapper to avoid .bind(this) and always use current class state
+        this.handleDidChangeStateEventWrapper = (ev) => {
+            return this.handleDidChangeStateEvent(ev);
+        };
+        this.camera = camera;
+        this.subscribeListener();
+    }
+    get privateCamera() {
+        return this.camera;
+    }
+    static getFrame(frameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield CameraController._proxy.$getFrame({ frameId });
+            if (result == null) {
+                return PrivateFrameData.empty();
+            }
+            const frameDataJSON = JSON.parse(result.data);
+            return PrivateFrameData.fromJSON(frameDataJSON);
+        });
+    }
+    static getFrameOrNull(frameId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield CameraController._proxy.$getFrame({ frameId });
+            if (result == null) {
+                return null;
+            }
+            const frameDataJSON = JSON.parse(result.data);
+            return PrivateFrameData.fromJSON(frameDataJSON);
+        });
+    }
+    getCurrentState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._proxy.$getCurrentCameraState({ position: this.privateCamera.position });
+            if (result == null) {
+                return FrameSourceState.Off;
+            }
+            return result.data;
+        });
+    }
+    getIsTorchAvailable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this._proxy.$isTorchAvailable({ position: this.privateCamera.position });
+            if (result == null) {
+                return false;
+            }
+            return result.data === 'true';
+        });
+    }
+    switchCameraToDesiredState(desiredState) {
+        return this._proxy.$switchCameraToDesiredState({ desiredStateJson: desiredState.toString() });
+    }
+    subscribeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._proxy.$registerListenerForCameraEvents();
+            this._proxy.subscribeForEvents([FrameSourceListenerEvents.didChangeState]);
+            this._proxy.eventEmitter.on(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEventWrapper);
+        });
+    }
+    unsubscribeListener() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._proxy.$unregisterListenerForCameraEvents();
+            this._proxy.unsubscribeFromEvents([FrameSourceListenerEvents.didChangeState]);
+            this._proxy.eventEmitter.off(FrameSourceListenerEvents.didChangeState, this.handleDidChangeStateEventWrapper);
+        });
+    }
+    dispose() {
+        this.unsubscribeListener();
+        this._proxy.dispose();
+    }
+    handleDidChangeStateEvent(ev) {
+        const event = EventDataParser.parse(ev.data);
+        if (event) {
+            if (event.cameraPosition !== this.privateCamera.position || !this.privateCamera.isActiveCamera) {
+                return;
+            }
+            this.privateCamera.currentCameraState = event.state;
+            this.privateCamera.listeners.forEach(listener => {
+                var _a;
+                (_a = listener === null || listener === void 0 ? void 0 : listener.didChangeState) === null || _a === void 0 ? void 0 : _a.call(listener, this.camera, this.privateCamera._desiredState);
+            });
+        }
+    }
+}
+
 class ControlImage extends DefaultSerializeable {
     constructor(type, data, name) {
         super();
@@ -2152,13 +2484,6 @@ class DataCaptureContext extends DefaultSerializeable {
     static get deviceID() {
         return DataCaptureContext.coreDefaults.deviceID;
     }
-    /**
-     * @deprecated
-     */
-    get deviceID() {
-        console.log('The instance property "deviceID" on the DataCaptureContext is deprecated, please use the static property DataCaptureContext.deviceID instead.');
-        return DataCaptureContext.deviceID;
-    }
     static forLicenseKey(licenseKey) {
         const instance = DataCaptureContext.create(licenseKey, null, null);
         // Call initialize to ensure the shared instance is updated.
@@ -2266,11 +2591,12 @@ class DataCaptureContext extends DefaultSerializeable {
     }
     removeModeInternal(mode) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.modes.includes(mode)) {
-                this.modes.splice(this.modes.indexOf(mode), 1);
-                mode._context = null;
-                this.controller.removeModeFromContext(mode);
+            const index = this.modes.indexOf(mode);
+            if (index !== -1) {
+                this.modes.splice(index, 1);
             }
+            mode._context = null;
+            yield this.controller.removeModeFromContext(mode);
         });
     }
     removeAllModes() {
@@ -2522,20 +2848,24 @@ class BaseDataCaptureView extends DefaultSerializeable {
         this.controller = new DataCaptureViewController(this);
     }
     addOverlay(overlay) {
-        if (this.overlays.includes(overlay)) {
-            return;
-        }
-        overlay.view = this;
-        this.overlays.push(overlay);
-        this.controller.updateView();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.overlays.includes(overlay)) {
+                return;
+            }
+            overlay.view = this;
+            this.overlays.push(overlay);
+            yield this.controller.updateView();
+        });
     }
     removeOverlay(overlay) {
-        if (!this.overlays.includes(overlay)) {
-            return;
-        }
-        overlay.view = null;
-        this.overlays.splice(this.overlays.indexOf(overlay), 1);
-        this.controller.updateView();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.overlays.includes(overlay)) {
+                return;
+            }
+            overlay.view = null;
+            this.overlays.splice(this.overlays.indexOf(overlay), 1);
+            yield this.controller.updateView();
+        });
     }
     removeAllOverlays() {
         if (this.overlays.length === 0) {
@@ -2683,27 +3013,6 @@ __decorate([
     ignoreFromSerialization
 ], BaseDataCaptureView.prototype, "isViewCreated", void 0);
 
-class ScreenStateManager {
-    constructor() {
-        this.activeScreenId = null;
-    }
-    static getInstance() {
-        if (!ScreenStateManager.instance) {
-            ScreenStateManager.instance = new ScreenStateManager();
-        }
-        return ScreenStateManager.instance;
-    }
-    setActiveScreen(screenId) {
-        if (this.activeScreenId === screenId) {
-            return;
-        }
-        this.activeScreenId = screenId;
-    }
-    isScreenActive(screenId) {
-        return (this.activeScreenId === null || this.activeScreenId === screenId);
-    }
-}
-
 class ZoomSwitchControl extends DefaultSerializeable {
     constructor() {
         super(...arguments);
@@ -2884,6 +3193,7 @@ __decorate([
 
 var VideoResolution;
 (function (VideoResolution) {
+    /** @deprecated Auto is deprecated. Please use the capture mode's recommendedCameraSettings for the best results. */
     VideoResolution["Auto"] = "auto";
     VideoResolution["HD"] = "hd";
     VideoResolution["FullHD"] = "fullHd";
@@ -3700,5 +4010,5 @@ function createNativeProxy(nativeCaller) {
 
 createEventEmitter();
 
-export { AdvancedInstanceAwareNativeProxy, AdvancedNativeProxy, AimerViewfinder, Anchor, BaseController, BaseDataCaptureView, BaseInstanceAwareNativeProxy, BaseNativeProxy, BaseNewController, Brush, Camera, CameraController, CameraPosition, CameraSettings, Color, ContextStatus, ControlImage, DataCaptureContext, DataCaptureContextEvents, DataCaptureContextSettings, DataCaptureViewController, DataCaptureViewEvents, DefaultSerializeable, Direction, EventDataParser, EventEmitter, Expiration, FactoryMaker, Feedback, FocusGestureStrategy, FocusRange, FontFamily, FrameDataSettings, FrameDataSettingsBuilder, FrameSourceListenerEvents, FrameSourceState, HTMLElementState, HtmlElementPosition, HtmlElementSize, ImageBuffer, ImageFrameSource, LaserlineViewfinder, LicenseInfo, LogoStyle, MarginsWithUnit, MeasureUnit, NativeProxy, NoViewfinder, NoneLocationSelection, NumberWithUnit, Observable, OpenSourceSoftwareLicenseInfo, Orientation, Point, PointWithUnit, PrivateFocusGestureDeserializer, PrivateFrameData, PrivateZoomGestureDeserializer, Quadrilateral, RadiusLocationSelection, Rect, RectWithUnit, RectangularLocationSelection, RectangularViewfinder, RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle, ScanIntention, ScanditIcon, ScanditIconBuilder, ScanditIconShape, ScanditIconType, ScreenStateManager, Size, SizeWithAspect, SizeWithUnit, SizeWithUnitAndAspect, SizingMode, Sound, SwipeToZoom, TapToFocus, TextAlignment, TorchState, TorchSwitchControl, Vibration, VibrationType, VideoResolution, WaveFormVibration, ZoomSwitchControl, createAdvancedInstanceAwareNativeProxy, createAdvancedNativeFromCtorProxy, createAdvancedNativeProxy, createNativeProxy, getCoreDefaults, ignoreFromSerialization, ignoreFromSerializationIfNull, loadCoreDefaults, nameForSerialization, serializationDefault };
+export { AdvancedInstanceAwareNativeProxy, AdvancedNativeProxy, AimerViewfinder, Anchor, BaseController, BaseDataCaptureView, BaseInstanceAwareNativeProxy, BaseNativeProxy, BaseNewController, Brush, Camera, CameraController, CameraOwnershipHelper, CameraOwnershipManager, CameraPosition, CameraSettings, Color, ContextStatus, ControlImage, DataCaptureContext, DataCaptureContextEvents, DataCaptureContextSettings, DataCaptureViewController, DataCaptureViewEvents, DefaultSerializeable, Direction, EventDataParser, EventEmitter, Expiration, FactoryMaker, Feedback, FocusGestureStrategy, FocusRange, FontFamily, FrameDataSettings, FrameDataSettingsBuilder, FrameSourceListenerEvents, FrameSourceState, HTMLElementState, HtmlElementPosition, HtmlElementSize, ImageBuffer, ImageFrameSource, LaserlineViewfinder, LicenseInfo, LogoStyle, MarginsWithUnit, MeasureUnit, NativeProxy, NoViewfinder, NoneLocationSelection, NumberWithUnit, Observable, OpenSourceSoftwareLicenseInfo, Orientation, Point, PointWithUnit, PrivateFocusGestureDeserializer, PrivateFrameData, PrivateZoomGestureDeserializer, Quadrilateral, RadiusLocationSelection, Rect, RectWithUnit, RectangularLocationSelection, RectangularViewfinder, RectangularViewfinderAnimation, RectangularViewfinderLineStyle, RectangularViewfinderStyle, ScanIntention, ScanditIcon, ScanditIconBuilder, ScanditIconShape, ScanditIconType, Size, SizeWithAspect, SizeWithUnit, SizeWithUnitAndAspect, SizingMode, Sound, SwipeToZoom, TapToFocus, TextAlignment, TorchState, TorchSwitchControl, Vibration, VibrationType, VideoResolution, WaveFormVibration, ZoomSwitchControl, createAdvancedInstanceAwareNativeProxy, createAdvancedNativeFromCtorProxy, createAdvancedNativeProxy, createNativeProxy, getCoreDefaults, ignoreFromSerialization, ignoreFromSerializationIfNull, loadCoreDefaults, nameForSerialization, serializationDefault };
 //# sourceMappingURL=index.js.map