@apocaliss92/scrypted-reolink-native 0.2.0 → 0.2.1

package/src/nvr.ts

@@ -1,18 +1,16 @@
-import type { EventsResponse, NativeVideoStreamVariant, ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent, StreamProfile } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { AdoptDevice, Device, DeviceDiscovery, DeviceProvider, DiscoveredDevice, Reboot, ScryptedDeviceType, ScryptedInterface, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
-import { ReolinkNativeCamera } from "./camera";
-import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { CommonCameraMixin } from "./common";
+import { ReolinkCamera } from "./camera";
 import { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import ReolinkNativePlugin from "./main";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, updateDeviceInfo } from "./utils";
-import { createBaichuanApi } from "./connect";
-import { parseStreamProfileFromId } from "./stream-utils";
 
 export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
+    private readonly onSimpleEventBound = (ev: ReolinkSimpleEvent) => this.onSimpleEvent(ev);
+
     storageSettings = new StorageSettings(this, {
         debugLogs: {
             title: 'Debug Events',
@@ -82,14 +80,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                         this.debugLogsResetTimeout = undefined;
                     }
 
-                    // Defer reset by 2 seconds to allow settings to settle
                     this.debugLogsResetTimeout = setTimeout(async () => {
                         this.debugLogsResetTimeout = undefined;
                         try {
-                            // Force reconnection with new debug options
                             this.baichuanApi = undefined;
                             this.ensureClientPromise = undefined;
-                            // Trigger reconnection
                             await this.ensureBaichuanClient();
                         } catch (e) {
                             logger.warn('Failed to reset client after debug logs change', e?.message || String(e));
@@ -106,7 +101,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         rtspChannel: number;
         deviceData: ReolinkBaichuanDeviceSummary;
     }>();
-    cameraNativeMap = new Map<string, CommonCameraMixin>();
+    cameraNativeMap = new Map<string, ReolinkCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
@@ -169,12 +164,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             onClose: async () => {
                 await this.reinit();
             },
-            onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
+            onSimpleEvent: this.onSimpleEventBound,
             getEventSubscriptionEnabled: () => true,
-            // getEventSubscriptionEnabled: () => {
-            //     const eventSource = this.storageSettings.values.eventSource || 'Native';
-            //     return eventSource === 'Native';
-            // },
         };
     }
 
@@ -187,7 +178,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     protected async onBeforeCleanup(): Promise<void> {
-        await this.unsubscribeFromAllEvents();
+        await this.unsubscribeFromEvents();
     }
 
     async reinit() {
@@ -196,7 +187,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             this.initReinitTimeout = undefined;
         }
 
-        // Schedule reinit with debounce
         this.scheduleInit(true);
     }
 
@@ -215,24 +205,12 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }, isReinit ? 500 : 2000);
     }
 
