@camera.ui/browser 0.0.110 → 0.0.111

package/dist/bundle.js.LICENSE.txt

@@ -1,23 +1,14 @@
 /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
 
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
 
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
-    ***************************************************************************** */
-
-/**
-     * splaytree v3.1.2
-     * Fast Splay tree for Node and browser
-     *
-     * @author Alexander Milevski <info@w8r.name>
-     * @license MIT
-     * @preserve
-     */
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */

package/dist/types/packages/client/browser/src/client.d.ts

@@ -5,19 +5,17 @@ export interface API {
     deviceManager: DeviceManager;
 }
 export declare class CameraUiClient {
-    private api;
-    private socketService?;
+    private interceptor;
     private config;
     private logger;
+    private proxy?;
     private token?;
-    private deviceManager?;
-    private coreManager?;
+    private _api?;
+    get api(): API | undefined;
     constructor(config: CameraUiClientConfig);
     connect(): Promise<API>;
     disconnect(): Promise<void>;
     updateCredentials(newConfig: CameraUiClientConfig): Promise<void>;
     private login;
-    getDeviceManager(): DeviceManager | undefined;
-    private checkSession;
-    private cleanUpClient;
+    private getNatsEndpoint;
 }

package/dist/types/packages/client/browser/src/proxy/cameraDevice.d.ts

@@ -1,30 +1,26 @@
-import { BaseCameraDevice } from '../../../../../packages/plugineer/src/polyglot/node/camera/index.js';
-import { CameraInterface } from '../../../../../packages/plugineer/src/polyglot/node/camera/interfaces/camera.js';
-import { CameraPTZInterface } from '../../../../../packages/plugineer/src/polyglot/node/camera/interfaces/ptz.js';
+import { BaseCameraDevice } from '../../../../../server/src/camera/index.js';
+import { CameraInterface } from '../../../../../server/src/camera/interfaces.js';
 import { Go2RTCSession } from '../streaming/go2rts-session.js';
-import type { Camera, CameraInternalSource, CameraSource } from '../../../../../shared/types/index.js';
-import type { SocketService } from '../socket.js';
-import type { BaseLogger, CameraDevice, Go2RTCSessionOptions } from '../types.js';
+import type { Camera, CameraSource, ProbeConfig, ProbeStream } from '../../../../../shared/types/index.js';
+import type { Proxy } from '../proxy.js';
+import type { BaseLogger, CameraDevice, CameraUiClientConfig, Go2RTCSessionOptions } from '../types.js';
 export declare class CameraDeviceProxy extends BaseCameraDevice implements CameraDevice {
-    private socketService;
-    private socket;
-    private pluginName;
-    private subject;
-    private _started;
-    get started(): boolean;
-    protected cameraDelegate: CameraInterface;
-    protected ptzDelegate: CameraPTZInterface;
+    private proxy;
+    private config;
+    private token;
+    private subscription?;
+    private namespaces;
+    protected cameraInterfaces: CameraInterface;
     get sources(): CameraSource[];
-    get internalSources(): CameraInternalSource[];
-    constructor(camera: Camera, socketService: SocketService, logger: BaseLogger);
-    start(): Promise<void>;
-    stop(): void;
-    close(): void;
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
+    constructor(proxy: Proxy, config: CameraUiClientConfig, token: string, camera: Camera, logger: BaseLogger);
+    init(): Promise<void>;
+    close(): Promise<void>;
     createWebRTCSession(options: Go2RTCSessionOptions): Go2RTCSession;
     refreshStates(): Promise<void>;
-    cleanup(): Promise<void>;
-    private listenToMessages;
-    private onRequest;
+    protected cleanup(): Promise<void>;
+    protected snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh?: boolean): Promise<ProbeStream | undefined>;
+    private onEventMessage;
+    private cameraControllerProxy;
+    private disconnectRpc;
 }

package/dist/types/packages/client/browser/src/proxy/coreManager.d.ts

