@apocaliss92/scrypted-reolink-native 0.1.30 → 0.1.31

package/package.json

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

package/src/baichuan-base.ts

@@ -58,10 +58,6 @@ export class BaichuanLogger implements Console {
         }
     }
 
-    isDebugEnabled(): boolean {
-        return this.isDebugEnabledCallback();
-    }
-
     // Console interface implementation - delegate to baseLogger
     assert(condition?: boolean, ...data: any[]): void {
         this.baseLogger.assert(condition, ...data);

package/src/camera-battery.ts

@@ -13,8 +13,6 @@ import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 
 export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
-    private lastPicture: { mo: MediaObject; atMs: number } | undefined;
-    private takePictureInFlight: Promise<MediaObject> | undefined;
     doorbellBinaryTimeout?: NodeJS.Timeout;
     motionDetected: boolean = false;
     motionTimeout: NodeJS.Timeout | undefined;
@@ -22,17 +20,11 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     private sleepCheckTimer: NodeJS.Timeout | undefined;
     private batteryUpdateTimer: NodeJS.Timeout | undefined;
     private lastBatteryLevel: number | undefined;
-    private forceNewSnapshot: boolean = false;
     private batteryUpdateInProgress: boolean = false;
 
-    private isBatteryInfoLoggingEnabled(): boolean {
-        const debugLogs = this.storageSettings.values.debugLogs || [];
-        return debugLogs.includes(DebugLogOption.BatteryInfo);
-    }
-
     constructor(
-        nativeId: string, 
-        public plugin: ReolinkNativePlugin, 
+        nativeId: string,
+        public plugin: ReolinkNativePlugin,
         nvrDevice?: ReolinkNativeNvrDevice,
         multiFocalDevice?: ReolinkNativeMultiFocalDevice
     ) {
@@ -43,53 +35,6 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         });
     }
 