-    /**
-     * Forward events received from Baichuan to the appropriate child device (Camera or MultiFocal).
-     * This ensures that only NVR (root device) subscribes to events, and events are forwarded down the hierarchy:
-     * - NVR → MultiFocal → Camera
-     * - NVR → Camera (directly)
-     */
-    private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
+    onSimpleEvent(ev: ReolinkSimpleEvent) {
         const logger = this.getBaichuanLogger();
 
-        // const eventSource = this.storageSettings.values.eventSource || 'Native';
-        // if (eventSource !== 'Native') {
-        //     return;
-        // }
-
         try {
-            logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
+            logger.debug(`Baichuan event on nvr: ${JSON.stringify(ev)}`);
 
-            // Find device (camera or multifocal) for this channel
             const channel = ev?.channel;
             if (channel === undefined) {
                 logger.error('Event has no channel, ignoring');
@@ -247,69 +225,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 return;
             }
 
-            // If target is a MultiFocal device, forward the event to it (it will forward to its camera children)
-            if (targetDevice instanceof ReolinkNativeMultiFocalDevice) {
-                targetDevice.forwardNativeEvent(ev);
-                return;
-            }
-
-            // Convert event to camera's processEvents format
-            const objects: string[] = [];
-            let motion = false;
-            let isSleepingEvent = false;
-            let isOnlineEvent = false;
-
-            switch (ev?.type) {
-                case 'motion':
-                    motion = true;
-                    break;
-                case 'doorbell':
-                    // Handle doorbell if camera supports it
-                    try {
-                        targetDevice.handleDoorbellEvent();
-                    }
-                    catch (e) {
-                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e?.message || String(e));
-                    }
-                    motion = true;
-                    break;
-                case 'people':
-                case 'vehicle':
-                case 'animal':
-                case 'face':
-                case 'package':
-                case 'other':
-                    objects.push(ev.type);
-                    motion = true;
-                    break;
-                case 'awake':
-                case 'sleeping':
-                    isSleepingEvent = true;
-                    break;
-                case 'offline':
-                case 'online':
-                    isOnlineEvent = true;
-                    break;
-                default:
-                    logger.error(`Unknown event type: ${ev?.type}`);
-                    return;
-            }
-
-            if (isSleepingEvent) {
-                targetDevice.updateSleepingState({
-                    reason: 'NVR',
-                    state: ev.type === 'sleeping' ? 'sleeping' : 'awake',
-                }).catch(() => { });
-            } else if (isOnlineEvent) {
-                (targetDevice as ReolinkNativeBatteryCamera).updateOnlineState(
-                    ev.type === 'online' ? true : false
-                ).catch(() => { });
-            } else {
-                // Process events on the target camera
-                targetDevice.processEvents({ motion, objects }).catch((e) => {
-                    logger.warn(`Error processing events for camera channel ${channel}`, e?.message || String(e));
-                });
-            }
+            targetDevice.onSimpleEvent(ev);
         }
         catch (e) {
             logger.warn('Error in NVR Native event forwarder', e?.message || String(e));
@@ -324,16 +240,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         return await this.ensureBaichuanClient();
     }
 
-    // async subscribeToAllEvents(): Promise<void> {
-    // const eventSource = this.storageSettings.values.eventSource || 'Native';
-
-    // if (eventSource !== 'Native') {
-    // await this.unsubscribeFromAllEvents();
-    // } else {
-    // await super.subscribeToEvents();
-    // }
-    // }
-
     private async runNvrDiagnostics(): Promise<void> {
         const logger = this.getBaichuanLogger();
         logger.log(`Starting NVR diagnostics...`);
@@ -350,96 +256,12 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }
     }
 
