@apocaliss92/scrypted-reolink-native 0.1.0 → 0.1.2

package/src/camera-battery.ts

@@ -7,7 +7,7 @@ import sdk, {
 import {
     CommonCameraMixin,
 } from "./common";
-import { createBaichuanApi, normalizeUid } from "./connect";
+import { DebugLogOption } from "./debug-options";
 import type ReolinkNativePlugin from "./main";
 
 export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
@@ -21,10 +21,11 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     private batteryUpdateTimer: NodeJS.Timeout | undefined;
     private lastBatteryLevel: number | undefined;
     private forceNewSnapshot: boolean = false;
+    private batteryUpdateInProgress: boolean = false;
 
     private isBatteryInfoLoggingEnabled(): boolean {
         const debugLogs = this.storageSettings.values.debugLogs || [];
-        return debugLogs.includes('batteryInfo');
+        return debugLogs.includes(DebugLogOption.BatteryInfo);
     }
 
     constructor(nativeId: string, public plugin: ReolinkNativePlugin) {
@@ -150,43 +151,15 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
                     this.sleeping = false;
                 }
 
-                // Try to get battery info only when camera is awake.
-                // NOTE: getBatteryInfo in UDP mode is best-effort and should not force reconnect/login.
-                try {
-                    const batteryInfo = await api.getBatteryInfo(channel);
-                    if (this.isBatteryInfoLoggingEnabled()) {
-                        this.console.log('getBatteryInfo result:', JSON.stringify(batteryInfo));
-                    }
-
-                    // Update battery percentage and charge status
-                    if (batteryInfo.batteryPercent !== undefined) {
-                        const oldLevel = this.lastBatteryLevel;
-                        this.batteryLevel = batteryInfo.batteryPercent;
-                        this.lastBatteryLevel = batteryInfo.batteryPercent;
-
-                        // 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.console.log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}% (charging: ${charging})`);
-                            } else {
-                                this.console.log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}%`);
-                            }
-                        }
-                    }
-                } catch (batteryError) {
-                    // Silently ignore battery info errors to avoid spam
-                    this.console.debug('Failed to get battery info:', batteryError);
-                }
-
-                // When camera wakes up, align auxiliary devices state and force snapshot (once)
+                // When camera wakes up (transition from sleeping to awake), align auxiliary devices state and force snapshot (once)
                 if (wasSleeping) {
                     this.alignAuxDevicesState().catch(() => { });
                     if (this.forceNewSnapshot) {
                         this.takePicture().catch(() => { });
                     }
                 }
+                // NOTE: We don't call getBatteryInfo() here anymore to avoid timeouts.
+                // Battery updates are handled by updateBatteryAndSnapshot() which properly wakes the camera.
             } else {
                 // Unknown state
                 this.console.debug(`Sleep status unknown: ${sleepStatus.reason}`);
@@ -198,83 +171,132 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     }
 
     private async updateBatteryAndSnapshot(): Promise<void> {
+        // Prevent multiple simultaneous calls
+        if (this.batteryUpdateInProgress) {
+            this.console.debug('Battery update already in progress, skipping');
+            return;
+        }
+
+        this.batteryUpdateInProgress = true;
         try {
             const channel = this.getRtspChannel();
-
             const updateIntervalMinutes = this.storageSettings.values.batteryUpdateIntervalMinutes ?? 10;
             this.console.log(`Force battery update interval started (every ${updateIntervalMinutes} minutes)`);
 
-            if (!this.baichuanApi) {
+            // Ensure we have a client connection
+            const api = await this.ensureClient();
+            if (!api) {
+                this.console.warn('Failed to ensure client connection for battery update');
                 return;
             }
 
-            const sleepStatus = this.baichuanApi.getSleepStatus({ channel });
-            if (sleepStatus.state !== 'awake') {
-                return;
+            // Check current sleep status
+            let sleepStatus = api.getSleepStatus({ channel });
+            
+            // If camera is sleeping, wake it up
+            if (sleepStatus.state === 'sleeping') {
+                this.console.log('Camera is sleeping, waking up for periodic update...');
+                try {
+                    await api.wakeUp(channel, { waitAfterWakeMs: 2000 });
+                    this.console.log('Wake command sent, waiting for camera to wake up...');
+                } catch (wakeError) {
+                    this.console.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.console.log('Camera is now awake');
+                        this.sleeping = false;
+                        break;
+                    }
+                }
+
+                if (!awake) {
+                    this.console.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 {
-                const batteryInfo = await this.baichuanApi.getBatteryInfo(channel);
+                const batteryInfo = await api.getBatteryInfo(channel);
                 if (this.isBatteryInfoLoggingEnabled()) {
                     this.console.log('getBatteryInfo result:', JSON.stringify(batteryInfo));
                 }
+                
                 if (batteryInfo.batteryPercent !== undefined) {
+                    const oldLevel = this.lastBatteryLevel;
                     this.batteryLevel = batteryInfo.batteryPercent;
                     this.lastBatteryLevel = batteryInfo.batteryPercent;
+
+                    // 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.console.log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}% (charging: ${charging})`);
+                        } else {
+                            this.console.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.console.log(`Battery level set: ${batteryInfo.batteryPercent}% (charging: ${charging})`);
+                        } else {
+                            this.console.log(`Battery level set: ${batteryInfo.batteryPercent}%`);
+                        }
+                    }
                 }
             } catch (e) {
-                this.console.debug('Failed to get battery info during periodic update:', e);
+                this.console.warn('Failed to get battery info during periodic update:', e);
             }
 
