@apocaliss92/scrypted-reolink-native 0.1.30 → 0.1.32

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, VideoClip, VideoClipOptions, VideoClips, VideoClipThumbnailOptions, 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 { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
+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, VideoClips {
     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,65 @@ 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,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipSize changed');
+            },
+        },
+        pipMargin: {
+            title: 'PIP Margin',
+            description: 'Margin from edge in pixels',
+            type: 'number',
+            defaultValue: 10,
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipMargin changed');
+            },
+        },
+        widerChannel: {
+            title: 'Wider Channel',
+            description: 'Channel number for wider lens (typically 0)',
+            type: 'number',
+            defaultValue: 0,
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('widerChannel changed');
+            },
+        },
+        teleChannel: {
+            title: 'Tele Channel',
+            description: 'Channel number for tele lens (typically 1)',
+            type: 'number',
+            defaultValue: 1,
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('teleChannel changed');
+            },
+        },
         // Battery camera specific
         uid: {
             title: 'UID',
@@ -240,6 +295,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 +318,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 +568,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;
@@ -529,7 +594,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     protected nvrDevice?: ReolinkNativeNvrDevice;
     protected multiFocalDevice?: ReolinkNativeMultiFocalDevice;
-    thisDevice: Settings
+    thisDevice: Settings;
+    isBattery: boolean;
+    isMultiFocal: boolean;
+    private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
 
     constructor(
         nativeId: string,
@@ -543,21 +611,46 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.multiFocalDevice = options.multiFocalDevice;
         this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
-        const isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
-        this.protocol = isBattery ? 'udp' : 'tcp';
+        this.isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
+        this.isMultiFocal = options.type === 'multi-focal' || options.type === 'multi-focal-battery';
+        this.protocol = this.isBattery ? 'udp' : 'tcp';
 
         setTimeout(async () => {
             await this.parentInit();
         }, 2000);
     }
 
+    /**
+     * TODO: Implement video clip fetching using Baichuan/NVR recordings API.
+     */
+    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
+        throw new Error("getVideoClips is not implemented yet.");
+    }
+
+    getVideoClip(videoId: string): Promise<MediaObject> {
+        throw new Error("getVideoClip is not implemented yet.");
+    }
+
+    getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
+        throw new Error("getVideoClipThumbnail is not implemented yet.");
+    }
+
+    removeVideoClips(...videoClipIds: string[]): Promise<void> {
+        throw new Error("removeVideoClips is not implemented yet.");
+    }
+
+    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;
         const debugOptions = this.getBaichuanDebugOptions();
-        const normalizedUid = this.protocol === 'udp' ? normalizeUid(uid) : undefined;
+        const normalizedUid = this.isBattery ? normalizeUid(uid) : undefined;
 