-    async unsubscribeFromAllEvents(): Promise<void> {
-        // Use base class implementation
-        await super.unsubscribeFromEvents();
-    }
-
-    /**
-     * Reinitialize event subscriptions based on selected event source
-     */
-    // private async reinitEventSubscriptions(): Promise<void> {
-    //     const logger = this.getBaichuanLogger();
-    // const { eventSource } = this.storageSettings.values;
-
-    // // Unsubscribe from Native events if switching away
-    // if (eventSource !== 'Native') {
-    //     await this.unsubscribeFromAllEvents();
-    // } else {
-    // this.subscribeToAllEvents().catch((e) => {
-    //     logger.warn('Failed to subscribe to Native events', e?.message || String(e));
-    // });
-    // }
-
-    // logger.log(`Event source set to: ${eventSource}`);
-    // }
-
-    /**
-     * Forward events from CGI source to cameras
-     */
-    // private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
-    //     const logger = this.getBaichuanLogger();
-
-    //     logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
-
-    //     // Use channel map for efficient lookup
-    //     for (const [channel, nativeId] of this.channelToNativeIdMap.entries()) {
-    //         const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
-    //         const cameraEventsData = eventsRes[channel];
-    //         if (cameraEventsData && targetCamera) {
-    //             targetCamera.processEvents(cameraEventsData);
-    //         }
-    //     }
-    // }
-
     async init() {
-        // const logger = this.getBaichuanLogger();
         await this.ensureBaichuanClient();
-
-        await this.updateDeviceInfo();
         await this.subscribeToEvents();
+        await this.discoverDevices(true);
 
-        // await this.reinitEventSubscriptions();
-
-        // setInterval(async () => {
-        //     if (this.processing) {
-        //         return;
-        //     }
-        //     this.processing = true;
-        //     try {
-        //         const api = await this.ensureBaichuanClient();
-
-        // const { eventSource } = this.storageSettings.values;
-
-        // if (eventSource === 'CGI') {
-        //     const eventsRes = await api.getAllChannelsEvents();
-        //     this.forwardCgiEvents(eventsRes.parsed);
-
-        //     const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
-
-        //     logger.debug(`Battery info call result: ${JSON.stringify({ batteryInfoData, response })}`);
-
-        //     this.cameraNativeMap.forEach((camera) => {
-        //         if (camera) {
-        //             const channel = camera.storageSettings.values.rtspChannel;
-        //             const cameraBatteryData = batteryInfoData[channel];
-        //             if (cameraBatteryData) {
-        //                 camera.updateSleepingState({
-        //                     reason: 'NVR',
-        //                     state: cameraBatteryData.sleeping ? 'sleeping' : 'awake',
-        //                     idleMs: 0,
-        //                     lastRxAtMs: 0,
-        //                 }).catch(() => { });
-        //             }
-        //         }
-        //     });
-        // }
-        //         } catch (e) {
-        //             logger.error('Error on events flow', e?.message || String(e));
-        //         } finally {
-        //             this.processing = false;
-        //         }
-        //     }, 1000);
+        await this.updateDeviceInfo();
     }
 
     async updateDeviceInfo(): Promise<void> {
@@ -474,18 +296,18 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         this.cameraNativeMap.delete(nativeId);
     }
 
