@apocaliss92/scrypted-reolink-native 0.3.5 → 0.3.7

package/dist/main.nodejs.js.LICENSE.txt

@@ -1,3 +1,258 @@
 /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
 
+/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
 /*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * cie94.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ciede2000.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * cmetric.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * common.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * constants.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ditherErrorDiffusionArray.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * euclidean.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * helper.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * hueStatistics.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * iq.ts - Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * lab2rgb.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * lab2xyz.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * manhattanNeuQuant.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * nearestColor.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * palette.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * pngQuant.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * point.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * pointContainer.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2hsl.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2lab.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgb2xyz.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * ssim.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * wuQuant.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * xyz2lab.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * xyz2rgb.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve
+ * MIT License
+ *
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * riemersma.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * colorHistogram.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * neuquant.ts - part of Image Quantization Library
+ */
+
+/**
+ * @preserve TypeScript port:
+ * Copyright 2015-2018 Igor Bezkrovnyi
+ * All rights reserved. (MIT Licensed)
+ *
+ * rgbquant.ts - part of Image Quantization Library
+ */

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.3.5",
+   "version": "0.3.7",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/baichuan-base.ts

@@ -1,6 +1,7 @@
 import type { BaichuanClientOptions, ReolinkBaichuanApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import { ScryptedDeviceBase } from "@scrypted/sdk";
 import { createBaichuanApi, type BaichuanTransport } from "./connect";
+import { StreamManager } from "./stream-utils";
 
 export interface BaichuanConnectionConfig {
     host: string;
@@ -176,6 +177,11 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
     private lastDisconnectTime: number = 0;
     private readonly reconnectBackoffMs: number = 2000; // 2 seconds minimum between reconnects
     private eventSubscriptionActive: boolean = false;
+    private lastEventTime: number = 0;
+    private pingInterval?: NodeJS.Timeout;
+    private autoRenewInterval?: NodeJS.Timeout;
+    private eventCheckInterval?: NodeJS.Timeout;
+    private consecutivePingFailures: number = 0;
 
     /**
      * Get the connection configuration for this instance
@@ -204,6 +210,12 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
      */
     protected abstract getStreamClientInputs(): BaichuanConnectionConfig;
 
+    /**
+     * Get StreamManager if available (optional, only for devices that support streaming)
+     * Override in subclasses that have a StreamManager
+     */
+    protected getStreamManager?(): StreamManager | undefined;
+
     /**
      * Get a Baichuan logger instance with formatting and debug control
      * This logger implements Console interface and can be used everywhere
@@ -293,6 +305,14 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                 this.baichuanApi = api;
                 this.connectionTime = Date.now();
 
+                // Start ping and auto-renewal for TCP connections
+                if (this.transport === 'tcp') {
+                    this.startConnectionMaintenance(api);
+                }
+
+                // Start event check for all connections
+                this.startEventCheck(api);
+
                 return api;
             }
             catch (e) {
@@ -449,11 +469,206 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             // ignore
         }
 
+        // Stop ping and auto-renewal intervals
+        this.stopConnectionMaintenance();
+
+        // Stop event check interval
+        this.stopEventCheck();
+
         // Reset state
         this.baichuanApi = undefined;
         this.ensureClientPromise = undefined;
     }
 
+    /**
+     * Get all active Baichuan connections (main + stream clients)
+     */
+    private getAllActiveConnections(): ReolinkBaichuanApi[] {
+        const connections: ReolinkBaichuanApi[] = [];
+        
+        // Add main connection if exists and is valid
+        if (this.baichuanApi) {
+            const isConnected = this.baichuanApi.client.isSocketConnected();
+            const isLoggedIn = this.baichuanApi.client.loggedIn;
+            if (isConnected && isLoggedIn) {
+                connections.push(this.baichuanApi);
+            }
+        }
+        
+        // Add all stream clients that are valid
+        for (const streamClient of this.streamClients.values()) {
+            const isConnected = streamClient.client.isSocketConnected();
+            const isLoggedIn = streamClient.client.loggedIn;
+            if (isConnected && isLoggedIn) {
+                connections.push(streamClient);
+            }
+        }
+        
+        return connections;
+    }
+
+    /**
+     * Start ping and auto-renewal maintenance for TCP connections
+     */
+    private startConnectionMaintenance(api: ReolinkBaichuanApi): void {
+        const logger = this.getBaichuanLogger();
+        
+        // Stop any existing intervals
+        this.stopConnectionMaintenance();
+
+        // Ping every 30 seconds to keep all connections alive
+        this.pingInterval = setInterval(async () => {
+            if (!this.baichuanApi || this.baichuanApi !== api) {
+                return; // Connection changed, stop this interval
+            }
+
+            try {
+                // Get all active connections (main + stream clients)
+                const allConnections = this.getAllActiveConnections();
+                logger.debug(`Pinging ${allConnections.length} connections`);
+                
+                if (allConnections.length === 0) {
+                    this.consecutivePingFailures++;
+                    logger.debug(`No active connections found, failures=${this.consecutivePingFailures}`);
+                    
+                    if (this.consecutivePingFailures >= 3) {
+                        logger.log('No active connections detected, renewing connection');
+                        await this.cleanupBaichuanApi();
+                        this.consecutivePingFailures = 0;
+                    }
+                    return;
+                }
+
+                // Ping all connections using the specific ping method
+                const pingResults = await Promise.allSettled(
+                    allConnections.map(async (conn) => {
+                        try {
+                            await conn.ping();
+                            return { success: true, conn };
+                        } catch (e) {
+                            return { success: false, conn, error: e };
+                        }
+                    })
+                );
+
+                // Check results
+                const failedPings = pingResults.filter(r => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.success));
+
+                if (failedPings.length > 0) {
+                    this.consecutivePingFailures++;
+                    logger.debug(`Ping failed for ${failedPings.length}/${allConnections.length} connections, failures=${this.consecutivePingFailures}`);
+                    
+                    if (this.consecutivePingFailures >= 3) {
+                        logger.log(`Multiple ping failures detected (${failedPings.length} connections), renewing connection`);
+                        await this.cleanupBaichuanApi();
+                        this.consecutivePingFailures = 0;
+                    }
+                } else {
+                    // All pings successful, reset failure counter
+                    this.consecutivePingFailures = 0;
+                    if (allConnections.length > 1) {
+                        logger.debug(`Ping successful for all ${allConnections.length} connections`);
+                    }
+                }
+            } catch (e) {
+                logger.debug(`Error in ping check: ${e?.message || String(e)}`);
+            }
+        }, 30_000); // Every 30 seconds
+
+        // Auto-renewal every 5 minutes if no active streams
+        this.autoRenewInterval = setInterval(async () => {
+            if (!this.baichuanApi || this.baichuanApi !== api) {
+                return; // Connection changed, stop this interval
+            }
+
+            try {
+                // Check if there are active streams
+                const hasActiveStreams = this.getStreamManager?.()?.hasActiveStreams() ?? false;
+                
+                if (!hasActiveStreams) {
+                    logger.log('No active streams detected, renewing connection (auto-renewal)');
+                    await this.cleanupBaichuanApi();
+                } else {
+                    logger.debug('Active streams detected, skipping auto-renewal');
+                }
+            } catch (e) {
+                logger.debug(`Error in auto-renewal check: ${e?.message || String(e)}`);
+            }
+        }, 5 * 60_000); // Every 5 minutes
+    }
+
+    /**
+     * Stop ping and auto-renewal maintenance
+     */
+    private stopConnectionMaintenance(): void {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = undefined;
+        }
+        if (this.autoRenewInterval) {
+            clearInterval(this.autoRenewInterval);
+            this.autoRenewInterval = undefined;
+        }
+        this.consecutivePingFailures = 0;
+    }
+
+    /**
+     * Start event check to monitor if events are being received
+     */
+    private startEventCheck(api: ReolinkBaichuanApi): void {
+        const logger = this.getBaichuanLogger();
+        
+        // Stop any existing interval
+        this.stopEventCheck();
+
+        // Check every minute if events are being received
+        this.eventCheckInterval = setInterval(async () => {
+            if (!this.baichuanApi || this.baichuanApi !== api) {
+                return; // Connection changed, stop this interval
+            }
+
+            // Only check if event subscription is active
+            if (!this.eventSubscriptionActive) {
+                return;
+            }
+
+            try {
+                const now = Date.now();
+                const timeSinceLastEvent = now - this.lastEventTime;
+                const fiveMinutesMs = 5 * 60 * 1000;
+
+                if (this.lastEventTime > 0 && timeSinceLastEvent > fiveMinutesMs) {
+                    logger.log(`No events received in the last ${Math.round(timeSinceLastEvent / 60_000)} minutes, restarting event listener`);
+                    // Restart event subscription
+                    await this.unsubscribeFromEvents();
+                    await this.subscribeToEvents();
+                } else if (this.lastEventTime === 0) {
+                    // If lastEventTime is 0, it means we just subscribed but haven't received any events yet
+                    // Wait a bit longer before considering it a problem
+                    const timeSinceSubscription = now - (this.connectionTime || now);
+                    if (timeSinceSubscription > fiveMinutesMs) {
+                        logger.log(`No events received since subscription (${Math.round(timeSinceSubscription / 60_000)} minutes ago), restarting event listener`);
+                        await this.unsubscribeFromEvents();
+                        await this.subscribeToEvents();
+                    }
+                }
+            } catch (e) {
+                logger.debug(`Error in event check: ${e?.message || String(e)}`);
+            }
+        }, 5_000); // Check every minute
+    }
+
+    /**
+     * Stop event check interval
+     */
+    private stopEventCheck(): void {
+        if (this.eventCheckInterval) {
+            clearInterval(this.eventCheckInterval);
+            this.eventCheckInterval = undefined;
+        }
+        this.lastEventTime = 0;
+    }
+
     /**
      * Subscribe to Baichuan simple events
      */
