@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.0

package/package.json

@@ -1,10 +1,11 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.42",
+   "version": "0.2.0",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",
    "scripts": {
+      "build:lib": "./build-lib.sh",
       "scrypted-setup-project": "scrypted-setup-project",
       "prescrypted-setup-project": "scrypted-package-json",
       "build": "scrypted-webpack",

package/src/baichuan-base.ts

@@ -162,7 +162,15 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
     protected baichuanApi: ReolinkBaichuanApi | undefined;
     protected ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
     protected connectionTime: number | undefined;
-    
+    transport: BaichuanTransport;
+    // Map of stream clients keyed by streamKey (profile + variantType)
+    private streamClients = new Map<string, ReolinkBaichuanApi>();
+
+    constructor(nativeId: string, transport: BaichuanTransport) {
+        super(nativeId);
+        this.transport = transport
+    }
+
     private errorListener?: (err: unknown) => void;
     private closeListener?: () => void;
     private lastDisconnectTime: number = 0;
@@ -189,6 +197,13 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
      */
     protected abstract getDeviceName(): string;
 
+    /**
+     * Get connection inputs for creating a stream client for a specific streamKey
+     * This method is called by createStreamClient to get the inputs needed to create a new client
+     * @param streamKey The unique stream key (e.g., "composite_default_main", "channel_0_main", etc.)
+     */
+    protected abstract getStreamClientInputs(): BaichuanConnectionConfig;
+
     /**
      * Get a Baichuan logger instance with formatting and debug control
      * This logger implements Console interface and can be used everywhere
@@ -216,11 +231,11 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
         if (this.baichuanApi) {
             const isConnected = this.baichuanApi.client.isSocketConnected();
             const isLoggedIn = this.baichuanApi.client.loggedIn;
-            
+
             // Only reuse if both conditions are true
             if (isConnected && isLoggedIn) {
-            return this.baichuanApi;
-        }
+                return this.baichuanApi;
+            }
 
             // If socket is not connected or not logged in, cleanup the stale client
             // This prevents leaking connections when the socket appears connected but isn't
@@ -251,33 +266,42 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             // Create new Baichuan client
             // BaichuanLogger implements Console, so it can be used directly
             const logger = this.getBaichuanLogger();
-            const api = await createBaichuanApi({
-                inputs: {
-                    host: config.host,
-                    username: config.username,
-                    password: config.password,
-                    uid: config.uid,
-                    logger,
-                    debugOptions: config.debugOptions,
-                    udpDiscoveryMethod: config.udpDiscoveryMethod,
-                },
-                transport: config.transport,
-            });
-
-            await api.login();
-
-            // Verify socket is connected before returning
-            if (!api.client.isSocketConnected()) {
-                throw new Error('Socket not connected after login');
-            }
+            try {
+                const api = await createBaichuanApi({
+                    inputs: {
+                        host: config.host,
+                        username: config.username,
+                        password: config.password,
+                        uid: config.uid,
+                        logger,
+                        debugOptions: config.debugOptions,
+                        udpDiscoveryMethod: config.udpDiscoveryMethod,
+                    },
+                    transport: config.transport,
+                });
+
+                await api.login();
+
+                // Verify socket is connected before returning
+                if (!api.client.isSocketConnected()) {
+                    throw new Error('Socket not connected after login');
+                }
 
-            // Attach listeners
-            this.attachBaichuanListeners(api);
+                // Attach listeners
+                this.attachBaichuanListeners(api);
 
-            this.baichuanApi = api;
-            this.connectionTime = Date.now();
+                this.baichuanApi = api;
+                this.connectionTime = Date.now();
 
-            return api;
+                return api;
+            }
+            catch (e) {
+                // Apply backoff for connection failures too, otherwise multiple callers can hammer connect().
+                this.lastDisconnectTime = Date.now();
+                // Ensure state is reset so next attempt is clean.
+                await this.cleanupBaichuanApi();
+                throw e;
+            }
         })();
 
         try {
@@ -310,7 +334,7 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                 return;
             }
             logger.error(`error: ${msg}`);
-            
+
             // Call custom error handler if provided
             if (callbacks.onError) {
                 try {
@@ -359,7 +383,7 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                 // Only cleanup if this is still the current API instance
                 // This prevents cleanup of a new connection that was created
                 // while the old one was closing
-            await this.cleanupBaichuanApi();
+                await this.cleanupBaichuanApi();
             }
 
             // Call custom close handler if provided
@@ -394,6 +418,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
         // Call before cleanup hook
         await this.onBeforeCleanup();
 
+        // Cleanup all stream clients
+        await this.cleanupStreamClients();
+
         // Remove all listeners
         if (this.closeListener) {
             try {
@@ -498,5 +525,97 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
         this.eventSubscriptionActive = false;
     }
+
+    private async createNewClient(): Promise<ReolinkBaichuanApi> {
+        const config = this.getStreamClientInputs();
+        const logger = this.getBaichuanLogger();
+
+        const api = await createBaichuanApi({
+            inputs: {
+                host: config.host,
+                username: config.username,
+                password: config.password,
+                uid: config.uid,
+                logger,
+                debugOptions: config.debugOptions,
+                udpDiscoveryMethod: config.udpDiscoveryMethod,
+            },
+            transport: config.transport,
+        });
+
+        await api.login();
+
+        return api;
+    }
+
+    /**
+     * Create or get a dedicated Baichuan API session for streaming (used by StreamManager).
+     * Returns an existing client if one exists for the same streamKey, otherwise creates a new one.
+     * @param streamKey The unique stream key (e.g., "composite_default_main", "channel_0_main", etc.)
+     */
+    async createStreamClient(streamKey: string): Promise<ReolinkBaichuanApi> {
+        const logger = this.getBaichuanLogger();
+
+        // Check if a client already exists for this streamKey
+        const existingClient = this.streamClients.get(streamKey);
+        if (existingClient) {
+            // Verify the client is still valid (connected and logged in)
+            const isConnected = existingClient.client.isSocketConnected();
+            const isLoggedIn = existingClient.client.loggedIn;
+
+            if (isConnected && isLoggedIn) {
+                // Return existing valid client
+                logger.log(`Reusing existing stream client for streamKey=${streamKey}`);
+                return existingClient;
+            }
+
+            logger.log(`Stale stream client detected for streamKey=${streamKey}, recreating`);
+            try {
+                if (existingClient.client.isSocketConnected()) {
+                    await existingClient.close();
+                }
+            } catch {
+                // ignore cleanup errors
+            }
+            this.streamClients.delete(streamKey);
+        }
+
+        // Create new client for this streamKey
+        const api = await this.createNewClient();
+
+        // Store in map for future reuse
+        this.streamClients.set(streamKey, api);
+        logger.log(`Created new stream client for streamKey=${streamKey}`);
+
+        // Clean up when client closes
+        api.client.once('close', () => {
+            const currentClient = this.streamClients.get(streamKey);
+            if (currentClient === api) {
+                this.streamClients.delete(streamKey);
+            }
+        });
+
+        return api;
+    }
+
+    /**
+     * Cleanup all stream clients (called during device cleanup)
+     */
+    async cleanupStreamClients(): Promise<void> {
+        const clients = Array.from(this.streamClients.values());
+        this.streamClients.clear();
+
+        await Promise.allSettled(
+            clients.map(async (api) => {
+                try {
+                    if (api.client.isSocketConnected()) {
+                        await api.close();
+                    }
+                } catch {
+                    // ignore cleanup errors
+                }
+            })
+        );
+    }
 }
 

