index.js

'use strict';

const axios = require('axios');

const NestConnection = require('./lib/nest-connection');

let ThermostatAccessory, HomeAwayAccessory, TempSensorAccessory, ProtectAccessory, LockAccessory;

require('promise.prototype.finally').shim(Promise);

Promise.delay = function(time_ms) {
    return new Promise(resolve => setTimeout(resolve, time_ms));
};

Promise.prototype.asCallback = function(callback) {
    this.then(res => callback(null, res)).catch(err => callback(err));
};

class NestPlatform {
    constructor(log, config, api) {
        // auth info
        this.config = config;
        this.log = log;
        this.api = api;
        this.accessoryLookup = {};
        this.cachedAccessories = [];

        api.on('didFinishLaunching', async () => {
            this.log('Fetching Nest devices.');

            const generateAccessories = function(data) {
                const foundAccessories = [];

                const loadDevices = function(DeviceType) {
                    const disableFlags = {
                        'thermostat': 'Thermostat.Disable',
                        'temp_sensor': 'TempSensor.Disable',
                        'protect': 'Protect.Disable',
                        'home_away_sensor': 'HomeAway.Disable',
                        'lock': 'Lock.Disable'
                    };

                    const devices = (data.devices && data.devices[DeviceType.deviceGroup]) || {};
                    for (const deviceId of Object.keys(devices)) {
                        const device = devices[deviceId];
                        const serialNumber = device.serial_number;
                        if (!this.optionSet(disableFlags[DeviceType.deviceType], serialNumber, deviceId)) {
                            const structureId = device.structure_id;
                            if (this.config.structureId && this.config.structureId !== structureId) {
                                this.log('Skipping device ' + deviceId + ' because it is not in the required structure. Has ' + structureId + ', looking for ' + this.config.structureId + '.');
                                continue;
                            }
                            const structure = data.structures[structureId];
                            const accessory = new DeviceType(this.conn, this.log, device, structure, this);
                            this.accessoryLookup[deviceId] = accessory;
                            foundAccessories.push(accessory);
                        }
                    }
                }.bind(this);

                loadDevices(ThermostatAccessory);
                loadDevices(HomeAwayAccessory);
                loadDevices(TempSensorAccessory);
                loadDevices(ProtectAccessory);
                loadDevices(LockAccessory);
                this.conn.accessories = this.accessoryLookup;

                return foundAccessories;
            }.bind(this);

            const updateAccessories = function(data, accList) {
                accList.map(function(acc) {
                    const group = data.devices[acc.deviceGroup];
                    const device = group && group[acc.deviceId];
                    if (device) {
                        const structureId = device.structure_id;
                        const structure = data.structures[structureId];
                        acc.updateData(device, structure);
                    }
                });
            };

            const handleUpdates = function(data) {
                if (Object.keys(this.accessoryLookup).length > 0) {
                    updateAccessories(data, this.accessoryLookup);
                }
            }.bind(this);

            try {
                this.conn = await this.setupConnection(this.optionSet('Debug.Verbose'), this.optionSet('Nest.FieldTest.Enable'));
                await this.conn.subscribe(handleUpdates);
                await this.conn.observe(handleUpdates);

                let initialState = this.conn.apiResponseToObjectTree(this.conn.currentState);
                this.accessoryLookup = generateAccessories(initialState);

                // Unregister any stale cached accessories not matched to a current device
                if (this.cachedAccessories.length > 0) {
                    try {
                        this.api.unregisterPlatformAccessories('@skirkpatrick88/homebridge-nest', 'Nest', this.cachedAccessories);
                    } catch (e) {
                        this.log.debug('Could not unregister stale cached accessories (may not be bridged yet): ' + e.message);
                    }
                    this.cachedAccessories = [];
                }
                // Register only new accessories (those without a matching cached entry)
                const newAccessories = this.accessoryLookup.filter(el => el.isNew).map(el => el.accessory);
                if (newAccessories.length > 0) {
                    this.api.registerPlatformAccessories('@skirkpatrick88/homebridge-nest', 'Nest', newAccessories);
                }

                let accessoriesMounted = this.accessoryLookup.map(el => el.constructor.name);

                if (this.config.readyCallback) {
                    try {
                        const cbUrl = new URL(this.config.readyCallback);
                        if (cbUrl.protocol !== 'https:') {
                            this.log.warn('readyCallback URL must use HTTPS; skipping callback.');
                        } else {
                            const counts = accessoriesMounted.reduce((acc, name) => {
                                if (name === 'NestThermostatAccessory') acc.thermostat_count++;
                                else if (name === 'NestTempSensorAccessory') acc.tempsensor_count++;
                                else if (name === 'NestProtectAccessory') acc.protect_count++;
                                else if (name === 'NestLockAccessory') acc.lock_count++;
                                return acc;
                            }, { thermostat_count: 0, tempsensor_count: 0, protect_count: 0, lock_count: 0 });
                            axios.post(this.config.readyCallback, counts).catch(() => { });
                        }
                    } catch(e) {
                        this.log.warn('readyCallback URL is invalid; skipping callback.');
                    }
                }
            } catch(err) {
                this.log.error(err);
                this.log.error('NOTE: Because we couldn\'t connect to the Nest service, your Nest devices in HomeKit will not be responsive.');
                this.cachedAccessories.forEach(accessory => {
                    accessory.services.forEach(service => {
                        service.characteristics.forEach(characteristic => {
                            if (characteristic.props.perms.includes(this.api.hap.Perms.PAIRED_READ)) {
                                characteristic.onGet(() => { throw new Error('Nest service not connected'); });
                            }
                            if (characteristic.props.perms.includes(this.api.hap.Perms.PAIRED_WRITE)) {
                                characteristic.onSet(async () => { throw new Error('Nest service not connected'); });
                            }
                        });
                    });
                });
            }
        });
    }