-            // // Wait a bit for the camera to fully wake up
-            // await new Promise(resolve => setTimeout(resolve, 2000));
-
-            // // Get battery info
-            // const batteryInfo = await api.getBatteryStatus(channel);
-            // if (batteryInfo.batteryPercent !== undefined) {
-            //     const oldLevel = this.lastBatteryLevel;
-            //     this.batteryLevel = batteryInfo.batteryPercent;
-            //     this.lastBatteryLevel = batteryInfo.batteryPercent;
-
-            //     // 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.console.log(`Battery level changed: ${oldLevel}% → ${batteryInfo.batteryPercent}% (charging: ${charging})`);
-            //         } else {
-            //             this.console.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.console.log(`Battery level set: ${batteryInfo.batteryPercent}% (charging: ${charging})`);
-            //         } else {
-            //             this.console.log(`Battery level set: ${batteryInfo.batteryPercent}%`);
-            //         }
-            //     }
-            // }
-
-            // // Update snapshot
-            // try {
-            //     const snapshotBuffer = await api.getSnapshot(channel);
-            //     const mo = await sdk.mediaManager.createMediaObject(snapshotBuffer, 'image/jpeg');
-            //     this.lastPicture = { mo, atMs: Date.now() };
-            //     this.console.log('Snapshot updated');
-            // } catch (snapshotError) {
-            //     this.console.warn('Failed to update snapshot during periodic update', snapshotError);
-            // }
-
-            // this.sleeping = false;
+            // 2. Align auxiliary devices state
+            try {
+                await this.alignAuxDevicesState();
+            } catch (e) {
+                this.console.warn('Failed to align auxiliary devices state:', e);
+            }
+
+            // 3. Update snapshot
+            try {
+                this.forceNewSnapshot = true;
+                await this.takePicture();
+                this.console.log('Snapshot updated during periodic update');
+            } catch (snapshotError) {
+                this.console.warn('Failed to update snapshot during periodic update:', snapshotError);
+            }
         } catch (e) {
             this.console.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) {
@@ -310,30 +332,8 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     }
 
     async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
-        if (!ipAddress || !username || !password) {
-            throw new Error('Missing camera credentials');
-        }
-        const normalizedUid = normalizeUid(uid);
-        if (!normalizedUid) throw new Error("UID is required for battery cameras (BCUDP)");
-
-        const debugOptions = this.getBaichuanDebugOptions();
-        const api = await createBaichuanApi(
-            {
-                inputs: {
-                    host: ipAddress,
-                    username,
-                    password,
-                    uid: normalizedUid,
-                    logger: this.console,
-                    ...(debugOptions ? { debugOptions } : {}),
-                },
-                transport: 'udp',
-                logger: this.console,
-            }
-        );
-        await api.login();
-
-        return api;
+        // Reuse the main Baichuan client connection instead of creating a new one
+        // This ensures we use a single session for everything (general + streams)
+        return await this.ensureClient();
     }
 }

package/src/camera.ts

@@ -95,7 +95,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
 
     async init() {
         this.startPeriodicTasks();
-        // Align auxiliary devices state on init
         await this.alignAuxDevicesState();
     }
 
