@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.0

package/src/common.ts

@@ -1,4 +1,4 @@
-import type { BaichuanClientOptions, DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamProfile, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanClientOptions, DeviceCapabilities, NativeVideoStreamVariant, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, SleepStatus, StreamProfile, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, Reboot, RequestMediaStreamOptions, RequestPictureOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoClip, VideoClipOptions, VideoClips, VideoClipThumbnailOptions, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import path from 'path';
@@ -19,12 +19,13 @@ import { ReolinkPtzPresets } from "./presets";
 import {
     createRfc4571CompositeMediaObjectFromStreamManager,
     createRfc4571MediaObjectFromStreamManager,
-    expectedVideoTypeFromUrlMediaStreamOptions,
+    extractVariantFromStreamId,
     parseStreamProfileFromId,
     selectStreamOption,
-    StreamManager
+    StreamManager,
+    StreamManagerOptions
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingsToVideoClips, sanitizeFfmpegOutput, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, pirSuffix, recordingsToVideoClips, sanitizeFfmpegOutput, sirenSuffix, updateDeviceInfo } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -47,7 +48,7 @@ class ReolinkCameraSiren extends ScryptedDeviceBase implements OnOff {
             this.camera.getBaichuanLogger().log(`Siren toggle: turnOff ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOff failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOff failed (device=${this.nativeId})`, e?.message || String(e));
             throw e;
         }
     }
@@ -60,7 +61,7 @@ class ReolinkCameraSiren extends ScryptedDeviceBase implements OnOff {
             this.camera.getBaichuanLogger().log(`Siren toggle: turnOn ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOn failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Siren toggle: turnOn failed (device=${this.nativeId})`, e?.message || String(e));
             throw e;
         }
     }
@@ -79,7 +80,7 @@ class ReolinkCameraFloodlight extends ScryptedDeviceBase implements OnOff, Brigh
             this.camera.getBaichuanLogger().log(`Floodlight toggle: setBrightness ok (device=${this.nativeId} brightness=${brightness})`);
         }
         catch (e) {
-            this.camera.getBaichuanLogger().warn(`Floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`, e?.message || String(e));
             throw e;
         }
     }
@@ -92,7 +93,7 @@ class ReolinkCameraFloodlight extends ScryptedDeviceBase implements OnOff, Brigh
             this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOff ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOff failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOff failed (device=${this.nativeId})`, e?.message || String(e));
             throw e;
         }
     }
@@ -105,7 +106,7 @@ class ReolinkCameraFloodlight extends ScryptedDeviceBase implements OnOff, Brigh
             this.camera.getBaichuanLogger().log(`Floodlight toggle: turnOn ok (device=${this.nativeId})`);
         }
         catch (e) {
-            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOn failed (device=${this.nativeId})`, e);
+            this.camera.getBaichuanLogger().warn(`Floodlight toggle: turnOn failed (device=${this.nativeId})`, e?.message || String(e));
             throw e;
         }
     }
@@ -223,6 +224,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             hide: true,
             defaultValue: 0,
         },
+        variantType: {
+            type: 'string',
+            hide: true,
+            defaultValue: 'default',
+            choices: ['default', 'autotrack', 'telephoto'] as NativeVideoStreamVariant[],
+        },
         capabilities: {
             json: true,
             hide: true,
@@ -231,65 +238,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             json: true,
             hide: true,
         },
-        // Multifocal composite stream PIP settings
-        pipPosition: {
-            title: 'PIP Position',
-            description: 'Position of the tele lens overlay on the wider lens view',
-            type: 'string',
-            defaultValue: 'bottom-right',
-            choices: [
-                'top-left',
-                'top-right',
-                'bottom-left',
-                'bottom-right',
-                'center',
-                'top-center',
-                'bottom-center',
-                'left-center',
-                'right-center',
-            ],
-            hide: true, // Only show for multifocal devices via getAdditionalSettings
-        },
-        pipSize: {
-            title: 'PIP Size',
-            description: 'Relative size of the PIP overlay (0.1 = 10%, 0.3 = 30%, etc.)',
-            type: 'number',
-            defaultValue: 0.25,
-            hide: true,
-            onPut: async () => {
-                this.scheduleStreamManagerRestart('pipSize changed');
-            },
-        },
-        pipMargin: {
-            title: 'PIP Margin',
-            description: 'Margin from edge in pixels',
-            type: 'number',
-            defaultValue: 10,
-            hide: true,
-            onPut: async () => {
-                this.scheduleStreamManagerRestart('pipMargin changed');
-            },
-        },
-        widerChannel: {
-            title: 'Wider Channel',
-            description: 'Channel number for wider lens (typically 0)',
-            type: 'number',
-            defaultValue: 0,
-            hide: true,
-            onPut: async () => {
-                this.scheduleStreamManagerRestart('widerChannel changed');
-            },
-        },
-        teleChannel: {
-            title: 'Tele Channel',
-            description: 'Channel number for tele lens (typically 1)',
-            type: 'number',
-            defaultValue: 1,
-            hide: true,
-            onPut: async () => {
-                this.scheduleStreamManagerRestart('teleChannel changed');
-            },
-        },
         // Battery camera specific
         uid: {
             title: 'UID',
@@ -307,6 +255,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             choices: ['local-direct', 'local-broadcast', 'remote', 'map', 'relay'],
             defaultValue: 'local-direct',
             hide: true,
+            subgroup: 'Advanced',
             onPut: async () => {
                 await this.credentialsChanged();
             }
@@ -370,7 +319,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                             // Trigger reconnection
                             await this.ensureClient();
                         } catch (e) {
-                            logger.warn('Failed to reset client after debug logs change', e);
+                            logger.warn('Failed to reset client after debug logs change', e?.message || String(e));
                         }
                     }, 2000);
                 }