    configureAccessory(accessory) {
        this.cachedAccessories.push(accessory);
    }

    consumeCachedAccessory(UUID) {
        const idx = this.cachedAccessories.findIndex(a => a.UUID === UUID);
        if (idx >= 0) {
            return this.cachedAccessories.splice(idx, 1)[0];
        }
        return null;
    }

    optionSet(key, serialNumber, deviceId) {
        return key && this.config.options && (this.config.options.includes(key) || (serialNumber && this.config.options.includes(key + '.' + serialNumber)) || (deviceId && this.config.options.includes(key + '.' + deviceId)));
    }

    async setupConnection(verbose, fieldTestMode) {
        if (!this.config.access_token && !this.config.googleAuth && !this.config.refreshToken && (!this.config.email || !this.config.password)) {
            throw('You did not specify your Nest account credentials {\'email\',\'password\'}, or an access_token, refreshToken, or googleAuth, in config.json');
        }

        if (this.config.googleAuth && this.config.refreshToken) {
            throw('You have specified both googleAuth and refreshToken in config.json. Please pick the one you want to use, and remove the other one');
        }

        if (this.config.googleAuth && (!this.config.googleAuth.issueToken || !this.config.googleAuth.cookies)) { // || !this.config.googleAuth.apiKey)) {
            throw('When using googleAuth, you must provide issueToken and cookies in config.json. Please see README.md for instructions');
        }

        const conn = new NestConnection(this.config, this.log, verbose, fieldTestMode);

        if (await conn.auth()) {
            return conn;
        } else {
            throw('Unable to authenticate with Google/Nest.');
        }
    }
}

module.exports = function(homebridge) {
    const exportedTypes = {
        Accessory: homebridge.platformAccessory,
        Service: homebridge.hap.Service,
        Characteristic: homebridge.hap.Characteristic,
        hap: homebridge.hap,
        uuid: homebridge.hap.uuid
    };

    require('./lib/nest-device-accessory')(exportedTypes);
    ThermostatAccessory = require('./lib/nest-thermostat-accessory')();
    HomeAwayAccessory = require('./lib/nest-homeaway-accessory')();
    TempSensorAccessory = require('./lib/nest-tempsensor-accessory')();
    ProtectAccessory = require('./lib/nest-protect-accessory')();
    LockAccessory = require('./lib/nest-lock-accessory')();

    homebridge.registerPlatform('@skirkpatrick88/homebridge-nest', 'Nest', NestPlatform);
};