-    async getDevice(nativeId: string): Promise<CommonCameraMixin> {
+    async getDevice(nativeId: string): Promise<ReolinkCamera> {
         let device = this.cameraNativeMap.get(nativeId);
 
         if (!device) {
             if (nativeId.endsWith(batteryCameraSuffix)) {
-                device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, this);
+                device = new ReolinkCamera(nativeId, this.plugin, { type: 'battery', nvrDevice: this });
             } else if (nativeId.endsWith(batteryMultifocalSuffix)) {
                 device = new ReolinkNativeMultiFocalDevice(nativeId, this.plugin, "multi-focal-battery", this);
             } else if (nativeId.endsWith(multifocalSuffix)) {
                 device = new ReolinkNativeMultiFocalDevice(nativeId, this.plugin, "multi-focal", this);
             } else {
-                device = new ReolinkNativeCamera(nativeId, this.plugin, this);
+                device = new ReolinkCamera(nativeId, this.plugin, { type: 'regular', nvrDevice: this });
             }
 
             if (device) {
@@ -529,6 +351,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         if (!channels.length) {
             logger.debug(`No channels found, ${JSON.stringify({ channels, devices })}`);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            await this.syncEntitiesFromRemote();
             return;
         }
 

package/src/presets.ts

@@ -1,5 +1,5 @@
 import type { PtzPreset } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import type { CommonCameraMixin } from "./common";
+import type { ReolinkCamera } from "./camera";
 
 export type PtzCapabilitiesShape = {
     presets?: Record<string, string>;
@@ -7,7 +7,7 @@ export type PtzCapabilitiesShape = {
 };
 
 export class ReolinkPtzPresets {
-    constructor(private camera: CommonCameraMixin & { ptzCapabilities?: any }) { }
+    constructor(private camera: ReolinkCamera & { ptzCapabilities?: any }) { }
 
     private get storageSettings() {
         return this.camera.storageSettings;

package/src/utils.ts

@@ -7,7 +7,7 @@ import https from "https";
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
-import { CommonCameraMixin } from "./common";
+import { ReolinkCamera } from "./camera";
 /**
  * Sanitize FFmpeg output or URLs to avoid leaking credentials
  */
@@ -135,7 +135,6 @@ export const updateDeviceInfo = async (props: {
 
         throw e;
     } finally {
-
         logger.log(`Device info updated`);
         logger.debug(`${JSON.stringify({ newInfo: device.info, deviceData })}`);
     }
@@ -443,7 +442,7 @@ export async function extractThumbnailFromVideo(props: {
     fileId: string;
     deviceId: string;
     logger?: Console;
-    device?: CommonCameraMixin;
+    device?: ReolinkCamera;
 }): Promise<MediaObject> {
     const { rtmpUrl, filePath, fileId, deviceId, device } = props;
     // Use device logger if available, otherwise fallback to provided logger
@@ -489,7 +488,7 @@ function getVideoClipCachePath(deviceId: string, fileId: string): string {
  * Checks cache first, then proxies RTMP stream if not cached
  */
 export async function handleVideoClipRequest(props: {
-    device: CommonCameraMixin;
+    device: ReolinkCamera;
     deviceId: string;
     fileId: string;
     request: HttpRequest;

package/src/camera-battery.ts

@@ -1,283 +0,0 @@
-import {
-    CommonCameraMixin,
-} from "./common";
-import type ReolinkNativePlugin from "./main";
-import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
-import { ReolinkNativeNvrDevice } from "./nvr";
-
-export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
-    doorbellBinaryTimeout?: NodeJS.Timeout;
-    motionDetected: boolean = false;
-    motionTimeout: NodeJS.Timeout | undefined;
-    private periodicStarted = false;
-    private sleepCheckTimer: NodeJS.Timeout | undefined;
-    private batteryUpdateTimer: NodeJS.Timeout | undefined;
-    private lastBatteryLevel: number | undefined;
-    private batteryUpdateInProgress: boolean = false;
-
-    constructor(
-        nativeId: string,
-        public plugin: ReolinkNativePlugin,
-        nvrDevice?: ReolinkNativeNvrDevice,
-        multiFocalDevice?: ReolinkNativeMultiFocalDevice
-    ) {
-        super(nativeId, plugin, {
-            type: 'battery',
-            nvrDevice,
-            multiFocalDevice,
-        });
-    }
-
-    async init(): Promise<void> {
-        this.startPeriodicTasks();
-        await this.alignAuxDevicesState();
-        await this.updateBatteryInfo();
-    }
-
-    async release(): Promise<void> {
-        this.stopPeriodicTasks();
-        return this.resetBaichuanClient();
-    }
-
-    async reportDevices(): Promise<void> {
-        // Do nothing
-    }
-
-    private stopPeriodicTasks(): void {
-        if (this.sleepCheckTimer) {
-            clearInterval(this.sleepCheckTimer);
-            this.sleepCheckTimer = undefined;
-        }
-        if (this.batteryUpdateTimer) {
-            clearInterval(this.batteryUpdateTimer);
-            this.batteryUpdateTimer = undefined;
-        }
-        this.periodicStarted = false;
-    }
-
-    private startPeriodicTasks(): void {
-        if (this.periodicStarted) return;
-        const logger = this.getBaichuanLogger();
-        this.periodicStarted = true;
-
-        logger.log('Starting periodic tasks for battery camera');
-
-        if (!this.nvrDevice && !this.multiFocalDevice) {
-            this.sleepCheckTimer = setInterval(async () => {
-                try {
-                    const api = this.baichuanApi;
-                    const channel = this.storageSettings.values.rtspChannel;
-
-                    if (!api) {
-                        if (!this.sleeping) {
-                            logger.log('Camera is sleeping: no active Baichuan client');
-                            this.sleeping = true;
-                        }
-                        return;
-                    }
-
-                    const sleepStatus = api.getSleepStatus({ channel });
-                    await this.updateSleepingState(sleepStatus);
-                } catch (e) {
-                    logger.warn('Error checking sleeping state:', e);
-                }
-            }, 5_000);
-        }
-
-        // Update battery and snapshot every N minutes
-        const { batteryUpdateIntervalMinutes = 10 } = this.storageSettings.values;
-        const updateIntervalMs = batteryUpdateIntervalMinutes * 60_000;
-        this.batteryUpdateTimer = setInterval(() => {
-            this.updateBatteryAndSnapshot().catch(() => { });
-        }, updateIntervalMs);
-
-        logger.log(`Periodic tasks started: sleep check every 5s, battery update every ${batteryUpdateIntervalMinutes} minutes`);
-    }
-
-    async checkRecordingAction(newBatteryLevel: number) {
-        const nvrDeviceId = this.plugin.nvrDeviceId;
-        if (nvrDeviceId && this.mixins.includes(nvrDeviceId)) {
-            const logger = this.getBaichuanLogger();
-
-            const settings = await this.thisDevice.getSettings();
-            const isRecording = !settings.find(setting => setting.key === 'recording:privacyMode')?.value;
-            const { lowThresholdBatteryRecording, highThresholdBatteryRecording } = this.storageSettings.values;
-
-            if (isRecording && newBatteryLevel < lowThresholdBatteryRecording) {
-                logger.log(`Recording is enabled, but battery level is below low threshold (${newBatteryLevel}% < ${lowThresholdBatteryRecording}%), disabling recording`);
-                await this.thisDevice.putSetting('recording:privacyMode', true);
-            } else if (!isRecording && newBatteryLevel > highThresholdBatteryRecording) {
-                logger.log(`Recording is disabled, but battery level is above high threshold (${newBatteryLevel}% > ${highThresholdBatteryRecording}%), enabling recording`);
-                await this.thisDevice.putSetting('recording:privacyMode', false);
-            }
-
-        }
-    }
-
-    async updateBatteryInfo() {
-        const api = await this.ensureClient();
-        const channel = this.storageSettings.values.rtspChannel;
-
-        const batteryInfo = await api.getBatteryInfo(channel);
-        if (this.isDebugEnabled()) {
-            this.getBaichuanLogger().debug('getBatteryInfo result:', JSON.stringify(batteryInfo));
-        }
-
-        if (batteryInfo.batteryPercent !== undefined) {
-            const oldLevel = this.lastBatteryLevel;
-            this.batteryLevel = batteryInfo.batteryPercent;
-            this.lastBatteryLevel = batteryInfo.batteryPercent;
-
-            let shouldCheckRecordingAction = true;
-
-            // Log only if battery level changed
-            if (oldLevel !== undefined && oldLevel !== batteryInfo.batteryPercent) {
-                if (batteryInfo.chargeStatus !== undefined) {
-                    // chargeStatus: "0"=charging, "1"=discharging, "2"=full
-                    const charging = batteryInfo.chargeStatus === "0" || batteryInfo.chargeStatus === "2";
-                    this.getBaichuanLogger().log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}% (charging: ${charging})`);
-                } else {
-                    this.getBaichuanLogger().log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}%`);
-                }
-            } else if (oldLevel === undefined) {
-                // First time setting battery level
-                if (batteryInfo.chargeStatus !== undefined) {
-                    const charging = batteryInfo.chargeStatus === "0" || batteryInfo.chargeStatus === "2";
-                    this.getBaichuanLogger().log(`Battery level set: ${batteryInfo.batteryPercent}% (charging: ${charging})`);
-                } else {
-                    this.getBaichuanLogger().log(`Battery level set: ${batteryInfo.batteryPercent}%`);
-                }
-            } else {
-                shouldCheckRecordingAction = false;
-            }
-
-            if (shouldCheckRecordingAction) {
-                await this.checkRecordingAction(batteryInfo.batteryPercent);
-            }
-        }
-    }
-
-    private async updateBatteryAndSnapshot(): Promise<void> {
-        // Prevent multiple simultaneous calls
-        if (this.batteryUpdateInProgress) {
-            this.getBaichuanLogger().debug('Battery update already in progress, skipping');
-            return;
-        }
-
-        this.batteryUpdateInProgress = true;
-        try {
-            const channel = this.storageSettings.values.rtspChannel;
-            const updateIntervalMinutes = this.storageSettings.values.batteryUpdateIntervalMinutes ?? 10;
-            this.getBaichuanLogger().log(`Force battery update interval started (every ${updateIntervalMinutes} minutes)`);
-
-            // Ensure we have a client connection
-            const api = await this.ensureClient();
-            if (!api) {
-                this.getBaichuanLogger().warn('Failed to ensure client connection for battery update');
-                return;
-            }
-
-            // Check current sleep status
-            let sleepStatus = api.getSleepStatus({ channel });
-
-            // If camera is sleeping, wake it up
-            if (sleepStatus.state === 'sleeping') {
-                this.getBaichuanLogger().log('Camera is sleeping, waking up for periodic update...');
-                try {
-                    await api.wakeUp(channel, { waitAfterWakeMs: 2000 });
-                    this.getBaichuanLogger().log('Wake command sent, waiting for camera to wake up...');
-                } catch (wakeError) {
-                    this.getBaichuanLogger().warn('Failed to wake up camera:', wakeError);
-                    return;
-                }
-
-                // Poll until camera is awake (with timeout)
-                const wakeTimeoutMs = 30000; // 30 seconds max
-                const startWakePoll = Date.now();
-                let awake = false;
-
-                while (Date.now() - startWakePoll < wakeTimeoutMs) {
-                    await new Promise(resolve => setTimeout(resolve, 1000)); // Check every second
-                    sleepStatus = api.getSleepStatus({ channel });
-                    if (sleepStatus.state === 'awake') {
-                        awake = true;
-                        this.getBaichuanLogger().log('Camera is now awake');
-                        this.sleeping = false;
-                        break;
-                    }
-                }
-
-                if (!awake) {
-                    this.getBaichuanLogger().warn('Camera did not wake up within timeout, skipping update');
-                    return;
-                }
-            } else if (sleepStatus.state === 'awake') {
-                this.sleeping = false;
-            }
-
-            // Now that camera is awake, update all states
-            // 1. Update battery info
-            try {
-                await this.updateBatteryInfo();
-            } catch (e) {
-                this.getBaichuanLogger().warn('Failed to get battery info during periodic update:', e);
-            }
-
-            // 2. Align auxiliary devices state
-            try {
-                await this.alignAuxDevicesState();
-            } catch (e) {
-                this.getBaichuanLogger().warn('Failed to align auxiliary devices state:', e);
-            }
-
-            // 3. Update snapshot
-            try {
-                this.forceNewSnapshot = true;
-                await this.takePicture();
-                this.getBaichuanLogger().log('Snapshot updated during periodic update');
-            } catch (snapshotError) {
-                this.getBaichuanLogger().warn('Failed to update snapshot during periodic update:', snapshotError);
-            }
-        } catch (e) {
-            this.getBaichuanLogger().warn('Failed to update battery and snapshot', e);
-        } finally {
-            this.batteryUpdateInProgress = false;
-        }
-    }
-
-    async resetBaichuanClient(reason?: any): Promise<void> {
-        try {
-            this.unsubscribedToEvents?.();
-
-            // Close all stream servers before closing the main connection
-            // This ensures streams are properly cleaned up when using shared connection
-            if (this.streamManager) {
-                const reasonStr = reason?.message || reason?.toString?.() || 'connection reset';
-                await this.streamManager.closeAllStreams(reasonStr);
-            }
-
-            await this.baichuanApi?.close();
-        }
-        catch (e) {
-            this.getBaichuanLogger().warn('Error closing Baichuan client during reset', e);
-        }
-        finally {
-            this.baichuanApi = undefined;
-            this.connectionTime = undefined;
-            this.ensureClientPromise = undefined;
-            if (this.sleepCheckTimer) {
-                clearInterval(this.sleepCheckTimer);
-                this.sleepCheckTimer = undefined;
-            }
-            if (this.batteryUpdateTimer) {
-                clearInterval(this.batteryUpdateTimer);
-                this.batteryUpdateTimer = undefined;
-            }
-        }
-
-        if (reason) {
-            const message = reason?.message || reason?.toString?.() || reason;
-            this.getBaichuanLogger().warn(`Baichuan client reset requested: ${message}`);
-        }
-    }
-}