@apocaliss92/scrypted-reolink-native 0.1.19 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.19",
+   "version": "0.1.21",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",
@@ -21,7 +21,8 @@
       "scrypted",
       "plugin",
       "reolink",
-      "neolink",
+      "native",
+      "native",
       "camera"
    ],
    "scrypted": {

package/src/camera.ts

@@ -70,17 +70,11 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
 
             // Reset client and clear cache on recoverable error
             await this.resetBaichuanClient(e);
-            this.cachedNetPort = undefined;
 
             // Important: callers must re-acquire the client inside fn.
             try {
                 return await fn();
             } catch (retryError) {
-                // If retry also fails with recoverable error, don't spam logs
-                if (this.isRecoverableBaichuanError(retryError)) {
-                    // Silently fail to avoid spam, but still throw to caller
-                    throw retryError;
-                }
                 throw retryError;
             }
         }

package/src/common.ts

@@ -1,4 +1,4 @@
-import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamSamplingSelection } 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, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
@@ -11,10 +11,8 @@ import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkNativeMultiFocalDevice } from "./multifocal";
 import { ReolinkPtzPresets } from "./presets";
 import {
-    buildVideoStreamOptions,
     createRfc4571MediaObjectFromStreamManager,
     expectedVideoTypeFromUrlMediaStreamOptions,
-    isNativeStreamId,
     parseStreamProfileFromId,
     selectStreamOption,
     StreamManager
@@ -222,6 +220,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             json: true,
             hide: true,
         },