@@ -631,6 +580,48 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.runDiagnostics();
             },
         },
+        // Multifocal composite stream PIP settings
+        pipPosition: {
+            title: 'PIP Position',
+            description: 'Position of the tele lens overlay on the wider lens view',
+            type: 'string',
+            defaultValue: 'bottom-right',
+            group: 'Composite stream',
+            choices: [
+                'top-left',
+                'top-right',
+                'bottom-left',
+                'bottom-right',
+                'center',
+                'top-center',
+                'bottom-center',
+                'left-center',
+                'right-center',
+            ],
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
+        pipSize: {
+            title: 'PIP Size',
+            description: 'Relative size of the PIP overlay (0.1 = 10%, 0.3 = 30%, etc.)',
+            type: 'number',
+            defaultValue: 0.25,
+            group: 'Composite stream',
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipSize changed');
+            },
+        },
+        pipMargin: {
+            title: 'PIP Margin',
+            description: 'Margin from edge in pixels',
+            type: 'number',
+            defaultValue: 10,
+            group: 'Composite stream',
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipMargin changed');
+            },
+        },
     });
 
     ptzPresets = new ReolinkPtzPresets(this);
@@ -651,20 +642,19 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     // Video stream properties
     protected cachedVideoStreamOptions?: UrlMediaStreamOptions[];
-    protected fetchingStreams = false;
+    protected fetchingStreamsPromise: Promise<UrlMediaStreamOptions[]> | undefined;
     protected lastNetPortCacheAttempt: number = 0;
     protected netPortCacheBackoffMs: number = 5000; // 5 seconds backoff on failure
 
     // Client management (inherited from BaseBaichuanClass)
-    protected readonly protocol: BaichuanTransport;
     private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
-    // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
 
+    abstract reportDevices(): Promise<void>;
+
     motionTimeout?: NodeJS.Timeout;
     doorbellBinaryTimeout?: NodeJS.Timeout;
-    initComplete?: boolean;
     resetBaichuanClient?(reason?: any): Promise<void>;
 
     protected nvrDevice?: ReolinkNativeNvrDevice;
@@ -672,6 +662,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     thisDevice: Settings;
     isBattery: boolean;
     isMultiFocal: boolean;
+    isOnNvr: boolean;
+    protocol: BaichuanTransport;
     private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
     private videoClipsAutoLoadInterval: NodeJS.Timeout | undefined;
     private videoClipsAutoLoadInProgress: boolean = false;
@@ -682,7 +674,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         public plugin: ReolinkNativePlugin,
         public options: CommonCameraMixinOptions
     ) {
-        super(nativeId);
+        const isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
+        const transport = isBattery || !!options.nvrDevice ? 'udp' : 'tcp';
+        super(nativeId, transport);
         this.plugin.mixinsMap.set(this.id, this);
 
         // Store NVR device reference if provided
@@ -690,9 +684,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.multiFocalDevice = options.multiFocalDevice;
         this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
-        this.isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
+        this.isBattery = isBattery;
         this.isMultiFocal = options.type === 'multi-focal' || options.type === 'multi-focal-battery';
-        this.protocol = this.isBattery ? 'udp' : 'tcp';
+        this.isOnNvr = !!this.nvrDevice || !!this.multiFocalDevice?.nvrDevice;
+        this.protocol = transport;
 
         setTimeout(async () => {
             await this.parentInit();
@@ -1003,7 +998,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 return mo;
             }
         } catch (e) {
-            logger.error(`getVideoClip: failed to get video clip ${videoId}`, e);
+            logger.error(`getVideoClip: failed to get video clip ${videoId}`, e?.message || String(e));
             throw e;
         }
     }
@@ -1100,13 +1095,13 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await fs.promises.writeFile(cachePath, buffer);
                 logger.debug(`[Thumbnail] Cached: fileId=${thumbnailId}, size=${buffer.length} bytes`);
             } catch (e) {
-                logger.warn(`[Thumbnail] Failed to cache: fileId=${thumbnailId}`, e);
+                logger.warn(`[Thumbnail] Failed to cache: fileId=${thumbnailId}`, e?.message || String(e));
                 // Continue even if caching fails
             }
 
             return thumbnail;
         } catch (e) {
-            logger.error(`[Thumbnail] Error: fileId=${thumbnailId}`, e);
+            logger.error(`[Thumbnail] Error: fileId=${thumbnailId}`, e?.message || String(e));
             throw e;
         }
     }
@@ -1136,7 +1131,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 logger.debug(`[getVideoClipRtmpUrl] NVR getVodUrl Download URL received: url="${url || 'none'}"`);
                 if (url) return url;
             } catch (e: any) {
-                logger.error(`[getVideoClipRtmpUrl] getVodUrl Download failed: ${e.message}`);
+                logger.error(`[getVideoClipRtmpUrl] getVodUrl Download failed: ${e?.message || String(e)}`);
             }
 
             throw new Error(`No streaming URL found from NVR for file ${fileId} after trying Playback and Download methods`);
@@ -1271,7 +1266,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
             logger.log(`Completed auto-loading video clips and thumbnails`);
         } catch (e) {
-            logger.error('Error during auto-loading video clips:', e);
+            logger.error('Error during auto-loading video clips:', e?.message || String(e));
         } finally {
             this.videoClipsAutoLoadInProgress = false;
             this.videoClipsAutoLoadMode = false;
@@ -1279,7 +1274,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async reboot(): Promise<void> {
-        const api = await this.ensureBaichuanClient();
+        const api = await this.ensureClient();
         await api.reboot();
     }
 
@@ -1293,6 +1288,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             throw new Error('UID is required for battery cameras (BCUDP)');
         }
 