@@ -114,7 +113,7 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
                     username,
                     password,
                     logger: this.console,
-                    ...(debugOptions ? { debugOptions } : {}),
+                    debugOptions
                 },
                 transport: 'tcp',
                 logger: this.console,

package/src/common.ts

@@ -1,8 +1,9 @@
 import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent } 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, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, SettingValue, Settings, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
-import { StorageSettings, StorageSettingsDict } from "@scrypted/sdk/storage-settings";
+import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
+import { convertDebugLogsToApiOptions, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkPtzPresets } from "./presets";
@@ -268,17 +269,36 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             combobox: true,
             immediate: true,
             defaultValue: [],
-            choices: ['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets', 'eventLogs', 'batteryInfo'],
+            choices: getDebugLogChoices(),
             onPut: async (ov, value) => {
-                // Only reconnect if Baichuan-client flags changed; toggling event logs should be immediate.
-                const oldSel = new Set(ov);
-                const newSel = new Set(value);
-                oldSel.delete('eventLogs');
-                newSel.delete('eventLogs');
+                const oldApiOptions = getApiRelevantDebugLogs(ov || []);
+                const newApiOptions = getApiRelevantDebugLogs(value || []);
+
+                const oldSel = new Set(oldApiOptions);
+                const newSel = new Set(newApiOptions);
 
                 const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
                 if (changed && this.resetBaichuanClient) {
-                    await this.resetBaichuanClient('debugLogs changed');
+                    // Clear any existing timeout
+                    if (this.debugLogsResetTimeout) {
+                        clearTimeout(this.debugLogsResetTimeout);
+                        this.debugLogsResetTimeout = undefined;
+                    }
+
+                    // Defer reset by 2 seconds to allow settings to settle
+                    this.debugLogsResetTimeout = setTimeout(async () => {
+                        this.debugLogsResetTimeout = undefined;
+                        try {
+                            await this.resetBaichuanClient('debugLogs changed');
+                            // Force reconnection with new debug options
+                            this.baichuanApi = undefined;
+                            this.ensureClientPromise = undefined;
+                            // Trigger reconnection
+                            await this.ensureClient();
+                        } catch (e) {
+                            this.getLogger().warn('Failed to reset client after debug logs change', e);
+                        }
+                    }, 2000);
                 }
             },
         },
@@ -461,6 +481,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     protected ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
     protected connectionTime: number | undefined;
     protected readonly protocol: BaichuanTransport;
+    private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
     // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
