@apocaliss92/scrypted-reolink-native 0.0.2 → 0.0.4

package/src/camera.ts

@@ -1,13 +1,13 @@
-import type { BatteryInfo, DeviceCapabilities, PtzCommand, ReolinkBaichuanApi, ReolinkSimpleEvent, StreamProfile } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, RequestPictureOptions, ResponseMediaStreamOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, Setting, Settings, Sleep, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
+import type { BatteryInfo, DebugOptions, DeviceCapabilities, PtzCommand, ReolinkBaichuanApi, StreamProfile } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, RequestPictureOptions, ResponseMediaStreamOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, Setting, Settings, Sleep, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from '@scrypted/sdk/storage-settings';
-import { RtspClient } from "../../scrypted/common/src/rtsp-server";
 import { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
+import { BaichuanTransport, connectBaichuanWithTcpUdpFallback, createBaichuanApi, maskUid } from './connect';
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkPtzPresets } from "./presets";
 import { parseStreamProfileFromId, StreamManager } from './stream-utils';
-import { connectBaichuanWithTcpUdpFallback, createBaichuanApi, maskUid } from './connect';
+import { getDeviceInterfaces } from "./utils";
 
 export const moToB64 = async (mo: MediaObject) => {
     const bufferImage = await sdk.mediaManager.convertMediaObjectToBuffer(mo, 'image/jpeg');
@@ -158,22 +158,19 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff {
 }
 
 // export class ReolinkNativeCamera extends ScryptedDeviceBase implements Camera, DeviceProvider, Intercom, ObjectDetector, PanTiltZoom, Sleep, VideoTextOverlays {
-export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCamera, Settings, Camera, DeviceProvider, Intercom, ObjectDetector, PanTiltZoom, Sleep, VideoTextOverlays {
+export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCamera, Settings, Camera, DeviceProvider, Intercom, ObjectDetector, PanTiltZoom, Sleep, VideoTextOverlays, BinarySensor {
     videoStreamOptions: Promise<UrlMediaStreamOptions[]>;
     motionTimeout: NodeJS.Timeout;
+    private doorbellBinaryTimeout: NodeJS.Timeout | undefined;
     siren: ReolinkCameraSiren;
     floodlight: ReolinkCameraFloodlight;
     pirSensor: ReolinkCameraPirSensor;
     private baichuanApi: ReolinkBaichuanApi | undefined;
+    private connectionTime: number | undefined;
     private refreshingState = false;
 
-    private subscribedToEvents = false;
-    private onSimpleEvent: ((ev: ReolinkSimpleEvent) => void) | undefined;
-    private eventsApi: ReolinkBaichuanApi | undefined;
-
     private periodicStarted = false;
     private statusPollTimer: NodeJS.Timeout | undefined;
-    private eventsRestartTimer: NodeJS.Timeout | undefined;
     private lastActivityMs = Date.now();
     private lastB64Snapshot: string | undefined;
     private lastSnapshotTaken: number | undefined;
@@ -181,13 +178,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
     private udpFallbackAlerted = false;
 
-    private dispatchEventsApplyTimer: NodeJS.Timeout | undefined;
-    private dispatchEventsApplySeq = 0;
-
-    private lastAppliedDispatchEventsKey: string | undefined;
-
-    intercomClient: RtspClient;
-
     private intercom: ReolinkBaichuanIntercom;
 
     private ptzPresets: ReolinkPtzPresets;
@@ -229,7 +219,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             defaultValue: ['motion', 'objects'],
             choices: ['motion', 'objects'],
             onPut: async () => {
-                this.scheduleApplyEventDispatchSettings();
+                await this.subscribeToEvents();
             },
         },
         debugLogs: {
@@ -248,7 +238,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                 oldSel.delete('eventLogs');
                 newSel.delete('eventLogs');
 
-                const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
+                const changed = oldSel.size !== newSel.size;
                 if (changed) {
                     await this.resetBaichuanClient('debugLogs changed');
                 }
@@ -396,6 +386,11 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             type: 'boolean',
             hide: true
         },
+        useUdp: {
+            type: 'boolean',
+            hide: true,
+            defaultValue: false
+        },
         intercomBlocksPerPayload: {
             subgroup: 'Advanced',
             title: 'Intercom Blocks Per Payload',
@@ -454,23 +449,15 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
     private async resetBaichuanClient(reason?: any): Promise<void> {
         try {
+            this.unsubscribedToEvents();
             await this.baichuanApi?.close();
         }
         catch (e) {
             this.getLogger().warn('Error closing Baichuan client during reset', e);
         }
         finally {
-            if (this.eventsApi && this.onSimpleEvent) {
-                try {
-                    this.eventsApi.simpleEvents.off('event', this.onSimpleEvent);
-                }
-                catch {
-                    // ignore
-                }
-            }
             this.baichuanApi = undefined;
-            this.subscribedToEvents = false;
-            this.eventsApi = undefined;
+            this.connectionTime = undefined;
         }
 
         if (reason) {
@@ -512,9 +499,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
         // Start event subscription after discovery.
         try {
-            if (this.isEventDispatchEnabled()) {
-                await this.ensureBaichuanEventSubscription();
-            }
+            await this.subscribeToEvents();
         }
         catch (e) {
             logger.warn('Failed to subscribe to Baichuan events', e);
@@ -536,7 +521,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             return this.baichuanApi;
         }
 
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
+        const { ipAddress, username, password, uid, useUdp } = this.storageSettings.values;
 
         if (!ipAddress || !username || !password) {
             throw new Error('Missing camera credentials');
@@ -547,7 +532,29 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         }
 
         const debugOptions = this.getBaichuanDebugOptions();
-        const { api } = await connectBaichuanWithTcpUdpFallback(
+
+        // Se useUdp è impostato, usa direttamente UDP senza provare TCP
+        if (useUdp) {
+            this.getLogger().log(`Using UDP transport directly (useUdp=${useUdp})`);
+            const api = await createBaichuanApi(
+                {
+                    host: ipAddress,
+                    username,
+                    password,
+                    uid,
+                    logger: this.console,
+                    ...(debugOptions ? { debugOptions } : {}),
+                },
+                'udp',
+            );
+            await api.login();
+            this.baichuanApi = api;
+            this.connectionTime = Date.now();
+            return api;
+        }
+
+        // Altrimenti prova TCP con fallback a UDP
+        const { api, transport } = await connectBaichuanWithTcpUdpFallback(
             {
                 host: ipAddress,
                 username,
@@ -567,20 +574,45 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             },
         );
 
+        // Se il fallback ha usato UDP, salva la setting per usare sempre UDP in futuro
+        if (transport === 'udp') {
+            await this.storageSettings.putSetting('useUdp', 'true');
+            this.getLogger().log(`TCP fallback to UDP detected. Saving useUdp setting for future connections.`);
+        }
+
         this.baichuanApi = api;
+        this.connectionTime = Date.now();
         return api;
     }
 
-    private async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        // Ensure the main client is initialized first so we know if this device needs UDP.
-        const primary = await this.ensureClient();
-        const transport = primary.client.getTransport();
+    private getBaichuanDebugOptions(): any | undefined {
+        const sel = new Set<string>(this.storageSettings.values.debugLogs);
+        if (!sel.size) return undefined;
+
+        const debugOptions: DebugOptions = {};
+        // Only pass through Baichuan client debug flags.
+        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'debugH264', 'debugParamSets']);
+        for (const k of sel) {
+            if (!clientKeys.has(k)) continue;
+            debugOptions[k] = true;
+        }
+        return Object.keys(debugOptions).length ? debugOptions : undefined;
+    }
 
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
+    private async createStreamClient(): Promise<ReolinkBaichuanApi> {
+        const { ipAddress, username, password, uid, useUdp } = this.storageSettings.values;
         if (!ipAddress || !username || !password) {
             throw new Error('Missing camera credentials');
         }
 
+        // Usa la setting useUdp per determinare il transport invece di ottenere dal client primario
+        // Questo garantisce che lo stream client usi lo stesso transport del client principale
+        const transport: BaichuanTransport = useUdp ? 'udp' : 'tcp';
+
+        if (useUdp) {
+            this.getLogger().log(`Creating stream client with UDP transport (useUdp=${useUdp})`);
+        }
+
         const debugOptions = this.getBaichuanDebugOptions();
         const api = await createBaichuanApi(
             {
@@ -612,194 +644,137 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         const channel = this.getRtspChannel();
 
         try {
-            const { capabilities, abilities, support, presets } = await api.getDeviceCapabilities(channel);
+            const { capabilities, abilities, support, presets } = await this.withBaichuanRetry(async () =>
+                api.getDeviceCapabilities(channel, {
+                    probeAi: false,
+                })
+            );
             this.storageSettings.values.capabilities = capabilities;
             this.ptzPresets.setCachedPtzPresets(presets);
-            this.console.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
-        }
-        catch (e) {
-            logger.error('Failed to refresh abilities', e);
-        }
 
-        // try {
-        //     await this.refreshAuxDevicesStatus();
-        // }
-        // catch (e) {
-        //     logger.error('Failed to refresh device status', e);
-        // }
 
-        try {
+            try {
+                const interfaces = getDeviceInterfaces({
+                    capabilities,
+                    logger: this.console,
+                });
 
-            const interfaces = await this.getDeviceInterfaces();
+                const device: Device = {
+                    nativeId: this.nativeId,
+                    providerNativeId: this.plugin.nativeId,
+                    name: this.name,
+                    interfaces,
+                    type: this.type as ScryptedDeviceType,
+                    info: this.info,
+                };
 
-            const device: Device = {
-                nativeId: this.nativeId,
-                providerNativeId: this.plugin.nativeId,
-                name: this.name,
-                interfaces,
-                type: this.type as ScryptedDeviceType,
-                info: this.info,
-            };
+                logger.log(`Updating device interfaces: ${JSON.stringify(interfaces)}`);
 
-            logger.log(`Updating device interfaces: ${JSON.stringify(interfaces)}`);
+                await sdk.deviceManager.onDeviceDiscovered(device);
+            } catch (e) {
+                logger.error('Failed to update device interfaces', e);
+            }
 
-            await sdk.deviceManager.onDeviceDiscovered(device);
-        } catch (e) {
-            logger.error('Failed to update device interfaces', e);
+            this.console.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
         }
-
-        this.refreshingState = false;
-    }
-
-    private async ensureBaichuanEventSubscription(): Promise<void> {
-        if (!this.isEventDispatchEnabled()) {
-            await this.disableBaichuanEventSubscription();
-            return;
+        catch (e) {
+            logger.error('Failed to refresh abilities', e);
         }
-        if (this.subscribedToEvents) return;
-        const api = await this.ensureClient();
 
         try {
-            await api.subscribeEvents();
+            await this.refreshAuxDevicesStatus();
         }
-        catch {
-            // Some firmwares don't require explicit subscribe or may reject it.
+        catch (e) {
+            logger.error('Failed to refresh device status', e);
         }
 
-        this.onSimpleEvent ||= (ev: any) => {
-            try {
-                if (!this.isEventDispatchEnabled()) return;
-                if (this.isEventLogsEnabled()) {
-                    this.getLogger().debug(`Baichuan event: ${JSON.stringify(ev)}`);
-                }
-                const channel = this.getRtspChannel();
-                if (ev?.channel !== undefined && ev.channel !== channel) return;
-
-                const objects: string[] = [];
-                let motion = false;
-
-                switch (ev?.type) {
-                    case 'motion':
-                        motion = this.shouldDispatchMotion();
-                        break;
-                    case 'doorbell':
-                        // Placeholder: treat doorbell as motion.
-                        motion = this.shouldDispatchMotion();
-                        break;
-                    case 'people':
-                    case 'vehicle':
-                    case 'animal':
-                    case 'face':
-                    case 'package':
-                    case 'other':
-                        if (this.shouldDispatchObjects()) objects.push(ev.type);
-                        break;
-                    default:
-                        return;
-                }
+        this.refreshingState = false;
+    }
 
-                this.processEvents({ motion, objects }).catch(() => { });
+    private onSimpleEvent = (ev: any) => {
+        try {
+            if (!this.isEventDispatchEnabled()) return;
+            if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
+                this.getLogger().debug(`Baichuan event: ${JSON.stringify(ev)}`);
             }
-            catch {
-                // ignore
+            const channel = this.getRtspChannel();
+            if (ev?.channel !== undefined && ev.channel !== channel) return;
+
+            const objects: string[] = [];
+            let motion = false;
+
+            switch (ev?.type) {
+                case 'motion':
+                    motion = this.shouldDispatchMotion();
+                    break;
+                case 'doorbell':
+                    this.binaryState = true;
+                    if (this.doorbellBinaryTimeout) clearTimeout(this.doorbellBinaryTimeout);
+                    this.doorbellBinaryTimeout = setTimeout(() => {
+                        this.binaryState = false;
+                        this.doorbellBinaryTimeout = undefined;
+                    }, 2000);
+
+                    motion = this.shouldDispatchMotion();
+                    break;
+                case 'people':
+                case 'vehicle':
+                case 'animal':
+                case 'face':
+                case 'package':
+                case 'other':
+                    if (this.shouldDispatchObjects()) objects.push(ev.type);
+                    break;
+                default:
+                    return;
             }
-        };
 
-        // Attach the handler to the current API instance, and detach from any previous instance.
-        if (this.eventsApi && this.eventsApi !== api && this.onSimpleEvent) {
-            try {
-                this.eventsApi.simpleEvents.off('event', this.onSimpleEvent);
-            }
-            catch {
-                // ignore
-            }
+            this.processEvents({ motion, objects }).catch(() => { });
         }
-        if (this.eventsApi !== api && this.onSimpleEvent) {
-            api.simpleEvents.on('event', this.onSimpleEvent);
-            this.eventsApi = api;
+        catch {
+            // ignore
         }
-
-        this.subscribedToEvents = true;
     }
 
-    private async disableBaichuanEventSubscription(): Promise<void> {
-        // Do not wake up battery cameras / do not force login: best-effort cleanup only.
+    private unsubscribedToEvents() {
         const api = this.getClient();
-        if (api?.client?.loggedIn) {
-            try {
-                await api.unsubscribeEvents();
-            }
-            catch {
-                // ignore
-            }
-        }
-
-        if (this.eventsApi && this.onSimpleEvent) {
-            try {
-                this.eventsApi.simpleEvents.off('event', this.onSimpleEvent);
-            }
-            catch {
-                // ignore
-            }
-        }
-
-        this.subscribedToEvents = false;
-        this.eventsApi = undefined;
-
-        if (this.motionTimeout) {
-            clearTimeout(this.motionTimeout);
-        }
-        this.motionDetected = false;
+        api.offSimpleEvent(this.onSimpleEvent);
     }
 
-    private async applyEventDispatchSettings(): Promise<void> {
+    private async subscribeToEvents(): Promise<void> {
         const logger = this.getLogger();
         const selection = Array.from(this.getDispatchEventsSelection()).sort();
-        const key = selection.join(',');
-        const prevKey = this.lastAppliedDispatchEventsKey;
-
-        if (prevKey !== undefined && prevKey !== key) {
-            logger.log(`Dispatch Events changed: ${selection.length ? selection.join(', ') : '(disabled)'}`);
-        }
+        const enabled = selection.length > 0;
 
-        // User-initiated settings change counts as activity.
+        // Settings change / init counts as activity.
         this.markActivity();
 
-        // Empty selection disables everything.
-        if (!this.isEventDispatchEnabled()) {
-            if (this.subscribedToEvents) {
-                logger.log('Event listener stopped (Dispatch Events disabled)');
-            }
-            await this.disableBaichuanEventSubscription();
-            this.lastAppliedDispatchEventsKey = key;
-            return;
-        }
-
-        // If motion is not selected, ensure state is cleared.
         if (!this.shouldDispatchMotion()) {
             if (this.motionTimeout) clearTimeout(this.motionTimeout);
             this.motionDetected = false;
         }
 
-        // Apply immediately even if we were already subscribed.
-        // If nothing actually changed and we're already subscribed, avoid a noisy resubscribe.
-        if (prevKey === key && this.subscribedToEvents) {
-            // Track baseline so later changes are logged.
-            this.lastAppliedDispatchEventsKey = key;
+        this.unsubscribedToEvents();
+
+        if (!enabled) {
+            if (this.doorbellBinaryTimeout) {
+                clearTimeout(this.doorbellBinaryTimeout);
+                this.doorbellBinaryTimeout = undefined;
+            }
+            this.binaryState = false;
             return;
         }
 
-        if (!this.subscribedToEvents) {
-            logger.log(`Event listener started (${selection.join(', ')})`);
-            await this.ensureBaichuanEventSubscription();
-            this.lastAppliedDispatchEventsKey = key;
+        const api = await this.ensureClient();
+
+        try {
+            api.onSimpleEvent(this.onSimpleEvent);
+            logger.log(`Subscribed to events (${selection.join(', ')})`);
+        }
+        catch (e) {
+            logger.warn('Failed to attach Baichuan event handler', e);
             return;
         }
-
-        logger.log(`Event listener restarting (${selection.join(', ')})`);
-        await this.disableBaichuanEventSubscription();
-        await this.ensureBaichuanEventSubscription();
-        this.lastAppliedDispatchEventsKey = key;
     }
 
     markActivity(): void {
@@ -821,7 +796,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
     async release() {
         this.statusPollTimer && clearInterval(this.statusPollTimer);
-        this.eventsRestartTimer && clearInterval(this.eventsRestartTimer);
         return this.resetBaichuanClient();
     }
 
@@ -832,10 +806,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         this.statusPollTimer = setInterval(() => {
             this.periodic10sTick().catch(() => { });
         }, 10_000);
-
-        this.eventsRestartTimer = setInterval(() => {
-            this.periodic60sRestartEvents().catch(() => { });
-        }, 60_000);
     }
 
     private async periodic10sTick(): Promise<void> {
@@ -847,46 +817,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         }
 
         await this.refreshAuxDevicesStatus();
-
-        // Best-effort: ensure we're subscribed.
-        if (this.isEventDispatchEnabled() && !this.subscribedToEvents) {
-            if (this.hasBattery()) {
-                const api = this.getClient();
-                if (!api?.client?.loggedIn) return;
-            }
-            await this.ensureBaichuanEventSubscription();
-        }
-    }
-
-    private async periodic60sRestartEvents(): Promise<void> {
-        if (this.shouldAvoidWakingBatteryCamera()) return;
-
-        if (!this.isEventDispatchEnabled()) {
-            await this.disableBaichuanEventSubscription();
-            return;
-        }
-
-        // Wired cameras can reconnect; battery cameras only operate on an existing active client.
-        if (!this.hasBattery()) {
-            await this.ensureClient();
-        }
-        else {
-            const api = this.getClient();
-            if (!api?.client?.loggedIn) return;
-        }
-
-        const api = this.getClient();
-        if (!api) return;
-
-        try {
-            await api.unsubscribeEvents();
-        }
-        catch {
-            // ignore
-        }
-
-        this.subscribedToEvents = false;
-        await this.ensureBaichuanEventSubscription();
     }
 
     private async refreshAuxDevicesStatus(): Promise<void> {
@@ -920,48 +850,45 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     }
 
     async getVideoTextOverlays(): Promise<Record<string, VideoTextOverlay>> {
-        const client = this.getClient();
-        if (!client) {
-            return;
-        }
-        // TODO: restore
-        // const { cachedOsd } = this.storageSettings.values;
-
-        // return {
-        //     osdChannel: {
-        //         text: cachedOsd.value.Osd.osdChannel.enable ? cachedOsd.value.Osd.osdChannel.name : undefined,
-        //     },
-        //     osdTime: {
-        //         text: !!cachedOsd.value.Osd.osdTime.enable,
-        //         readonly: true,
-        //     }
-        // }
+        const client = await this.ensureClient();
+        const channel = this.getRtspChannel();
+
+        const osd = await client.getOsd(channel);
+
+        return {
+            osdChannel: {
+                text: osd?.osdChannel?.enable ? osd.osdChannel.name : undefined,
+            },
+            osdTime: {
+                text: !!osd?.osdTime?.enable,
+                readonly: true,
+            },
+        };
     }
 
     async setVideoTextOverlay(id: 'osdChannel' | 'osdTime', value: VideoTextOverlay): Promise<void> {
         const client = await this.ensureClient();
-        if (!client) {
-            return;
-        }
-        // TODO: restore
+        const channel = this.getRtspChannel();
 
-        // const osd = await client.getOsd();
+        const osd = await client.getOsd(channel);
 
-        // if (id === 'osdChannel') {
-        //     osd.osdChannel.enable = value.text ? 1 : 0;
-        //     // name must always be valid.
-        //     osd.osdChannel.name = typeof value.text === 'string' && value.text
-        //         ? value.text
-        //         : osd.osdChannel.name || 'Camera';
-        // }
-        // else if (id === 'osdTime') {
-        //     osd.osdTime.enable = value.text ? 1 : 0;
-        // }
-        // else {
-        //     throw new Error('unknown overlay: ' + id);
-        // }
+        if (id === 'osdChannel') {
+            const nextName = typeof value?.text === 'string' ? value.text.trim() : '';
+            const enable = !!nextName || value?.text === true;
+            osd.osdChannel.enable = enable ? 1 : 0;
+            // Name must always be valid when enabled.
+            if (enable) {
+                osd.osdChannel.name = nextName || osd.osdChannel.name || this.name || 'Camera';
+            }
+        }
+        else if (id === 'osdTime') {
+            osd.osdTime.enable = value?.text ? 1 : 0;
+        }
+        else {
+            throw new Error('unknown overlay: ' + id);
+        }
 
-        // await client.setOsd(channel, osd);
+        await client.setOsd(channel, osd);
     }
 
     updatePtzCaps() {
@@ -992,7 +919,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         const channel = this.getRtspChannel();
 
         // Preset navigation.
-        const preset = (command as any).preset;
+        const preset = command.preset;
         if (preset !== undefined && preset !== null) {
             const presetId = Number(preset);
             if (!Number.isFinite(presetId)) {
@@ -1101,6 +1028,16 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         return Boolean(capabilities?.hasBattery);
     }
 
+    hasIntercom() {
+        const capabilities = this.getAbilities();
+        return Boolean(capabilities?.hasIntercom);
+    }
+
+    isDoorbell() {
+        const capabilities = this.getAbilities() as any;
+        return Boolean(capabilities?.isDoorbell);
+    }
+
     getPtzCapabilities() {
         const capabilities = this.getAbilities();
         const hasZoom = Boolean(capabilities?.hasZoom);
@@ -1125,48 +1062,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         return Boolean(capabilities?.hasPir);
     }
 
-    async getDeviceInterfaces() {
-        const interfaces = [
-            ScryptedInterface.VideoCamera,
-            ScryptedInterface.Settings,
-            ...this.plugin.getCameraInterfaces(),
-        ];
-
-        try {
-            // Expose Intercom if the camera supports Baichuan talkback.
-            try {
-                const api = this.getClient();
-                if (api) {
-                    const ability = await api.getTalkAbility(this.getRtspChannel());
-                    if (Array.isArray((ability as any)?.audioConfigList) && (ability as any).audioConfigList.length > 0) {
-                        interfaces.push(ScryptedInterface.Intercom);
-                    }
-                }
-            }
-            catch {
-                // ignore: camera likely doesn't support talkback
-            }
-
-            const { hasPtz } = this.getPtzCapabilities();
-
-            if (hasPtz) {
-                interfaces.push(ScryptedInterface.PanTiltZoom);
-            }
-            if ((await this.getObjectTypes()).classes.length > 0) {
-                interfaces.push(ScryptedInterface.ObjectDetector);
-            }
-            if (this.hasSiren() || this.hasFloodlight() || this.hasPirEvents())
-                interfaces.push(ScryptedInterface.DeviceProvider);
-            if (this.hasBattery()) {
-                interfaces.push(ScryptedInterface.Battery, ScryptedInterface.Sleep);
-            }
-        } catch (e) {
-            this.getLogger().error('Error getting device interfaces', e);
-        }
-
-        return interfaces;
-    }
-
     async processBatteryData(data: BatteryInfo) {
         const logger = this.getLogger();
         const batteryLevel = data.batteryPercent;
@@ -1210,7 +1105,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
         if (!this.isEventDispatchEnabled()) return;
 
-        if (this.isEventLogsEnabled()) {
+        if (this.storageSettings.values.dispatchEvents.includes('eventLogs')) {
             logger.debug(`Events received: ${JSON.stringify(events)}`);
         }
 
@@ -1246,40 +1141,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         }
     }
 
-    private normalizeDebugLogs(value: unknown): string[] {
-        const allowed = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'debugH264', 'debugParamSets', 'eventLogs']);
-
-        const items = Array.isArray(value) ? value : (typeof value === 'string' ? [value] : []);
-        const out: string[] = [];
-        for (const v of items) {
-            if (typeof v !== 'string') continue;
-            const s = v.trim();
-            if (!allowed.has(s)) continue;
-            out.push(s);
-        }
-        return Array.from(new Set(out));
-    }
-
-    private getBaichuanDebugOptions(): any | undefined {
-        const sel = new Set(this.normalizeDebugLogs((this.storageSettings.values as any).debugLogs));
-        if (!sel.size) return undefined;
-
-        // Keep this as `any` so we don't need to import DebugOptions types here.
-        const debugOptions: any = {};
-        // Only pass through Baichuan client debug flags.
-        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'debugH264', 'debugParamSets']);
-        for (const k of sel) {
-            if (!clientKeys.has(k)) continue;
-            debugOptions[k] = true;
-        }
-        return Object.keys(debugOptions).length ? debugOptions : undefined;
-    }
-
-    private isEventLogsEnabled(): boolean {
-        const sel = new Set(this.normalizeDebugLogs((this.storageSettings.values as any).debugLogs));
-        return sel.has('eventLogs');
-    }
-
     private getDispatchEventsSelection(): Set<'motion' | 'objects'> {
         return new Set(this.storageSettings.values.dispatchEvents);
     }
@@ -1296,26 +1157,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         return this.getDispatchEventsSelection().has('objects');
     }
 
-    private scheduleApplyEventDispatchSettings(): void {
-        // Debounce to avoid rapid apply loops while editing multi-select.
-        this.dispatchEventsApplySeq++;
-        const seq = this.dispatchEventsApplySeq;
-
-        if (this.dispatchEventsApplyTimer) {
-            clearTimeout(this.dispatchEventsApplyTimer);
-        }
-
-        this.dispatchEventsApplyTimer = setTimeout(() => {
-            // Fire-and-forget; never block settings UI.
-            this.applyEventDispatchSettings().catch((e) => {
-                // Only log once per debounce window.
-                if (seq === this.dispatchEventsApplySeq) {
-                    this.getLogger().warn('Failed to apply Dispatch Events setting', e);
-                }
-            });
-        }, 300);
-    }
-
     async takeSnapshotInternal(timeout?: number) {
         this.markActivity();
         return this.withBaichuanRetry(async () => {
@@ -1366,7 +1207,9 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         }
 
         if (canTake) {
-            return this.takeSnapshotInternal(options?.timeout);
+            if (this.connectionTime && (Date.now() - this.connectionTime) > 5000) {
+                return this.takeSnapshotInternal(options?.timeout);
+            }
         } else if (this.lastB64Snapshot) {
             const mo = await b64ToMo(this.lastB64Snapshot);
 
@@ -1391,6 +1234,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         const selected = vsos?.find(s => s.id === vso.id) || vsos?.[0];
         if (!selected)
             throw new Error('No stream options available');
+        this.getLogger().log(`Creating video stream for option id=${selected.id} name=${selected.name}`);
 
         const profile = parseStreamProfileFromId(selected.id) || 'main';
 
@@ -1402,17 +1246,15 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                 : selected?.video?.codec?.includes('264') ? 'H264'
                     : undefined;
 
-            const { host, port, sdp, audio } = await this.streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType as any);
+            const { host, port, sdp, audio } = await this.streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
 
             const { url: _ignoredUrl, ...mso }: any = selected;
-            // This stream is delivered as RFC4571 (RTP over raw TCP), not RTSP.
-            // Mark it accordingly to avoid RTSP-specific handling in downstream plugins.
             mso.container = 'rtp';
             if (audio) {
                 mso.audio ||= {};
                 mso.audio.codec = audio.codec;
                 mso.audio.sampleRate = audio.sampleRate;
-                (mso.audio as any).channels = audio.channels;
+                mso.audio.channels = audio.channels;
             }
 
             const rfc = {