package/src/camera-battery.ts

@@ -1,16 +1,9 @@
-import type { ReolinkBaichuanApi, SleepStatus } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, {
-    type MediaObject,
-    RequestPictureOptions,
-    ResponsePictureOptions
-} from "@scrypted/sdk";
 import {
     CommonCameraMixin,
 } from "./common";
-import { DebugLogOption } from "./debug-options";
 import type ReolinkNativePlugin from "./main";
-import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
+import { ReolinkNativeNvrDevice } from "./nvr";
 
 export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     doorbellBinaryTimeout?: NodeJS.Timeout;
@@ -46,6 +39,10 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         return this.resetBaichuanClient();
     }
 
+    async reportDevices(): Promise<void> {
+        // Do nothing
+    }
+
     private stopPeriodicTasks(): void {
         if (this.sleepCheckTimer) {
             clearInterval(this.sleepCheckTimer);
@@ -97,56 +94,6 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         logger.log(`Periodic tasks started: sleep check every 5s, battery update every ${batteryUpdateIntervalMinutes} minutes`);
     }
 
-    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);
-        }
-    }
-
     async checkRecordingAction(newBatteryLevel: number) {
         const nvrDeviceId = this.plugin.nvrDeviceId;
         if (nvrDeviceId && this.mixins.includes(nvrDeviceId)) {

package/src/camera.ts

@@ -22,7 +22,6 @@ export const b64ToMo = async (b64: string) => {
 export class ReolinkNativeCamera extends CommonCameraMixin {
     videoStreamOptions: Promise<UrlMediaStreamOptions[]>;
     motionTimeout?: NodeJS.Timeout;
-    initComplete: boolean = false;
     doorbellBinaryTimeout?: NodeJS.Timeout;
     ptzCapabilities?: any;
 
@@ -43,13 +42,17 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         });
     }
 
+    async reportDevices(): Promise<void> {
+        // Do nothing
+    }
+
     async resetBaichuanClient(reason?: any): Promise<void> {
         try {
             this.unsubscribedToEvents?.();
             await this.baichuanApi?.close();
         }
         catch (e) {
-            this.getBaichuanLogger().warn('Error closing Baichuan client during reset', e);
+            this.getBaichuanLogger().warn('Error closing Baichuan client during reset', e?.message || String(e));
         }
         finally {
             this.baichuanApi = undefined;