@jaak.ai/stamps 2.0.1 → 2.1.0-beta.2

package/dist/collection/services/CameraService.js

@@ -1,14 +1,18 @@
 export class CameraService {
-    logger;
     eventBus;
     availableCameras = [];
     selectedCameraId = null;
     deviceType = 'desktop';
     preferredCameraFacing = null;
     preferredCamera = 'auto';
-    isManuallySelected = false;
-    constructor(logger, eventBus, preferredCamera = 'auto') {
-        this.logger = logger;
+    // Optimization: Static caches for performance
+    static cameraCapabilitiesCache = new Map();
+    static deviceEnumerationCache = null;
+    static CACHE_DURATION = 30000; // 30 seconds
+    // Stream management for optimization
+    currentStreamPromise;
+    lastStreamConstraints;
+    constructor(eventBus, preferredCamera = 'auto') {
         this.eventBus = eventBus;
         this.preferredCamera = preferredCamera;
     }
@@ -25,18 +29,21 @@ export class CameraService {
         else {
             this.deviceType = 'desktop';
         }
-        this.logger.state('DISPOSITIVO_DETECTADO', {
-            deviceType: this.deviceType,
-            userAgent: navigator.userAgent,
-            screenDimensions: { width: window.innerWidth, height: window.innerHeight }
-        });
         return this.deviceType;
     }
     async enumerateDevices() {
         try {
+            // Check cache first for optimization
+            const now = Date.now();
+            if (CameraService.deviceEnumerationCache &&
+                (now - CameraService.deviceEnumerationCache.timestamp) < CameraService.CACHE_DURATION) {
+                this.availableCameras = CameraService.deviceEnumerationCache.devices;
+                await this.setInitialCameraPreference();
+                this.eventBus.emit('camera-changed', this.selectedCameraId);
+                return this.availableCameras;
+            }
             const permissionStatus = await this.checkCameraPermission();
             if (permissionStatus === 'denied') {
-                this.logger.error('Permiso de cámara denegado por el usuario');
                 return [];
             }
             if (permissionStatus === 'prompt') {
@@ -44,25 +51,31 @@ export class CameraService {
                 tempStream.getTracks().forEach(track => track.stop());
             }
             const devices = await navigator.mediaDevices.enumerateDevices();
-            this.availableCameras = devices.filter(device => device.kind === 'videoinput');
-            this.logger.state('CAMARAS_DETECTADAS', {
-                count: this.availableCameras.length,
-                cameras: this.availableCameras.map(cam => ({
-                    id: cam.deviceId,
-                    label: cam.label || 'Unknown Camera'
-                }))
-            });
-            this.setInitialCameraPreference();
-            this.logger.state('PREFERENCIA_INICIAL_APLICADA', {
-                selectedCameraId: this.selectedCameraId,
-                preferredCameraFacing: this.preferredCameraFacing,
-                preferredCamera: this.preferredCamera
+            const allCameras = devices.filter(device => device.kind === 'videoinput');
+            // Filter out virtual cameras
+            this.availableCameras = allCameras.filter(camera => {
+                const isVirtual = this.isVirtualCamera(camera);
+                if (isVirtual) {
+                    console.log(`Virtual camera detected and filtered: ${camera.label}`);
+                }
+                return !isVirtual;
             });
+            // Check if there are physical cameras available
+            if (this.availableCameras.length === 0) {
+                console.log('No physical cameras available');
+                this.eventBus.emit('error', new Error('Cámaras virtuales no están permitidas. Use una cámara física.'));
+                return [];
+            }
+            // Cache the results for optimization
+            CameraService.deviceEnumerationCache = {
+                devices: this.availableCameras,
+                timestamp: now
+            };
+            await this.setInitialCameraPreference();
             this.eventBus.emit('camera-changed', this.selectedCameraId);
             return this.availableCameras;
         }
         catch (error) {
-            this.logger.error('Error al enumerar cámaras disponibles:', error);
             this.handleCameraPermissionError(error);
             return [];
         }
@@ -83,8 +96,6 @@ export class CameraService {
         }
         this.selectedCameraId = cameraId;
         this.updatePreferredFacing(camera);
-        this.isManuallySelected = true; // Mark as manually selected
-        this.savePreference();
         this.eventBus.emit('camera-changed', cameraId);
     }
     getPreferredFacing() {
@@ -93,14 +104,35 @@ export class CameraService {
     async setupCamera(constraints) {
         try {
             const finalConstraints = constraints || await this.getMaxResolution();
-            const stream = await navigator.mediaDevices.getUserMedia({
+            // Optimization: Check if we can reuse existing stream with same constraints
+            if (this.currentStreamPromise && this.constraintsEqual(finalConstraints, this.lastStreamConstraints)) {
+                return await this.currentStreamPromise;
+            }
+            // Create new stream promise for lazy loading
+            this.currentStreamPromise = navigator.mediaDevices.getUserMedia({
                 video: finalConstraints,
                 audio: false
             });
+            this.lastStreamConstraints = finalConstraints;
+            const stream = await this.currentStreamPromise;
+            // Validate that active stream is not from a virtual camera
+            const videoTrack = stream.getVideoTracks()[0];
+            if (videoTrack) {
+                const settings = videoTrack.getSettings();
+                const deviceId = settings.deviceId;
+                if (deviceId) {
+                    const devices = await navigator.mediaDevices.enumerateDevices();
+                    const currentDevice = devices.find(device => device.deviceId === deviceId);
+                    if (currentDevice && this.isVirtualCamera(currentDevice)) {
+                        console.log(`Virtual camera detected in active stream: ${currentDevice.label}`);
+                        stream.getTracks().forEach(track => track.stop());
+                        throw new Error('Cámaras virtuales no están permitidas. Use una cámara física.');
+                    }
+                }
+            }
             return stream;
         }
         catch (error) {
-            this.logger.error('Error en setupCamera, intentando con restricciones básicas:', error);
             // Fallback to basic constraints if getMaxResolution fails
             const basicConstraints = {
                 width: { ideal: 1280 },
@@ -110,65 +142,43 @@ export class CameraService {
             if (this.deviceType !== 'desktop' && this.preferredCameraFacing) {
                 basicConstraints.facingMode = this.preferredCameraFacing;
             }
-            this.logger.state('USANDO_RESTRICCIONES_BASICAS', { constraints: basicConstraints });
-            return await navigator.mediaDevices.getUserMedia({
+            this.currentStreamPromise = navigator.mediaDevices.getUserMedia({
                 video: basicConstraints,
                 audio: false
             });
+            this.lastStreamConstraints = basicConstraints;
+            const stream = await this.currentStreamPromise;
+            // Validate fallback stream as well
+            const videoTrack = stream.getVideoTracks()[0];
+            if (videoTrack) {
+                const settings = videoTrack.getSettings();
+                const deviceId = settings.deviceId;
+                if (deviceId) {
+                    const devices = await navigator.mediaDevices.enumerateDevices();
+                    const currentDevice = devices.find(device => device.deviceId === deviceId);
+                    if (currentDevice && this.isVirtualCamera(currentDevice)) {
+                        console.log(`Virtual camera detected in fallback stream: ${currentDevice.label}`);
+                        stream.getTracks().forEach(track => track.stop());
+                        throw new Error('Cámaras virtuales no están permitidas. Use una cámara física.');
+                    }
+                }
+            }
+            return stream;
         }
     }
     async switchCamera(cameraId) {
         const selectedCamera = this.availableCameras.find(cam => cam.deviceId === cameraId);
         if (!selectedCamera) {
-            this.logger.warn('Cámara seleccionada no encontrada, re-enumerando dispositivos...');
             await this.enumerateDevices();
             return;
         }
-        await this.setSelectedCamera(cameraId);
-        this.logger.state('CAMARA_CAMBIADA', {
-            label: selectedCamera.label,
-            deviceId: selectedCamera.deviceId,
-            isManuallySelected: this.isManuallySelected
-        });
-    }
-    async flipToNextCamera() {
-        if (!this.isMultipleCamerasAvailable())
+        // Validate that the target camera is not virtual
+        if (this.isVirtualCamera(selectedCamera)) {
+            console.log(`Attempted to switch to virtual camera: ${selectedCamera.label}`);
+            this.eventBus.emit('error', new Error('No se puede cambiar a cámara virtual'));
             return;
-        const currentIndex = this.availableCameras.findIndex(camera => camera.deviceId === this.selectedCameraId);
-        const nextIndex = (currentIndex + 1) % this.availableCameras.length;
-        const nextCamera = this.availableCameras[nextIndex];
-        await this.switchCamera(nextCamera.deviceId);
-    }
-    savePreference() {
-        try {
-            const preference = {
-                cameraId: this.selectedCameraId,
-                facing: this.preferredCameraFacing,
-                timestamp: Date.now()
-            };
-            localStorage.setItem('jaak-stamps-camera-preference', JSON.stringify(preference));
-            this.logger.state('PREFERENCIA_CAMARA_GUARDADA', preference);
-        }
-        catch (error) {
-            this.logger.warn('Error al guardar preferencia de cámara:', error);
-        }
-    }
-    loadPreference() {
-        try {
-            const saved = localStorage.getItem('jaak-stamps-camera-preference');
-            if (saved) {
-                const preference = JSON.parse(saved);
-                const isStillAvailable = this.availableCameras.some(camera => camera.deviceId === preference.cameraId);
-                if (isStillAvailable) {
-                    this.selectedCameraId = preference.cameraId;
-                    this.preferredCameraFacing = preference.facing;
-                    this.logger.state('PREFERENCIA_CAMARA_CARGADA', preference);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.warn('Error al cargar preferencia de cámara:', error);
         }
+        await this.setSelectedCamera(cameraId);
     }
     isRearCamera(stream) {
         const videoTrack = stream.getVideoTracks()[0];
@@ -177,13 +187,18 @@ export class CameraService {
         const settings = videoTrack.getSettings();
         return settings.facingMode === 'environment';
     }
-    getCameraInfo() {
-        return {
-            availableCameras: this.availableCameras.map(camera => ({
+    async getCameraInfo() {
+        const availableCamerasWithAutofocus = await Promise.all(this.availableCameras.map(async (camera) => {
+            const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
+            return {
                 id: camera.deviceId,
                 label: camera.label || 'Unknown Camera',
-                selected: camera.deviceId === this.selectedCameraId
-            })),
+                selected: camera.deviceId === this.selectedCameraId,
+                hasAutofocus
+            };
+        }));
+        return {
+            availableCameras: availableCamerasWithAutofocus,
             selectedCameraId: this.selectedCameraId,
             deviceType: this.deviceType,
             isMultipleCamerasAvailable: this.isMultipleCamerasAvailable(),
@@ -199,7 +214,6 @@ export class CameraService {
             return permission.state;
         }
         catch (error) {
-            this.logger.warn('No se pudo verificar permisos de cámara:', error);
             return 'prompt';
         }
     }
@@ -207,35 +221,48 @@ export class CameraService {
         this.availableCameras = [];
         this.eventBus.emit('error', new Error(`Camera permission error: ${error.message}`));
     }
-    setInitialCameraPreference() {
+    async setInitialCameraPreference() {
         if (this.availableCameras.length === 0)
             return;
-        // Clear any existing localStorage preferences to ensure fresh start
-        localStorage.removeItem('jaak-stamps-camera-preference');
-        this.logger.state('APLICANDO_PREFERENCIA_INICIAL', {
-            preferredCamera: this.preferredCamera,
-            availableCamerasCount: this.availableCameras.length
-        });
-        this.isManuallySelected = false; // Reset manual selection flag
         if (this.preferredCamera === 'front') {
-            this.selectFrontCamera();
+            await this.selectFrontCamera();
         }
         else if (this.preferredCamera === 'back') {
-            this.selectBackCamera();
+            await this.selectBackCamera();
         }
         else {
-            this.selectAutoCamera();
+            await this.selectAutoCamera();
         }
     }
-    selectFrontCamera() {
+    async checkCameraAutofocus(deviceId) {
+        try {
+            // Check cache first for optimization
+            if (CameraService.cameraCapabilitiesCache.has(deviceId)) {
+                const cached = CameraService.cameraCapabilitiesCache.get(deviceId);
+                return typeof cached === 'boolean' ? cached : false;
+            }
+            const stream = await navigator.mediaDevices.getUserMedia({
+                video: { deviceId: { exact: deviceId } }
+            });
+            const videoTrack = stream.getVideoTracks()[0];
+            const capabilities = videoTrack.getCapabilities();
+            stream.getTracks().forEach(track => track.stop());
+            const hasFocusMode = capabilities.focusMode && Array.isArray(capabilities.focusMode) && capabilities.focusMode.length > 0;
+            const hasAutofocus = hasFocusMode && (capabilities.focusMode.includes('continuous') ||
+                capabilities.focusMode.includes('auto'));
+            // Cache the result for future use
+            CameraService.cameraCapabilitiesCache.set(deviceId, hasAutofocus);
+            return hasAutofocus;
+        }
+        catch (error) {
+            // Cache negative result to avoid repeated failures
+            CameraService.cameraCapabilitiesCache.set(deviceId, false);
+            return false;
+        }
+    }
+    async selectFrontCamera() {
         this.preferredCameraFacing = 'user';
-        this.logger.state('BUSCANDO_CAMARA_FRONTAL', {
-            availableCameras: this.availableCameras.map(cam => ({
-                id: cam.deviceId,
-                label: cam.label
-            }))
-        });
-        const frontCamera = this.availableCameras.find(camera => {
+        const frontCameras = this.availableCameras.filter(camera => {
             const label = camera.label.toLowerCase();
             return label.includes('front') ||
                 label.includes('user') ||
@@ -243,24 +270,24 @@ export class CameraService {
                 label.includes('frontal') ||
                 (!label.includes('back') && !label.includes('rear') && !label.includes('environment'));
         });
-        // If not found, use the first camera (usually front on mobile)
-        this.selectedCameraId = frontCamera ? frontCamera.deviceId : this.availableCameras[0].deviceId;
-        this.logger.state('CAMARA_FRONTAL_SELECCIONADA', {
-            found: !!frontCamera,
-            label: frontCamera?.label || this.availableCameras[0].label,
-            deviceId: this.selectedCameraId
-        });
+        let selectedCamera = null;
+        if (frontCameras.length > 0) {
+            for (const camera of frontCameras) {
+                const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
+                if (hasAutofocus) {
+                    selectedCamera = camera;
+                    break;
+                }
+            }
+            if (!selectedCamera) {
+                selectedCamera = frontCameras[0];
+            }
+        }
+        this.selectedCameraId = selectedCamera ? selectedCamera.deviceId : this.availableCameras[0].deviceId;
     }
-    selectBackCamera() {
+    async selectBackCamera() {
         this.preferredCameraFacing = 'environment';
-        this.logger.state('BUSCANDO_CAMARA_TRASERA', {
-            availableCameras: this.availableCameras.map(cam => ({
-                id: cam.deviceId,
-                label: cam.label
-            }))
-        });
-        // Try to find rear camera with multiple detection methods
-        let backCamera = this.availableCameras.find(camera => {
+        const backCameras = this.availableCameras.filter(camera => {
             const label = camera.label.toLowerCase();
             return label.includes('back') ||
                 label.includes('rear') ||
@@ -268,34 +295,33 @@ export class CameraService {
                 label.includes('trasera') ||
                 label.includes('posterior');
         });
-        // If not found by label, try to use the last camera (usually rear on mobile)
-        if (!backCamera && this.availableCameras.length > 1) {
-            backCamera = this.availableCameras[this.availableCameras.length - 1];
-            this.logger.state('USANDO_ULTIMA_CAMARA_COMO_TRASERA', {
-                label: backCamera.label,
-                deviceId: backCamera.deviceId
-            });
+        let selectedCamera = null;
+        if (backCameras.length > 0) {
+            for (const camera of backCameras) {
+                const hasAutofocus = await this.checkCameraAutofocus(camera.deviceId);
+                if (hasAutofocus) {
+                    selectedCamera = camera;
+                    break;
+                }
+            }
+            if (!selectedCamera) {
+                selectedCamera = backCameras[0];
+            }
         }
-        this.selectedCameraId = backCamera ? backCamera.deviceId : this.availableCameras[0].deviceId;
-        this.logger.state('CAMARA_TRASERA_SELECCIONADA', {
-            found: !!backCamera,
-            label: backCamera?.label || this.availableCameras[0].label,
-            deviceId: this.selectedCameraId
-        });
+        else if (this.availableCameras.length > 1) {
+            const lastCamera = this.availableCameras[this.availableCameras.length - 1];
+            const hasAutofocus = await this.checkCameraAutofocus(lastCamera.deviceId);
+            selectedCamera = hasAutofocus ? lastCamera : this.availableCameras[this.availableCameras.length - 1];
+        }
+        this.selectedCameraId = selectedCamera ? selectedCamera.deviceId : this.availableCameras[0].deviceId;
     }
-    selectAutoCamera() {
+    async selectAutoCamera() {
         if (this.deviceType === 'mobile' || this.deviceType === 'tablet') {
-            this.selectBackCamera();
-            this.logger.state('CAMARA_AUTO_SELECCIONADA_MOBILE', { type: 'rear' });
+            await this.selectBackCamera();
         }
         else {
             // For desktop, prefer front camera (usually built-in webcam)
-            this.selectFrontCamera();
-            this.logger.state('CAMARA_AUTO_SELECCIONADA_DESKTOP', {
-                type: 'front',
-                label: this.availableCameras[0].label,
-                deviceId: this.selectedCameraId
-            });
+            await this.selectFrontCamera();
         }
     }
     updatePreferredFacing(camera) {
@@ -311,40 +337,19 @@ export class CameraService {
                 await this.detectDeviceType();
             }
             const videoConstraints = {};
-            this.logger.state('CONFIGURANDO_CONSTRAINS_CAMARA', {
-                selectedCameraId: this.selectedCameraId,
-                preferredCameraFacing: this.preferredCameraFacing,
-                preferredCamera: this.preferredCamera,
-                deviceType: this.deviceType,
-                isManuallySelected: this.isManuallySelected
-            });
-            if (this.isManuallySelected && this.selectedCameraId) {
-                // When manually selected, use deviceId for exact camera selection
+            // Priority 1: Always use deviceId if available (ensures specific camera with autofocus)
+            if (this.selectedCameraId) {
                 videoConstraints.deviceId = { exact: this.selectedCameraId };
-                this.logger.state('USANDO_CAMARA_MANUAL', {
-                    deviceId: this.selectedCameraId
-                });
             }
+            // Priority 2: Use facingMode as fallback when no specific camera is selected
             else if (this.preferredCameraFacing) {
-                // Use facingMode for initial preference-based selection
-                // Use 'ideal' instead of 'exact' to avoid OverconstrainedError on desktop
                 const facingConstraint = this.deviceType === 'desktop'
                     ? { ideal: this.preferredCameraFacing }
                     : { exact: this.preferredCameraFacing };
                 videoConstraints.facingMode = facingConstraint;
-                this.logger.state('USANDO_FACING_CONSTRAINT', {
-                    facingMode: this.preferredCameraFacing,
-                    constraintType: this.deviceType === 'desktop' ? 'ideal' : 'exact'
-                });
-            }
-            else if (this.selectedCameraId) {
-                videoConstraints.deviceId = { exact: this.selectedCameraId };
-                this.logger.state('USANDO_CAMARA_SELECCIONADA', {
-                    deviceId: this.selectedCameraId
-                });
             }
+            // Priority 3: Fallback to preferredCamera setting
             else {
-                // Use preferredCamera setting to determine default facing mode
                 if (this.preferredCamera === 'front') {
                     videoConstraints.facingMode = "user";
                 }
@@ -352,24 +357,25 @@ export class CameraService {
                     videoConstraints.facingMode = "environment";
                 }
                 else {
-                    // Auto mode: use environment for mobile/tablet, user for desktop
                     videoConstraints.facingMode = (this.deviceType === 'mobile' || this.deviceType === 'tablet') ? "environment" : "user";
                 }
-                this.logger.state('USANDO_PREFERENCIA_CONFIGURADA', {
-                    facingMode: videoConstraints.facingMode,
-                    preferredCamera: this.preferredCamera,
-                    deviceType: this.deviceType
-                });
             }
-            const tempStream = await navigator.mediaDevices.getUserMedia({
-                video: videoConstraints
-            });
-            const videoTrack = tempStream.getVideoTracks()[0];
-            const capabilities = videoTrack.getCapabilities();
-            tempStream.getTracks().forEach(track => track.stop());
+            // Optimization: Use cached capabilities if available
+            let capabilities;
+            if (this.selectedCameraId && CameraService.cameraCapabilitiesCache.has(this.selectedCameraId + '_caps')) {
+                capabilities = JSON.parse(CameraService.cameraCapabilitiesCache.get(this.selectedCameraId + '_caps'));
+            }
+            else {
+                const tempStream = await navigator.mediaDevices.getUserMedia({ video: videoConstraints });
+                const videoTrack = tempStream.getVideoTracks()[0];
+                capabilities = videoTrack.getCapabilities();
+                tempStream.getTracks().forEach(track => track.stop());
+                // Cache capabilities for future use
+                if (this.selectedCameraId) {
+                    CameraService.cameraCapabilitiesCache.set(this.selectedCameraId + '_caps', JSON.stringify(capabilities));
+                }
+            }
             const constraints = { ...videoConstraints };
-            // Enhanced focus and image quality settings
-            this.applyAdvancedCameraSettings(constraints, capabilities);
             if (capabilities.width && capabilities.height) {
                 const maxWidth = Math.min(capabilities.width.max, 1920);
                 const maxHeight = Math.min(capabilities.height.max, 1080);
@@ -383,15 +389,20 @@ export class CameraService {
                     constraints.height = { ideal: maxHeight };
                 }
             }
-            this.logger.state('CONFIGURACION_CAMARA_OPTIMIZADA', {
-                constraints,
-                capabilities: this.getCapabilitiesSummary(capabilities)
-            });
+            // Configure autofocus if camera has the capability
+            const capabilitiesAny = capabilities;
+            if (capabilitiesAny.focusMode && Array.isArray(capabilitiesAny.focusMode)) {
+                if (capabilitiesAny.focusMode.includes('continuous')) {
+                    constraints.focusMode = 'continuous';
+                }
+                else if (capabilitiesAny.focusMode.includes('auto')) {
+                    constraints.focusMode = 'auto';
+                }
+            }
             return constraints;
         }
         catch (err) {
-            this.logger.warn('No se pudieron obtener capacidades de cámara, usando configuración de respaldo');
-            // Ensure device type is detected before determining constraints
+            // Fallback logic with minimal temporary streams
             if (!this.deviceType || this.deviceType === 'desktop') {
                 await this.detectDeviceType();
             }
@@ -400,25 +411,16 @@ export class CameraService {
                 width: { ideal: isTablet ? 1280 : 1920 },
                 height: { ideal: isTablet ? 720 : 1080 }
             };
-            // Apply basic focus settings even for fallback
-            this.applyBasicFocusSettings(fallbackConstraints);
-            if (this.isManuallySelected && this.selectedCameraId) {
-                // When manually selected, use deviceId for exact camera selection
+            if (this.selectedCameraId) {
                 fallbackConstraints.deviceId = { exact: this.selectedCameraId };
             }
             else if (this.preferredCameraFacing) {
-                // Use facingMode for initial preference-based selection
-                // Use 'ideal' instead of 'exact' to avoid OverconstrainedError on desktop
                 const facingConstraint = this.deviceType === 'desktop'
                     ? { ideal: this.preferredCameraFacing }
                     : { exact: this.preferredCameraFacing };
                 fallbackConstraints.facingMode = facingConstraint;
             }
-            else if (this.selectedCameraId) {
-                fallbackConstraints.deviceId = { exact: this.selectedCameraId };
-            }
             else {
-                // Use preferredCamera setting to determine default facing mode
                 if (this.preferredCamera === 'front') {
                     fallbackConstraints.facingMode = "user";
                 }
@@ -426,165 +428,57 @@ export class CameraService {
                     fallbackConstraints.facingMode = "environment";
                 }
                 else {
-                    // Auto mode: use environment for mobile/tablet, user for desktop
                     fallbackConstraints.facingMode = (this.deviceType === 'mobile' || this.deviceType === 'tablet') ? "environment" : "user";
                 }
             }
             return fallbackConstraints;
         }
     }
-    applyAdvancedCameraSettings(constraints, capabilities) {
-        // Apply standard camera settings that are widely supported
-        // Frame rate optimization
-        if (capabilities.frameRate) {
-            constraints.frameRate = {
-                ideal: 30,
-                min: 15,
-                max: 60
-            };
-        }
-        // Width and height constraints for optimal resolution
-        if (capabilities.width && capabilities.height) {
-            constraints.width = {
-                ideal: Math.min(1920, capabilities.width.max || 1920),
-                min: 640
-            };
-            constraints.height = {
-                ideal: Math.min(1080, capabilities.height.max || 1080),
-                min: 480
-            };
-        }
-        // Apply enhanced constraints through advanced array for better browser compatibility
-        const advancedConstraints = [];
-        // Try to set optimal settings through advanced constraints
-        const advanced = {};
-        // Focus mode - use 'any' type to bypass TypeScript limitations
-        if (capabilities.focusMode) {
-            if (capabilities.focusMode.includes('continuous')) {
-                advanced.focusMode = 'continuous';
-            }
-            else if (capabilities.focusMode.includes('single-shot')) {
-                advanced.focusMode = 'single-shot';
-            }
-        }
-        // Focus distance for close objects
-        if (capabilities.focusDistance) {
-            advanced.focusDistance = {
-                ideal: 0.4, // 40cm - optimal for document capture
-                min: 0.2,
-                max: 1.0
-            };
-        }
-        // Zoom control
-        if (capabilities.zoom) {
-            advanced.zoom = {
-                ideal: 1.0,
-                min: capabilities.zoom.min,
-                max: Math.min(capabilities.zoom.max, 3.0)
-            };
-        }
-        // Add advanced constraints if any were set
-        if (Object.keys(advanced).length > 0) {
-            advancedConstraints.push(advanced);
-        }
-        if (advancedConstraints.length > 0) {
-            constraints.advanced = advancedConstraints;
-        }
-    }
-    applyBasicFocusSettings(constraints) {
-        // Apply basic focus settings when capabilities are not available
-        // Use advanced constraints for non-standard properties
-        const advanced = {
-            focusMode: 'continuous',
-            exposureMode: 'continuous',
-            whiteBalanceMode: 'continuous'
-        };
-        if (!constraints.advanced) {
-            constraints.advanced = [];
-        }
-        constraints.advanced.push(advanced);
-        constraints.frameRate = { ideal: 30 };
+    // Optimization helper methods
+    constraintsEqual(a, b) {
+        if (!a || !b)
+            return false;
+        return JSON.stringify(a) === JSON.stringify(b);
     }
-    getCapabilitiesSummary(capabilities) {
-        return {
-            hasAutoFocus: !!capabilities.focusMode,
-            hasFocusDistance: !!capabilities.focusDistance,
-            hasExposureControl: !!capabilities.exposureMode,
-            hasWhiteBalance: !!capabilities.whiteBalanceMode,
-            hasZoom: !!capabilities.zoom,
-            hasTorch: capabilities.torch !== undefined,
-            hasImageControls: !!(capabilities.brightness || capabilities.contrast || capabilities.saturation || capabilities.sharpness),
-            resolutionRange: capabilities.width && capabilities.height ?
-                `${capabilities.width.min}x${capabilities.height.min} - ${capabilities.width.max}x${capabilities.height.max}` : 'unknown'
-        };
+    // Cleanup method for optimization
+    static clearCaches() {
+        CameraService.cameraCapabilitiesCache.clear();
+        CameraService.deviceEnumerationCache = null;
     }
-    // New method to enable torch/flash for better illumination
-    async setTorchEnabled(enabled, stream) {
-        try {
-            if (!stream) {
-                this.logger.warn('No hay stream disponible para controlar el flash');
-                return false;
-            }
-            const videoTrack = stream.getVideoTracks()[0];
-            if (!videoTrack) {
-                this.logger.warn('No hay track de video disponible');
-                return false;
-            }
-            const capabilities = videoTrack.getCapabilities();
-            if (capabilities.torch === undefined) {
-                this.logger.warn('El dispositivo no soporta control de flash');
-                return false;
-            }
-            await videoTrack.applyConstraints({
-                advanced: [{ torch: enabled }]
-            });
-            this.logger.state('FLASH_CONTROLADO', { enabled });
-            return true;
-        }
-        catch (error) {
-            this.logger.error('Error al controlar el flash:', error);
-            return false;
-        }
+    // Method to invalidate device cache when needed
+    invalidateDeviceCache() {
+        CameraService.deviceEnumerationCache = null;
     }
-    // Method to manually trigger focus on a specific point
-    async focusAtPoint(x, y, stream) {
-        try {
-            if (!stream) {
-                this.logger.warn('No hay stream disponible para enfocar');
-                return false;
-            }
-            const videoTrack = stream.getVideoTracks()[0];
-            if (!videoTrack) {
-                this.logger.warn('No hay track de video disponible');
-                return false;
-            }
-            const capabilities = videoTrack.getCapabilities();
-            if (!capabilities.focusMode || !capabilities.focusMode.includes('single-shot')) {
-                this.logger.warn('El dispositivo no soporta enfoque manual');
-                return false;
-            }
-            // Trigger single-shot focus
-            await videoTrack.applyConstraints({
-                advanced: [{ focusMode: 'single-shot' }]
-            });
-            // Return to continuous focus after a short delay
-            setTimeout(async () => {
-                try {
-                    await videoTrack.applyConstraints({
-                        advanced: [{ focusMode: 'continuous' }]
-                    });
-                }
-                catch (error) {
-                    this.logger.warn('Error al volver a enfoque continuo:', error);
-                }
-            }, 1000);
-            this.logger.state('ENFOQUE_MANUAL_ACTIVADO', { x, y });
-            return true;
-        }
-        catch (error) {
-            this.logger.error('Error al enfocar manualmente:', error);
-            return false;
-        }
+    isVirtualCamera(device) {
+        const label = device.label.toLowerCase();
+        const virtualCameraIndicators = [
+            'obs',
+            'virtual',
+            'snap camera',
+            'manycam',
+            'xsplit',
+            'camtwist',
+            'ecamm',
+            'nvidia broadcast',
+            'droidcam',
+            'iriun',
+            'elgato',
+            'streamlabs',
+            'wirecast',
+            'zoom virtual',
+            'teams virtual',
+            'mmhmm',
+            'camo',
+            'reincubate camo',
+            'webcamoid',
+            'splitcam',
+            'cheese',
+            'guvcview',
+            'yawcam',
+            'webcam 7',
+            'altserver'
+        ];
+        return virtualCameraIndicators.some(indicator => label.includes(indicator));
     }
 }
 //# sourceMappingURL=CameraService.js.map