@apocaliss92/scrypted-reolink-native 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.0",
+   "version": "0.1.1",
    "description": "Reolink Native plugin for Scrypted",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/camera-battery.ts

@@ -21,6 +21,7 @@ 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 || [];
@@ -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,77 +171,118 @@ 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;
         }
     }
 

package/src/common.ts

@@ -480,6 +480,10 @@ 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 || '',
+            },
         });
 
         setTimeout(async () => {
@@ -1317,7 +1321,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);
     }
 

package/src/connect.ts

@@ -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}`);

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,
             });

package/src/stream-utils.ts

@@ -20,6 +20,14 @@ export interface StreamManagerOptions {
      */
     createStreamClient: () => Promise<ReolinkBaichuanApi>;
     getLogger: () => Console;
+    /**
+     * Credentials to include in the TCP stream (username, password).
+     * Uses the same credentials as the main connection.
+     */
+    credentials: {
+        username: string;
+        password: string;
+    };
 }
 
 export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
@@ -207,7 +215,7 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
 }): Promise<MediaObject> {
     const { streamManager, channel, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
 
-    const { host, port, sdp, audio } = await streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
 
     // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
     try {
@@ -230,8 +238,13 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
         mso.audio.channels = audio.channels;
     }
 
+    // Build URL with credentials: tcp://username:password@host:port
+    const encodedUsername = encodeURIComponent(username || '');
+    const encodedPassword = encodeURIComponent(password || '');
+    const url = `tcp://${encodedUsername}:${encodedPassword}@${host}:${port}`;
+
     const rfc = {
-        url: `tcp://${host}:${port}`,
+        url,
         sdp,
         mediaStreamOptions: mso as ResponseMediaStreamOptions,
     };
@@ -241,9 +254,18 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
     });
 }
 
+type RfcServerInfo = {
+    host: string;
+    port: number;
+    sdp: string;
+    audio?: { codec: string; sampleRate: number; channels: number };
+    username: string;
+    password: string;
+};
+
 export class StreamManager {
     private nativeRfcServers = new Map<string, ScryptedRfc4571TcpServer>();
-    private nativeRfcServerCreatePromises = new Map<string, Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }>>();
+    private nativeRfcServerCreatePromises = new Map<string, Promise<RfcServerInfo>>();
 
     constructor(private opts: StreamManagerOptions) {
     }
@@ -257,7 +279,7 @@ export class StreamManager {
         channel: number,
         profile: StreamProfile,
         expectedVideoType?: 'H264' | 'H265',
-    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+    ): Promise<RfcServerInfo> {
         const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
         if (existingCreate) {
             return await existingCreate;
@@ -272,7 +294,14 @@ export class StreamManager {
                     );
                 }
                 else {
-                    return { host: cached.host, port: cached.port, sdp: cached.sdp, audio: cached.audio };
+                    return {
+                        host: cached.host,
+                        port: cached.port,
+                        sdp: cached.sdp,
+                        audio: cached.audio,
+                        username: (cached as any).username || this.opts.credentials.username,
+                        password: (cached as any).password || this.opts.credentials.password,
+                    };
                 }
             }
 
@@ -288,6 +317,10 @@ export class StreamManager {
 
             const api = await this.opts.createStreamClient();
             const { createScryptedRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+
+            // Use the same credentials as the main connection
+            const { username, password } = this.opts.credentials;
+
             const created = await createScryptedRfc4571TcpServer({
                 api,
                 channel,
@@ -295,6 +328,8 @@ export class StreamManager {
                 logger: this.getLogger(),
                 expectedVideoType: expectedVideoType as VideoType | undefined,
                 closeApiOnTeardown: true,
+                username,
+                password,
             });
 
             this.nativeRfcServers.set(streamKey, created);
@@ -303,7 +338,14 @@ export class StreamManager {
                 if (current?.server === created.server) this.nativeRfcServers.delete(streamKey);
             });
 
-            return { host: created.host, port: created.port, sdp: created.sdp, audio: created.audio };
+            return {
+                host: created.host,
+                port: created.port,
+                sdp: created.sdp,
+                audio: created.audio,
+                username: (created as any).username || this.opts.credentials.username,
+                password: (created as any).password || this.opts.credentials.password,
+            };
         })();
 
         this.nativeRfcServerCreatePromises.set(streamKey, createPromise);
@@ -320,7 +362,7 @@ export class StreamManager {
         profile: StreamProfile,
         streamKey: string,
         expectedVideoType?: 'H264' | 'H265',
-    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+    ): Promise<RfcServerInfo> {
         return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
     }
 }