@@ -1,16 +1,14 @@
-import type { CoreManager as CoreManagerInterface, FfmpegArgs, IceServer } from '../../../../../shared/types/index.js';
-import type { SocketService } from '../socket.js';
-import type { BaseLogger } from '../types.js';
-export declare class CoreManager implements CoreManagerInterface {
-    private socketService;
-    private socket;
-    private logger;
-    private pluginName;
-    private subject;
-    constructor(socketService: SocketService, logger: BaseLogger);
+import type { CuiPlugin, FfmpegArgs, HWAccelOptions, IceServer, CoreManager as ICoreManager } from '../../../../../shared/types/index.js';
+import type { Proxy } from '../proxy.js';
+export declare class CoreManager implements ICoreManager {
+    private proxy;
+    private namespaces;
+    private rpcConnections;
+    constructor(proxy: Proxy);
+    connectToPlugin(pluginName: string): Promise<CuiPlugin | undefined>;
     getFFmpegPath(): Promise<string>;
-    getHwaccelInfo(targetCodec: 'h264' | 'h265'): Promise<FfmpegArgs>;
+    getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]>;
     getServerAddresses(): Promise<string[]>;
     getIceServers(): Promise<IceServer[]>;
-    private onRequest;
+    private coreManagerProxy;
 }

package/dist/types/packages/client/browser/src/proxy/deviceManager.d.ts

@@ -1,18 +1,16 @@
-import type { SocketService } from '../socket.js';
-import type { BaseLogger, CameraDevice } from '../types.js';
+import type { Proxy } from '../proxy.js';
+import type { BaseLogger, CameraDevice, CameraUiClientConfig } from '../types.js';
 interface DeviceManagerBrowserProxyMethods {
-    getCameraByName(name: string): Promise<CameraDevice | undefined>;
-    getCameraById(id: string): Promise<CameraDevice | undefined>;
+    getCamera(cameraIdOrName: string): Promise<CameraDevice | undefined>;
 }
 export declare class DeviceManager implements DeviceManagerBrowserProxyMethods {
-    private socketService;
-    private socket;
+    private proxy;
+    private config;
+    private token;
     private logger;
-    private pluginName;
-    private subject;
-    constructor(socketService: SocketService, logger: BaseLogger);
-    getCameraById(id: string): Promise<CameraDevice | undefined>;
-    getCameraByName(name: string): Promise<CameraDevice | undefined>;
-    private onRequest;
+    private namespaces;
+    constructor(proxy: Proxy, config: CameraUiClientConfig, token: string, logger: BaseLogger);
+    getCamera(cameraIdOrName: string): Promise<CameraDevice | undefined>;
+    private deviceManagerProxy;
 }
 export {};

package/dist/types/packages/client/browser/src/proxy.d.ts

@@ -0,0 +1,7 @@
+import { ClientInstance } from '@camera.ui/rpc-client';
+import type { ClientConnectionOptions } from '@camera.ui/rpc-common';
+export declare class Proxy extends ClientInstance {
+    constructor(options: ClientConnectionOptions);
+    protected onStart(): Promise<void>;
+    protected onStop(): Promise<void>;
+}

package/dist/types/packages/client/browser/src/streaming/config.d.ts

@@ -0,0 +1,21 @@
+export declare function createConfig(): {
+    WEBRTC: {
+        RECONNECT_TIMER: number;
+        TIMEOUT_TIMER: number;
+        ICE_SERVERS: {
+            urls: string;
+        }[];
+    };
+    QUALITY: {
+        METRICS_INTERVAL: number;
+        METRICS_WINDOW: number;
+        STABILITY_PERIOD: number;
+        PACKET_LOSS_THRESHOLD: number;
+        FRAME_DROP_THRESHOLD: number;
+        QUALITY_CHANGE_COOLDOWN: number;
+    };
+    MEDIA: {
+        BUFFER_SIZE: number;
+        DEFAULT_CODECS: string[];
+    };
+};

package/dist/types/packages/client/browser/src/streaming/go2rts-session.d.ts