+        operationChannels: {
+            json: true,
+            hide: true,
+        },
         // Battery camera specific
         uid: {
             title: 'UID',
@@ -503,7 +505,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     // Video stream properties
     protected cachedVideoStreamOptions?: UrlMediaStreamOptions[];
     protected fetchingStreams = false;
-    protected cachedNetPort?: { rtsp?: { port?: number; enable?: number }; rtmp?: { port?: number; enable?: number } };
     protected lastNetPortCacheAttempt: number = 0;
     protected netPortCacheBackoffMs: number = 5000; // 5 seconds backoff on failure
 
@@ -752,7 +753,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const selection = Array.from(this.getDispatchEventsSelection?.() ?? new Set()).sort();
         const enabled = selection.length > 0;
 
-        logger.log(`subscribeToEvents called: enabled=${enabled}, selection=[${selection.join(', ')}], protocol=${this.protocol}`);
+        logger.debug(`subscribeToEvents called: enabled=${enabled}, selection=[${selection.join(', ')}], protocol=${this.protocol}`);
 
         this.unsubscribedToEvents();
 
@@ -1288,54 +1289,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
-    protected getRtspAddress(): string {
-        const { ipAddress } = this.storageSettings.values;
-        const rtspPort = this.cachedNetPort?.rtsp?.port ?? 554;
-        return `${ipAddress}:${rtspPort}`;
-    }
-
-    protected getRtmpAddress(): string {
-        const { ipAddress } = this.storageSettings.values;
-        const rtmpPort = this.cachedNetPort?.rtmp?.port ?? 1935;
-        return `${ipAddress}:${rtmpPort}`;
-    }
-
-    protected async ensureNetPortCache(): Promise<void> {
-        const logger = this.getBaichuanLogger();
-
-        if (this.cachedNetPort) {
-            return;
-        }
-
-        // Implement backoff to avoid spam when socket is closed
-        const now = Date.now();
-        if (now - this.lastNetPortCacheAttempt < this.netPortCacheBackoffMs) {
-            // Use defaults if we're in backoff period
-            this.cachedNetPort = {
-                rtsp: { port: 554, enable: 1 },
-                rtmp: { port: 1935, enable: 1 },
-            };
-            return;
-        }
-
-        this.lastNetPortCacheAttempt = now;
-
-        try {
-            const client = await this.ensureClient();
-            this.cachedNetPort = await client.getNetPort();
-        } catch (e) {
-            // Only log if it's not a recoverable error to avoid spam
-            if (!this.isRecoverableBaichuanError?.(e)) {
-                logger.warn('Failed to get net port, using defaults', e);
-            }
-            // Use defaults if we can't get the ports
-            this.cachedNetPort = {
-                rtsp: { port: 554, enable: 1 },
-                rtmp: { port: 1935, enable: 1 },
-            };
-        }
-    }
-
     async getVideoStreamOptions(): Promise<UrlMediaStreamOptions[]> {
         const logger = this.getBaichuanLogger();
 
@@ -1353,36 +1306,44 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         const client = await this.ensureClient();
 
-        const { ipAddress, rtspChannel } = this.storageSettings.values;
+        const { rtspChannel } = this.storageSettings.values;
 
         try {
-            await this.ensureNetPortCache();
-        } catch (e) {
-            if (!this.isRecoverableBaichuanError?.(e)) {
-                logger.warn('Failed to ensure net port cache, falling back to Native', e);
+            const { nativeStreams, rtmpStreams, rtspStreams } = await client.buildVideoStreamOptions(rtspChannel);
+
+            let supportedStreams: ReolinkSupportedStream[] = [];
+            if (this.nvrDevice && this.nvrDevice.info.model === 'HOMEHUB') {
+                supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
+            } else {
+                supportedStreams = [...rtspStreams, ...rtmpStreams, ...nativeStreams];
             }
-        }
 
-        try {
-            streams = await buildVideoStreamOptions(
-                {
-                    client,
-                    ipAddress,
-                    cachedNetPort: this.cachedNetPort,
-                    nvrDevice: this.nvrDevice,
-                    rtspChannel,
-                    logger,
-                },
-            );
+            for (const supportedStream of supportedStreams) {
+                const { id, metadata, url, name, container } = supportedStream;
+
+                const codec = String(metadata.videoEncType || "").includes("264")
+                    ? "h264"
+                    : String(metadata.videoEncType || "").includes("265")
+                        ? "h265"
+                        : String(metadata.videoEncType || "").toLowerCase();
+
+                streams.push({
+                    id,
+                    name,
+                    url,
+                    container,
+                    video: { codec, width: metadata.width, height: metadata.height },
+                    // audio: { codec: metadata.audioCodec }
+                })
+            }
         } catch (e) {
             if (!this.isRecoverableBaichuanError?.(e)) {
                 logger.warn('Failed to build RTSP/RTMP stream options, falling back to Native', e);
             }
-            this.cachedNetPort = undefined;
         }
 
         if (streams.length) {
-            logger.log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
+            logger.log('Fetched video stream options', { streams });
             this.cachedVideoStreamOptions = streams;
             return streams;
         }
@@ -1397,13 +1358,13 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const selected = selectStreamOption(vsos, vso);
 
         // Check if this is a native stream (prefixed with "native_")
-        const isNative = isNativeStreamId(selected.id);
 
         // If stream has RTSP/RTMP URL (not native), add credentials and create MediaStreamUrl
-        if (!isNative && selected.url && (selected.container === 'rtsp' || selected.container === 'rtmp')) {
+        if (selected.url && (selected.container === 'rtsp' || selected.container === 'rtmp')) {
             const urlWithCredentials = this.addRtspCredentials(selected.url);
             const ret: MediaStreamUrl = {
                 container: selected.container,
+                // url: selected.url,
                 url: urlWithCredentials,
                 mediaStreamOptions: selected,
             };
@@ -1429,22 +1390,16 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 expectedVideoType,
                 selected,
                 sourceId: this.id,
-                onDetectedCodec: (detectedCodec) => {
-                    // Update cached stream options with detected codec
-                    const nativeId = `native_${profile}`;
-                    const name = `Native ${profile}`;
-
-                    const prev = this.cachedVideoStreamOptions ?? [];
-                    const next = prev.filter((s) => s.id !== nativeId);
-                    next.push({
-                        name,
-                        id: nativeId,
-                        container: 'rtp',
-                        video: { codec: detectedCodec },
-                        url: ``
-                    });
-                    this.cachedVideoStreamOptions = next;
-                },
+                // onDetectedCodec: (detectedCodec) => {
+                //     const prev = this.cachedVideoStreamOptions ?? [];
+                //     const next = prev.filter((s) => s.id !== nativeId);
+                //     next.push({
+                //         container: 'rtp',
+                //         video: { codec: detectedCodec },
+                //         url: ``
+                //     });
+                //     this.cachedVideoStreamOptions = next;
+                // },
             });
         };
 
@@ -1467,7 +1422,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     async credentialsChanged(): Promise<void> {
         this.cachedVideoStreamOptions = undefined;
-        this.cachedNetPort = undefined;
     }
 
     // PTZ Presets methods

package/src/connect.ts

@@ -1,4 +1,4 @@
-import type { BaichuanClientOptions, ReolinkBaichuanApi, ReolinkDeviceInfo } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanClientOptions, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 
 export type BaichuanTransport = "tcp" | "udp";
 
@@ -16,29 +16,6 @@ export function normalizeUid(uid?: string): string | undefined {
     return v ? v : undefined;
 }
 
-export function maskUid(uid: string): string {
-    const v = uid.trim();
-    if (v.length <= 8) return v;
-    return `${v.slice(0, 4)}…${v.slice(-4)}`;
-}
-
-export function isTcpFailureThatShouldFallbackToUdp(e: unknown): boolean {
-    const message = (e as any)?.message || (e as any)?.toString?.() || "";
-    if (typeof message !== "string") return false;
-
-    // Fallback only on transport/connection style failures.
-    // Wrong credentials won't be fixed by switching to UDP.
-    return (
-        message.includes("ECONNREFUSED") ||
-        message.includes("ETIMEDOUT") ||
-        message.includes("EHOSTUNREACH") ||
-        message.includes("ENETUNREACH") ||
-        message.includes("socket hang up") ||
-        message.includes("TCP connection timeout") ||
-        message.includes("Baichuan socket closed")
-    );
-}
-
 export async function createBaichuanApi(props: {
     inputs: BaichuanConnectInputs,
     transport: BaichuanTransport,
@@ -108,178 +85,3 @@ export async function createBaichuanApi(props: {
     attachErrorHandler(api);
     return api;
 }
-
-export type UdpFallbackInfo = {
-    host: string;
-    uid?: string;
-    uidMissing: boolean;
-    tcpError: unknown;
-};
-
-export type DeviceType = 'camera' | 'battery-cam' | 'nvr' | 'multifocal';
-
-export type AutoDetectResult = {
-    type: DeviceType;
-    transport: BaichuanTransport;
-    uid: string;
-    deviceInfo?: ReolinkDeviceInfo;
-    channelNum?: number;
-};
-
-/**
- * Simple ping check to verify IP is reachable
- */
-async function pingHost(host: string, timeoutMs: number = 3000): Promise<boolean> {
-    return new Promise((resolve) => {
-        const { exec } = require('child_process');
-        const platform = process.platform;
-        const pingCmd = platform === 'win32' ? `ping -n 1 -w ${timeoutMs} ${host}` : `ping -c 1 -W ${Math.floor(timeoutMs / 1000)} ${host}`;
-
-        exec(pingCmd, (error: any) => {
-            resolve(!error);
-        });
-    });
-}
-
-/**
- * Auto-detect device type by trying TCP first, then UDP if needed.
- * - First: Ping the IP to verify it's reachable
- * - TCP success: Check if NVR (multiple channels) or regular camera
- * - TCP failure: Try UDP (always battery camera)
- */
-export async function autoDetectDeviceType(
-    inputs: BaichuanConnectInputs,
-    logger: Console,
-): Promise<AutoDetectResult> {
-    const { host, username, password, uid } = inputs;
-
-    // Ping the host first to verify it's reachable
-    logger.log(`[AutoDetect] Pinging ${host}...`);
-    const isReachable = await pingHost(host);
-    if (!isReachable) {
-        logger.warn(`[AutoDetect] Host ${host} is not reachable via ping, but continuing with connection attempt...`);
-    } else {
-        logger.log(`[AutoDetect] Host ${host} is reachable`);
-    }
-
-    // Try TCP first
-    let tcpApi: ReolinkBaichuanApi | undefined;
-    try {
-        logger.log(`[AutoDetect] Trying TCP connection to ${host}...`);
-        tcpApi = await createBaichuanApi({
-            inputs: { host, username, password, logger },
-            transport: 'tcp',
-            logger,
-        });
-        await tcpApi.login();
-
-        // Get device info to check device type
-        const deviceInfo = await tcpApi.getInfo();
-        const { support } = await tcpApi.getDeviceCapabilities();
-        const channelNum = support?.channelNum ?? 1;
-
-        logger.log(`[AutoDetect] TCP connection successful. channelNum=${channelNum}`);
-
-        // Multi-focal devices have 2 or 3 channels
-        if (channelNum === 2 || channelNum === 3) {
-            logger.log(`[AutoDetect] Detected multi-focal device (${channelNum} channels, channelNum=${channelNum})`);
-            await tcpApi.close();
-            return {
-                type: 'multifocal',
-                transport: 'tcp',
-                uid: uid || '',
-                deviceInfo,
-                channelNum,
-            };
-        }
-
-        // If channelNum > 1, it's likely an NVR
-        if (channelNum > 1) {
-            logger.log(`[AutoDetect] Detected NVR (${channelNum} channels)`);
-            await tcpApi.close();
-            return {
-                type: 'nvr',
-                transport: 'tcp',
-                uid: uid || '',
-                deviceInfo,
-                channelNum,
-            };
-        }
-
-        // Single channel device - regular camera
-        logger.log(`[AutoDetect] Detected regular camera (single channel)`);
-        await tcpApi.close();
-        return {
-            type: 'camera',
-            transport: 'tcp',
-            uid: uid || '',
-            deviceInfo,
-            channelNum: 1,
-        };
-    } catch (tcpError) {
-        // TCP failed, try UDP (battery camera)
-        if (tcpApi) {
-            try {
-                await tcpApi.close();
-            } catch {
-                // ignore
-            }
-        }
-
-        if (!isTcpFailureThatShouldFallbackToUdp(tcpError)) {
-            // Not a transport error, rethrow
-            throw tcpError;
-        }
-
-        logger.log(`[AutoDetect] TCP failed, trying UDP (battery camera)...`);
-        const normalizedUid = normalizeUid(uid);
-        if (!normalizedUid) {
-            throw new Error(
-                `TCP connection failed and device likely requires UDP/BCUDP. UID is required for battery cameras (ip=${host}).`
-            );
-        }
-
-        try {
-            const udpApi = await createBaichuanApi({
-                inputs: { host, username, password, uid: normalizedUid, logger },
-                transport: 'udp',
-                logger,
-            });
-            await udpApi.login();
-
-            const deviceInfo = await udpApi.getInfo();
-            const { support } = await udpApi.getDeviceCapabilities();
-            const channelNum = support?.channelNum ?? 1;
-
-            // Multi-focal devices can also be UDP (battery multi-focal cameras)
-            if (channelNum === 2 || channelNum === 3) {
-                logger.log(`[AutoDetect] UDP connection successful. Detected multi-focal device (${channelNum} channels).`);
-                await udpApi.close();
-                return {
-                    type: 'multifocal',
-                    transport: 'udp',
-                    uid: normalizedUid,
-                    deviceInfo,
-                    channelNum,
-                };
-            }
-
-            // Regular battery camera
-            logger.log(`[AutoDetect] UDP connection successful. Detected battery camera.`);
-            await udpApi.close();
-
-            return {
-                type: 'battery-cam',
-                transport: 'udp',
-                uid: normalizedUid,
-                deviceInfo,
-                channelNum: 1,
-            };
-        } catch (udpError) {
-            logger.error(`[AutoDetect] Both TCP and UDP failed. TCP error: ${tcpError}, UDP error: ${udpError}`);
-            throw new Error(
-                `Failed to connect via both TCP and UDP. TCP: ${(tcpError as any)?.message || tcpError}, UDP: ${(udpError as any)?.message || udpError}`
-            );
-        }
-    }
-}

package/src/main.ts

@@ -1,12 +1,12 @@
-import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting, Settings } from "@scrypted/sdk";
+import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting } from "@scrypted/sdk";
+import { BaseBaichuanClass } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { ReolinkNativeNvrDevice } from "./nvr";
+import { CommonCameraMixin } from "./common";
+import { createBaichuanApi } from "./connect";
 import { ReolinkNativeMultiFocalDevice } from "./multifocal";
-import { autoDetectDeviceType, createBaichuanApi, type BaichuanTransport } from "./connect";
+import { ReolinkNativeNvrDevice } from "./nvr";
 import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
-import { BaseBaichuanClass } from "./baichuan-base";
-import { CommonCameraMixin } from "./common";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
@@ -45,6 +45,8 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         // Auto-detect device type (camera, battery-cam, or nvr)
         this.console.log(`[AutoDetect] Starting device type detection for ${ipAddress}...`);
+        const { autoDetectDeviceType } = await import("@apocaliss92/reolink-baichuan-js");
+
         const detection = await autoDetectDeviceType(
             {
                 host: ipAddress,
@@ -53,7 +55,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 uid,
                 logger: this.console,
             },
-            this.console
         );
 
         this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport})`);
@@ -88,11 +89,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.username = username;
             device.storageSettings.values.password = password;
             device.storageSettings.values.uid = detection.uid || '';
-            
-            // Update the protocol based on detection result
-            // Note: This requires updating the protocol property, but it's readonly
-            // The transport is already set in the constructor during createDevice
-            // For now, we'll rely on the constructor parameter
 
             return nativeId;
         }
@@ -162,7 +158,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             const rtspChannel = 0;
             const { abilities, capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
 
-            this.console.log(JSON.stringify({ abilities, capabilities, deviceInfo }));
+            this.console.log(nativeId, JSON.stringify({ abilities, capabilities, deviceInfo }));
 
             const { interfaces, type } = getDeviceInterfaces({
                 capabilities,
@@ -178,6 +174,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             });
 
             const device = await this.getDevice(nativeId) as CommonCameraMixin;
+            this.console.log(name, interfaces, type, device);
 
             device.info = deviceInfo;
             device.classes = objects;
@@ -240,10 +237,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
         } else if (nativeId.endsWith(nvrSuffix)) {
             return new ReolinkNativeNvrDevice(nativeId, this);
         } else if (nativeId.endsWith(multifocalSuffix)) {
-            // Get transport from device settings if available, otherwise default to TCP
-            // The transport is determined during autoDetect and should be stored
-            // For now, we'll try to infer from UID presence (if UID is set, likely UDP)
-            // Default to TCP for now - the transport will be set correctly during createDevice
             return new ReolinkNativeMultiFocalDevice(nativeId, this, 'tcp');
         } else {
             return new ReolinkNativeCamera(nativeId, this);