wiim2mqtt 0.1.0

package/lib/commands.js

@@ -0,0 +1,332 @@
+/**
+ * Pure mapping of friendly items to device commands and of device values to friendly values.
+ * Nothing in here talks to the network.
+ */
+
+import {toBoolean, toVolume} from './payload.js';
+
+/** http getPlayerStatus.status → play_state */
+export const PLAY_STATES = {
+    play: 'playing',
+    pause: 'paused',
+    stop: 'stopped',
+    loading: 'loading',
+    load: 'loading',
+};
+
+/** upnp TransportState → play_state */
+export const TRANSPORT_STATES = {
+    PLAYING: 'playing',
+    PAUSED_PLAYBACK: 'paused',
+    STOPPED: 'stopped',
+    TRANSITIONING: 'loading',
+    NO_MEDIA_PRESENT: 'stopped',
+};
+
+/**
+ * Sources. mode = getPlayerStatus.mode, switchmode = setPlayerCmd:switchmode argument,
+ * medium = upnp PlaybackStorageMedium values.
+ */
+export const SOURCES = [
+    {mode: 0, name: 'none'},
+    {mode: 1, name: 'airplay'},
+    {mode: 2, name: 'dlna'},
+    {mode: 10, name: 'wifi', switchmode: 'wifi'},
+    {mode: 11, name: 'usb', switchmode: 'udisk', medium: ['USB', 'UDISK']},
+    {mode: 16, name: 'sdcard'},
+    {mode: 20, name: 'api'},
+    {mode: 31, name: 'spotify'},
+    {mode: 32, name: 'tidal'},
+    {mode: 40, name: 'line_in', switchmode: 'line-in', medium: ['LINE-IN', 'RCA', 'AUX']},
+    {mode: 41, name: 'bluetooth', switchmode: 'bluetooth', medium: ['BLUETOOTH']},
+    {mode: 43, name: 'optical', switchmode: 'optical', medium: ['OPTICAL']},
+    {mode: 99, name: 'multiroom'},
+    {name: 'hdmi', switchmode: 'hdmi', medium: ['HDMI']},
+    {name: 'coaxial', switchmode: 'coaxial', medium: ['COAXIAL', 'COAX']},
+    {name: 'phono', switchmode: 'phono', medium: ['PHONO']},
+];
+
+/** switchable sources (the default source_list) */
+export const SWITCHABLE_SOURCES = SOURCES.filter((s) => s.switchmode).map((s) => s.name);
+
+export function sourceFromMode(mode) {
+    const n = Number(mode);
+    const source = SOURCES.find((s) => s.mode === n);
+    return source ? source.name : `mode_${n}`;
+}
+
+export function sourceFromMedium(medium) {
+    if (!medium) {
+        return undefined;
+    }
+    const m = String(medium).toUpperCase();
+    const source = SOURCES.find((s) => s.medium && s.medium.includes(m));
+    return source ? source.name : undefined;
+}
+
+export function switchmodeFor(sourceName) {
+    const source = SOURCES.find((s) => s.name === String(sourceName).toLowerCase());
+    return source && source.switchmode;
+}
+
+/** read value (getPlayerStatus.loop / upnp LoopMode) → {repeat, shuffle} */
+export const LOOP = {
+    0: {repeat: 'all', shuffle: false},
+    1: {repeat: 'one', shuffle: false},
+    2: {repeat: 'all', shuffle: true},
+    3: {repeat: 'off', shuffle: true},
+    4: {repeat: 'off', shuffle: false},
+    5: {repeat: 'one', shuffle: true},
+};
+
+/** {repeat, shuffle} → setPlayerCmd:loopmode:<n> */
+export const LOOPMODE_SET = {
+    'all:false': -1,
+    'one:false': 1,
+    'all:true': 2,
+    'off:true': 3,
+    'off:false': 0,
+    'one:true': 5,
+};
+
+export const REPEAT_MODES = ['off', 'one', 'all'];
+
+export function loopToRepeatShuffle(loop) {
+    return LOOP[Number(loop)] || {repeat: 'off', shuffle: false};
+}
+
+export function loopmodeFor(repeat, shuffle) {
+    const key = `${repeat}:${Boolean(shuffle)}`;
+    if (!(key in LOOPMODE_SET)) {
+        throw new Error(`unsupported repeat/shuffle combination ${key}`);
+    }
+    return LOOPMODE_SET[key];
+}
+
+/** friendly items that can be set; everything else on set/ is rejected */
+export const SET_ITEMS = [
+    'volume',
+    'volume_up',
+    'volume_down',
+    'mute',
+    'play',
+    'pause',
+    'stop',
+    'next',
+    'prev',
+    'toggle',
+    'play_state',
+    'seek',
+    'position',
+    'source',
+    'repeat',
+    'shuffle',
+    'preset',
+    'join',
+    'leave',
+    'ungroup',
+    'kick',
+    'reboot',
+    'cmd',
+];
+
+/** items that accept an empty payload */
+export const OPTIONAL_PAYLOAD = new Set([
+    'volume_up',
+    'volume_down',
+    'play',
+    'pause',
+    'stop',
+    'next',
+    'prev',
+    'toggle',
+    'leave',
+    'ungroup',
+    'reboot',
+]);
+
+function int(value) {
+    const n = typeof value === 'number' ? value : Number(String(value).trim());
+    return Number.isFinite(n) ? Math.round(n) : undefined;
+}
+
+/** seconds from a number, "mm:ss" or "h:mm:ss" */
+export function toSeconds(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && value >= 0 ? Math.round(value) : undefined;
+    }
+    const text = String(value).trim();
+    if (/^\d+(\.\d+)?$/.test(text)) {
+        return Math.round(Number(text));
+    }
+    if (/^\d+(:\d{1,2}){1,2}$/.test(text)) {
+        return text.split(':').reduce((acc, p) => acc * 60 + Number(p), 0);
+    }
+    return undefined;
+}
+
+function findPreset(list, value) {
+    const n = int(value);
+    if (n !== undefined) {
+        return n;
+    }
+    const name = String(value).trim().toLowerCase();
+    const preset = (Array.isArray(list) ? list : []).find((p) => String(p.name).toLowerCase() === name);
+    return preset ? preset.number : undefined;
+}
+
+function isIp(value) {
+    return /^\d{1,3}(\.\d{1,3}){3}$/.test(String(value).trim());
+}
+
+/**
+ * Map set/<item> with a parsed payload to a command.
+ * @param {string} item
+ * @param {*} value parsed payload (parsePayload)
+ * @param {(item: string) => *} get last known friendly value
+ * @returns {{api?: string, target?: 'master', verify?: string[], noop?: true}}
+ * @throws Error with a human-readable reason when the payload is invalid
+ */
+export function commandFor(item, value, get) {
+    switch (item) {
+        case 'volume': {
+            const v = toVolume(value);
+            if (v === undefined) {
+                throw new Error(`invalid volume ${JSON.stringify(value)}`);
+            }
+            return {api: `setPlayerCmd:vol:${v}`, verify: ['volume']};
+        }
+        case 'volume_up':
+        case 'volume_down': {
+            const step = value === undefined || value === true || value === '' ? 5 : int(value);
+            if (step === undefined || step < 1) {
+                throw new Error(`invalid step ${JSON.stringify(value)}`);
+            }
+            const current = int(get('volume'));
+            if (current === undefined) {
+                throw new Error('current volume unknown');
+            }
+            const v = toVolume(item === 'volume_up' ? current + step : current - step);
+            return {api: `setPlayerCmd:vol:${v}`, verify: ['volume']};
+        }
+        case 'mute': {
+            const b = toBoolean(value);
+            if (b === undefined) {
+                throw new Error(`invalid mute ${JSON.stringify(value)}`);
+            }
+            return {api: `setPlayerCmd:mute:${b ? 1 : 0}`, verify: ['mute']};
+        }
+        case 'play': {
+            if (typeof value === 'string' && /^[a-z][a-z0-9+.-]*:\/\//i.test(value)) {
+                return {api: `setPlayerCmd:play:${value}`, verify: ['play_state', 'title']};
+            }
+            return {api: 'setPlayerCmd:resume', verify: ['play_state']};
+        }
+        case 'pause':
+            return {api: 'setPlayerCmd:pause', verify: ['play_state']};
+        case 'stop':
+            return {api: 'setPlayerCmd:stop', verify: ['play_state']};
+        case 'next':
+            return {api: 'setPlayerCmd:next', verify: ['title']};
+        case 'prev':
+            return {api: 'setPlayerCmd:prev', verify: ['title']};
+        case 'toggle':
+            return {api: 'setPlayerCmd:onepause', verify: ['play_state']};
+        case 'play_state': {
+            const state = String(value).toLowerCase();
+            const api = {
+                playing: 'resume',
+                play: 'resume',
+                paused: 'pause',
+                pause: 'pause',
+                stopped: 'stop',
+                stop: 'stop',
+            }[state];
+            if (!api) {
+                throw new Error(`invalid play_state ${JSON.stringify(value)} (playing|paused|stopped)`);
+            }
+            return {api: `setPlayerCmd:${api}`, verify: ['play_state']};
+        }
+        case 'seek':
+        case 'position': {
+            const s = toSeconds(value);
+            if (s === undefined) {
+                throw new Error(`invalid position ${JSON.stringify(value)} (seconds or mm:ss)`);
+            }
+            return {api: `setPlayerCmd:seek:${s}`, verify: ['position']};
+        }
+        case 'source': {
+            const switchmode = switchmodeFor(value);
+            if (!switchmode) {
+                throw new Error(
+                    `source ${JSON.stringify(value)} cannot be selected (${SWITCHABLE_SOURCES.join(', ')})`,
+                );
+            }
+            return {api: `setPlayerCmd:switchmode:${switchmode}`, verify: ['source']};
+        }
+        case 'repeat': {
+            const repeat = String(value).toLowerCase();
+            if (!REPEAT_MODES.includes(repeat)) {
+                throw new Error(`invalid repeat ${JSON.stringify(value)} (off|one|all)`);
+            }
+            return {api: `setPlayerCmd:loopmode:${loopmodeFor(repeat, get('shuffle'))}`, verify: ['repeat', 'shuffle']};
+        }
+        case 'shuffle': {
+            const shuffle = toBoolean(value);
+            if (shuffle === undefined) {
+                throw new Error(`invalid shuffle ${JSON.stringify(value)}`);
+            }
+            const repeat = REPEAT_MODES.includes(get('repeat')) ? get('repeat') : 'off';
+            return {api: `setPlayerCmd:loopmode:${loopmodeFor(repeat, shuffle)}`, verify: ['repeat', 'shuffle']};
+        }
+        case 'preset': {
+            const n = findPreset(get('preset_list'), value);
+            const max = int(get('preset_max')) || 12;
+            if (n === undefined) {
+                throw new Error(`unknown preset ${JSON.stringify(value)}`);
+            }
+            if (n < 1 || n > max) {
+                throw new Error(`preset ${n} out of range 1..${max}`);
+            }
+            return {api: `MCUKeyShortClick:${n}`, verify: ['title', 'source', 'play_state']};
+        }
+        case 'join': {
+            const ip = String(value).trim();
+            if (!isIp(ip)) {
+                throw new Error(`join needs the master's ip address, got ${JSON.stringify(value)}`);
+            }
+            return {api: `ConnectMasterAp:JoinGroupMaster:eth${ip}:wifi0.0.0.0`, verify: ['group_role']};
+        }
+        case 'leave': {
+            const master = get('group_master');
+            const ip = get('ip');
+            if (!master || !ip) {
+                throw new Error('not in a group (group_master/ip unknown)');
+            }
+            return {api: `multiroom:SlaveKickout:${ip}`, target: 'master', verify: ['group_role']};
+        }
+        case 'ungroup':
+            return {api: 'multiroom:Ungroup', verify: ['group_slaves', 'group_role']};
+        case 'kick': {
+            const slaves = Array.isArray(get('group_slaves')) ? get('group_slaves') : [];
+            const text = String(value).trim();
+            const slave = isIp(text)
+                ? {ip: text}
+                : slaves.find((s) => String(s.name).toLowerCase() === text.toLowerCase());
+            if (!slave) {
+                throw new Error(`unknown slave ${JSON.stringify(value)}`);
+            }
+            return {api: `multiroom:SlaveKickout:${slave.ip}`, verify: ['group_slaves']};
+        }
+        case 'reboot': {
+            if (value !== undefined && toBoolean(value) === false) {
+                return {noop: true};
+            }
+            return {api: 'reboot'};
+        }
+        case 'cmd':
+            return {api: String(value), raw: true};
+        default:
+            throw new Error(`unknown item ${item}`);
+    }
+}