@@ -1,71 +1,286 @@
-import type { VideoStreamingMode } from '../../../../../shared/types/index.js';
-import type { SocketService } from '../socket.js';
-import type { BaseLogger, CameraDevice, Go2RTCSessionOptions } from '../types.js';
+import type { CameraSource, StreamingRole, VideoStreamingMode } from '../../../../../shared/types/index.js';
+import type { CameraDeviceProxy } from '../proxy/cameraDevice.js';
+import type { BaseLogger, CameraUiClientConfig, Go2RTCSessionOptions } from '../types.js';
+/**
+ * Manages streaming sessions using go2rtc as backend service
+ * Supports WebRTC, MSE, and automatic mode switching
+ */
 export declare class Go2RTCSession extends EventTarget {
-    private cameraDevice;
-    private socketService;
-    private logger;
-    private options;
-    private videoPlayer;
-    private socket;
-    private streamId;
-    hasBackchannel: boolean;
-    hasAudio: boolean;
-    closed: boolean;
+    private readonly cameraDevice;
+    private readonly logger;
+    private readonly config;
+    private readonly token;
+    private readonly initialOptions;
+    private readonly videoPlayer;
+    private readonly CONFIG;
+    private ws?;
     private pc;
     private micTransceiver;
-    private buf;
     private mediaSource;
     private sourceBuffer;
+    private buf;
     private bufLen;
-    private mseCodecs;
-    private videoPlayerMp4?;
-    private media;
     private codecList;
+    private streamProbe?;
+    private metrics;
+    private metricsInterval?;
+    private lastQualityChange;
+    private isMonitoring;
+    private wsReconnectTimer?;
     private wsReconnectTimeout?;
     private webrtcConnectTimeout?;
     private webrtcReconnectTimeout?;
-    private wsReconnectTimer?;
-    private webrtcReconnectTimer;
-    private webrtcTimeoutTimer;
-    private _finishLoading;
-    private _firstFrameReceived;
+    private firstFrameReceived;
     private animationFrameId?;
-    private isAutoSwitching;
+    private userRequestedMode;
+    private internalMode;
+    private activeMode;
+    private isAutoSwitchingInProgress;
+    private _closed;
+    private _hasBackchannel;
+    private _hasAudio;
+    private _hasVideo;
+    private _finishLoading;
+    private userRequestedRole;
+    private effectiveRole;
+    private _streamingSource?;
+    /**
+     * Get current streaming source
+     */
+    get streamingSource(): CameraSource | undefined;
+    /**
+     * Is the session closed
+     */
+    get closed(): boolean;
+    /**
+     * Indicates if backchannel (two-way audio) is available
+     */
+    get hasBackchannel(): boolean;
+    /**
+     * Indicates if audio is available in the stream
+     */
+    get hasAudio(): boolean;
+    /**
+     * Indicates if video is available in the stream
+     */
+    get hasVideo(): boolean;
+    /**
+     * Indicates if loading has finished
+     */
+    get finishLoading(): boolean;
+    /**
+     * User requested streaming mode
+     */
     get mode(): VideoStreamingMode;
+    /**
+     * Current effective mode being used (never 'auto')
+     */
+    get currentMode(): VideoStreamingMode;
+    /**
+     * Current effective resolution being used
+     */
+    get currentResolution(): StreamingRole;
+    /**
+     * Prefix for logging, includes camera name and mode
+     */
     private get logPrefix();
-    constructor(cameraDevice: CameraDevice, socketService: SocketService, logger: BaseLogger, options: Go2RTCSessionOptions);
-    connect(customMode?: VideoStreamingMode): void;
-    disconnect(): void;
-    reconnect(customMode?: VideoStreamingMode): Promise<void>;
-    reset(): void;
+    /**
+     * WebSocket URL with proper authentication and source
+     */
+    private get wsUrl();
+    /**
+     * Creates a new Go2RTCSession
+     */
+    constructor(cameraDevice: CameraDeviceProxy, config: CameraUiClientConfig, token: string, logger: BaseLogger, options: Go2RTCSessionOptions);
+    /**
+     * Starts the streaming session
+     * @param customMode Optional mode override for this start
+     */
+    start(customMode?: VideoStreamingMode): Promise<void>;
+    /**
+     * Closes the streaming session
+     */
     close(): void;
+    /**
+     * Restarts the streaming session
+     * @param customMode Optional mode override for restart
+     * @param sourceChange Whether restart is due to source change
+     */
+    restart(customMode?: VideoStreamingMode, sourceChange?: boolean): Promise<void>;
+    /**
+     * Toggles microphone track for two-way audio
+     * @param track Media track or null to disable
+     */
     toggleMicrophone(track: MediaStreamTrack | null): Promise<void>;
+    /**
+     * Changes the stream resolution
+     * @param role Target resolution or 'auto' for adaptive
+     */
+    toggleRole(role: StreamingRole | 'auto'): Promise<void>;
+    /**
+     * Changes the streaming transport mode
+     * @param mode Target transport mode
+     */
+    toggleMode(mode: VideoStreamingMode): Promise<void>;
+    /**
+     * Initialize streaming source based on user preferences
+     */
+    private initializeStreamingSource;
+    /**
+     * Check if a stream is WebRTC compatible
+     */
+    private checkWebRTCCompatibility;
+    /**
+     * Initialize adaptive streaming if role is auto
+     */
+    private initializeAdaptiveStreaming;
+    /**
+     * Select initial mode based on codec compatibility
+     * If we know WebRTC won't work, don't even try it
+     */
+    private selectInitialMode;
+    /**
+     * Set up WebSocket connection
+     */
+    private connectWs;
+    /**
+     * Disconnect and clean up WebSocket
+     */
+    private disconnectWs;
+    /**
+     * Reset internal state completely
+     */
+    private reset;
+    /**
+     * WebSocket open event handler
+     */
     private onWsOpen;
+    /**
+     * WebSocket close event handler - handles reconnection
+     */
     private onWsClose;
+    /**
+     * WebSocket message handler - routes to appropriate processor
+     */
     private onWsMessage;
+    /**
+     * Handle streaming errors from server
+     */
+    private handleStreamError;
+    /**
+     * Request WebRTC session
+     * @param autoMode Whether this is part of auto mode detection
+     */
     private requestWebrtc;
+    /**
+     * Process WebRTC signaling messages
+     */
     private onWebrtcData;
+    /**
+     * Request MSE session
+     */
     private requestMse;
+    /**
+     * Process MSE initialization message
+     */
     private onMseData;
+    /**
+     * Process MSE binary data
+     */
     private onMseBuffer;
+    /**
+     * Request auto mode (tries both WebRTC and MSE)
+     */
     private requestAuto;
-    private requestMjpeg;
-    private onMjpegBuffer;
-    private requestMp4;
-    private onMp4Buffer;
-    private requestHls;
-    private onHlsData;
-    private handleAutoMode;
-    private evaluateStreamQuality;
-    private evaluateMSEQuality;
-    private onStreamInfo;
+    /**
+     * Send message to WebSocket
+     */
+    private send;
+    /**
+     * Switch to WebRTC in auto mode
+     */
+    private switchToWebRTC;
+    /**
+     * Play video with automatic muting fallback if autoplay is blocked
+     */
     private play;
+    /**
+     * Start quality monitoring for adaptive streaming
+     */
+    private startQualityMonitoring;
+    /**
+     * Stop quality monitoring
+     */
+    private stopQualityMonitoring;
+    /**
+     * Gather metrics from current connection
+     */
+    private gatherMetrics;
+    /**
+     * Analyze quality metrics to determine stability
+     */
+    private analyzeQualityMetrics;
+    /**
+     * Analyze current quality and adapt resolution if needed
+     */
+    private analyzeAndAdaptQuality;
+    /**
+     * Change stream resolution
+     * @param resolution Target resolution
+     * @param reason Why the change is happening (for logging)
+     * @param initial Whether this is initial setup
+     */
+    private setStreamResolution;
+    /**
+     * Find the best source for a requested resolution
+     */
+    private getSourceForResolution;
+    /**
+     * Handle first frame received in WebRTC mode
+     */
     private onFirstFrameWebrtc;
+    /**
+     * Handle camera device change event
+     */
+    private setActiveMode;
+    /**
+     * Handle first frame received event
+     */
     private onFirstFrame;
+    /**
+     * Handle loaded data event from video element
+     */
+    private onLoadedData;
+    /**
+     * Mark loading as finished and dispatch event
+     */
     private onFinishLoading;
-    private setMode;
+    /**
+     * Create a list of supported codecs based on browser
+     */
     private createCodecsList;
+    /**
+     * Parse codecs list into string for MSE
+     */
     private parseCodecs;
-    private btoaBinary;
+    /**
+     * Probe stream capabilities
+     */
+    private probeStream;
+    /**
+     * Check if audio codec is WebRTC compatible
+     */
+    private isWebRtcCompatibleAudioCodec;
+    /**
+     * Check if video codec is WebRTC compatible
+     */
+    private isWebRtcCompatibleVideoCodec;
+    /**
+     * Create WebSocket source name from camera and source
+     */
+    private createWsSourceName;
+    /**
+     * Check if H.265 is supported by the browser's WebRTC implementation
+     */
+    private isWebRTCH265Supported;
 }

