homebridge-lovesac-stealthtech 0.0.0-development

package/dist/protocol/LovesacDevice.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LovesacDevice = void 0;
+const responses_1 = require("./responses");
+const constants_1 = require("./constants");
+const commands = __importStar(require("./commands"));
+const settings_1 = require("../settings");
+const CODE_NAMES = {
+    [constants_1.ResponseCode.Volume]: 'Volume',
+    [constants_1.ResponseCode.CenterVolume]: 'Center',
+    [constants_1.ResponseCode.Treble]: 'Treble',
+    [constants_1.ResponseCode.Bass]: 'Bass',
+    [constants_1.ResponseCode.Mute]: 'Mute',
+    [constants_1.ResponseCode.QuietMode]: 'Quiet Mode',
+    [constants_1.ResponseCode.Balance]: 'Balance',
+    [constants_1.ResponseCode.Layout]: 'Layout',
+    [constants_1.ResponseCode.Source]: 'Source',
+    [constants_1.ResponseCode.Power]: 'Power',
+    [constants_1.ResponseCode.Preset]: 'Preset',
+    [constants_1.ResponseCode.Covering]: 'Covering',
+    [constants_1.ResponseCode.ArmType]: 'Arm Type',
+    [constants_1.ResponseCode.Subwoofer]: 'Subwoofer',
+    [constants_1.ResponseCode.RearVolume]: 'Rear',
+};
+function formatStateValue(code, value) {
+    switch (code) {
+        case constants_1.ResponseCode.Power:
+            return value === 0 ? 'On' : 'Off';
+        case constants_1.ResponseCode.Mute:
+        case constants_1.ResponseCode.QuietMode:
+        case constants_1.ResponseCode.Subwoofer:
+            return value === 1 ? 'Yes' : 'No';
+        case constants_1.ResponseCode.Source:
+            return constants_1.SOURCE_NAMES[value] ?? String(value);
+        case constants_1.ResponseCode.Preset:
+            return constants_1.PRESET_NAMES[value] ?? String(value);
+        default:
+            return String(value);
+    }
+}
+class LovesacDevice {
+    connectionManager;
+    log;
+    state;
+    stateListeners = [];
+    stateInitialized = false;
+    mcuVersion = '';
+    versionListeners = [];
+    pollTimer = null;
+    constructor(connectionManager, log) {
+        this.connectionManager = connectionManager;
+        this.log = log;
+        this.state = (0, responses_1.createDefaultState)();
+        this.connectionManager.setNotificationHandler((data) => {
+            this.handleNotification(data);
+        });
+        this.connectionManager.onReconnect(() => {
+            this.requestStateRefresh().catch(err => {
+                this.log.warn('Reconnect state refresh failed: %s', (0, settings_1.errorMessage)(err));
+            });
+        });
+    }
+    onStateChange(listener) {
+        this.stateListeners.push(listener);
+    }
+    isStateInitialized() {
+        return this.stateInitialized;
+    }
+    onVersionResolved(callback) {
+        this.versionListeners.push(callback);
+    }
+    async requestStateRefresh() {
+        await this.connectionManager.enqueue(commands.requestDeviceInfo());
+        await this.connectionManager.enqueue(commands.requestVersionInfo());
+    }
+    startPolling(intervalSeconds) {
+        if (intervalSeconds <= 0) {
+            this.log.info('Background polling disabled');
+            return;
+        }
+        this.log.info('Starting background poll every %ds', intervalSeconds);
+        // Immediate initial fetch — onReconnect will also fire on first connect
+        this.requestStateRefresh().catch(err => {
+            this.log.warn('Initial state refresh failed (will retry on next poll): %s', (0, settings_1.errorMessage)(err));
+        });
+        this.pollTimer = setInterval(() => {
+            this.requestStateRefresh().catch(err => {
+                this.log.warn('Background poll failed: %s', (0, settings_1.errorMessage)(err));
+            });
+        }, intervalSeconds * 1000);
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    getResolvedAddress() {
+        return this.connectionManager.getResolvedAddress();
+    }
+    // --- Power ---
+    async setPower(on) {
+        this.log.info('Setting power %s', on ? 'ON' : 'OFF');
+        await this.connectionManager.enqueue(commands.setPower(on));
+    }
+    // --- Volume ---
+    async setVolume(volume) {
+        this.log.info('Setting volume to %d', volume);
+        await this.connectionManager.enqueue(commands.setVolume(volume));
+    }
+    volumeToPercent(volume) {
+        return Math.round((volume / settings_1.MAX_VOLUME) * 100);
+    }
+    percentToVolume(percent) {
+        return Math.round((percent / 100) * settings_1.MAX_VOLUME);
+    }
+    async volumeUp(step) {
+        const newVol = Math.min(settings_1.MAX_VOLUME, this.state.volume + step);
+        await this.setVolume(newVol);
+    }
+    async volumeDown(step) {
+        const newVol = Math.max(0, this.state.volume - step);
+        await this.setVolume(newVol);
+    }
+    // --- Mute ---
+    async setMute(muted) {
+        this.log.info('Setting mute %s', muted ? 'ON' : 'OFF');
+        await this.connectionManager.enqueue(commands.setMute(muted));
+    }
+    // --- Quiet Mode ---
+    async setQuietMode(on) {
+        this.log.info('Setting quiet mode %s', on ? 'ON' : 'OFF');
+        await this.connectionManager.enqueue(commands.setQuietMode(on));
+    }
+    // --- Source ---
+    async setSource(source) {
+        this.log.info('Setting source to %d', source);
+        await this.connectionManager.enqueue(commands.setSource(source));
+    }
+    // --- Preset ---
+    async setPreset(preset) {
+        this.log.info('Setting preset to %d', preset);
+        // Optimistically update cached state so switches respond immediately
+        const readVal = (0, constants_1.presetWriteToRead)(preset);
+        if (readVal !== undefined) {
+            this.state.preset = readVal;
+        }
+        await this.connectionManager.enqueue(commands.setPreset(preset));
+    }
+    isPresetActive(readValue) {
+        return this.state.preset === readValue;
+    }
+    // --- Internal ---
+    handleNotification(data) {
+        // Check for version response: CC 05/06 AA 01 03 <type> <major> <minor>
+        if (data.length >= 8 && data[2] === 0xAA && data[3] === 0x01 && data[4] === 0x03) {
+            const type = data[5]; // 01=MCU, 02=DSP, 03=EQ
+            const major = data[6];
+            const minor = data[7];
+            const ver = `${major}.${minor}`;
+            if (type === 0x01 && !this.mcuVersion) {
+                this.mcuVersion = ver;
+                this.log.info('Firmware version: %s', ver);
+                for (const listener of this.versionListeners) {
+                    listener();
+                }
+            }
+            return;
+        }
+        const parsed = (0, responses_1.parseNotification)(data);
+        if (!parsed) {
+            this.log.debug('Ignoring non-status notification: %s', data.toString('hex'));
+            return;
+        }
+        const changed = (0, responses_1.applyResponse)(this.state, parsed);
+        if (changed === responses_1.OUT_OF_RANGE) {
+            this.log.warn('Out-of-range value for %s: %d (ignored)', CODE_NAMES[parsed.code] ?? `0x${parsed.code.toString(16)}`, parsed.value);
+            return;
+        }
+        this.stateInitialized = true;
+        if (changed) {
+            this.log.debug('State: %s = %s', CODE_NAMES[parsed.code] ?? `0x${parsed.code.toString(16)}`, formatStateValue(parsed.code, parsed.value));
+            for (const listener of this.stateListeners) {
+                try {
+                    listener(parsed.code, parsed.value);
+                }
+                catch (err) {
+                    this.log.error('State listener error: %s', (0, settings_1.errorMessage)(err));
+                }
+            }
+        }
+    }
+}
+exports.LovesacDevice = LovesacDevice;

package/dist/protocol/commands.d.ts

@@ -0,0 +1,20 @@
+import { PresetWriteValue, SourceValue } from './constants';
+export interface BleCommand {
+    characteristicUuid: string;
+    data: Buffer;
+}
+export declare function setVolume(volume: number): BleCommand;
+export declare function setBass(bass: number): BleCommand;
+export declare function setTreble(treble: number): BleCommand;
+export declare function setCenterVolume(center: number): BleCommand;
+export declare function setRearVolume(rear: number): BleCommand;
+export declare function setMute(muted: boolean): BleCommand;
+export declare function setQuietMode(on: boolean): BleCommand;
+export declare function setBalance(balance: number): BleCommand;
+export declare function setPower(on: boolean): BleCommand;
+export declare function setPreset(preset: PresetWriteValue): BleCommand;
+export declare function setSource(source: SourceValue): BleCommand;
+export declare function requestDeviceInfo(): BleCommand;
+export declare function requestVersionInfo(): BleCommand;
+export declare function setPlayPause(value: number): BleCommand;
+export declare function setSkip(value: number): BleCommand;

package/dist/protocol/commands.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setVolume = setVolume;
+exports.setBass = setBass;
+exports.setTreble = setTreble;
+exports.setCenterVolume = setCenterVolume;
+exports.setRearVolume = setRearVolume;
+exports.setMute = setMute;
+exports.setQuietMode = setQuietMode;
+exports.setBalance = setBalance;
+exports.setPower = setPower;
+exports.setPreset = setPreset;
+exports.setSource = setSource;
+exports.requestDeviceInfo = requestDeviceInfo;
+exports.requestVersionInfo = requestVersionInfo;
+exports.setPlayPause = setPlayPause;
+exports.setSkip = setSkip;
+const settings_1 = require("../settings");
+// Format A: AA <cmdId> <subCmdId> 01 <value>
+function formatA(cmdId, subCmdId, value) {
+    return Buffer.from([0xAA, cmdId, subCmdId, 0x01, value]);
+}
+// Format B: AA <cmdId> <value> 00
+function formatB(cmdId, value) {
+    return Buffer.from([0xAA, cmdId, value, 0x00]);
+}
+function eqCommand(subCmdId, value) {
+    return { characteristicUuid: settings_1.CharUUID.EqControl, data: formatA(0x03, subCmdId, value) };
+}
+// Volume: 0-36
+function setVolume(volume) {
+    return eqCommand(0x02, Math.max(0, Math.min(36, volume)));
+}
+// Bass: 0-20
+function setBass(bass) {
+    return eqCommand(0x01, Math.max(0, Math.min(20, bass)));
+}
+// Treble: 0-20
+function setTreble(treble) {
+    return eqCommand(0x00, Math.max(0, Math.min(20, treble)));
+}
+// Center volume: 0-30
+function setCenterVolume(center) {
+    return eqCommand(0x03, Math.max(0, Math.min(30, center)));
+}
+// Rear volume: 0-30
+function setRearVolume(rear) {
+    return eqCommand(0x0A, Math.max(0, Math.min(30, rear)));
+}
+// Mute: true=muted, false=unmuted
+function setMute(muted) {
+    return eqCommand(0x09, muted ? 1 : 0);
+}
+// Quiet mode (night mode): true=on, false=off
+function setQuietMode(on) {
+    return eqCommand(0x04, on ? 1 : 0);
+}
+// Balance: 0-100 (50=center)
+function setBalance(balance) {
+    return {
+        characteristicUuid: settings_1.CharUUID.AudioPath,
+        data: formatA(0x04, 0x00, Math.max(0, Math.min(100, balance))),
+    };
+}
+// Power: true=on, false=off (standby)
+function setPower(on) {
+    return {
+        characteristicUuid: settings_1.CharUUID.AudioPath,
+        data: formatA(0x04, 0x01, on ? 1 : 0),
+    };
+}
+// Preset (sound mode)
+function setPreset(preset) {
+    return {
+        characteristicUuid: settings_1.CharUUID.EqControl,
+        data: formatB(0x03, preset),
+    };
+}
+// Input source
+function setSource(source) {
+    return {
+        characteristicUuid: settings_1.CharUUID.Source,
+        data: formatB(0x07, source),
+    };
+}
+// Request full device state dump
+function requestDeviceInfo() {
+    return {
+        characteristicUuid: settings_1.CharUUID.DeviceInfo,
+        data: formatB(0x01, 0x01),
+    };
+}
+// Request version info (AA 01 01 01 — last byte 01 distinguishes from state request)
+function requestVersionInfo() {
+    return {
+        characteristicUuid: settings_1.CharUUID.DeviceInfo,
+        data: Buffer.from([0xAA, 0x01, 0x01, 0x01]),
+    };
+}
+// Play/Pause (Bluetooth source)
+function setPlayPause(value) {
+    return {
+        characteristicUuid: settings_1.CharUUID.PlayerControl,
+        data: formatA(0x05, 0x00, value),
+    };
+}
+// Skip forward/backward (Bluetooth source)
+function setSkip(value) {
+    return {
+        characteristicUuid: settings_1.CharUUID.PlayerControl,
+        data: formatA(0x05, 0x01, value),
+    };
+}

package/dist/protocol/constants.d.ts

@@ -0,0 +1,40 @@
+export declare enum ResponseCode {
+    Volume = 1,
+    CenterVolume = 2,
+    Treble = 3,
+    Bass = 4,
+    Mute = 5,
+    QuietMode = 6,
+    Balance = 7,
+    Layout = 8,
+    Source = 9,
+    Power = 10,
+    Preset = 11,
+    Covering = 12,
+    ArmType = 13,
+    Subwoofer = 14,
+    RearVolume = 15
+}
+export declare enum PresetWriteValue {
+    TV = 5,
+    News = 6,
+    Movies = 7,
+    Music = 8,
+    Manual = 9
+}
+export declare enum PresetReadValue {
+    Movies = 0,
+    Music = 1,
+    TV = 2,
+    News = 3
+}
+export declare enum SourceValue {
+    HDMI = 0,
+    Bluetooth = 1,
+    AUX = 2,
+    Optical = 3
+}
+export declare function presetReadToWrite(readVal: PresetReadValue): PresetWriteValue;
+export declare function presetWriteToRead(writeVal: PresetWriteValue): PresetReadValue | undefined;
+export declare const PRESET_NAMES: Record<PresetReadValue, string>;
+export declare const SOURCE_NAMES: Record<SourceValue, string>;

package/dist/protocol/constants.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_NAMES = exports.PRESET_NAMES = exports.SourceValue = exports.PresetReadValue = exports.PresetWriteValue = exports.ResponseCode = void 0;
+exports.presetReadToWrite = presetReadToWrite;
+exports.presetWriteToRead = presetWriteToRead;
+// Response codes — last 2 bytes of UpStream notifications: <code> <value>
+var ResponseCode;
+(function (ResponseCode) {
+    ResponseCode[ResponseCode["Volume"] = 1] = "Volume";
+    ResponseCode[ResponseCode["CenterVolume"] = 2] = "CenterVolume";
+    ResponseCode[ResponseCode["Treble"] = 3] = "Treble";
+    ResponseCode[ResponseCode["Bass"] = 4] = "Bass";
+    ResponseCode[ResponseCode["Mute"] = 5] = "Mute";
+    ResponseCode[ResponseCode["QuietMode"] = 6] = "QuietMode";
+    ResponseCode[ResponseCode["Balance"] = 7] = "Balance";
+    ResponseCode[ResponseCode["Layout"] = 8] = "Layout";
+    ResponseCode[ResponseCode["Source"] = 9] = "Source";
+    ResponseCode[ResponseCode["Power"] = 10] = "Power";
+    ResponseCode[ResponseCode["Preset"] = 11] = "Preset";
+    ResponseCode[ResponseCode["Covering"] = 12] = "Covering";
+    ResponseCode[ResponseCode["ArmType"] = 13] = "ArmType";
+    ResponseCode[ResponseCode["Subwoofer"] = 14] = "Subwoofer";
+    ResponseCode[ResponseCode["RearVolume"] = 15] = "RearVolume";
+})(ResponseCode || (exports.ResponseCode = ResponseCode = {}));
+// Preset WRITE values (sent to device)
+var PresetWriteValue;
+(function (PresetWriteValue) {
+    PresetWriteValue[PresetWriteValue["TV"] = 5] = "TV";
+    PresetWriteValue[PresetWriteValue["News"] = 6] = "News";
+    PresetWriteValue[PresetWriteValue["Movies"] = 7] = "Movies";
+    PresetWriteValue[PresetWriteValue["Music"] = 8] = "Music";
+    PresetWriteValue[PresetWriteValue["Manual"] = 9] = "Manual";
+})(PresetWriteValue || (exports.PresetWriteValue = PresetWriteValue = {}));
+// Preset READ values (received in notifications)
+var PresetReadValue;
+(function (PresetReadValue) {
+    PresetReadValue[PresetReadValue["Movies"] = 0] = "Movies";
+    PresetReadValue[PresetReadValue["Music"] = 1] = "Music";
+    PresetReadValue[PresetReadValue["TV"] = 2] = "TV";
+    PresetReadValue[PresetReadValue["News"] = 3] = "News";
+})(PresetReadValue || (exports.PresetReadValue = PresetReadValue = {}));
+// Source values (same for read and write)
+var SourceValue;
+(function (SourceValue) {
+    SourceValue[SourceValue["HDMI"] = 0] = "HDMI";
+    SourceValue[SourceValue["Bluetooth"] = 1] = "Bluetooth";
+    SourceValue[SourceValue["AUX"] = 2] = "AUX";
+    SourceValue[SourceValue["Optical"] = 3] = "Optical";
+})(SourceValue || (exports.SourceValue = SourceValue = {}));
+// Maps a preset read value to the corresponding write value
+function presetReadToWrite(readVal) {
+    switch (readVal) {
+        case PresetReadValue.Movies: return PresetWriteValue.Movies;
+        case PresetReadValue.Music: return PresetWriteValue.Music;
+        case PresetReadValue.TV: return PresetWriteValue.TV;
+        case PresetReadValue.News: return PresetWriteValue.News;
+        default: throw new Error(`Unknown preset read value: ${readVal}`);
+    }
+}
+// Maps a preset write value to the corresponding read value
+function presetWriteToRead(writeVal) {
+    switch (writeVal) {
+        case PresetWriteValue.Movies: return PresetReadValue.Movies;
+        case PresetWriteValue.Music: return PresetReadValue.Music;
+        case PresetWriteValue.TV: return PresetReadValue.TV;
+        case PresetWriteValue.News: return PresetReadValue.News;
+        default: return undefined;
+    }
+}
+exports.PRESET_NAMES = {
+    [PresetReadValue.Movies]: 'Movies',
+    [PresetReadValue.Music]: 'Music',
+    [PresetReadValue.TV]: 'TV',
+    [PresetReadValue.News]: 'News',
+};
+exports.SOURCE_NAMES = {
+    [SourceValue.HDMI]: 'HDMI-ARC',
+    [SourceValue.Bluetooth]: 'Bluetooth',
+    [SourceValue.AUX]: 'AUX',
+    [SourceValue.Optical]: 'Optical',
+};

package/dist/protocol/responses.d.ts

@@ -0,0 +1,36 @@
+import { ResponseCode, PresetReadValue, SourceValue } from './constants';
+export interface DeviceState {
+    power: boolean;
+    volume: number;
+    mute: boolean;
+    source: SourceValue;
+    preset: PresetReadValue;
+    quietMode: boolean;
+    bass: number;
+    treble: number;
+    centerVolume: number;
+    rearVolume: number;
+    balance: number;
+    subwooferConnected: boolean;
+}
+export declare function createDefaultState(): DeviceState;
+export interface ParsedResponse {
+    code: ResponseCode;
+    value: number;
+}
+/**
+ * Parse a BLE notification from the UpStream characteristic.
+ * Returns the response code and value, or undefined if not a standard status response.
+ *
+ * Notifications have the format: CC 05/06 AA ... <code> <value>
+ * The last 2 bytes are always code + value for standard status responses.
+ * Version and OTA responses are ignored (handled separately if needed).
+ */
+export declare function parseNotification(data: Buffer): ParsedResponse | undefined;
+/**
+ * Apply a parsed response to the device state. Returns true if state changed.
+ * Out-of-range values are logged and ignored to guard against firmware bugs.
+ */
+export declare function applyResponse(state: DeviceState, response: ParsedResponse): boolean;
+/** Sentinel: applyResponse returns this for out-of-range values so the caller can log a warning. */
+export declare const OUT_OF_RANGE: boolean;