-        if (this.protocol === 'udp' && !normalizedUid) {
+        if (this.isBattery && !normalizedUid) {
             throw new Error('UID is required for battery cameras (BCUDP)');
         }
 
@@ -581,8 +674,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 // For battery cameras, don't auto-resubscribe after idle disconnects
                 // (idle disconnects are normal for battery cameras to save power)
                 // Events will be resubscribed when ensureClient() is called for actual operations
-                const isBattery = this.options.type === 'battery';
-                if (!isBattery) {
+                if (!this.isBattery) {
                     // For non-battery cameras, resubscribe to events after reconnection
                     setTimeout(async () => {
                         try {
@@ -599,9 +691,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         };
     }
 
-
     protected isDebugEnabled(): boolean {
-        return this.isEventLogsEnabled();
+        return this.storageSettings.values.debugLogs;
     }
 
     protected getDeviceName(): string {
@@ -609,7 +700,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        if (this.protocol === 'udp') {
+        if (this.isBattery) {
             return await fn();
         } else {
             try {
@@ -680,8 +771,38 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
-    createStreamClient(): Promise<ReolinkBaichuanApi> {
-        throw new Error("Method not implemented.");
+    /**
+     * Create a dedicated Baichuan API session for streaming (used by StreamManager).
+     *
+     * - For TCP devices (regular + multifocal), this creates a new TCP session with its own client.
+     * - For UDP/battery devices, this reuses the existing client via ensureClient().
+     */
+    async createStreamClient(): Promise<ReolinkBaichuanApi> {
+        // Battery / BCUDP path: reuse the main client to avoid extra wake-ups and sockets.
+        if (this.isBattery) {
+            return await this.ensureClient();
+        }
+
+        // TCP path: create a separate session for streaming (RFC4571/composite/NVR-friendly).
+        const { ipAddress, username, password } = this.storageSettings.values;
+        const logger = this.getBaichuanLogger();
+
+        const debugOptions = this.getBaichuanDebugOptions();
+        const api = await createBaichuanApi(
+            {
+                inputs: {
+                    host: ipAddress,
+                    username,
+                    password,
+                    logger,
+                    debugOptions,
+                },
+                transport: 'tcp',
+            },
+        );
+
+        await api.login();
+        return api;
     }
 
     public getAbilities(): DeviceCapabilities {
@@ -693,8 +814,78 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     getBaichuanDebugOptions(): any | undefined {
-        const debugLogs = this.storageSettings.values.debugLogs || [];
-        return convertDebugLogsToApiOptions(debugLogs);
+        const socketDebugLogs = this.storageSettings.values.socketApiDebugLogs || [];
+        return convertDebugLogsToApiOptions(socketDebugLogs);
+    }
+
+    /**
+     * Initialize or recreate the StreamManager, taking into account multifocal composite options.
+     */
+    protected initStreamManager(logger: Console, forceRecreate: boolean = false): void {
+        const { username, password } = this.storageSettings.values;
+
+        const baseOptions: any = {
+            createStreamClient: () => this.createStreamClient(),
+            getLogger: () => logger,
+            credentials: {
+                username,
+                password,
+            },
+            sharedConnection: this.isBattery,
+        };
+
+        if (this.isMultiFocal) {
+            const values: any = this.storageSettings.values;
+            const pipPosition = values.pipPosition || 'bottom-right';
+            const pipSize = values.pipSize ?? 0.25;
+            const pipMargin = values.pipMargin ?? 10;
+            const widerChannel = values.widerChannel ?? 0;
+            const teleChannel = values.teleChannel ?? 1;
+
+            baseOptions.compositeOptions = {
+                widerChannel,
+                teleChannel,
+                pipPosition,
+                pipSize,
+                pipMargin,
+            };
+        }
+
+        if (!this.streamManager || forceRecreate) {
+            this.streamManager = new StreamManager(baseOptions);
+        }
+    }
+
+    /**
+     * Debounced restart of StreamManager when PIP/composite settings change.
+     * Also notifies listeners so that active streams (prebuffer, etc.) restart cleanly.
+     */
+    protected scheduleStreamManagerRestart(reason: string): void {
+        const logger = this.getBaichuanLogger();
+        logger.log(`Scheduling StreamManager restart (${reason})`);
+
+        if (this.streamManagerRestartTimeout) {
+            clearTimeout(this.streamManagerRestartTimeout);
+            this.streamManagerRestartTimeout = undefined;
+        }
+
+        this.streamManagerRestartTimeout = setTimeout(async () => {
+            this.streamManagerRestartTimeout = undefined;
+            const restartLogger = this.getBaichuanLogger();
+            try {
+                restartLogger.log('Restarting StreamManager due to PIP/composite settings change');
+                this.initStreamManager(restartLogger, true);
+
+                // Notify consumers (e.g. prebuffer) that stream configuration changed.
+                try {
+                    this.onDeviceEvent(ScryptedInterface.VideoCamera, undefined);
+                } catch {
+                    // best-effort
+                }
+            } catch (e) {
+                restartLogger.warn('Failed to restart StreamManager after settings change', e);
+            }
+        }, 500);
     }
 
     isRecoverableBaichuanError(e: any): boolean {
@@ -1029,11 +1220,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 +1300,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.isBattery) {
+            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 +1578,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 +1647,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 +1800,20 @@ 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;
 
-        this.storageSettings.settings.uid.hide = !isBattery;
-        this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !isBattery;
-        this.storageSettings.settings.lowThresholdBatteryRecording.hide = !isBattery;
-        this.storageSettings.settings.highThresholdBatteryRecording.hide = !isBattery;
+        this.storageSettings.settings.uid.hide = !this.isBattery;
+        this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !this.isBattery;
+        this.storageSettings.settings.lowThresholdBatteryRecording.hide = !this.isBattery;
+        this.storageSettings.settings.highThresholdBatteryRecording.hide = !this.isBattery;
 
-        if (isBatteryCamera && !this.storageSettings.values.mixinsSetup) {
+        // Show PIP settings only for multifocal devices
+        this.storageSettings.settings.pipPosition.hide = !this.isMultiFocal;
+        this.storageSettings.settings.pipSize.hide = !this.isMultiFocal;
+        this.storageSettings.settings.pipMargin.hide = !this.isMultiFocal;
+        this.storageSettings.settings.widerChannel.hide = !this.isMultiFocal;
+        this.storageSettings.settings.teleChannel.hide = !this.isMultiFocal;
+
+        if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
             try {
                 const device = sdk.systemManager.getDeviceById<Settings>(this.id);
                 if (device) {
@@ -1571,39 +1835,30 @@ 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,
-            });
+        // Initialize StreamManager (with composite options for multifocal devices)
+        this.initStreamManager(logger);
 
-            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',
 };
 
 /**