package/dist/types/packages/client/browser/src/streaming/types.d.ts

@@ -0,0 +1,38 @@
+export interface Go2RTCMessageBase {
+    type: 'mse' | 'webrtc/candidate' | 'webrtc/answer' | 'webrtc/offer' | 'error';
+}
+export interface MSEMessage extends Go2RTCMessageBase {
+    type: 'mse';
+    value: string | ArrayBuffer;
+}
+export interface WebRTCAnswerMessage extends Go2RTCMessageBase {
+    type: 'webrtc/answer';
+    value: string;
+}
+export interface WebRTCOfferMessage extends Go2RTCMessageBase {
+    type: 'webrtc/offer';
+    value: string;
+}
+export interface WebRTCCandidateMessage extends Go2RTCMessageBase {
+    type: 'webrtc/candidate';
+    value?: string;
+}
+export type WebRTCMessage = WebRTCAnswerMessage | WebRTCCandidateMessage;
+export interface ErrorMessage extends Go2RTCMessageBase {
+    type: 'error';
+    value: string;
+}
+export type Go2RTCMessage = MSEMessage | WebRTCMessage | ErrorMessage;
+export type Go2RTCWsMessage = WebRTCOfferMessage | WebRTCCandidateMessage | MSEMessage;
+export interface NetworkMetrics {
+    packetsLost: number;
+    packetsReceived: number;
+    framesDropped: number;
+    framesReceived: number;
+    timestamp: number;
+}
+export interface QualityMetrics {
+    packetLossRate: number;
+    frameDropRate: number;
+    isStable: boolean;
+}

