facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/services/backends/openpose-backend.service.spec.ts

@@ -0,0 +1,81 @@
+import { TestBed } from '@angular/core/testing';
+import { of, throwError } from 'rxjs';
+import { OpenPoseBackendService } from './openpose-backend.service';
+import { BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+describe('OpenPoseBackendService', () => {
+  describe('without backend client', () => {
+    let service: OpenPoseBackendService;
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({ providers: [OpenPoseBackendService] });
+      service = TestBed.inject(OpenPoseBackendService);
+    });
+
+    it('should be created', () => {
+      expect(service).toBeTruthy();
+    });
+
+    it('isAvailable returns false', () => {
+      expect(service.isAvailable()).toBe(false);
+    });
+
+    it('getName returns openpose', () => {
+      expect(service.getName()).toBe('openpose');
+    });
+
+    it('verifyLiveness throws error without client', (done) => {
+      service.verifyLiveness('img').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Backend HTTP client not configured');
+          done();
+        }
+      });
+    });
+  });
+
+  describe('with backend client', () => {
+    let service: OpenPoseBackendService;
+    let mockClient: any;
+
+    beforeEach(() => {
+      mockClient = {
+        createSession: jest.fn().mockReturnValue(of({ sessionId: 's1' })),
+        analyzeLiveness: jest.fn().mockReturnValue(of({ isLive: true, confidence: 0.9, metadata: { backend: 'openpose' } })),
+      };
+
+      TestBed.configureTestingModule({
+        providers: [
+          OpenPoseBackendService,
+          { provide: BACKEND_HTTP_CLIENT, useValue: mockClient }
+        ]
+      });
+      service = TestBed.inject(OpenPoseBackendService);
+    });
+
+    it('isAvailable returns true', () => {
+      expect(service.isAvailable()).toBe(true);
+    });
+
+    it('verifyLiveness creates session and analyzes', (done) => {
+      service.verifyLiveness('imgdata').subscribe(res => {
+        expect(res.isLive).toBe(true);
+        expect(res.confidence).toBe(0.9);
+        expect(mockClient.createSession).toHaveBeenCalledWith('openpose');
+        expect(mockClient.analyzeLiveness).toHaveBeenCalledWith('s1', 'openpose', 'imgdata', ['imgdata']);
+        done();
+      });
+    });
+
+    it('verifyLiveness handles error', (done) => {
+      mockClient.createSession.mockReturnValue(throwError(() => new Error('Network error')));
+
+      service.verifyLiveness('imgdata').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('OpenPose verification failed');
+          done();
+        }
+      });
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backends/openpose-backend.service.ts

@@ -0,0 +1,72 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { Observable, switchMap, map, catchError, throwError, retry, timeout, timer } from 'rxjs';
+import { BackendResponse } from '../../interfaces/backend-response.interface';
+import { IBackendAdapter } from '../../interfaces/backend-adapter.interface';
+import { IBackendHttpClient, BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+/**
+ * OpenPose/MoveNet Liveness Backend
+ * Connects to Express backend API which uses TensorFlow.js and MoveNet for pose estimation
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class OpenPoseBackendService implements IBackendAdapter {
+  private readonly REQUEST_TIMEOUT = 30000; // 30 seconds
+  private readonly MAX_RETRIES = 3;
+
+  constructor(
+    @Optional() @Inject(BACKEND_HTTP_CLIENT) private backendClient: IBackendHttpClient | null
+  ) {}
+
+  verifyLiveness(imageData: string, videoBlob?: Blob): Observable<BackendResponse> {
+    if (!this.backendClient) {
+      console.warn('[OpenPoseBackend] No backend HTTP client configured');
+      return throwError(() => new Error('Backend HTTP client not configured. Provide BACKEND_HTTP_CLIENT.'));
+    }
+
+    // Create session with OpenPose backend
+    return this.backendClient.createSession('openpose').pipe(
+      timeout(this.REQUEST_TIMEOUT),
+      switchMap(session => {
+        // Analyze liveness with the session
+        return this.backendClient!.analyzeLiveness(
+          session.sessionId,
+          'openpose',
+          imageData,
+          [imageData] // Send as frames array
+        );
+      }),
+      timeout(this.REQUEST_TIMEOUT),
+      retry({
+        count: this.MAX_RETRIES,
+        delay: (error, retryCount) => {
+          console.warn(`OpenPose backend retry attempt ${retryCount}/${this.MAX_RETRIES}`, error);
+          // Exponential backoff: 1s, 2s, 4s
+          const delayMs = Math.min(1000 * Math.pow(2, retryCount - 1), 5000);
+          return timer(delayMs);
+        }
+      }),
+      map(response => ({
+        isLive: response.isLive,
+        confidence: response.confidence,
+        details: response.metadata
+      })),
+      catchError(error => {
+        console.error('OpenPose backend error after retries:', error);
+        if (error.name === 'TimeoutError') {
+          return throwError(() => new Error('OpenPose request timed out. Please try again.'));
+        }
+        return throwError(() => new Error('OpenPose verification failed. Please check your connection.'));
+      })
+    );
+  }
+
+  isAvailable(): boolean {
+    return this.backendClient !== null;
+  }
+
+  getName(): string {
+    return 'openpose';
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/backends/rekognition-analysis-backend.service.spec.ts

@@ -0,0 +1,69 @@
+import { TestBed } from '@angular/core/testing';
+import { of, throwError } from 'rxjs';
+import { RekognitionAnalysisBackendService } from './rekognition-analysis-backend.service';
+import { BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+describe('RekognitionAnalysisBackendService', () => {
+  describe('without backend client', () => {
+    let service: RekognitionAnalysisBackendService;
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({ providers: [RekognitionAnalysisBackendService] });
+      service = TestBed.inject(RekognitionAnalysisBackendService);
+    });
+
+    it('should be created', () => { expect(service).toBeTruthy(); });
+    it('isAvailable returns false', () => { expect(service.isAvailable()).toBe(false); });
+    it('getName returns amazon', () => { expect(service.getName()).toBe('amazon'); });
+
+    it('verifyLiveness throws error without client', (done) => {
+      service.verifyLiveness('img').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Backend HTTP client not configured');
+          done();
+        }
+      });
+    });
+  });
+
+  describe('with backend client', () => {
+    let service: RekognitionAnalysisBackendService;
+    let mockClient: any;
+
+    beforeEach(() => {
+      mockClient = {
+        createSession: jest.fn().mockReturnValue(of({ sessionId: 's1' })),
+        analyzeLiveness: jest.fn().mockReturnValue(of({ isLive: true, confidence: 0.92, metadata: { backend: 'amazon' } })),
+      };
+
+      TestBed.configureTestingModule({
+        providers: [
+          RekognitionAnalysisBackendService,
+          { provide: BACKEND_HTTP_CLIENT, useValue: mockClient }
+        ]
+      });
+      service = TestBed.inject(RekognitionAnalysisBackendService);
+    });
+
+    it('isAvailable returns true', () => { expect(service.isAvailable()).toBe(true); });
+
+    it('verifyLiveness creates session and analyzes', (done) => {
+      service.verifyLiveness('imgdata').subscribe(res => {
+        expect(res.isLive).toBe(true);
+        expect(res.confidence).toBe(0.92);
+        expect(mockClient.createSession).toHaveBeenCalledWith('amazon');
+        done();
+      });
+    });
+
+    it('verifyLiveness handles error', (done) => {
+      mockClient.createSession.mockReturnValue(throwError(() => new Error('Network error')));
+      service.verifyLiveness('imgdata').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Amazon Rekognition verification failed');
+          done();
+        }
+      });
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/backends/rekognition-analysis-backend.service.ts

@@ -0,0 +1,83 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { Observable, switchMap, map, catchError, throwError, retry, timeout, timer, of } from 'rxjs';
+import { BackendResponse } from '../../interfaces/backend-response.interface';
+import { IBackendAdapter } from '../../interfaces/backend-adapter.interface';
+import { IBackendHttpClient, BACKEND_HTTP_CLIENT } from '../../interfaces/backend-http-client.interface';
+
+/**
+ * Amazon Rekognition Analysis Backend
+ * Connects to Express backend API which calls AWS Rekognition DetectFaces API
+ * for face detection and pose/liveness analysis.
+ *
+ * Note: This is different from AWS Face Liveness service (used in the test app's
+ * aws-face-liveness.service.ts which handles FaceLiveness sessions).
+ * This service uses Rekognition's DetectFaces for static image analysis.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class RekognitionAnalysisBackendService implements IBackendAdapter {
+  private readonly REQUEST_TIMEOUT = 30000; // 30 seconds
+  private readonly MAX_RETRIES = 3;
+
+  constructor(
+    @Optional() @Inject(BACKEND_HTTP_CLIENT) private backendClient: IBackendHttpClient | null
+  ) {}
+
+  verifyLiveness(imageData: string, videoBlob?: Blob): Observable<BackendResponse> {
+    if (!this.backendClient) {
+      console.warn('[RekognitionAnalysisBackend] No backend HTTP client configured');
+      return throwError(() => new Error('Backend HTTP client not configured. Provide BACKEND_HTTP_CLIENT.'));
+    }
+
+    // Create session with Amazon backend
+    return this.backendClient.createSession('amazon').pipe(
+      timeout(this.REQUEST_TIMEOUT),
+      switchMap(session => {
+        // Analyze liveness with the session
+        return this.backendClient!.analyzeLiveness(
+          session.sessionId,
+          'amazon',
+          imageData,
+          [imageData] // Send as frames array
+        );
+      }),
+      timeout(this.REQUEST_TIMEOUT),
+      retry({
+        count: this.MAX_RETRIES,
+        delay: (error, retryCount) => {
+          console.warn(`Rekognition backend retry attempt ${retryCount}/${this.MAX_RETRIES}`, error);
+          // Exponential backoff: 1s, 2s, 4s
+          const delayMs = Math.min(1000 * Math.pow(2, retryCount - 1), 5000);
+          return timer(delayMs);
+        }
+      }),
+      map(response => ({
+        isLive: response.isLive,
+        confidence: response.confidence,
+        details: response.metadata
+      })),
+      catchError(error => {
+        console.error('Rekognition backend error after retries:', error);
+        if (error.name === 'TimeoutError') {
+          return throwError(() => new Error('Amazon Rekognition request timed out. Please try again.'));
+        }
+        return throwError(() => new Error('Amazon Rekognition verification failed. Please check your connection.'));
+      })
+    );
+  }
+
+  isAvailable(): boolean {
+    return this.backendClient !== null;
+  }
+
+  getName(): string {
+    return 'amazon';
+  }
+}
+
+/**
+ * @deprecated Use RekognitionAnalysisBackendService instead.
+ * This alias is kept for backwards compatibility.
+ */
+export const AmazonBackendService = RekognitionAnalysisBackendService;

package/projects/facecog-liveness-verification/src/lib/services/camera.service.spec.ts

@@ -0,0 +1,200 @@
+import { TestBed } from '@angular/core/testing';
+import { CameraService } from './camera.service';
+
+describe('CameraService', () => {
+  let service: CameraService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [CameraService]
+    });
+    service = TestBed.inject(CameraService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('getStream returns null initially', () => {
+    expect(service.getStream()).toBeNull();
+  });
+
+  it('isRecording returns false initially', () => {
+    expect(service.isRecording()).toBe(false);
+  });
+
+  it('isCameraActive returns false initially', () => {
+    expect(service.isCameraActive()).toBe(false);
+  });
+
+  it('getCameraState returns correct initial state', () => {
+    const state = service.getCameraState();
+    expect(state.hasStream).toBe(false);
+    expect(state.isActive).toBe(false);
+    expect(state.isRecording).toBe(false);
+    expect(state.trackCount).toBe(0);
+  });
+
+  it('stopCamera is safe when no stream', () => {
+    expect(() => service.stopCamera()).not.toThrow();
+  });
+
+  it('requestPermissions falls back to browser API', async () => {
+    const result = await service.requestPermissions();
+    expect(result).toBe(true);
+    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalled();
+  });
+
+  it('startCamera sets up stream', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+
+    const stream = await service.startCamera(video);
+    expect(stream).toBeDefined();
+    expect(service.getStream()).toBe(stream);
+  });
+
+  it('startCameraLegacy returns true on success', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+
+    const result = await service.startCameraLegacy(video);
+    expect(result).toBe(true);
+  });
+
+  it('startCameraLegacy returns false on failure', async () => {
+    (navigator.mediaDevices.getUserMedia as jest.Mock).mockRejectedValueOnce(new Error('No camera'));
+    const video = document.createElement('video');
+
+    const result = await service.startCameraLegacy(video);
+    expect(result).toBe(false);
+  });
+
+  it('captureFrame returns data URL', () => {
+    const video = document.createElement('video');
+    const origCreateElement = document.createElement.bind(document);
+    jest.spyOn(document, 'createElement').mockImplementation((tag: string) => {
+      const el = origCreateElement(tag);
+      if (tag === 'canvas') {
+        (el as any).toDataURL = jest.fn().mockReturnValue('data:image/jpeg;base64,mock');
+      }
+      return el;
+    });
+    const frame = service.captureFrame(video);
+    expect(frame).toContain('data:image');
+    (document.createElement as jest.Mock).mockRestore();
+  });
+
+  it('captureFrames returns multiple frames', async () => {
+    const video = document.createElement('video');
+    const frames = await service.captureFrames(video, 3, 10);
+    expect(frames.length).toBe(3);
+  });
+
+  it('analyzeBrightness returns brightness data', () => {
+    const video = document.createElement('video');
+    const data = service.analyzeBrightness(video);
+    expect(data).toBeDefined();
+    expect(typeof data.brightness).toBe('number');
+    expect(typeof data.isLowLight).toBe('boolean');
+    expect(typeof data.isTooLight).toBe('boolean');
+  });
+
+  it('startBrightnessMonitoring returns interval id', () => {
+    const video = document.createElement('video');
+    const callback = jest.fn();
+    const id = service.startBrightnessMonitoring(video, callback, 100);
+    expect(typeof id).toBe('number');
+    service.stopBrightnessMonitoring(id);
+  });
+
+  it('startRecording returns false when no stream', () => {
+    expect(service.startRecording()).toBe(false);
+  });
+
+  it('startRecording returns true when stream exists', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+    await service.startCamera(video);
+
+    const result = service.startRecording();
+    expect(result).toBe(true);
+    expect(service.isRecording()).toBe(true);
+  });
+
+  it('stopRecording rejects when no recorder', async () => {
+    await expect(service.stopRecording()).rejects.toThrow('No media recorder');
+  });
+
+  it('releaseCameraForFaceTec cleans up everything', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+    await service.startCamera(video);
+
+    service.releaseCameraForFaceTec();
+    expect(service.getStream()).toBeNull();
+    expect(service.isRecording()).toBe(false);
+  });
+
+  it('checkPermissions falls back to browser permissions API', async () => {
+    const mockQuery = jest.fn().mockResolvedValue({ state: 'granted' });
+    Object.defineProperty(navigator, 'permissions', {
+      value: { query: mockQuery },
+      writable: true,
+      configurable: true
+    });
+    const result = await service.checkPermissions();
+    expect(typeof result).toBe('boolean');
+  });
+
+  it('checkPermissions returns false when all APIs fail', async () => {
+    Object.defineProperty(navigator, 'permissions', {
+      value: { query: jest.fn().mockRejectedValue(new Error('Not supported')) },
+      writable: true,
+      configurable: true
+    });
+    const result = await service.checkPermissions();
+    expect(result).toBe(false);
+  });
+
+  it('requestPermissions returns false when getUserMedia fails', async () => {
+    (navigator.mediaDevices.getUserMedia as jest.Mock).mockRejectedValueOnce(new Error('Denied'));
+    const result = await service.requestPermissions();
+    expect(result).toBe(false);
+  });
+
+  it('stopCamera stops tracks and clears stream', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+    await service.startCamera(video);
+    expect(service.getStream()).not.toBeNull();
+
+    service.stopCamera();
+    expect(service.getStream()).toBeNull();
+  });
+
+  it('reacquireCameraForGestures returns true on success', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+    const result = await service.reacquireCameraForGestures(video);
+    expect(result).toBe(true);
+  });
+
+  it('reacquireCameraForGestures returns false on failure', async () => {
+    (navigator.mediaDevices.getUserMedia as jest.Mock).mockRejectedValueOnce(new Error('No camera'));
+    const video = document.createElement('video');
+    const result = await service.reacquireCameraForGestures(video);
+    expect(result).toBe(false);
+  });
+
+  it('releaseCameraForFaceTec stops recording if active', async () => {
+    const video = document.createElement('video');
+    Object.defineProperty(video, 'play', { value: jest.fn().mockResolvedValue(undefined) });
+    await service.startCamera(video);
+    service.startRecording();
+    expect(service.isRecording()).toBe(true);
+
+    service.releaseCameraForFaceTec();
+    expect(service.getStream()).toBeNull();
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/camera.service.ts

@@ -0,0 +1,155 @@
+import { Injectable } from '@angular/core';
+import { ICameraProvider, BrightnessData } from '../interfaces/camera-provider.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CameraService implements ICameraProvider {
+  private mediaStream: MediaStream | null = null;
+  private mediaRecorder: MediaRecorder | null = null;
+  private recordedChunks: Blob[] = [];
+
+  async checkPermissions(): Promise<boolean> {
+    try {
+      const { Camera } = await import('@capacitor/camera');
+      const p = await Camera.checkPermissions();
+      return p.camera === 'granted';
+    } catch {
+      try {
+        const r = await navigator.permissions.query({ name: 'camera' as PermissionName });
+        return r.state === 'granted';
+      } catch {
+        return false;
+      }
+    }
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    try {
+      const { Camera } = await import('@capacitor/camera');
+      const p = await Camera.requestPermissions();
+      if (p.camera === 'granted') return true;
+    } catch { /* fallback to browser */ }
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ video: { facingMode: 'user' }, audio: false });
+      stream.getTracks().forEach(t => t.stop());
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async startCamera(videoElement: HTMLVideoElement): Promise<MediaStream> {
+    const c = { video: { facingMode: 'user' as const, width: { ideal: 1280 }, height: { ideal: 720 } }, audio: false };
+    this.mediaStream = await navigator.mediaDevices.getUserMedia(c);
+    videoElement.srcObject = this.mediaStream;
+    await videoElement.play();
+    return this.mediaStream;
+  }
+
+  async startCameraLegacy(videoElement: HTMLVideoElement): Promise<boolean> {
+    try {
+      await this.startCamera(videoElement);
+      return true;
+    } catch { return false; }
+  }
+
+  stopCamera(): void {
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach(t => t.stop());
+      this.mediaStream = null;
+    }
+  }
+
+  startRecording(): boolean {
+    if (!this.mediaStream) return false;
+    try {
+      this.recordedChunks = [];
+      this.mediaRecorder = new MediaRecorder(this.mediaStream, { mimeType: 'video/webm;codecs=vp9' });
+      this.mediaRecorder.ondataavailable = e => { if (e.data.size > 0) this.recordedChunks.push(e.data); };
+      this.mediaRecorder.start();
+      return true;
+    } catch { return false; }
+  }
+
+  stopRecording(): Promise<Blob> {
+    return new Promise((resolve, reject) => {
+      if (!this.mediaRecorder) { reject(new Error('No media recorder')); return; }
+      this.mediaRecorder.onstop = () => resolve(new Blob(this.recordedChunks, { type: 'video/webm' }));
+      this.mediaRecorder.stop();
+    });
+  }
+
+  captureFrame(videoElement: HTMLVideoElement): string {
+    const c = document.createElement('canvas');
+    c.width = videoElement.videoWidth;
+    c.height = videoElement.videoHeight;
+    const ctx = c.getContext('2d');
+    if (!ctx) throw new Error('Could not get canvas context');
+    ctx.drawImage(videoElement, 0, 0, c.width, c.height);
+    return c.toDataURL('image/jpeg', 0.9);
+  }
+
+  async captureFrames(videoElement: HTMLVideoElement, count = 5, interval = 200): Promise<string[]> {
+    const out: string[] = [];
+    for (let i = 0; i < count; i++) {
+      out.push(this.captureFrame(videoElement));
+      if (i < count - 1) await new Promise(r => setTimeout(r, interval));
+    }
+    return out;
+  }
+
+  isRecording(): boolean { return this.mediaRecorder?.state === 'recording'; }
+  getStream(): MediaStream | null { return this.mediaStream; }
+
+  analyzeBrightness(videoElement: HTMLVideoElement): BrightnessData {
+    const c = document.createElement('canvas');
+    const w = Math.min(videoElement.videoWidth, 320);
+    const h = Math.min(videoElement.videoHeight, 240);
+    c.width = w; c.height = h;
+    const ctx = c.getContext('2d');
+    if (!ctx) return { brightness: 128, isLowLight: false, isTooLight: false };
+    ctx.drawImage(videoElement, 0, 0, w, h);
+    try {
+      const d = ctx.getImageData(0, 0, w, h).data;
+      let sum = 0;
+      for (let i = 0; i < d.length; i += 4) sum += 0.299 * d[i] + 0.587 * d[i + 1] + 0.114 * d[i + 2];
+      const b = sum / (d.length / 4);
+      return { brightness: b, isLowLight: b < 60, isTooLight: b > 200 };
+    } catch {
+      return { brightness: 128, isLowLight: false, isTooLight: false };
+    }
+  }
+
+  startBrightnessMonitoring(
+    videoElement: HTMLVideoElement,
+    callback: (data: BrightnessData) => void,
+    intervalMs = 1000
+  ): number {
+    return window.setInterval(() => callback(this.analyzeBrightness(videoElement)), intervalMs);
+  }
+
+  stopBrightnessMonitoring(intervalId: number): void { clearInterval(intervalId); }
+
+  releaseCameraForFaceTec(): void {
+    if (this.isRecording()) this.stopRecording().catch(() => {});
+    if (this.mediaStream) { this.mediaStream.getTracks().forEach(t => t.stop()); this.mediaStream = null; }
+    this.mediaRecorder = null;
+    this.recordedChunks = [];
+  }
+
+  async reacquireCameraForGestures(videoElement: HTMLVideoElement): Promise<boolean> {
+    await new Promise(r => setTimeout(r, 500));
+    try { await this.startCamera(videoElement); return true; } catch { return false; }
+  }
+
+  isCameraActive(): boolean { return this.mediaStream != null && this.mediaStream.active; }
+  getCameraState(): { hasStream: boolean; isActive: boolean; isRecording: boolean; trackCount: number } {
+    return {
+      hasStream: this.mediaStream != null,
+      isActive: this.mediaStream?.active ?? false,
+      isRecording: this.isRecording(),
+      trackCount: this.mediaStream?.getTracks().length ?? 0
+    };
+  }
+}