@@ -480,6 +501,12 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         this.streamManager = new StreamManager({
             createStreamClient: () => this.createStreamClient(),
             getLogger: () => this.getLogger(),
+            credentials: {
+                username: this.storageSettings.values.username || '',
+                password: this.storageSettings.values.password || '',
+            },
+            // For battery cameras, we use a shared connection
+            sharedConnection: options.type === 'battery',
         });
 
         setTimeout(async () => {
@@ -505,17 +532,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     getBaichuanDebugOptions(): any | undefined {
-        const sel = new Set<string>(this.storageSettings.values.debugLogs);
-        if (!sel.size) return undefined;
-
-        const debugOptions: any = {};
-        // Only pass through Baichuan client debug flags.
-        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets']);
-        for (const k of sel) {
-            if (!clientKeys.has(k)) continue;
-            debugOptions[k] = true;
-        }
-        return Object.keys(debugOptions).length ? debugOptions : undefined;
+        const debugLogs = this.storageSettings.values.debugLogs || [];
+        return convertDebugLogsToApiOptions(debugLogs);
     }
 
     isRecoverableBaichuanError(e: any): boolean {
@@ -560,12 +578,12 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         try {
             const logger = this.getLogger();
 
-            if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+            if (this.isEventLogsEnabled()) {
                 logger.log(`Baichuan event: ${JSON.stringify(ev)}`);
             }
 
             if (!this.isEventDispatchEnabled()) {
-                if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                if (this.isEventLogsEnabled()) {
                     logger.debug('Event dispatch is disabled, ignoring event');
                 }
                 return;
@@ -573,7 +591,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
             const channel = this.getRtspChannel();
             if (ev?.channel !== undefined && ev.channel !== channel) {
-                if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                if (this.isEventLogsEnabled()) {
                     logger.debug(`Event channel ${ev.channel} does not match camera channel ${channel}, ignoring`);
                 }
                 return;
@@ -585,7 +603,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             switch (ev?.type) {
                 case 'motion':
                     motion = true;
-                    if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                    if (this.isEventLogsEnabled()) {
                         logger.log(`Motion event received (may be PIR or MD)`);
                     }
                     break;
@@ -603,7 +621,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                     motion = true;
                     break;
                 default:
-                    if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                    if (this.isEventLogsEnabled()) {
                         logger.debug(`Unknown event type: ${ev?.type}`);
                     }
                     return;
@@ -859,6 +877,11 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
     }
 
+    isEventLogsEnabled(): boolean {
+        const debugLogs = this.storageSettings.values.debugLogs || [];
+        return debugLogs.includes(DebugLogOption.EventLogs);
+    }
+
     // BinarySensor interface implementation (for doorbell)
     handleDoorbellEvent(): void {
         if (!this.doorbellBinaryTimeout) {
@@ -1317,7 +1340,6 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             });
         };
 
-        // Use withBaichuanRetry (regular cameras have retry logic, battery cameras just execute)
         return await this.withBaichuanRetry(createStreamFn);
     }
 
@@ -1391,7 +1413,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                         password,
                         uid: normalizedUid,
                         logger: this.console,
-                        ...(debugOptions ? { debugOptions } : {}),
+                        debugOptions,
                     },
                     transport: this.protocol,
                     logger: this.console,

package/src/connect.ts

@@ -8,7 +8,7 @@ export type BaichuanConnectInputs = {
     password: string;
     uid?: string;
     logger?: Console;
-    debugOptions?: unknown;
+    debugOptions?: BaichuanClientOptions['debugOptions'];
 };
 
 export function normalizeUid(uid?: string): string | undefined {
@@ -52,7 +52,7 @@ export async function createBaichuanApi(props: {
         username: inputs.username,
         password: inputs.password,
         logger: inputs.logger,
-        ...(inputs.debugOptions ? { debugOptions: inputs.debugOptions } : {}),
+        debugOptions: inputs.debugOptions ?? {}
     };
 
     const attachErrorHandler = (api: ReolinkBaichuanApi) => {
@@ -66,9 +66,11 @@ export async function createBaichuanApi(props: {
                 // Only log if it's not a recoverable error to avoid spam
                 if (typeof msg === 'string' && (
                     msg.includes('Baichuan socket closed') ||
-                    msg.includes('Baichuan UDP stream closed')
+                    msg.includes('Baichuan UDP stream closed') ||
+                    msg.includes('Not running')
                 )) {
-                    // Silently ignore recoverable socket close errors
+                    // Silently ignore recoverable socket close errors and "Not running" errors
+                    // "Not running" is common for UDP/battery cameras when sleeping or during initialization
                     return;
                 }
                 logger.error(`[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`);
@@ -84,6 +86,8 @@ export async function createBaichuanApi(props: {
         }
     };
 
+    logger.log('Connecting with options:', JSON.stringify(base, null, 2));
+
     if (transport === "tcp") {
         const api = new ReolinkBaichuanApi({
             ...base,
@@ -102,6 +106,7 @@ export async function createBaichuanApi(props: {
         ...base,
         transport: "udp",
         uid,
+        idleDisconnect: true,
     });
     attachErrorHandler(api);
     return api;

package/src/debug-options.ts

@@ -0,0 +1,105 @@
+import type { DebugOptions } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+
+/**
+ * User-friendly debug log options enum
+ */
+export enum DebugLogOption {
+    /** General debug logs */
+    General = 'general',
+    /** RTSP proxy/server debug logs */
+    DebugRtsp = 'debugRtsp',
+    /** Stream command tracing */
+    TraceStream = 'traceStream',
+    /** Talkback tracing */
+    TraceTalk = 'traceTalk',
+    /** Event tracing */
+    TraceEvents = 'traceEvents',
+    /** H.264 debug logs */
+    DebugH264 = 'debugH264',
+    /** SPS/PPS parameter sets debug logs */
+    DebugParamSets = 'debugParamSets',
+    /** Event logs (plugin-specific, not passed to API) */
+    EventLogs = 'eventLogs',
+    /** Battery info logs (plugin-specific, not passed to API) */
+    BatteryInfo = 'batteryInfo',
+}
+
+/**
+ * Maps user-friendly enum values to API DebugOptions keys
+ */
+export function mapDebugLogToApiOption(option: DebugLogOption): keyof DebugOptions | null {
+    const mapping: Record<DebugLogOption, keyof DebugOptions | null> = {
+        [DebugLogOption.General]: 'general',
+        [DebugLogOption.DebugRtsp]: 'debugRtsp',
+        [DebugLogOption.TraceStream]: 'traceStream',
+        [DebugLogOption.TraceTalk]: 'traceTalk',
+        [DebugLogOption.TraceEvents]: 'traceEvents',
+        [DebugLogOption.DebugH264]: 'debugH264',
+        [DebugLogOption.DebugParamSets]: 'debugParamSets',
+        [DebugLogOption.EventLogs]: null, // Plugin-specific, not passed to API
+        [DebugLogOption.BatteryInfo]: null, // Plugin-specific, not passed to API
+    };
+    return mapping[option];
+}
+
+/**
+ * Convert array of DebugLogOption enum values to API DebugOptions
+ * Only includes options that are relevant to the API (excludes plugin-specific options)
+ */
+export function convertDebugLogsToApiOptions(debugLogs: string[]): DebugOptions | undefined {
+    const apiOptions: DebugOptions = {};
+    const debugLogsSet = new Set(debugLogs);
+
+    // Iterate over enum values and build API options based on what's selected
+    for (const [key, friendlyName] of Object.entries(DebugLogDisplayNames)) {
+        if (debugLogsSet.has(friendlyName)) {
+            const apiKey = mapDebugLogToApiOption(key as DebugLogOption);
+            if (apiKey) {
+                apiOptions[apiKey] = true;
+            }
+        }
+    }
+
+    console.log(debugLogs, apiOptions);
+    return Object.keys(apiOptions).length > 0 ? apiOptions : undefined;
+}
+
+/**
+ * Get only the API-relevant debug log options (excludes plugin-specific options)
+ * Used to determine if reconnection is needed when debug options change
+ */
+export function getApiRelevantDebugLogs(debugLogs: string[]): string[] {
+    return debugLogs.filter(log => {
+        const option = log as DebugLogOption;
+        const apiKey = mapDebugLogToApiOption(option);
+        // Only include options that map to API keys (exclude plugin-specific options)
+        return apiKey !== null;
+    });
+}
+
+/**
+ * User-friendly display names for debug log options
+ */
+export const DebugLogDisplayNames: Record<DebugLogOption, string> = {
+    [DebugLogOption.General]: 'General',
+    [DebugLogOption.DebugRtsp]: 'RTSP',
+    [DebugLogOption.TraceStream]: 'Trace stream',
+    [DebugLogOption.TraceTalk]: 'Trace talk',
+    [DebugLogOption.TraceEvents]: 'Trace events XML',
+    [DebugLogOption.DebugH264]: 'H264',
+    [DebugLogOption.DebugParamSets]: 'Video param sets',
+    [DebugLogOption.EventLogs]: 'Object detection events',
+    [DebugLogOption.BatteryInfo]: 'Battery info update',
+};
+
+/**
+ * Get debug log choices with user-friendly names
+ * Returns array of strings in format "value=displayName" for Scrypted settings
+ */
+export function getDebugLogChoices(): string[] {
+    return Object.values(DebugLogOption).map(option => {
+        const displayName = DebugLogDisplayNames[option];
+        return `${displayName}`;
+    });
+}
+

package/src/intercom.ts

@@ -69,6 +69,22 @@ export class ReolinkBaichuanIntercom {
 
         const session = await this.camera.withBaichuanRetry(async () => {
             const api = await this.camera.ensureClient();
+            
+            // For UDP/battery cameras, wake up the camera if it's sleeping before creating talk session
+            if (this.camera.options?.type === 'battery') {
+                try {
+                    const sleepStatus = api.getSleepStatus({ channel });
+                    if (sleepStatus.state === 'sleeping') {
+                        logger.log('Camera is sleeping, waking up for intercom...');
+                        await api.wakeUp(channel, { waitAfterWakeMs: 2000 });
+                        // Wait a bit more to ensure camera is fully awake
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
+                } catch (e) {
+                    logger.debug('Failed to check/wake camera for intercom, proceeding anyway', e);
+                }
+            }
+            
             return await api.createTalkSession(channel, {
                 blocksPerPayload: this.blocksPerPayload,
             });