package/dist/types/packages/client/browser/src/types.d.ts

@@ -1,9 +1,10 @@
 import type { Observable, Subject } from 'rxjs';
-import type { BaseCameraDevice } from '../../../../packages/plugineer/src/polyglot/node/camera/index.js';
-import type { VideoStreamingMode } from '../../../../shared/types/index.js';
+import type { BaseCameraDevice } from '../../../../server/src/camera/index.js';
+import type { StreamingRole, VideoStreamingMode } from '../../../../shared/types/index.js';
 import type { Go2RTCSession } from './streaming/go2rts-session.js';
-export type { AudioSetEvent, AudioState, BatterySetEvent, BatteryState, CameraDetectionSettings, CameraRoles, CameraSource, CameraZone, Detection, DetectionZone, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, Point, SirenSetEvent, SirenState, VideoStreamingMode, ZoneFilter, ZoneType, } from '../../../../shared/types/index.js';
+export * from '@camera.ui/types';
 export type { Go2RTCSession } from './streaming/go2rts-session.js';
+export type { VideoStreamingMode } from '../../../../shared/types/index.js';
 export type CameraUiClientConfig = WithCredentials | WithToken;
 export interface BasicBrowserPeerConnection {
     enableMicrophone(track: MediaStreamTrack): void;
@@ -19,14 +20,11 @@ export interface BasicBrowserPeerConnection {
     close(): void;
 }
 export interface CameraDevice extends BaseCameraDevice {
-    readonly started: boolean;
-    start(): Promise<void>;
-    stop(): void;
-    close(): void;
+    close(): Promise<void>;
     createWebRTCSession(options: Go2RTCSessionOptions): Go2RTCSession;
 }
 export interface Go2RTCSessionOptions {
-    sourceName: string;
+    role: StreamingRole | 'auto';
     mode: VideoStreamingMode;
     videoElement: HTMLVideoElement;
     wsReconnectTimeout?: number;