@switchbot/homebridge-switchbot/dist/device/plug.js

The SwitchBot plugin allows you to access your SwitchBot device(s) from HomeKit.

/*
* For Testing Locally:
* import { SwitchBotBLEModel, SwitchBotBLEModelName } from '/Users/Shared/GitHub/OpenWonderLabs/node-switchbot/dist/index.js';
*/
import { SwitchBotBLEModel, SwitchBotBLEModelName } from 'node-switchbot';
import { debounceTime, interval, skipWhile, Subject, take, tap } from 'rxjs';
import { formatDeviceIdAsMac } from '../utils.js';
import { deviceBase } from './device.js';
export class Plug extends deviceBase {
    platform;
    // Services
    Outlet;
    // OpenAPI
    deviceStatus;
    // Webhook
    webhookContext;
    // BLE
    serviceData;
    // Updates
    plugUpdateInProgress;
    doPlugUpdate;
    constructor(platform, accessory, device) {
        super(platform, accessory, device);
        this.platform = platform;
        // Set category
        accessory.category = 7 /* this.hap.Categories.OUTLET */;
        // this is subject we use to track when we need to POST changes to the SwitchBot API
        this.doPlugUpdate = new Subject();
        this.plugUpdateInProgress = false;
        // Initialize Outlet Service
        accessory.context.Outlet = accessory.context.Outlet ?? {};
        this.Outlet = {
            Name: accessory.displayName,
            Service: accessory.getService(this.hap.Service.Outlet) ?? accessory.addService(this.hap.Service.Outlet),
            On: accessory.context.On || false,
        };
        accessory.context.Outlet = this.Outlet;
        // Initialize Outlet Characteristics
        this.Outlet.Service.setCharacteristic(this.hap.Characteristic.Name, this.Outlet.Name).getCharacteristic(this.hap.Characteristic.On).onGet(() => {
            return this.Outlet.On;
        }).onSet(this.OnSet.bind(this));
        // Retrieve initial values and updateHomekit
        try {
            this.debugLog('Retrieve initial values and update Homekit');
            this.refreshStatus();
        }
        catch (e) {
            this.errorLog(`failed to retrieve initial values and update Homekit, Error: ${e.message ?? e}`);
        }
        // regisiter webhook event handler if enabled
        try {
            this.debugLog('Registering Webhook Event Handler');
            this.registerWebhook();
        }
        catch (e) {
            this.errorLog(`failed to registerWebhook, Error: ${e.message ?? e}`);
        }
        // regisiter platform BLE event handler if enabled
        try {
            this.debugLog('Registering Platform BLE Event Handler');
            this.registerPlatformBLE();
        }
        catch (e) {
            this.errorLog(`failed to registerPlatformBLE, Error: ${e.message ?? e}`);
        }
        // Start an update interval
        interval(this.deviceRefreshRate * 1000)
            .pipe(skipWhile(() => this.plugUpdateInProgress))
            .subscribe(async () => {
            await this.refreshStatus();
        });
        // Watch for Plug change events
        // We put in a debounce of 100ms so we don't make duplicate calls
        this.doPlugUpdate
            .pipe(tap(() => {
            this.plugUpdateInProgress = true;
        }), debounceTime(this.devicePushRate * 1000))
            .subscribe(async () => {
            try {
                await this.pushChanges();
            }
            catch (e) {
                await this.apiError(e);
                this.errorLog(`failed pushChanges with ${device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
            }
            this.plugUpdateInProgress = false;
        });
    }
    async BLEparseStatus() {
        this.debugLog('BLEparseStatus');
        this.debugLog(`(powerState) = BLE: (${this.serviceData.state}), current:(${this.Outlet.On})`);
        // On
        this.Outlet.On = this.serviceData.state === 'on';
        this.debugLog(`On: ${this.Outlet.On}`);
    }
    async openAPIparseStatus() {
        this.debugLog('openAPIparseStatus');
        this.debugLog(`(powerState) = OpenAPI: (${this.deviceStatus.power}), current:(${this.Outlet.On})`);
        // On
        this.Outlet.On = this.deviceStatus.power === 'on';
        this.debugLog(`On: ${this.Outlet.On}`);
        // Firmware Version
        if (this.deviceStatus.version) {
            const version = this.deviceStatus.version.toString();
            this.debugLog(`Firmware Version: ${version.replace(/^V|-.*$/g, '')}`);
            const deviceVersion = version.replace(/^V|-.*$/g, '') ?? '0.0.0';
            this.accessory
                .getService(this.hap.Service.AccessoryInformation)
                .setCharacteristic(this.hap.Characteristic.HardwareRevision, deviceVersion)
                .setCharacteristic(this.hap.Characteristic.FirmwareRevision, deviceVersion)
                .getCharacteristic(this.hap.Characteristic.FirmwareRevision)
                .updateValue(deviceVersion);
            this.accessory.context.version = deviceVersion;
            this.debugSuccessLog(`version: ${this.accessory.context.version}`);
        }
    }
    async parseStatusWebhook() {
        this.debugLog('parseStatusWebhook');
        this.debugLog(`(powerState) = Webhook: (${this.webhookContext.powerState}), current:(${this.Outlet.On})`);
        // On
        this.Outlet.On = this.webhookContext.powerState === 'ON';
        this.debugLog(`On: ${this.Outlet.On}`);
    }
    /**
     * Asks the SwitchBot API for the latest device information
     */
    async refreshStatus() {
        if (!this.device.enableCloudService && this.OpenAPI) {
            this.errorLog(`refreshStatus enableCloudService: ${this.device.enableCloudService}`);
        }
        else if (this.BLE) {
            await this.BLERefreshStatus();
        }
        else if (this.OpenAPI && this.platform.config.credentials?.token) {
            await this.openAPIRefreshStatus();
        }
        else {
            await this.offlineOff();
            this.debugWarnLog(`Connection Type: ${this.device.connectionType}, refreshStatus will not happen.`);
        }
    }
    async BLERefreshStatus() {
        this.debugLog('BLERefreshStatus');
        const switchBotBLE = await this.switchbotBLE();
        if (switchBotBLE === undefined) {
            await this.BLERefreshConnection(switchBotBLE);
        }
        else {
            // Start to monitor advertisement packets
            (async () => {
                // Start to monitor advertisement packets
                const serviceData = await this.monitorAdvertisementPackets(switchBotBLE);
                // Update HomeKit
                if ((serviceData.model === SwitchBotBLEModel.PlugMiniUS || SwitchBotBLEModel.PlugMiniJP)
                    && serviceData.modelName === (SwitchBotBLEModelName.PlugMini || SwitchBotBLEModelName.PlugMini)) {
                    this.serviceData = serviceData;
                    if (serviceData !== undefined || serviceData !== null) {
                        await this.BLEparseStatus();
                        await this.updateHomeKitCharacteristics();
                    }
                    else {
                        this.errorLog(`serviceData is either undefined or null, serviceData: ${JSON.stringify(serviceData)}`);
                        await this.BLERefreshConnection(switchBotBLE);
                    }
                }
                else {
                    this.errorLog(`failed to get serviceData, serviceData: ${JSON.stringify(serviceData)}`);
                    await this.BLERefreshConnection(switchBotBLE);
                }
            })();
        }
    }
    async registerPlatformBLE() {
        this.debugLog('registerPlatformBLE');
        if (this.config.options?.BLE && !this.device.disablePlatformBLE) {
            this.debugLog('is listening to Platform BLE.');
            try {
                const formattedDeviceId = formatDeviceIdAsMac(this.device.deviceId);
                this.device.bleMac = formattedDeviceId;
                this.debugLog(`bleMac: ${this.device.bleMac}`);
                this.platform.bleEventHandler[this.device.bleMac] = async (context) => {
                    try {
                        this.serviceData = context;
                        if (context !== undefined || context !== null) {
                            this.debugLog(`received BLE: ${JSON.stringify(context)}`);
                            await this.BLEparseStatus();
                            await this.updateHomeKitCharacteristics();
                        }
                        else {
                            this.errorLog(`context is either undefined or null, context: ${JSON.stringify(context)}`);
                            await this.BLERefreshConnection(context);
                        }
                    }
                    catch (e) {
                        this.errorLog(`failed to handle BLE. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
                    }
                };
            }
            catch (error) {
                this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
            }
        }
        else {
            this.debugLog('is not listening to Platform BLE');
        }
    }
    async openAPIRefreshStatus() {
        this.debugLog('openAPIRefreshStatus');
        try {
            const response = await this.deviceRefreshStatus();
            const deviceStatus = response.body;
            this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
            if (await this.successfulStatusCodes(deviceStatus)) {
                this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                this.deviceStatus = deviceStatus.body;
                await this.openAPIparseStatus();
                await this.updateHomeKitCharacteristics();
            }
            else {
                this.debugWarnLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
            }
        }
        catch (e) {
            await this.apiError(e);
            this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
        }
    }
    async registerWebhook() {
        if (this.device.webhook) {
            this.debugLog('is listening webhook.');
            this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
                try {
                    this.webhookContext = context;
                    if (context !== undefined || context !== null) {
                        this.debugLog(`received Webhook: ${JSON.stringify(context)}`);
                        await this.parseStatusWebhook();
                        await this.updateHomeKitCharacteristics();
                    }
                    else {
                        this.errorLog(`context is either undefined or null, context: ${JSON.stringify(context)}`);
                    }
                }
                catch (e) {
                    this.errorLog(`failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e.message ?? e}`);
                }
            };
        }
        else {
            this.debugLog('is not listening webhook.');
        }
    }
    /**
     * Pushes the requested changes to the SwitchBot API
     * deviceType              commandType   Command     command parameter     Description
     * Plug               -    "command"     "turnOff"   "default"    =        set to OFF state
     * Plug               -    "command"     "turnOn"    "default"    =        set to ON state
     * Plug Mini (US/JP)  -    "command"     "turnOn"    "default"    =        set to ON state
     * Plug Mini (US/JP)  -    "command"     "turnOff"   "default"    =        set to OFF state
     * Plug Mini (US/JP)  -    "command"     "toggle"    "default"    =        toggle state
     */
    async pushChanges() {
        if (!this.device.enableCloudService && this.OpenAPI) {
            this.errorLog(`pushChanges enableCloudService: ${this.device.enableCloudService}`);
        }
        else if (this.BLE) {
            await this.BLEpushChanges();
        }
        else if (this.OpenAPI && this.platform.config.credentials?.token) {
            await this.openAPIpushChanges();
        }
        else {
            await this.offlineOff();
            this.debugWarnLog(`Connection Type: ${this.device.connectionType}, pushChanges will not happen.`);
        }
        // Refresh the status from the API
        interval(15000)
            .pipe(skipWhile(() => this.plugUpdateInProgress))
            .pipe(take(1))
            .subscribe(async () => {
            await this.refreshStatus();
        });
    }
    async BLEpushChanges() {
        this.debugLog('BLEpushChanges');
        if (this.Outlet.On !== this.accessory.context.On) {
            this.debugLog(`BLEpushChanges On: ${this.Outlet.On}, OnCached: ${this.accessory.context.On}`);
            const switchBotBLE = await this.platform.connectBLE(this.accessory, this.device);
            try {
                const formattedDeviceId = formatDeviceIdAsMac(this.device.deviceId);
                this.device.bleMac = formattedDeviceId;
                this.debugLog(`bleMac: ${this.device.bleMac}`);
                if (switchBotBLE !== false) {
                    switchBotBLE
                        .discover({ model: this.device.bleModel, id: this.device.bleMac })
                        .then(async (device_list) => {
                        const deviceList = device_list;
                        this.infoLog(`On: ${this.Outlet.On}`);
                        return await this.retryBLE({
                            max: this.maxRetryBLE(),
                            fn: async () => {
                                if (this.Outlet.On) {
                                    return await deviceList[0].turnOn();
                                }
                                else {
                                    return await deviceList[0].turnOff();
                                }
                            },
                        });
                    })
                        .then(async () => {
                        this.successLog(`On: ${this.Outlet.On} sent over SwitchBot BLE, sent successfully`);
                        await this.updateHomeKitCharacteristics();
                    })
                        .catch(async (e) => {
                        await this.apiError(e);
                        this.errorLog(`failed BLEpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
                        await this.BLEPushConnection();
                    });
                }
                else {
                    this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${JSON.stringify(switchBotBLE)}`);
                    await this.BLEPushConnection();
                }
            }
            catch (error) {
                this.errorLog(`failed to format device ID as MAC, Error: ${error}`);
            }
        }
        else {
            this.debugLog(`No changes (BLEpushChanges), On: ${this.Outlet.On}, OnCached: ${this.accessory.context.On}`);
        }
    }
    async openAPIpushChanges() {
        this.debugLog('openAPIpushChanges');
        if (this.Outlet.On !== this.accessory.context.On) {
            const command = this.Outlet.On ? 'turnOn' : 'turnOff';
            const bodyChange = {
                command: `${command}`,
                parameter: 'default',
                commandType: 'command',
            };
            this.debugLog(`SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`);
            try {
                const response = await this.pushChangeRequest(bodyChange);
                const deviceStatus = response.body;
                this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                if (await this.successfulStatusCodes(deviceStatus)) {
                    this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`);
                    await this.updateHomeKitCharacteristics();
                }
                else {
                    await this.statusCode(deviceStatus.statusCode);
                }
            }
            catch (e) {
                await this.apiError(e);
                this.errorLog(`failed openAPIpushChanges with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`);
            }
        }
        else {
            this.debugLog(`No changes (openAPIpushChanges), On: ${this.Outlet.On}, OnCached: ${this.accessory.context.On}`);
        }
    }
    /**
     * Handle requests to set the value of the "On" characteristic
     */
    async OnSet(value) {
        if (this.Outlet.On !== this.accessory.context.On) {
            this.infoLog(`Set On: ${value}`);
        }
        else {
            this.debugLog(`No Changes, On: ${value}`);
        }
        this.Outlet.On = value;
        this.doPlugUpdate.next();
    }
    async updateHomeKitCharacteristics() {
        // On
        await this.updateCharacteristic(this.Outlet.Service, this.hap.Characteristic.On, this.Outlet.On, 'On');
    }
    async BLEPushConnection() {
        if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
            this.warnLog('Using OpenAPI Connection to Push Changes');
            await this.openAPIpushChanges();
        }
    }
    async BLERefreshConnection(switchbot) {
        this.errorLog(`wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
        if (this.platform.config.credentials?.token && this.device.connectionType === 'BLE/OpenAPI') {
            this.warnLog('Using OpenAPI Connection to Refresh Status');
            await this.openAPIRefreshStatus();
        }
    }
    async offlineOff() {
        if (this.device.offline) {
            this.Outlet.Service.updateCharacteristic(this.hap.Characteristic.On, false);
        }
    }
    async apiError(e) {
        this.Outlet.Service.updateCharacteristic(this.hap.Characteristic.On, e);
    }
}
//# sourceMappingURL=plug.js.map