@apocaliss92/scrypted-reolink-native 0.0.1

package/src/presets.ts

@@ -0,0 +1,209 @@
+import type { PtzPreset } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+
+import type { ReolinkNativeCamera } from "./camera";
+
+export type PtzCapabilitiesShape = {
+    presets?: Record<string, string>;
+    [key: string]: unknown;
+};
+
+export class ReolinkPtzPresets {
+    constructor(private camera: ReolinkNativeCamera) { }
+
+    private get storageSettings() {
+        return this.camera.storageSettings;
+    }
+
+    private getPtzCapabilitiesStore(): PtzCapabilitiesShape | undefined {
+        return this.camera.ptzCapabilities as PtzCapabilitiesShape | undefined;
+    }
+
+    private setPtzCapabilitiesStore(next: PtzCapabilitiesShape): void {
+        this.camera.ptzCapabilities = next;
+    }
+
+    private parsePresetIdFromSettingValue(value: string): number | undefined {
+        const s = String(value ?? '').trim();
+        if (!s) return undefined;
+        const idPart = s.includes('=') ? s.split('=')[0] : s;
+        const id = Number(idPart);
+        return Number.isFinite(id) ? id : undefined;
+    }
+
+    private syncEnabledPresetsSettingAndCaps(available: PtzPreset[]): void {
+        const enabled = (this.storageSettings.values.presets ?? []) as string[];
+
+        // If the user hasn't configured the "presets" setting, keep the auto-discovered preset list
+        // (setCachedPtzPresets already applied it).
+        if (!enabled.length) return;
+
+        const nameById = new Map<number, string>(available.map((p) => [p.id, p.name]));
+
+        // Apply only enabled presets mapping, but do NOT prune or rewrite the setting.
+        // Prefer user-provided names ("id=name"), fallback to camera-provided name.
+        const mapped: Record<string, string> = {};
+        for (const entry of enabled) {
+            const id = this.parsePresetIdFromSettingValue(entry);
+            if (id === undefined) continue;
+
+            const providedName = entry.includes('=')
+                ? entry.substring(entry.indexOf('=') + 1).trim()
+                : '';
+            const name = providedName || nameById.get(id);
+            if (!name) continue;
+
+            mapped[String(id)] = name;
+        }
+
+        this.setPtzCapabilitiesStore({
+            ...(this.getPtzCapabilitiesStore() ?? {}),
+            presets: mapped,
+        });
+    }
+
+    setCachedPtzPresets(presets: PtzPreset[] | undefined): void {
+        const list = Array.isArray(presets) ? presets : [];
+        this.storageSettings.values.cachedPresets = list;
+
+        const mapped: Record<string, string> = {};
+        for (const p of list) {
+            mapped[String(p.id)] = p.name;
+        }
+
+        this.setPtzCapabilitiesStore({
+            ...(this.getPtzCapabilitiesStore() ?? {}),
+            presets: mapped,
+        });
+    }
+
+    getCachedPtzPresets(): PtzPreset[] {
+        const v = this.storageSettings.values.cachedPresets;
+        return Array.isArray(v) ? (v as PtzPreset[]) : [];
+    }
+
+    nextFreePresetId(existing: PtzPreset[]): number {
+        const used = new Set(existing.map((p) => p.id));
+        for (let id = 1; id <= 255; id++) {
+            if (!used.has(id)) return id;
+        }
+        throw new Error('No free PTZ preset id available (1..255)');
+    }
+
+    async refreshPtzPresets(): Promise<PtzPreset[]> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+        const presets = await client.getPtzPresets(channel);
+        this.setCachedPtzPresets(presets);
+        this.syncEnabledPresetsSettingAndCaps(presets);
+        return presets;
+    }
+
+    async moveToPreset(presetId: number): Promise<void> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+        await client.moveToPtzPreset(channel, presetId);
+    }
+
+    /** Create a new PTZ preset at current position. */
+    async createPtzPreset(name: string, presetId?: number): Promise<PtzPreset> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+        const trimmed = String(name ?? '').trim();
+        if (!trimmed) throw new Error('Preset name is required');
+        const existing = await client.getPtzPresets(channel);
+        const existingIds = new Set(existing.map((p) => p.id));
+
+        const maxAttempts = 5;
+        let lastUpdated: PtzPreset[] = [];
+        let chosenId: number | undefined;
+
+        const initialId = presetId ?? this.nextFreePresetId(existing);
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const id = presetId ?? (initialId + attempt);
+            if (!presetId && existingIds.has(id)) continue;
+
+            await client.setPtzPreset(channel, id, trimmed);
+
+            const updated = await client.getPtzPresets(channel);
+            lastUpdated = updated;
+
+            const persisted = updated.some((p) => p.id === id);
+            if (persisted) {
+                chosenId = id;
+                break;
+            }
+
+            // If the camera isn't exposing any presets at all, it may be keeping low IDs reserved/disabled.
+            // Try the next ID.
+        }
+
+        if (chosenId === undefined) {
+            this.setCachedPtzPresets(lastUpdated);
+            this.syncEnabledPresetsSettingAndCaps(lastUpdated);
+            throw new Error(
+                `PTZ preset save did not persist (camera returned an empty/unchanged preset list). Try a different preset id.`
+            );
+        }
+
+        this.setCachedPtzPresets(lastUpdated);
+
+        // If the "presets" setting is in use, auto-add the newly created preset so it becomes
+        // immediately selectable/visible in the UI. If it's empty/unconfigured, don't start using it.
+        const enabled = (this.storageSettings.values.presets ?? []) as string[];
+        if (enabled.length) {
+            const already = enabled.some((e) => this.parsePresetIdFromSettingValue(e) === chosenId);
+            if (!already) {
+                enabled.push(`${chosenId}=${trimmed}`);
+                this.storageSettings.values.presets = enabled;
+            }
+        }
+
+        // Re-apply enabled mapping (so custom names/filters remain effective after setCachedPtzPresets).
+        this.syncEnabledPresetsSettingAndCaps(lastUpdated);
+        return { id: chosenId, name: trimmed };
+    }
+
+    /** Overwrite an existing preset with the current PTZ position (and keep its current name). */
+    async updatePtzPresetToCurrentPosition(presetId: number): Promise<void> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+
+        const current = this.getCachedPtzPresets();
+        const found = current.find((p) => p.id === presetId);
+        const name = found?.name ?? `Preset ${presetId}`;
+
+        await client.setPtzPreset(channel, presetId, name);
+        await this.refreshPtzPresets();
+    }
+
+    /** Best-effort delete/disable a preset (firmware dependent). */
+    async deletePtzPreset(presetId: number): Promise<void> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+        await client.deletePtzPreset(channel, presetId);
+
+        // Keep enabled preset list clean (remove deleted id), but do not rewrite names for others.
+        const enabledRaw = this.storageSettings.values.presets as unknown;
+        if (Array.isArray(enabledRaw) && enabledRaw.length) {
+            const filtered = (enabledRaw as unknown[])
+                .filter((v) => typeof v === 'string')
+                .filter((e) => this.parsePresetIdFromSettingValue(e as string) !== presetId) as string[];
+            this.storageSettings.values.presets = filtered;
+        }
+
+        await this.refreshPtzPresets();
+    }
+
+    /** Rename a preset while trying to preserve its position (will move camera to that preset first). */
+    async renamePtzPreset(presetId: number, newName: string): Promise<void> {
+        const client = await this.camera.ensureClient();
+        const channel = this.camera.getRtspChannel();
+        const trimmed = String(newName ?? '').trim();
+        if (!trimmed) throw new Error('Preset name is required');
+
+        // Warning: this moves the camera.
+        await client.moveToPtzPreset(channel, presetId);
+        await client.setPtzPreset(channel, presetId, trimmed);
+        await this.refreshPtzPresets();
+    }
+}