-    async takePicture(options?: RequestPictureOptions): Promise<MediaObject> {
-        const logger = this.getBaichuanLogger();
-        // Allow new snapshot if:
-        // 1. forceNewSnapshot is true, OR
-        // 2. Camera is awake AND last snapshot was taken at least 10 seconds ago
-        // const minSnapshotIntervalMs = 10_000; // 10 seconds
-        // const now = Date.now();
-        const shouldTakeNewSnapshot = this.forceNewSnapshot;
-        // const now = Date.now();
-        // const shouldTakeNewSnapshot = this.forceNewSnapshot || 
-        //     (!this.sleeping && this.lastPicture && (now - this.lastPicture.atMs >= minSnapshotIntervalMs));
-
-        if (!shouldTakeNewSnapshot && this.lastPicture) {
-            logger.debug(`Returning cached snapshot, taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
-            return this.lastPicture.mo;
-        }
-
-        if (this.takePictureInFlight) {
-            return await this.takePictureInFlight;
-        }
-
-        logger.log(`Taking new snapshot from camera (forceNewSnapshot: ${this.forceNewSnapshot})`);
-        this.forceNewSnapshot = false;
-
-        this.takePictureInFlight = (async () => {
-            const channel = this.storageSettings.values.rtspChannel;
-            const snapshotBuffer = await this.withBaichuanClient(async (api) => {
-                return await api.getSnapshot(channel);
-            });
-            const mo = await sdk.mediaManager.createMediaObject(snapshotBuffer, 'image/jpeg');
-            this.lastPicture = { mo, atMs: Date.now() };
-            logger.log(`Snapshot taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
-            return mo;
-        })();
-
-        try {
-            return await this.takePictureInFlight;
-        }
-        finally {
-            this.takePictureInFlight = undefined;
-        }
-    }
-
-    async getPictureOptions(): Promise<ResponsePictureOptions[]> {
-        return [];
-    }
-
     async init(): Promise<void> {
         this.startPeriodicTasks();
         await this.alignAuxDevicesState();
@@ -154,7 +99,7 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
 
     async updateSleepingState(sleepStatus: SleepStatus): Promise<void> {
         try {
-            if (this.isBatteryInfoLoggingEnabled()) {
+            if (this.isDebugEnabled()) {
                 this.getBaichuanLogger().debug('getSleepStatus result:', JSON.stringify(sleepStatus));
             }
 
@@ -212,7 +157,7 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         const channel = this.storageSettings.values.rtspChannel;
 
         const batteryInfo = await api.getBatteryInfo(channel);
-        if (this.isBatteryInfoLoggingEnabled()) {
+        if (this.isDebugEnabled()) {
             this.getBaichuanLogger().debug('getBatteryInfo result:', JSON.stringify(batteryInfo));
         }
 

package/src/camera.ts

@@ -175,21 +175,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         return fn(client);
     }
 
-    async takePicture(options?: RequestPictureOptions) {
-        try {
-            return this.withBaichuanRetry(async () => {
-                const client = await this.ensureClient();
-                const snapshotBuffer = await client.getSnapshot(this.storageSettings.values.rtspChannel);
-                const mo = await this.createMediaObject(snapshotBuffer, 'image/jpeg');
-
-                return mo;
-            });
-        } catch (e) {
-            this.getBaichuanLogger().error('Error taking snapshot', e);
-            throw e;
-        }
-    }
-
     async getPictureOptions(): Promise<ResponsePictureOptions[]> {
         return [];
     }

package/src/common.ts

@@ -1,17 +1,18 @@
 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 sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, Reboot, RequestMediaStreamOptions, RequestPictureOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import path from 'path';
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { normalizeUid, type BaichuanTransport } from "./connect";
-import { convertDebugLogsToApiOptions, DebugLogDisplayNames, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
+import { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkPtzPresets } from "./presets";
 import {
+    createRfc4571CompositeMediaObjectFromStreamManager,
     createRfc4571MediaObjectFromStreamManager,
     expectedVideoTypeFromUrlMediaStreamOptions,
     parseStreamProfileFromId,
@@ -134,7 +135,8 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
     }
 
     async getSettings(): Promise<Setting[]> {
-        return this.storageSettings.getSettings();
+        const settings = await this.storageSettings.getSettings();
+        return settings;
     }
 
     async putSetting(key: string, value: SettingValue): Promise<void> {
@@ -187,7 +189,7 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
     }
 }
 
-export abstract class CommonCameraMixin extends BaseBaichuanClass implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom {
+export abstract class CommonCameraMixin extends BaseBaichuanClass implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom, Reboot {
     storageSettings = new StorageSettings(this, {
         // Basic connection settings
         ipAddress: {
@@ -197,12 +199,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.credentialsChanged();
             }
         },
-        debugEvents: {
-            title: 'Debug Events',
-            type: 'boolean',
-            immediate: true,
-            hide: true,
-        },
         username: {
             type: 'string',
             title: 'Username',
@@ -230,6 +226,53 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             json: true,
             hide: true,
         },
+        // Multifocal composite stream PIP settings
+        pipPosition: {
+            title: 'PIP Position',
+            description: 'Position of the tele lens overlay on the wider lens view',
+            type: 'string',
+            defaultValue: 'bottom-right',
+            choices: [
+                'top-left',
+                'top-right',
+                'bottom-left',
+                'bottom-right',
+                'center',
+                'top-center',
+                'bottom-center',
+                'left-center',
+                'right-center',
+            ],
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
+        pipSize: {
+            title: 'PIP Size',
+            description: 'Relative size of the PIP overlay (0.1 = 10%, 0.3 = 30%, etc.)',
+            type: 'number',
+            defaultValue: 0.25,
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
+        pipMargin: {
+            title: 'PIP Margin',
+            description: 'Margin from edge in pixels',
+            type: 'number',
+            defaultValue: 10,
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
+        widerChannel: {
+            title: 'Wider Channel',
+            description: 'Channel number for wider lens (typically 0)',
+            type: 'number',
+            defaultValue: 0,
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
+        teleChannel: {
+            title: 'Tele Channel',
+            description: 'Channel number for tele lens (typically 1)',
+            type: 'number',
+            defaultValue: 1,
+            hide: true, // Only show for multifocal devices via getAdditionalSettings
+        },
         // Battery camera specific
         uid: {
             title: 'UID',
@@ -240,6 +283,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.credentialsChanged();
             }
         },
+        debugLogs: {
+            title: 'Debug logs',
+            type: 'boolean',
+            immediate: true,
+        },
         mixinsSetup: {
             type: 'boolean',
             hide: true,
@@ -258,10 +306,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.subscribeToEvents();
             },
         },
-        debugLogs: {
+        socketApiDebugLogs: {
             subgroup: 'Advanced',
-            title: 'Debug Logs',
-            description: 'Enable specific debug logs. Baichuan client logs require reconnect; event logs are immediate.',
+            title: 'Socket API Debug Logs',
+            description: 'Enable specific debug logs.',
             multiple: true,
             combobox: true,
             immediate: true,
@@ -508,6 +556,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     floodlight?: ReolinkCameraFloodlight;
     pirSensor?: ReolinkCameraPirSensor;
 
+
+    private lastPicture: { mo: MediaObject; atMs: number } | undefined;
+    private takePictureInFlight: Promise<MediaObject> | undefined;
+    forceNewSnapshot: boolean = false;
+
     // Video stream properties
     protected cachedVideoStreamOptions?: UrlMediaStreamOptions[];
     protected fetchingStreams = false;
@@ -551,6 +604,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }, 2000);
     }
 
+    async reboot(): Promise<void> {
+        const api = await this.ensureBaichuanClient();
+        await api.reboot();
+    }
+
     // BaseBaichuanClass abstract methods implementation
     protected getConnectionConfig(): BaichuanConnectionConfig {
         const { ipAddress, username, password, uid } = this.storageSettings.values;
@@ -599,9 +657,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         };
     }
 
-
     protected isDebugEnabled(): boolean {
-        return this.isEventLogsEnabled();
+        return this.storageSettings.values.debugLogs;
     }
 
     protected getDeviceName(): string {
@@ -1029,11 +1086,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
-    isEventLogsEnabled(): boolean {
-        const debugLogs = this.storageSettings.values.debugLogs || [];
-        return debugLogs.includes(DebugLogDisplayNames[DebugLogOption.EventLogs]);
-    }
-
     // BinarySensor interface implementation (for doorbell)
     handleDoorbellEvent(): void {
         if (!this.doorbellBinaryTimeout) {
@@ -1114,9 +1166,59 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         await this.storageSettings.putSetting(key, value);
     }
 
-    // Camera interface methods (must be implemented by subclasses)
-    abstract takePicture(options?: any): Promise<MediaObject>;
-    abstract getPictureOptions(): Promise<any[]>;
+    async takePicture(options?: RequestPictureOptions) {
+        if (this.protocol === 'tcp') {
+            try {
+                return this.withBaichuanRetry(async () => {
+                    const client = await this.ensureClient();
+                    const snapshotBuffer = await client.getSnapshot(this.storageSettings.values.rtspChannel);
+                    const mo = await this.createMediaObject(snapshotBuffer, 'image/jpeg');
+
+                    return mo;
+                });
+            } catch (e) {
+                this.getBaichuanLogger().error('Error taking snapshot', e);
+                throw e;
+            }
+        } else {
+            const logger = this.getBaichuanLogger();
+            const shouldTakeNewSnapshot = this.forceNewSnapshot;
+
+            if (!shouldTakeNewSnapshot && this.lastPicture) {
+                logger.log(`Returning cached snapshot, taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
+                return this.lastPicture.mo;
+            }
+
+            if (this.takePictureInFlight) {
+                return await this.takePictureInFlight;
+            }
+
+            logger.log(`Taking new snapshot from camera (forceNewSnapshot: ${this.forceNewSnapshot})`);
+            this.forceNewSnapshot = false;
+
+            this.takePictureInFlight = (async () => {
+                const channel = this.storageSettings.values.rtspChannel;
+                const snapshotBuffer = await this.withBaichuanClient(async (api) => {
+                    return await api.getSnapshot(channel);
+                });
+                const mo = await sdk.mediaManager.createMediaObject(snapshotBuffer, 'image/jpeg');
+                this.lastPicture = { mo, atMs: Date.now() };
+                logger.log(`Snapshot taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
+                return mo;
+            })();
+
+            try {
+                return await this.takePictureInFlight;
+            }
+            finally {
+                this.takePictureInFlight = undefined;
+            }
+        }
+    }
+
+    async getPictureOptions(): Promise<ResponsePictureOptions[]> {
+        return [];
+    }
 
     // Intercom interface methods
     async startIntercom(media: MediaObject): Promise<void> {
@@ -1342,12 +1444,15 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         const client = await this.ensureClient();
 
-        const { rtspChannel } = this.storageSettings.values;
+        // For multifocal devices, use undefined channel to get composite streams
+        const isMultiFocal = this.options.type === 'multi-focal' || this.options.type === 'multi-focal-battery';
+        const channel = isMultiFocal ? undefined : this.storageSettings.values.rtspChannel;
 
         try {
-            const { nativeStreams, rtmpStreams, rtspStreams } = await client.buildVideoStreamOptions(rtspChannel);
+            const { nativeStreams, rtmpStreams, rtspStreams } = await client.buildVideoStreamOptions(channel);
 
             let supportedStreams: ReolinkSupportedStream[] = [];
+            // Homehub RTMP is not efficient, crashes, offers native streams to not overload the hub
             if (this.nvrDevice && this.nvrDevice.info.model === 'HOMEHUB') {
                 supportedStreams = [...nativeStreams, ...rtspStreams, ...rtmpStreams];
             } else {
@@ -1408,6 +1513,28 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             throw new Error('StreamManager not initialized');
         }
 
+        // Check if this is a composite stream request (for multifocal devices)
+        const isComposite = selected.id?.startsWith('composite_');
+        if (isComposite && this.options && (this.options.type === 'multi-focal' || this.options.type === 'multi-focal-battery')) {
+            const profile = parseStreamProfileFromId(selected.id.replace('composite_', '')) || 'main';
+            const streamKey = `composite_${profile}`;
+            const expectedVideoType = expectedVideoTypeFromUrlMediaStreamOptions(selected);
+
+            const createStreamFn = async () => {
+                return await createRfc4571CompositeMediaObjectFromStreamManager({
+                    streamManager: this.streamManager!,
+                    profile,
+                    streamKey,
+                    expectedVideoType,
+                    selected,
+                    sourceId: this.id,
+                });
+            };
+
+            return await this.withBaichuanRetry(createStreamFn);
+        }
+
+        // Regular stream for single channel
         const profile = parseStreamProfileFromId(selected.id) || 'main';
         const channel = this.storageSettings.values.rtspChannel;
         const streamKey = `${channel}_${profile}`;
@@ -1539,17 +1666,22 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         const { username, password } = this.storageSettings.values;
-        const isCamera = this.options.type === 'regular' || this.options.type === 'battery';
-        const isBatteryCamera = this.options.type === 'battery';
-        const isBatteryMultiFocal = this.options.type === 'multi-focal-battery';
-        const isBattery = isBatteryCamera || isBatteryMultiFocal;
+        const isBattery = ['multi-focal-battery', 'battery'].includes(this.options.type);
+        const isMultiFocal = ['multi-focal', 'multi-focal'].includes(this.options.type);
 
         this.storageSettings.settings.uid.hide = !isBattery;
         this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !isBattery;
         this.storageSettings.settings.lowThresholdBatteryRecording.hide = !isBattery;
         this.storageSettings.settings.highThresholdBatteryRecording.hide = !isBattery;
 
-        if (isBatteryCamera && !this.storageSettings.values.mixinsSetup) {
+        // Show PIP settings only for multifocal devices
+        this.storageSettings.settings.pipPosition.hide = !isMultiFocal;
+        this.storageSettings.settings.pipSize.hide = !isMultiFocal;
+        this.storageSettings.settings.pipMargin.hide = !isMultiFocal;
+        this.storageSettings.settings.widerChannel.hide = !isMultiFocal;
+        this.storageSettings.settings.teleChannel.hide = !isMultiFocal;
+
+        if (isBattery && !this.storageSettings.values.mixinsSetup) {
             try {
                 const device = sdk.systemManager.getDeviceById<Settings>(this.id);
                 if (device) {
@@ -1571,39 +1703,37 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
-        if (isCamera) {
-            this.streamManager = new StreamManager({
-                createStreamClient: () => this.createStreamClient(),
-                getLogger: () => logger as Console,
-                credentials: {
-                    username,
-                    password
-                },
-                sharedConnection: isBattery,
-            });
+        this.streamManager = new StreamManager({
+            createStreamClient: () => this.createStreamClient(),
+            getLogger: () => logger,
+            credentials: {
+                username,
+                password
+            },
+            sharedConnection: isBattery,
+        });
 
-            const { hasIntercom, hasPtz } = this.getAbilities();
+        const { hasIntercom, hasPtz } = this.getAbilities();
 
-            if (hasIntercom) {
-                this.intercom = new ReolinkBaichuanIntercom(this);
-            }
+        if (hasIntercom) {
+            this.intercom = new ReolinkBaichuanIntercom(this);
+        }
 
-            if (hasPtz) {
-                const choices = (this.presets || []).map((preset: any) => preset.id + '=' + preset.name);
+        if (hasPtz) {
+            const choices = (this.presets || []).map((preset: any) => preset.id + '=' + preset.name);
 
-                this.storageSettings.settings.presets.choices = choices;
-                this.storageSettings.settings.ptzSelectedPreset.choices = choices;
+            this.storageSettings.settings.presets.choices = choices;
+            this.storageSettings.settings.ptzSelectedPreset.choices = choices;
 
-                this.storageSettings.settings.presets.hide = false;
-                this.storageSettings.settings.ptzMoveDurationMs.hide = false;
-                this.storageSettings.settings.ptzZoomStep.hide = false;
-                this.storageSettings.settings.ptzCreatePreset.hide = false;
-                this.storageSettings.settings.ptzSelectedPreset.hide = false;
-                this.storageSettings.settings.ptzUpdateSelectedPreset.hide = false;
-                this.storageSettings.settings.ptzDeleteSelectedPreset.hide = false;
+            this.storageSettings.settings.presets.hide = false;
+            this.storageSettings.settings.ptzMoveDurationMs.hide = false;
+            this.storageSettings.settings.ptzZoomStep.hide = false;
+            this.storageSettings.settings.ptzCreatePreset.hide = false;
+            this.storageSettings.settings.ptzSelectedPreset.hide = false;
+            this.storageSettings.settings.ptzUpdateSelectedPreset.hide = false;
+            this.storageSettings.settings.ptzDeleteSelectedPreset.hide = false;
 
-                this.updatePtzCaps();
-            }
+            this.updatePtzCaps();
         }
 
         if (this.nvrDevice || this.multiFocalDevice) {

package/src/debug-options.ts

@@ -18,10 +18,6 @@ export enum DebugLogOption {
     DebugH264 = 'debugH264',
     /** SPS/PPS parameter sets debug logs */
     DebugParamSets = 'debugParamSets',
-    /** Event logs (plugin-specific, not passed to API) */
-    EventLogs = 'eventLogs',
-    /** Battery info logs (plugin-specific, not passed to API) */
-    BatteryInfo = 'batteryInfo',
 }
 
 /**
@@ -36,8 +32,6 @@ export function mapDebugLogToApiOption(option: DebugLogOption): keyof DebugOptio
         [DebugLogOption.TraceEvents]: 'traceEvents',
         [DebugLogOption.DebugH264]: 'debugH264',
         [DebugLogOption.DebugParamSets]: 'debugParamSets',
-        [DebugLogOption.EventLogs]: null, // Plugin-specific, not passed to API
-        [DebugLogOption.BatteryInfo]: null, // Plugin-specific, not passed to API
     };
     return mapping[option];
 }
@@ -88,8 +82,6 @@ export const DebugLogDisplayNames: Record<DebugLogOption, string> = {
     [DebugLogOption.TraceEvents]: 'Trace events XML',
     [DebugLogOption.DebugH264]: 'H264',
     [DebugLogOption.DebugParamSets]: 'Video param sets',
-    [DebugLogOption.EventLogs]: 'Object detection events',
-    [DebugLogOption.BatteryInfo]: 'Battery info update',
 };
 
 /**

package/src/main.ts

@@ -57,7 +57,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             },
         );
 
-        this.console.log(`[AutoDetect] Detected device type ${detection.type} on transport ${detection.transport}: ${JSON.stringify(detection.deviceInfo)}`);
+        this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport})`);
+
+        // Use the API that was successfully used for detection
+        const detectedApi = detection.api;
 
         // Handle multi-focal device case
         if (detection.type === 'multifocal') {
@@ -69,18 +72,12 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
             settings.newCamera ||= name;
 
-            const interfaces = [
-                ScryptedInterface.Settings,
-                ScryptedInterface.DeviceProvider,
-                ScryptedInterface.Reboot,
-            ];
-
-            if (isBattery) {
-                interfaces.push(
-                    ScryptedInterface.Battery,
-                    ScryptedInterface.Sleep
-                );
-            }
+            const { capabilities, objects, presets } = await detectedApi.getDeviceCapabilities();
+
+            const { interfaces } = getDeviceInterfaces({
+                capabilities,
+                logger: this.console,
+            });
 
             await sdk.deviceManager.onDeviceDiscovered({
                 nativeId,
@@ -94,10 +91,13 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             if (!(device instanceof ReolinkNativeMultiFocalDevice)) {
                 throw new Error('Expected multi-focal device but got different type');
             }
+            device.classes = objects;
+            device.presets = presets;
             device.storageSettings.values.ipAddress = ipAddress;
             device.storageSettings.values.username = username;
             device.storageSettings.values.password = password;
             device.storageSettings.values.uid = detection.uid || '';
+            device.storageSettings.values.capabilities = capabilities;
 
             return nativeId;
         }
@@ -149,22 +149,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         settings.newCamera ||= name;
 
-        // Create API connection to get capabilities
-        const api = await createBaichuanApi({
-            inputs: {
-                host: ipAddress,
-                username,
-                password,
-                uid: detection.uid,
-                logger: this.console,
-            },
-            transport: detection.transport,
-        });
-
+        // Use the API that was successfully used for detection
         try {
-            await api.login();
             const rtspChannel = 0;
-            const { capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
+            const { capabilities, objects, presets } = await detectedApi.getDeviceCapabilities(rtspChannel);
 
             const { interfaces, type } = getDeviceInterfaces({
                 capabilities,
@@ -197,9 +185,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             this.console.error('Error adding Reolink device', e);
             throw e;
         }
-        finally {
-            await api.close();
-        }
     }
 
     async releaseDevice(id: string, nativeId: ScryptedNativeId): Promise<void> {