homebridge-rfxcom-devices/dist/platform.js

It is simple Homebridge platform plugin allowing 433mhz RF device support to Homekit.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HomebridgePlatform = void 0;
const settings_1 = require("./settings");
const platformAccessoryButton_1 = require("./platformAccessoryButton");
const rfxcom_1 = __importDefault(require("rfxcom"));
const eventing_bus_1 = __importDefault(require("eventing-bus"));
class HomebridgePlatform {
    /**
     *
     * @param {Logger} log
     * @param {PlatformConfig} config
     * @param {API} api
     */
    constructor(log, config, api) {
        this.log = log;
        this.config = config;
        this.api = api;
        this.Service = this.api.hap.Service;
        this.Characteristic = this.api.hap.Characteristic;
        this.accessories = [];
        this.customConfig = this.config;
        this.log.debug('Finished initializing platform:', this.customConfig.name);
        this.api.on('didFinishLaunching', () => {
            this.discoverDevices();
        });
        this.initRfxCom();
        (async () => {
            await this.listenRfxCom();
        })();
    }
    /**
     *
     * @param {PlatformAccessory} accessory
     */
    configureAccessory(accessory) {
        this.log.info('Loading accessory from cache:', accessory.displayName);
        this.accessories.push(accessory);
    }
    initRfxCom() {
        this.log.info('Init RFXCom device to listen.');
        this.rfxCom = new rfxcom_1.default.RfxCom(this.customConfig.serialport, { debug: true });
    }
    async listenRfxCom() {
        return new Promise((resolve, reject) => {
            const timeout = setTimeout(() => {
                reject('timeout');
            }, 12000);
            try {
                const light = (type, evt) => {
                    this.log.info('RFXCom device receive data :', evt);
                    eventing_bus_1.default.publish('rfxcom_detection', evt);
                };
                this.rfxCom.on('lighting1', (evt) => light('lighting1', evt));
                this.rfxCom.on('lighting2', (evt) => light('lighting2', evt));
                this.rfxCom.on('lighting3', (evt) => light('lighting3', evt));
                this.rfxCom.on('lighting4', (evt) => light('lighting4', evt));
                this.rfxCom.on('lighting5', (evt) => light('lighting5', evt));
                this.rfxCom.on('lighting6', (evt) => light('lighting6', evt));
                eventing_bus_1.default.on('rfxcom_enable', () => {
                    this.log.info('RFXCom enable.');
                });
                this.rfxCom.initialise(() => {
                    this.log.info('RFXCom device initialised.');
                    eventing_bus_1.default.publish('rfxcom_enable');
                    clearTimeout(timeout);
                    resolve();
                });
            }
            catch (e) {
                clearTimeout(timeout);
                reject(e);
            }
        });
    }
    discoverDevices() {
        if (this.customConfig.devices === undefined || this.customConfig.devices === null) {
            return;
        }
        const devices = this.customConfig.devices.map((device) => {
            device.UUID = this.api.hap.uuid.generate(device.uniqueid);
            return device;
        });
        const accessoriesActuallyConfigured = this.accessories.map(accessory => accessory.UUID);
        const toAdd = devices.filter(accessory => accessoriesActuallyConfigured.indexOf(accessory.UUID) < 0);
        const toUpdate = devices.filter(accessory => accessoriesActuallyConfigured.indexOf(accessory.UUID) >= 0);
        const toDelete = accessoriesActuallyConfigured.filter(uuidConfigured => {
            return devices.map(accessory => accessory.UUID).indexOf(uuidConfigured) < 0;
        });
        for (const device of toAdd) {
            const accessory = new this.api.platformAccessory(device.name, device.UUID);
            accessory.context.device = device;
            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
            this.instanceAccessory(device, accessory);
            this.log.info('Adding new accessory:', device.name);
        }
        for (const device of toUpdate) {
            const existingAccessory = this.accessories.find(accessory => accessory.UUID === device.UUID);
            if (existingAccessory) {
                this.api.updatePlatformAccessories([existingAccessory]);
                this.instanceAccessory(device, existingAccessory);
                this.log.info('Restoring existing accessory from cache:', existingAccessory.displayName);
            }
        }
        for (const deviceUUID of toDelete) {
            const existingAccessory = this.accessories.find(accessory => accessory.UUID === deviceUUID);
            if (existingAccessory) {
                this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [existingAccessory]);
                this.log.info('Removing existing accessory from cache:', existingAccessory.displayName);
            }
        }
    }
    /**
     * @param {Device} device
     * @param {PlatformAccessory} accessory
     * @private
     */
    instanceAccessory(device, accessory) {
        switch (device.type) {
            case 'button':
                new platformAccessoryButton_1.PlatformAccessoryButton(this, accessory);
                break;
        }
    }
}
exports.HomebridgePlatform = HomebridgePlatform;
//# sourceMappingURL=platform.js.map