package/src/stream-utils.ts

@@ -0,0 +1,112 @@
+import type {
+    ReolinkBaichuanApi,
+    StreamProfile,
+    ScryptedRfc4571TcpServer,
+    VideoType,
+} from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+
+export interface StreamManagerOptions {
+    /**
+     * Creates a dedicated Baichuan session for streaming.
+     * Required to support concurrent main+ext streams on firmwares where streamType overlaps.
+     */
+    createStreamClient: () => Promise<ReolinkBaichuanApi>;
+    getLogger: () => Console;
+}
+
+export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
+    if (!id)
+        return;
+    if (id === 'mainstream')
+        return 'main';
+    if (id === 'substream')
+        return 'sub';
+    if (id === 'extstream')
+        return 'ext';
+
+    return;
+}
+
+export class StreamManager {
+    private nativeRfcServers = new Map<string, ScryptedRfc4571TcpServer>();
+    private nativeRfcServerCreatePromises = new Map<string, Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }>>();
+
+    constructor(private opts: StreamManagerOptions) {
+    }
+
+    private getLogger() {
+        return this.opts.getLogger();
+    }
+
+    private async ensureNativeRfcServer(
+        streamKey: string,
+        channel: number,
+        profile: StreamProfile,
+        expectedVideoType?: 'H264' | 'H265',
+    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+        const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
+        if (existingCreate) {
+            return await existingCreate;
+        }
+
+        const createPromise = (async () => {
+            const cached = this.nativeRfcServers.get(streamKey);
+            if (cached?.server?.listening) {
+                if (expectedVideoType && cached.videoType !== expectedVideoType) {
+                    this.getLogger().warn(
+                        `Native RFC cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
+                    );
+                }
+                else {
+                    return { host: cached.host, port: cached.port, sdp: cached.sdp, audio: cached.audio };
+                }
+            }
+
+            if (cached) {
+                try {
+                    await cached.close('recreate');
+                }
+                catch {
+                    // ignore
+                }
+                this.nativeRfcServers.delete(streamKey);
+            }
+
+            const api = await this.opts.createStreamClient();
+            const { createScryptedRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+            const created = await createScryptedRfc4571TcpServer({
+                api,
+                channel,
+                profile,
+                logger: this.getLogger(),
+                expectedVideoType: expectedVideoType as VideoType | undefined,
+                closeApiOnTeardown: true,
+            });
+
+            this.nativeRfcServers.set(streamKey, created);
+            created.server.once('close', () => {
+                const current = this.nativeRfcServers.get(streamKey);
+                if (current?.server === created.server) this.nativeRfcServers.delete(streamKey);
+            });
+
+            return { host: created.host, port: created.port, sdp: created.sdp, audio: created.audio };
+        })();
+
+        this.nativeRfcServerCreatePromises.set(streamKey, createPromise);
+        try {
+            return await createPromise;
+        }
+        finally {
+            this.nativeRfcServerCreatePromises.delete(streamKey);
+        }
+    }
+
+    async getRfcStream(
+        channel: number,
+        profile: StreamProfile,
+        streamKey: string,
+        expectedVideoType?: 'H264' | 'H265',
+    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+        return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
+    }
+}

package/src/utils.ts

@@ -0,0 +1,60 @@
+
+import MqttClient from '../../scrypted-apocaliss-base/src/mqtt-client';
+
+export const getMqttTopics = (cameraName: string) => {
+    const statusTopic = `neolink/${cameraName}/status`;
+    const batteryStatusTopic = `neolink/${cameraName}/status/battery_level`;
+    const motionStatusTopic = `neolink/${cameraName}/status/motion`;
+    const disconnecteStatusdTopic = `neolink/${cameraName}/status/disconnected`;
+    const previewStatusTopic = `neolink/${cameraName}/status/preview`;
+    const ptzPresetsStatusTopic = `neolink/${cameraName}/status/ptz/preset`;
+
+    const batteryQueryTopic = `neolink/${cameraName}/query/battery`;
+    const previewQueryTopic = `neolink/${cameraName}/query/preview`;
+    const ptzPreviewQueryTopic = `neolink/${cameraName}/query/ptz/preset`;
+
+    const ptzControlTopic = `neolink/${cameraName}/control/ptz`;
+    const ptzPresetControlTopic = `neolink/${cameraName}/control/preset`;
+    const floodlightControlTopic = `neolink/${cameraName}/control/floodlight`;
+    const floodlightTasksControlTopic = `neolink/${cameraName}/control/floodlight_tasks`;
+    const sirenControlTopic = `neolink/${cameraName}/control/siren`;
+    const rebootControlTopic = `neolink/${cameraName}/control/reboot`;
+    const ledControlTopic = `neolink/${cameraName}/control/led`;
+    const irControlTopic = `neolink/${cameraName}/control/ir`;
+    const pirControlTopic = `neolink/${cameraName}/control/pir`;
+
+    return {
+        statusTopic,
+        batteryStatusTopic,
+        motionStatusTopic,
+        disconnecteStatusdTopic,
+        ptzPresetsStatusTopic,
+        previewStatusTopic,
+        batteryQueryTopic,
+        previewQueryTopic,
+        ptzPreviewQueryTopic,
+        ptzControlTopic,
+        ptzPresetControlTopic,
+        floodlightControlTopic,
+        floodlightTasksControlTopic,
+        sirenControlTopic,
+        rebootControlTopic,
+        ledControlTopic,
+        irControlTopic,
+        pirControlTopic,
+    }
+}
+
+export const subscribeToNeolinkTopic = async (client: MqttClient, topic: string, console: Console, cb: (value?: any) => void) => {
+    client.subscribe([topic], async (messageTopic, message) => {
+        const messageString = message.toString();
+        if (messageTopic === topic) {
+            cb(messageString);
+        }
+    });
+
+}
+
+export const unsubscribeFromNeolinkTopic = async (client: MqttClient, topic: string, console: Console) => {
+    client.unsubscribe([topic]);
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "module": "Node16",
+        "target": "ES2021",
+        "resolveJsonModule": true,
+        "moduleResolution": "Node16",
+        "esModuleInterop": true,
+        "sourceMap": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}