@@ -493,10 +708,19 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             return;
         }
 
-        // Subscribe to events
+        // Subscribe to events with wrapper to track last event time
         try {
-            await api.onSimpleEvent(callbacks.onSimpleEvent);
+            const originalHandler = callbacks.onSimpleEvent;
+            const wrappedHandler = (ev: ReolinkSimpleEvent) => {
+                // Update last event time
+                this.lastEventTime = Date.now();
+                // Call original handler
+                originalHandler(ev);
+            };
+            
+            await api.onSimpleEvent(wrappedHandler);
             this.eventSubscriptionActive = true;
+            this.lastEventTime = Date.now(); // Initialize on subscription
             logger.log('Subscribed to Baichuan events');
         }
         catch (e) {

package/src/camera.ts

@@ -1512,6 +1512,13 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
         return convertDebugLogsToApiOptions(socketDebugLogs);
     }
 
+    /**
+     * Get StreamManager if available
+     */
+    protected getStreamManager(): StreamManager | undefined {
+        return this.streamManager;
+    }
+
     /**
      * Initialize or recreate the StreamManager, taking into account multifocal composite options.
      */
@@ -2070,7 +2077,7 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
     async takePictureInternal(client: ReolinkBaichuanApi) {
         const { rtspChannel, variantType } = this.storageSettings.values;
         const logger = this.getBaichuanLogger();
-        logger.log(`Taking new snapshot from camera: forceNewSnapshot=${this.forceNewSnapshot} channel=${rtspChannel} variant=${variantType}`);
+        logger.debug(`Taking new snapshot from camera: forceNewSnapshot=${this.forceNewSnapshot} channel=${rtspChannel} variant=${variantType}`);
 
         const compositeOptions = this.isMultiFocal ? {
             widerChannel: this.isOnNvr ? rtspChannel : undefined,
@@ -2124,7 +2131,7 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
             }
 
             if (!shouldTakeNewSnapshot && this.lastPicture) {
-                logger.log(`Returning cached snapshot, taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
+                logger.debug(`Returning cached snapshot, taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
                 return this.lastPicture.mo;
             }
 
@@ -2781,15 +2788,18 @@ export class ReolinkCamera extends BaseBaichuanClass implements VideoCamera, Cam
 
             if (sleepStatus.state === 'sleeping') {
                 if (!this.sleeping) {
-                    this.getBaichuanLogger().log(`Camera is sleeping: ${sleepStatus.reason}`);
+                    this.getBaichuanLogger().log(`Camera is sleeping`);
                     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.getBaichuanLogger().log(`Camera is awake`);
                     this.sleeping = false;
+                    const client = await this.ensureClient();
+                    await client.wakeUp();
+                    await this.takePictureInternal(client);
                 }
 
                 if (wasSleeping) {

package/src/stream-utils.ts

@@ -456,6 +456,18 @@ export class StreamManager {
         });
     }
 
+    /**
+     * Check if there are any active streams (servers that are listening).
+     */
+    hasActiveStreams(): boolean {
+        for (const server of this.nativeRfcServers.values()) {
+            if (server?.server?.listening) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Close all active stream servers.
      * Useful when the main connection is reset and streams need to be recreated.