@apocaliss92/scrypted-reolink-native 0.1.32 → 0.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.32",
+   "version": "0.1.33",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",
@@ -33,7 +33,8 @@
          "ScryptedDeviceCreator",
          "DeviceProvider",
          "DeviceCreator",
-         "Settings"
+         "Settings",
+         "HttpRequestHandler"
       ]
    },
    "dependencies": {

package/src/baichuan-base.ts

@@ -208,14 +208,27 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
      * Ensure Baichuan client is connected and ready
      */
     async ensureBaichuanClient(): Promise<ReolinkBaichuanApi> {
+        // Prevent concurrent login storms - check promise first
+        if (this.ensureClientPromise) return await this.ensureClientPromise;
+
         // Reuse existing client if socket is still connected and logged in
-        if (this.baichuanApi && this.baichuanApi.client.isSocketConnected() && this.baichuanApi.client.loggedIn) {
-            return this.baichuanApi;
+        // Check this AFTER checking the promise to avoid race conditions
+        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;
+            }
+            
+            // 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
+            const logger = this.getBaichuanLogger();
+            logger.log(`Stale client detected: connected=${isConnected}, loggedIn=${isLoggedIn}, cleaning up`);
+            await this.cleanupBaichuanApi();
         }
 
-        // Prevent concurrent login storms
-        if (this.ensureClientPromise) return await this.ensureClientPromise;
-
         // Apply backoff to avoid aggressive reconnection after disconnection
         if (this.lastDisconnectTime > 0) {
             const timeSinceDisconnect = Date.now() - this.lastDisconnectTime;
@@ -309,6 +322,13 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
         // Close listener
         this.closeListener = async () => {
+            // Prevent multiple concurrent cleanup operations
+            if (!this.baichuanApi || this.baichuanApi !== api) {
+                // This close event is for a different/old client, ignore it
+                logger.debug('Close event for stale client, ignoring');
+                return;
+            }
+
             try {
                 const wasConnected = api.client.isSocketConnected();
                 const wasLoggedIn = api.client.loggedIn;
@@ -330,8 +350,16 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
             logger.log(`Socket closed, resetting client state for reconnection (last disconnect ${timeSinceLastDisconnect}ms ago)`);
 
-            // Cleanup
-            await this.cleanupBaichuanApi();
+            // Mark as disconnected immediately to prevent reuse
+            // This prevents race conditions where ensureBaichuanClient might check
+            // isSocketConnected() before cleanup completes
+            const currentApi = this.baichuanApi;
+            if (currentApi === api) {
+                // 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();
+            }
 
             // Call custom close handler if provided
             if (callbacks.onClose) {

package/src/camera-battery.ts

@@ -318,10 +318,4 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
             this.getBaichuanLogger().warn(`Baichuan client reset requested: ${message}`);
         }
     }
-
-    protected async withBaichuanClient<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T> {
-        const client = await this.ensureClient();
-        return fn(client);
-    }
-
 }

package/src/camera.ts

@@ -103,24 +103,15 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         await this.alignAuxDevicesState();
     }
 
-    async getDetectionInput(detectionId: string, eventId?: any): Promise<MediaObject> {
-        return null;
-    }
-
     async processEvents(events: { motion?: boolean; objects?: string[] }) {
         const logger = this.getBaichuanLogger();
 
         if (!this.isEventDispatchEnabled()) return;
 
-        if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+        if (this.isDebugEnabled()) {
             logger.debug(`Events received: ${JSON.stringify(events)}`);
         }
 
-        // const debugEvents = this.storageSettings.values.debugEvents;
-        // if (debugEvents) {
-        //     logger.debug(`Events received: ${JSON.stringify(events)}`);
-        // }
-
         if (this.shouldDispatchMotion() && events.motion !== this.motionDetected) {
             if (events.motion) {
                 this.motionDetected = true;
@@ -147,30 +138,4 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
             sdk.deviceManager.onDeviceEvent(this.nativeId, ScryptedInterface.ObjectDetector, od);
         }
     }
-
-    protected async withBaichuanClient<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T> {
-        const client = await this.ensureClient();
-        return fn(client);
-    }
-
-    async getPictureOptions(): Promise<ResponsePictureOptions[]> {
-        return [];
-    }
-
-    async getOtherSettings(): Promise<Setting[]> {
-        return await this.getSettings();
-    }
-
-    showRtspUrlOverride() {
-        return false;
-    }
-
-
-    async startIntercom(media: MediaObject): Promise<void> {
-        await this.intercom.start(media);
-    }
-
-    stopIntercom(): Promise<void> {
-        return this.intercom.stop();
-    }
 }