+        // Prevent accidental connections to localhost (Node will default host=127.0.0.1 when host is undefined).
+        // This shows up as connect ECONNREFUSED 127.0.0.1:9000 and will never recover with socket resets.
+        if (!this.isBattery && !ipAddress) {
+            throw new Error('IP Address is required for TCP devices');
+        }
+
         return {
             host: ipAddress,
             username,
@@ -1304,23 +1305,33 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         };
     }
 
+    protected getStreamClientInputs(): BaichuanConnectionConfig {
+        const { ipAddress, username, password } = this.storageSettings.values;
+        const debugOptions = this.getBaichuanDebugOptions();
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            transport: this.transport,
+            debugOptions,
+        };
+    }
+
     protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
         return {
-            onError: undefined, // Use default error handling
             onClose: async () => {
                 // Reset client state on close
                 // The base class already handles cleanup
                 // For battery cameras, don't auto-resubscribe after idle disconnects
                 // (idle disconnects are normal for battery cameras to save power)
-                // Events will be resubscribed when ensureClient() is called for actual operations
                 if (!this.isBattery) {
-                    // For non-battery cameras, resubscribe to events after reconnection
                     setTimeout(async () => {
                         try {
                             await this.subscribeToEvents();
                         } catch (e) {
                             const logger = this.getBaichuanLogger();
-                            logger.warn('Failed to resubscribe to events after reconnection', e);
+                            logger.warn('Failed to resubscribe to events after reconnection', e?.message || String(e));
                         }
                     }, 1000);
                 }
@@ -1339,8 +1350,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        return await fn();
-
         if (this.isBattery) {
             return await fn();
         } else {
@@ -1400,7 +1409,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.log(`Diagnostics file: ${result.diagnosticsPath}`);
             logger.log(`Streams directory: ${result.streamsDir}`);
         } catch (e) {
-            logger.error('Failed to run diagnostics', e);
+            logger.error('Failed to run diagnostics', e?.message || String(e));
             throw e;
         }
     }
@@ -1423,46 +1432,64 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
      * - For TCP devices (regular + multifocal), this creates a new TCP session with its own client.
      * - For UDP/battery devices, this reuses the existing client via ensureClient().
      */
-    async createStreamClient(profile?: StreamProfile): Promise<ReolinkBaichuanApi> {
-        // Battery / BCUDP path: reuse the main client to avoid extra wake-ups and sockets.
-        if (this.isBattery) {
-            return await this.ensureClient();
+    async createStreamClient(streamKey: string): Promise<ReolinkBaichuanApi> {
+        // Determine who should create the socket based on device hierarchy:
+        // 1. Camera of multifocal with nvrDevice -> nvrDevice creates the socket
+        // 2. Camera of multifocal (without nvrDevice) -> multiFocalDevice creates the socket
+        // 3. Camera of nvr -> nvrDevice creates the socket
+        // 4. Standalone camera -> camera creates its own socket (via base class)
+
+        // Case 1: Camera of multifocal with nvrDevice -> delegate to nvrDevice
+        if (this.multiFocalDevice?.nvrDevice) {
+            return await this.multiFocalDevice.nvrDevice.createStreamClient(streamKey);
         }
 
-        // For TCP path: create a new client ONLY for "ext" profile
-        // For other profiles (main, sub), reuse the main client
-        if (profile !== 'ext') {
-            return await this.ensureClient();
+        // Case 2: Camera of multifocal (without nvrDevice) -> delegate to multiFocalDevice
+        if (this.multiFocalDevice) {
+            return await this.multiFocalDevice.createStreamClient(streamKey);
         }
 
-        // TCP path with ext profile: create a separate session for streaming (RFC4571/composite/NVR-friendly).
-        const { ipAddress, username, password } = this.storageSettings.values;
-        const logger = this.getBaichuanLogger();
+        // Case 3: Camera of nvr -> delegate to nvrDevice
+        if (this.nvrDevice) {
+            return await this.nvrDevice.createStreamClient(streamKey);
+        }
 
-        const debugOptions = this.getBaichuanDebugOptions();
-        const api = await createBaichuanApi(
-            {
-                inputs: {
-                    host: ipAddress,
-                    username,
-                    password,
-                    logger,
-                    debugOptions,
-                },
-                transport: 'tcp',
-            },
-        );
+        // Case 4: Standalone camera -> create its own socket using base class method
+        // For battery cameras, reuse the main client
+        // if (this.isBattery) {
+        //     return await this.ensureClient();
+        // }
 
-        await api.login();
-        return api;
+        // For TCP standalone cameras, use base class createStreamClient which manages stream clients per streamKey
+        return await super.createStreamClient(streamKey);
     }
 
     public getAbilities(): DeviceCapabilities {
         if (this.multiFocalDevice) {
-            return this.multiFocalDevice.getInterfaces(this.storageSettings.values.rtspChannel).capabilities;
+            const variantType = this.storageSettings.values.variantType;
+            const ifaces = this.multiFocalDevice.getInterfaces(variantType);
+            if (ifaces?.capabilities) return ifaces.capabilities;
         } else {
-            return this.storageSettings.values.capabilities;
+            const caps = this.storageSettings.values.capabilities;
+            if (caps) return caps;
         }
+
+        // Safe fallback to avoid crashes during init when connection hasn't succeeded yet.
+        return {
+            channel: this.storageSettings.values.rtspChannel ?? 0,
+            ptzMode: 'none',
+            hasPan: false,
+            hasTilt: false,
+            hasZoom: false,
+            hasPresets: false,
+            hasPtz: false,
+            hasBattery: !!this.isBattery,
+            hasIntercom: false,
+            hasSiren: false,
+            hasFloodlight: false,
+            hasPir: false,
+            isDoorbell: false,
+        };
     }
 
     getBaichuanDebugOptions(): any | undefined {
@@ -1473,33 +1500,36 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     /**
      * Initialize or recreate the StreamManager, taking into account multifocal composite options.
      */
-    protected initStreamManager(logger: Console, forceRecreate: boolean = false): void {
+    protected initStreamManager(logger?: Console, forceRecreate: boolean = false): void {
         const { username, password } = this.storageSettings.values;
+        // Ensure logger is always valid - use provided logger or get from device, fallback to console
+        const validLogger = logger || this.getBaichuanLogger() || console;
 
-        const baseOptions: any = {
-            createStreamClient: (profile?: StreamProfile) => this.createStreamClient(profile),
-            getLogger: () => logger,
+        const baseOptions: StreamManagerOptions = {
+            createStreamClient: this.createStreamClient.bind(this),
+            logger: validLogger,
             credentials: {
                 username,
                 password,
             },
-            sharedConnection: this.isBattery,
+            sharedConnection: this.isBattery || !!this.nvrDevice,
         };
 
         if (this.isMultiFocal) {
-            const values: any = this.storageSettings.values;
-            const pipPosition = values.pipPosition || 'bottom-right';
-            const pipSize = values.pipSize ?? 0.25;
-            const pipMargin = values.pipMargin ?? 10;
-            const widerChannel = values.widerChannel ?? 0;
-            const teleChannel = values.teleChannel ?? 1;
+            const { pipPosition, pipSize, pipMargin, rtspChannel } = this.storageSettings.values;
+
+            // On NVR/Hub, TrackMix lenses are selected via stream variant, not via a separate channel.
+            // Use rtspChannel for BOTH wide and tele so the library can request tele via streamType/variant.
+            const wider = this.isOnNvr ? rtspChannel : undefined;
+            const tele = this.isOnNvr ? rtspChannel : undefined;
 
             baseOptions.compositeOptions = {
-                widerChannel,
-                teleChannel,
+                widerChannel: wider,
+                teleChannel: tele,
                 pipPosition,
                 pipSize,
                 pipMargin,
+                onNvr: this.isOnNvr,
             };
         }
 
@@ -1523,10 +1553,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         this.streamManagerRestartTimeout = setTimeout(async () => {
             this.streamManagerRestartTimeout = undefined;
-            const restartLogger = this.getBaichuanLogger();
+            const logger = this.getBaichuanLogger();
             try {
-                restartLogger.log('Restarting StreamManager due to PIP/composite settings change');
-                this.initStreamManager(restartLogger, true);
+                logger.log('Restarting StreamManager due to PIP/composite settings change');
+                this.initStreamManager(logger, true);
 
                 // Invalidate snapshot cache for battery/multifocal-battery so that
                 // the next snapshot reflects the new PIP/composite configuration.
@@ -1542,7 +1572,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                     // best-effort
                 }
             } catch (e) {
-                restartLogger.warn('Failed to restart StreamManager after settings change', e);
+                logger.warn('Failed to restart StreamManager after settings change', e);
             }
         }, 500);
     }
@@ -1598,6 +1628,29 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 return;
             }
 
+            // Handle battery/online/sleeping events separately from motion events
+            switch (ev?.type) {
+                case 'awake':
+                case 'sleeping':
+                    // Update sleeping state for battery cameras or devices that support it
+                    this.updateSleepingState({
+                        reason: ev?.type === 'sleeping' ? 'sleeping' : 'awake',
+                        state: ev.type === 'sleeping' ? 'sleeping' : 'awake',
+                    }).catch((e) => {
+                        logger.warn('Error updating sleeping state', e);
+                    });
+                    return; // These events are handled, no need to process as motion events
+                
+                case 'offline':
+                case 'online':
+                    // Update online state for battery cameras or devices that support it
+                    this.updateOnlineState(ev.type === 'online').catch((e) => {
+                        logger.warn('Error updating online state', e);
+                    });
+                    return; // These events are handled, no need to process as motion events
+            }
+
+            // Handle motion and object detection events
             const objects: string[] = [];
             let motion = false;
 
@@ -1632,11 +1685,21 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
+    /**
+     * Subscribe to Baichuan events only if this is a standalone device (not a child of NVR or MultiFocal).
+     * If this device has a parent (nvrDevice or multiFocalDevice), events will be forwarded from the parent.
+     * This ensures that only the root device in the hierarchy subscribes to events, avoiding duplicate subscriptions.
+     */
     async subscribeToEvents(): Promise<void> {
+        // If this device has a parent (NVR or MultiFocal), don't subscribe - events will be forwarded from parent
         if (this.nvrDevice || this.multiFocalDevice) {
+            const logger = this.getBaichuanLogger();
+            logger.debug(`Device has parent (nvrDevice=${!!this.nvrDevice}, multiFocalDevice=${!!this.multiFocalDevice}), skipping event subscription (events will be forwarded from parent)`);
             return;
         }
 
+        const api = await this.ensureClient();
+
         const logger = this.getBaichuanLogger();
         const selection = Array.from(this.getDispatchEventsSelection?.() ?? new Set()).sort();
         const enabled = selection.length > 0;
@@ -1661,8 +1724,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             return;
         }
 
-        const api = await this.ensureClient();
-
         try {
             await api.onSimpleEvent(this.onSimpleEvent);
             logger.log(`Subscribed to events (${selection.join(', ')}) on ${this.protocol} connection`);
@@ -1898,7 +1959,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.binaryState = false;
     }
 
-    async reportDevices(): Promise<void> {
+    async reportDevicesParent(): Promise<void> {
         const abilities = this.getAbilities();
 
         const { hasSiren, hasFloodlight, hasPir } = abilities;
@@ -1946,6 +2007,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 type: ScryptedDeviceType.Switch,
             };
             sdk.deviceManager.onDeviceDiscovered(device);
+
+            this.reportDevices && await this.reportDevices();
         }
     }
 
@@ -1959,15 +2022,42 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         await this.storageSettings.putSetting(key, value);
     }
 
+    async takePictureInternal(client: ReolinkBaichuanApi) {
+        const { rtspChannel, variantType } = this.storageSettings.values;
+        const logger = this.getBaichuanLogger();
+        logger.log(`Taking new snapshot from camera: forceNewSnapshot=${this.forceNewSnapshot} channel=${rtspChannel} variant=${variantType}`);
+
+        const compositeOptions = this.isMultiFocal ? {
+            widerChannel: this.isOnNvr ? rtspChannel : undefined,
+            teleChannel: this.isOnNvr ? rtspChannel : undefined,
+            pipPosition: this.storageSettings.values.pipPosition || 'bottom-right',
+            pipSize: this.storageSettings.values.pipSize ?? 0.25,
+            pipMargin: this.storageSettings.values.pipMargin ?? 10,
+            onNvr: this.isOnNvr,
+        } : undefined;
+
+        // For multifocal devices, request a composite snapshot by passing channel=undefined.
+        const channelArg = this.isMultiFocal ? undefined : rtspChannel;
+
+        const snapshotBuffer = await client.getSnapshot(
+            channelArg,
+            {
+                onNvr: this.isOnNvr,
+                variant: variantType,
+                ...(compositeOptions ? { compositeOptions } : {}),
+            }
+        );
+        const mo = await this.createMediaObject(snapshotBuffer, 'image/jpeg');
+
+        return mo;
+    }
+
     async takePicture(options?: RequestPictureOptions) {
         if (!this.isBattery) {
             try {
                 return this.withBaichuanRetry(async () => {
                     const client = await this.ensureClient();
-                    const snapshotBuffer = await client.getSnapshot(this.storageSettings.values.rtspChannel);
-                    const mo = await this.createMediaObject(snapshotBuffer, 'image/jpeg');
-
-                    return mo;
+                    return await this.takePictureInternal(client);
                 });
             } catch (e) {
                 this.getBaichuanLogger().error('Error taking snapshot', e);
@@ -1985,16 +2075,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             if (this.takePictureInFlight) {
                 return await this.takePictureInFlight;
             }
-
-            logger.log(`Taking new snapshot from camera (forceNewSnapshot: ${this.forceNewSnapshot})`);
             this.forceNewSnapshot = false;
 
             this.takePictureInFlight = (async () => {
-                const channel = this.storageSettings.values.rtspChannel;
-                const snapshotBuffer = await this.withBaichuanClient(async (api) => {
-                    return await api.getSnapshot(channel);
-                });
-                const mo = await sdk.mediaManager.createMediaObject(snapshotBuffer, 'image/jpeg');
+                const client = await this.ensureClient();
+                const mo = await this.takePictureInternal(client);
                 this.lastPicture = { mo, atMs: Date.now() };
                 logger.log(`Snapshot taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
                 return mo;
@@ -2231,71 +2316,153 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             return this.cachedVideoStreamOptions;
         }
 
-        if (this.fetchingStreams) {
-            return [];
+        // If there's already a fetch in progress, return the existing promise
+        if (this.fetchingStreamsPromise) {
+            return this.fetchingStreamsPromise;
         }
 
-        this.fetchingStreams = true;
+        // Create and save the promise
+        this.fetchingStreamsPromise = (async (): Promise<UrlMediaStreamOptions[]> => {
+            try {
+                let streams: UrlMediaStreamOptions[] = [];
 
-        let streams: UrlMediaStreamOptions[] = [];
+                const client = await this.ensureClient();
 
-        const client = await this.ensureClient();
+                const { rtspChannel, variantType } = this.storageSettings.values;
 
-        // For multifocal devices, use undefined channel to get composite streams
-        const isMultiFocal = this.options.type === 'multi-focal' || this.options.type === 'multi-focal-battery';
-        const channel = isMultiFocal ? undefined : this.storageSettings.values.rtspChannel;
+                try {
+                    // Lens-scoped behavior: request streams only for the current lens/variant.
+                    // This keeps a single native_main and native_sub for the device.
+                    const lensParam: NativeVideoStreamVariant | undefined = variantType as any;
+
+                    const { nativeStreams, rtmpStreams, rtspStreams } = await client.buildVideoStreamOptions({
+                        onNvr: this.isOnNvr,
+                        channel: rtspChannel,
+                        compositeOnly: this.isMultiFocal,
+                        ...(lensParam !== undefined ? { lens: lensParam } : {})
+                    });
 
-        try {
-            const { nativeStreams, rtmpStreams, rtspStreams } = await client.buildVideoStreamOptions(channel);
-
-            let supportedStreams: ReolinkSupportedStream[] = [];
-            // Homehub RTMP is not efficient, crashes, offers native streams to not overload the hub
-            // if (this.nvrDevice && this.nvrDevice.info.model === 'HOMEHUB') {
-            supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
-            // } else {
-            //     supportedStreams = [...rtspStreams, ...rtmpStreams, ...nativeStreams];
-            // }
-
-            for (const supportedStream of supportedStreams) {
-                const { id, metadata, url, name, container } = supportedStream;
-
-                const codec = String(metadata.videoEncType || "").includes("264")
-                    ? "h264"
-                    : String(metadata.videoEncType || "").includes("265")
-                        ? "h265"
-                        : String(metadata.videoEncType || "").toLowerCase();
-
-                streams.push({
-                    id,
-                    name,
-                    url,
-                    container,
-                    video: { codec, width: metadata.width, height: metadata.height },
-                    // audio: { codec: metadata.audioCodec }
-                })
-            }
-        } catch (e) {
-            if (!this.isRecoverableBaichuanError?.(e)) {
-                logger.warn('Failed to build RTSP/RTMP stream options, falling back to Native', e);
-            }
-        }
+                    // const urls = client.getRtspUrl(rtspChannel);
+
+                    // let supportedStreams: ReolinkSupportedStream[] = [];
+                    const supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
+                    // logger.log({ supportedStreams, variantType, lensParam, rtspChannel, onNvr: this.isOnNvr, nativeStreams: nativeStreams.map(s => ({ id: s.id, nativeVariant: s.nativeVariant, lens: s.lens })), rtspStreams: rtspStreams.map(s => ({ id: s.id, lens: s.lens })), rtmpStreams: rtmpStreams.map(s => ({ id: s.id, lens: s.lens })) });
+
+                    for (const supportedStream of supportedStreams) {
+                        const { id, metadata, url, name, container, nativeVariant, lens } = supportedStream;
+
+                        // Composite streams are re-encoded to H.264 by the library (ffmpeg/libx264).
+                        // Do not infer codec from underlying camera metadata.
+                        const isComposite = id.startsWith('composite_') || lens === 'composite';
+                        const codec = isComposite
+                            ? 'h264'
+                            : String(metadata.videoEncType || "").includes("264")
+                                ? "h264"
+                                : String(metadata.videoEncType || "").includes("265")
+                                    ? "h265"
+                                    : String(metadata.videoEncType || "").toLowerCase();
+
+                        // Preserve variant information for native RTP streams by ensuring the URL contains it.
+                        let finalUrl = url;
+                        const variantFromIdOrUrl = extractVariantFromStreamId(id, url);
+                        const variantToInject = (nativeVariant && nativeVariant !== 'default')
+                            ? nativeVariant
+                            : variantFromIdOrUrl;
+
+                        if (variantToInject && container === 'rtp') {
+                            try {
+                                const urlObj = new URL(url);
+                                if (!urlObj.searchParams.has('variant')) {
+                                    urlObj.searchParams.set('variant', variantToInject);
+                                    finalUrl = urlObj.toString();
+                                }
+                            } catch {
+                                // Invalid URL, use original
+                            }
+                        }
 
-        if (streams.length) {
-            logger.log('Fetched video stream options', streams.map((s) => s.name).join(', '));
-            logger.debug(JSON.stringify(streams));
-            this.cachedVideoStreamOptions = streams;
-            return streams;
-        }
+                        streams.push({
+                            id,
+                            name,
+                            url: finalUrl,
+                            container,
+                            video: { codec, width: metadata.width, height: metadata.height },
+                            // audio: { codec: metadata.audioCodec }
+                        })
+                    }
+                } catch (e) {
+                    if (!this.isRecoverableBaichuanError?.(e)) {
+                        logger.warn('Failed to build RTSP/RTMP stream options, falling back to Native', e?.message || String(e));
+                    }
+                }
+
+                if (streams.length) {
+                    logger.log('Fetched video stream options', streams.map((s) => s.name).join(', '));
+                    logger.debug(JSON.stringify(streams));
+                    this.cachedVideoStreamOptions = streams;
+                    return streams;
+                }
 
-        this.fetchingStreams = false;
+                return [];
+            } finally {
+                // Always clear the promise when done (success or failure)
+                this.fetchingStreamsPromise = undefined;
+            }
+        })();
+
+        return this.fetchingStreamsPromise;
     }
 
     async getVideoStream(vso: RequestMediaStreamOptions): Promise<MediaObject> {
         if (!vso) throw new Error("video streams not set up or no longer exists.");
 
         const vsos = await this.getVideoStreamOptions();
+        const logger = this.getBaichuanLogger();
+
+        logger.debug(`Available streams: ${vsos?.map(s => s.id).join(', ') || 'none'}`);
+        logger.debug(`Requested stream ID: '${vso?.id}'`);
+
         const selected = selectStreamOption(vsos, vso);
 
+        // If the request explicitly asks for a variant (e.g. native_telephoto_main),
+        // never override it with the device's variantType preference.
+        // const requestedVariant = vso?.id ? extractVariantFromStreamId(vso.id, undefined) : undefined;
+
+        // If we have variantType set and the selected stream doesn't have the variant,
+        // try to find a stream with the correct variant that matches the profile
+        // const variantType = this.storageSettings.values.variantType;
+        // if (!requestedVariant && variantType && variantType !== 'default') {
+        //     const profile = parseStreamProfileFromId(selected.id) || 'main';
+
+        //     // On NVR, firmwares vary: some expose the tele lens as 'autotrack', others as 'telephoto'.
+        //     // When variantType is set, prefer that variant but fall back to the other tele variant if present.
+        //     const preferred = variantType as 'autotrack' | 'telephoto';
+        //     const fallbacks: Array<'autotrack' | 'telephoto'> = this.isOnNvr && preferred === 'telephoto'
+        //         ? ['telephoto', 'autotrack']
+        //         : this.isOnNvr && preferred === 'autotrack'
+        //             ? ['autotrack', 'telephoto']
+        //             : [preferred];
+
+        //     const extractedVariant = extractVariantFromStreamId(selected.id, selected.url);
+        //     for (const v of fallbacks) {
+        //         const variantId = `native_${v}_${profile}`;
+        //         const variantStream = vsos?.find(s => s.id === variantId);
+        //         if (!variantStream) {
+        //             logger.debug(`Variant stream '${variantId}' not found in available streams`);
+        //             continue;
+        //         }
+        //         // Only use variant stream if the selected one doesn't already have a variant,
+        //         // or if the selected one has a different variant than what we want.
+        //         if (!extractedVariant || extractedVariant !== v) {
+        //             logger.log(`Preferring variant stream: '${variantId}' over '${selected.id}' (variantType='${variantType}')`);
+        //             selected = variantStream;
+        //         }
+        //         break;
+        //     }
+        // }
+
+        logger.log(`Selected stream: id='${selected.id}', url='${selected.url}'`);
+
         if (selected.url && (selected.container === 'rtsp' || selected.container === 'rtmp')) {
             const urlWithCredentials = this.addRtspCredentials(selected.url);
             const ret: MediaStreamUrl = {
@@ -2311,20 +2478,25 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         // Check if this is a composite stream request (for multifocal devices)
-        const isComposite = selected.id?.startsWith('composite_');
-        if (isComposite && this.options && (this.options.type === 'multi-focal' || this.options.type === 'multi-focal-battery')) {
+        // const isComposite = selected.id?.startsWith('composite_');
+        // if (isComposite && this.options && (this.options.type === 'multi-focal' || this.options.type === 'multi-focal-battery')) {
+        if (selected.id?.startsWith('composite_')) {
             const profile = parseStreamProfileFromId(selected.id.replace('composite_', '')) || 'main';
-            const streamKey = `composite_${profile}`;
-            const expectedVideoType = expectedVideoTypeFromUrlMediaStreamOptions(selected);
+            // Include variantType in streamKey to ensure each variantType has its own unique socket
+            // This is important for multifocal devices where different variantTypes may request composite streams
+            const variantType = this.storageSettings.values.variantType || 'default';
+            const streamKey = `composite_${variantType}_${profile}`;
+
+            logger.log(`Creating composite stream: profile=${profile}, variantType=${variantType}, streamKey=${streamKey}`);
 
             const createStreamFn = async () => {
                 return await createRfc4571CompositeMediaObjectFromStreamManager({
-                    streamManager: this.streamManager!,
+                    streamManager: this.streamManager,
                     profile,
                     streamKey,
-                    expectedVideoType,
                     selected,
                     sourceId: this.id,
+                    variantType,
                 });
             };
 
@@ -2334,28 +2506,34 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         // Regular stream for single channel
         const profile = parseStreamProfileFromId(selected.id) || 'main';
         const channel = this.storageSettings.values.rtspChannel;
-        const streamKey = `${channel}_${profile}`;
-        const expectedVideoType = expectedVideoTypeFromUrlMediaStreamOptions(selected);
+        // Extract variant from stream ID or URL if present (e.g., "autotrack" from "native_autotrack_main" or "?variant=autotrack")
+        let variant = extractVariantFromStreamId(selected.id, selected.url);
+
+        // Fallback: if no variant found in stream ID/URL, use variantType from device settings
+        // This is important for multi-focal devices where the device has a variantType setting
+        if (!variant && this.storageSettings.values.variantType && this.storageSettings.values.variantType !== 'default') {
+            variant = this.storageSettings.values.variantType as 'autotrack' | 'telephoto';
+            logger.log(`Using variant from device settings: '${variant}' (not found in stream ID/URL)`);
+        }
+
+        logger.log(`Stream selection: id='${selected.id}', profile='${profile}', channel=${channel}, variant='${variant || 'default'}'`);
+
+        // Include variant in streamKey to distinguish streams with different variants
+        const streamKey = variant ? `${channel}_${variant}_${profile}` : `${channel}_${profile}`;
 
         const createStreamFn = async () => {
+            // Honor the requested variant. Some NVR firmwares label the tele lens as either
+            // 'autotrack' or 'telephoto', and the library exposes both when available.
+            logger.log(`Creating RFC4571 stream: channel=${channel}, profile=${profile}, variant=${variant || 'default'}, streamKey=${streamKey}`);
+
             return await createRfc4571MediaObjectFromStreamManager({
                 streamManager: this.streamManager!,
                 channel,
                 profile,
                 streamKey,
-                expectedVideoType,
+                variant,
                 selected,
                 sourceId: this.id,
-                // onDetectedCodec: (detectedCodec) => {
-                //     const prev = this.cachedVideoStreamOptions ?? [];
-                //     const next = prev.filter((s) => s.id !== nativeId);
-                //     next.push({
-                //         container: 'rtp',
-                //         video: { codec: detectedCodec },
-                //         url: ``
-                //     });
-                //     this.cachedVideoStreamOptions = next;
-                // },
             });
         };
 
@@ -2364,10 +2542,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     async ensureClient(): Promise<ReolinkBaichuanApi> {
         if (this.nvrDevice) {
-            return await this.nvrDevice.ensureBaichuanClient();
+            return await this.nvrDevice.ensureClient();
         }
         if (this.multiFocalDevice) {
-            return await this.multiFocalDevice.ensureBaichuanClient();
+            return await this.multiFocalDevice.ensureClient();
         }
 
         // Use base class implementation
@@ -2426,16 +2604,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await sdk.deviceManager.onDeviceDiscovered(device);
 
                 logger.log(`Device interfaces updated`);
+                logger.debug(JSON.stringify({ hasNvr: !!this.nvrDevice, hasMultiFocal: !!this.multiFocalDevice, hasPlugin: !!this.plugin }));
                 logger.debug(`${JSON.stringify(device)}`);
             } catch (e) {
-                logger.error('Failed to update device interfaces', e);
+                logger.error('Failed to update device interfaces', e?.message || String(e));
             }
 
-            logger.log(`Refreshed device capabilities: ${JSON.stringify(capabilities)}`);
-            logger.debug(`Refreshed device capabilities: ${JSON.stringify({ abilities, support, presets, objects })}`);
+            logger.log(`Refreshed device capabilities`);
+            logger.debug(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets, objects })}`);
         }
         catch (e) {
-            logger.error('Failed to refresh abilities', e);
+            logger.error('Failed to refresh abilities', e?.message || String(e));
         }
 
         this.refreshingState = false;
@@ -2444,23 +2623,27 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     async parentInit(): Promise<void> {
         const logger = this.getBaichuanLogger();
 
+        this.init && await this.init();
+
         try {
             await this.ensureClient();
             await this.updateDeviceInfo();
         }
         catch (e) {
-            logger.warn('Failed to update device info during init', e);
+            logger.warn('Failed to update device info during init', e?.message || String(e));
         }
 
+        await this.refreshDeviceState();
+
         if (!this.multiFocalDevice) {
             try {
-                await this.refreshDeviceState();
                 await this.reportDevices();
             }
             catch (e) {
-                logger.warn('Failed to connect/refresh during init', e);
+                logger.warn('Failed to connect/refresh during init', e?.message || String(e));
             }
         }
+
         this.storageSettings.settings.socketApiDebugLogs.hide = !!this.nvrDevice;
         this.storageSettings.settings.clipsSource.hide = !this.nvrDevice;
         this.storageSettings.settings.clipsSource.defaultValue = this.nvrDevice ? "NVR" : "Device";
@@ -2475,10 +2658,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.storageSettings.settings.pipPosition.hide = !this.isMultiFocal;
         this.storageSettings.settings.pipSize.hide = !this.isMultiFocal;
         this.storageSettings.settings.pipMargin.hide = !this.isMultiFocal;
-        this.storageSettings.settings.widerChannel.hide = !this.isMultiFocal;
-        this.storageSettings.settings.teleChannel.hide = !this.isMultiFocal;
 
-        this.storageSettings.settings.uid.hide = !this.isBattery;
+        this.storageSettings.settings.uid.hide = !this.isBattery
         this.storageSettings.settings.discoveryMethod.hide = !this.isBattery && !this.nvrDevice;
 
         if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
@@ -2492,7 +2673,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 }
             }
             catch (e) {
-                logger.warn('Failed to setup mixins during init', e);
+                logger.warn('Failed to setup mixins during init', e?.message || String(e));
             }
         }
 
@@ -2503,8 +2684,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
-        // Initialize StreamManager (with composite options for multifocal devices)
-        this.initStreamManager(logger);
+        try {
+            this.initStreamManager();
+        }
+        catch (e) {
+            logger.warn('Failed to initialize StreamManager', e);
+        }
 
         const { hasIntercom, hasPtz } = this.getAbilities();
 
@@ -2529,23 +2714,69 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             this.updatePtzCaps();
         }
 
-        if (this.nvrDevice || this.multiFocalDevice) {
+        const parentDevice = this.nvrDevice || this.multiFocalDevice;
+        if (parentDevice) {
             this.storageSettings.settings.username.hide = true;
             this.storageSettings.settings.password.hide = true;
             this.storageSettings.settings.ipAddress.hide = true;
 
-            this.storageSettings.settings.username.defaultValue = this.nvrDevice.storageSettings.values.username;
-            this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
-            this.storageSettings.settings.ipAddress.defaultValue = this.nvrDevice.storageSettings.values.ipAddress;
+            this.storageSettings.settings.username.defaultValue = parentDevice.storageSettings.values.username;
+            this.storageSettings.settings.password.defaultValue = parentDevice.storageSettings.values.password;
+            this.storageSettings.settings.ipAddress.defaultValue = parentDevice.storageSettings.values.ipAddress;
         }
 
-        await this.init();
+        this.updateVideoClipsAutoLoad();
 
-        this.initComplete = true;
+        this.onDeviceEvent(ScryptedInterface.Settings, '');
+    }
 
-        // Initialize video clips auto-load if enabled
-        this.updateVideoClipsAutoLoad();
+    async updateSleepingState(sleepStatus: SleepStatus): Promise<void> {
+        try {
+            if (this.isDebugEnabled()) {
+                this.getBaichuanLogger().debug('getSleepStatus result:', JSON.stringify(sleepStatus));
+            }
+
+            if (sleepStatus.state === 'sleeping') {
+                if (!this.sleeping) {
+                    this.getBaichuanLogger().log(`Camera is sleeping: ${sleepStatus.reason}`);
+                    this.sleeping = true;
+                }
+            } else if (sleepStatus.state === 'awake') {
+                // Camera is awake
+                const wasSleeping = this.sleeping;
+                if (wasSleeping) {
+                    this.getBaichuanLogger().log(`Camera woke up: ${sleepStatus.reason}`);
+                    this.sleeping = false;
+                }
+
+                if (wasSleeping) {
+                    this.alignAuxDevicesState().catch(() => { });
+                    if (this.forceNewSnapshot) {
+                        this.takePicture().catch(() => { });
+                    }
+                }
+            } else {
+                // Unknown state
+                this.getBaichuanLogger().debug(`Sleep status unknown: ${sleepStatus.reason}`);
+            }
+        } catch (e) {
+            // Silently ignore errors in sleep check to avoid spam
+            this.getBaichuanLogger().debug('Error in updateSleepingState:', e);
+        }
     }
-}
 
+    async updateOnlineState(isOnline: boolean): Promise<void> {
+        try {
+            if (this.isDebugEnabled()) {
+                this.getBaichuanLogger().debug('updateOnlineState result:', isOnline);
+            }
 
+            if (isOnline !== this.online) {
+                this.online = isOnline;
+            }
+        } catch (e) {
+            // Silently ignore errors in sleep check to avoid spam
+            this.getBaichuanLogger().debug('Error in updateOnlineState:', e);
+        }
+    }
+}