homebridge-arlo/index.js

Arlo plugin for homebridge

'use strict';

const Arlo = require('node-arlo');
const debug = require('debug')('Homebridge-Arlo');
const ArloCameraSource = require('./ArloCameraSource.js');

const DEFAULT_SUBSCRIBE_TIME = 60000;

let Accessory, PlatformAccessory, Characteristic, Service, StreamController, UUIDGen, HAP;

module.exports = function (homebridge) {
    Accessory = homebridge.hap.Accessory;
    PlatformAccessory = homebridge.platformAccessory;
    Characteristic = homebridge.hap.Characteristic;
    Service = homebridge.hap.Service;
    StreamController = homebridge.hap.StreamController;
    UUIDGen = homebridge.hap.uuid;
    HAP = homebridge.hap;

    homebridge.registerPlatform('homebridge-arlo', 'Arlo', ArloPlatform, true);
};

class ArloPlatform {
    constructor(log, config, api) {
        if (!config) {
            log.warn("Ignoring Arlo Platform setup because it is not configured");
            this.disabled = true;
            return;
        }

        this.config = config;
        this.api = api;
        if (!api || api.version < 2.1) { throw new Error('Unexpected API version (less than 2.1)') }
        this.accessories = {};
        this.log = log;

        this.config = this.config || {};

        let include_cameras = true
        if (this.config.include_cameras === undefined) {
            this.config.include_cameras = true
        }

        this.setupListeners();
    }

    addAccessory(device) {
        let deviceName  = device.getName(),
            deviceModel = device.getModel(),
            deviceType  = device.getType();

        if (deviceType === Arlo.BASESTATION) {
            this.log("Found: Base Station - %s [%s]", deviceName, device.id);

            let accessory = new PlatformAccessory(deviceName, UUIDGen.generate(device.id));

            accessory.getService(Service.AccessoryInformation)
                .setCharacteristic(Characteristic.Manufacturer, "Arlo");

            accessory.addService(Service.SecuritySystem, deviceName);

            this.accessories[accessory.UUID] = new ArloBaseStationAccessory(this.log, this.config, accessory, device);
            this.api.registerPlatformAccessories("homebridge-arlo", "Arlo", [accessory]);
        }
        else if (deviceType === Arlo.CAMERA && this.config.include_cameras === true) {
            this.log("Found: Camera - %s [%s]", deviceName, device.id);

            let accessory = new PlatformAccessory(deviceName, UUIDGen.generate(device.id), Accessory.Categories.CAMERA);

            
            let service = accessory.getService(Service.AccessoryInformation);

            service.setCharacteristic(Characteristic.Manufacturer, "Arlo")
                   .setCharacteristic(Characteristic.Model, deviceModel);

            service.getCharacteristic(Characteristic.FirmwareRevision);
            service.getCharacteristic(Characteristic.HardwareRevision);

            accessory.addService(Service.BatteryService, deviceName);
            accessory.addService(Service.MotionSensor, deviceName);

            service = accessory.addService(Service.CameraControl, deviceName);
            service = accessory.addService(Service.Microphone, deviceName);

            service.addCharacteristic(Characteristic.NightVision);
            service.addCharacteristic(Characteristic.ImageMirroring);
            service.addCharacteristic(Characteristic.ImageRotation)
                    .setProps({
                        maxValue: 180,
                        minValue: 0,
                        minStep: 180
                    });

            accessory.configureCameraSource(new ArloCameraSource(this.log, accessory, device, HAP, this.config.streaming));

            this.accessories[accessory.UUID] = new ArloCameraAccessory(this.log, accessory, device);
            this.api.publishCameraAccessories("homebridge-arlo", [accessory]);
        }
        else if (deviceType === Arlo.Q && this.config.include_cameras === true) {
            this.log("Found: Camera - %s [%s]", device.id, device.id);

            let accessory = new PlatformAccessory(device.id, UUIDGen.generate(device.id), Accessory.Categories.CAMERA);

            let service = accessory.getService(Service.AccessoryInformation);

            service.setCharacteristic(Characteristic.Manufacturer, "Arlo")
                   .setCharacteristic(Characteristic.Model, deviceModel);

            service.getCharacteristic(Characteristic.FirmwareRevision);
            service.getCharacteristic(Characteristic.HardwareRevision);

            accessory.addService(Service.MotionSensor, deviceName);

            service = accessory.addService(Service.CameraControl, deviceName);

            service.addCharacteristic(Characteristic.NightVision);
            service.addCharacteristic(Characteristic.ImageMirroring);
            service.addCharacteristic(Characteristic.ImageRotation)
                    .setProps({
                        maxValue: 180,
                        minValue: 0,
                        minStep: 180
                    });

            accessory.configureCameraSource(new ArloCameraSource(this.log, accessory, device, HAP, this.config.streaming));

            accessory.addService(Service.SecuritySystem, deviceName);

            this.accessories[accessory.UUID] = new ArloQAccessory(this.log, this.config, accessory, device);
            this.api.publishCameraAccessories("homebridge-arlo", [accessory]);
        }
    }

    configureAccessory(accessory) {
        this.accessories[accessory.UUID] = accessory;
    }

    setupListeners() {
        this.api.on('didFinishLaunching', function() {
            var arlo = new Arlo();

            arlo.on(Arlo.FOUND, function(device) {
                let uuid = UUIDGen.generate(device.id);
                let accessory = this.accessories[uuid];

                if (accessory === undefined) {
                    this.addAccessory(device);
                }
                else if(device.getType() === Arlo.BASESTATION) {
                    this.log("Online: Base Station %s [%s]", accessory.displayName, device.id);
                    this.accessories[uuid] = new ArloBaseStationAccessory(this.log, this.config, (accessory instanceof ArloBaseStationAccessory ? accessory.accessory : accessory), device);
                }
                else if(device.getType() === Arlo.CAMERA && this.config.include_cameras === true) {
                    this.log("Online: Camera %s [%s]", accessory.displayName, device.id);
                    this.accessories[uuid] = new ArloCameraAccessory(this.log, (accessory instanceof ArloCameraAccessory ? accessory.accessory : accessory), device);
                }
                else if(device.getType() === Arlo.Q && this.config.include_cameras === true) {
                    this.log("Online: Camera %s [%s]", accessory.displayName, device.id);
                    this.accessories[uuid] = new ArloQAccessory(this.log, this.config, (accessory instanceof ArloQAccessory ? accessory.accessory : accessory), device);
                }
            }.bind(this));

            arlo.login(this.config.email, this.config.password);
        }.bind(this));
    }
}

class ArloBaseStationAccessory {
    constructor(log, config, accessory, device) {
        this.accessory = accessory;
        this.device = device;
        this.log = log;
        
        config = config || {};

        this.STAY_ARM = config.stay_arm || Arlo.ARMED;
        this.NIGHT_ARM = config.night_arm || Arlo.ARMED;
        this.interval = config.interval || DEFAULT_SUBSCRIBE_TIME;

        this.accessory
            .getService(Service.AccessoryInformation)
            .setCharacteristic(Characteristic.Model, device.getModel())
            .setCharacteristic(Characteristic.SerialNumber, device.getSerialNumber());

        this.setupListeners();
        this.accessory.updateReachability(true);
    }

    setupListeners() {
        this.accessory
            .getService(Service.SecuritySystem)
            .getCharacteristic(Characteristic.SecuritySystemTargetState)
            .on('set', this.setTargetState.bind(this));
    
        this.device.on(Arlo.ARMED, function() {
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemTargetState)
                .updateValue(Characteristic.SecuritySystemTargetState.AWAY_ARM);
    
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                .updateValue(Characteristic.SecuritySystemCurrentState.AWAY_ARM);
        }.bind(this));
        
        this.device.on(Arlo.DISARMED, function() {
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemTargetState)
                .updateValue(Characteristic.SecuritySystemTargetState.DISARM);
    
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                .updateValue(Characteristic.SecuritySystemCurrentState.DISARMED);
        }.bind(this));

        if (this.STAY_ARM !== Arlo.ARMED) {
            this.device.on(this.STAY_ARM, function() {
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemTargetState)
                    .updateValue(Characteristic.SecuritySystemTargetState.STAY_ARM);
        
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                    .updateValue(Characteristic.SecuritySystemCurrentState.STAY_ARM);
            }.bind(this));
        }

        if (this.NIGHT_ARM !== Arlo.ARMED) {
            this.device.on(this.NIGHT_ARM, function() {
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemTargetState)
                    .updateValue(Characteristic.SecuritySystemTargetState.NIGHT_ARM);
        
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                    .updateValue(Characteristic.SecuritySystemCurrentState.NIGHT_ARM);
            }.bind(this));
        }
        
        setInterval(
            function(){
                this.device.subscribe();
            }.bind(this),
            (this.interval)
        );
    }

    setTargetState(state, callback) {
        switch(state) {
            case Characteristic.SecuritySystemTargetState.AWAY_ARM:
                this.device.arm(function() {
                    callback(null);
                    this.device.emit(Arlo.ARMED);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.DISARM:
                this.device.disarm(function() {
                    callback(null);
                    this.device.emit(Arlo.DISARMED);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.STAY_ARM:
                this.device.setMode(this.STAY_ARM, function() {
                    callback(null);
                    this.device.emit(this.STAY_ARM);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.NIGHT_ARM:
                this.device.setMode(this.NIGHT_ARM, function() {
                    callback(null);
                    this.device.emit(this.NIGHT_ARM);
                }.bind(this));
                break;
        }
    }
}

class ArloCameraAccessory {
    constructor(log, accessory, device) {
        this.accessory = accessory;
        this.device = device;
        this.log = log;

        this.accessory
            .getService(Service.AccessoryInformation)
            .setCharacteristic(Characteristic.Model, device.getModel())
            .setCharacteristic(Characteristic.SerialNumber, device.getSerialNumber());

        this.setupListeners();
        this.device.get();
    }

    setupListeners() {
        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.On)
            .on('set', this.setPrivacyActive.bind(this));

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageMirroring)
            .on('set', this.setImageMirroring.bind(this));

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageRotation)
            .on('set', this.setImageRotation.bind(this));

        setTimeout(function(){
            this.device.get();
        }.bind(this));

        this.device.on(Arlo.BATTERY, this.updateBatteryLevel.bind(this));
        this.device.on(Arlo.CHARGING, this.updateChargingState.bind(this));
        this.device.on(Arlo.MOTION, this.updateMotionDetected.bind(this));

        this.device.on(Arlo.UPDATE, function(info) {
            this.updateInfo(info);
            this.updateConnectionState(info.connectionState);
            this.updateImageMirroring(info.mirror);
            this.updateImageRotation(info.flip);
            this.updateNightVision(info.nightVisionMode);
            this.updatePrivacyActive(info.privacyActive);
        }.bind(this));
    }

    setImageMirroring(value, callback) {
        this.device.set({mirror: value}, function() {
            callback(null);
        })
    }

    setImageRotation(value, callback) {
        this.device.set({flip: (value > 0 ? true : false)}, function() {
            callback(null);
        })
    }

    setPrivacyActive(value, callback) {
        this.device.set({privacyActive: value == false}, function() {
            callback(null);
        })
    }

    updateInfo(info) {
        if (info === undefined) {
            return;
        }

        let service = this.accessory.getService(Service.AccessoryInformation);

        if (info.modelId) {
            service.getCharacteristic(Characteristic.Model).updateValue(info.modelId);
        }

        if (info.serialNumber) {
            service.getCharacteristic(Characteristic.SerialNumber).updateValue(info.serialNumber);
        }

        if (info.swVersion) {
            service.getCharacteristic(Characteristic.FirmwareRevision).updateValue(info.swVersion);
        }

        if (info.hwVersion) {
            service.getCharacteristic(Characteristic.HardwareRevision).updateValue(info.hwVersion);
        }
    }

    updateBatteryLevel(batteryLevel) {
        if (batteryLevel === undefined) {
            return;
        }

        this.accessory
            .getService(Service.BatteryService)
            .getCharacteristic(Characteristic.BatteryLevel)
            .updateValue(batteryLevel);
    }

    updateChargingState(value) {
        let state = Characteristic.ChargingState.NOT_CHARGEABLE;

        if (value !== undefined) {
            state = value != 'Off' ? Characteristic.ChargingState.CHARGING : Characteristic.ChargingState.NOT_CHARGING;
        }

        this.accessory
            .getService(Service.BatteryService)
            .getCharacteristic(Characteristic.ChargingState)
            .updateValue(state);
    }

    updateConnectionState(connectionState) {
        if (connectionState === undefined) {
            return;
        }

        let online = connectionState === 'available';
        this.log("%s: Camera %s [%s]", (online ? 'Online' : 'Offline'), this.accessory.displayName, this.device.id);
    }

    updateMotionDetected(motionDetected) {
        if (motionDetected === undefined) {
            return;
        }

        this.accessory
            .getService(Service.MotionSensor)
            .getCharacteristic(Characteristic.MotionDetected)
            .updateValue(motionDetected);
    }

    updateImageMirroring(mirror) {
        if (mirror === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageMirroring)
            .updateValue(mirror);
    }

    updateImageRotation(flip) {
        if (flip === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageRotation)
            .updateValue(flip === true ? 180 : 0);
    }

    updateNightVision(nightVisionMode) {
        if (nightVisionMode === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.NightVision)
            .updateValue(nightVisionMode === 1);
    }

    updatePrivacyActive(privacyActive) {
        if (privacyActive === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.On)
            .updateValue(privacyActive == false);
    }
}

class ArloQAccessory {
    constructor(log, config, accessory, device) {
        this.accessory = accessory;
        this.device = device;
        this.log = log;

        config = config || {};

        this.STAY_ARM = config.stay_arm || Arlo.ARMED;
        this.NIGHT_ARM = config.night_arm || Arlo.ARMED;
        this.interval = config.interval || DEFAULT_SUBSCRIBE_TIME;

        this.accessory
            .getService(Service.AccessoryInformation)
            .setCharacteristic(Characteristic.Model, device.getModel())
            .setCharacteristic(Characteristic.SerialNumber, device.getSerialNumber());

        this.setupListeners();
    }

    setupListeners() {
        this.accessory
            .getService(Service.SecuritySystem)
            .getCharacteristic(Characteristic.SecuritySystemTargetState)
            .on('set', this.setTargetState.bind(this));

        this.device.on(Arlo.ARMED, function() {
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemTargetState)
                .updateValue(Characteristic.SecuritySystemTargetState.AWAY_ARM);

            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                .updateValue(Characteristic.SecuritySystemCurrentState.AWAY_ARM);
        }.bind(this));

        this.device.on(Arlo.DISARMED, function() {
            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemTargetState)
                .updateValue(Characteristic.SecuritySystemTargetState.DISARM);

            this.accessory
                .getService(Service.SecuritySystem)
                .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                .updateValue(Characteristic.SecuritySystemCurrentState.DISARMED);
        }.bind(this));

        if (this.STAY_ARM !== Arlo.ARMED) {
            this.device.on(this.STAY_ARM, function() {
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemTargetState)
                    .updateValue(Characteristic.SecuritySystemTargetState.STAY_ARM);

                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                    .updateValue(Characteristic.SecuritySystemCurrentState.STAY_ARM);
            }.bind(this));
        }

        if (this.NIGHT_ARM !== Arlo.ARMED) {
            this.device.on(this.NIGHT_ARM, function() {
                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemTargetState)
                    .updateValue(Characteristic.SecuritySystemTargetState.NIGHT_ARM);

                this.accessory
                    .getService(Service.SecuritySystem)
                    .getCharacteristic(Characteristic.SecuritySystemCurrentState)
                    .updateValue(Characteristic.SecuritySystemCurrentState.NIGHT_ARM);
            }.bind(this));
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.On)
            .on('set', this.setPrivacyActive.bind(this));

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageMirroring)
            .on('set', this.setImageMirroring.bind(this));

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageRotation)
            .on('set', this.setImageRotation.bind(this));

        this.accessory
            .getService(Service.MotionSensor)
            .getCharacteristic(Characteristic.MotionDetected)
            .on('get', this.get.bind(this));

        this.device.on(Arlo.MOTION, this.updateMotionDetected.bind(this));

        this.device.on(Arlo.UPDATE, function(info) {
            this.updateInfo(info);
            this.updateConnectionState(info.connectionState);
            this.updateImageMirroring(info.mirror);
            this.updateImageRotation(info.flip);
            this.updateNightVision(info.nightVisionMode);
            this.updatePrivacyActive(info.privacyActive);
        }.bind(this));

        setInterval(
            function() {
                this.device.subscribe();
            }.bind(this),
            (this.interval)
        );
    }

    get(callback) {
        if (this.device) {
            this.device.get();
        }

        callback(null, null)
    }

    setImageMirroring(value, callback) {
        this.device.set({mirror: value}, function() {
            callback(null);
        })
    }

    setImageRotation(value, callback) {
        this.device.set({flip: (value > 0 ? true : false)}, function() {
            callback(null);
        })
    }

    setPrivacyActive(value, callback) {
        this.device.set({privacyActive: value == false}, function() {
            callback(null);
        })
    }

    setTargetState(state, callback) {
        switch(state) {
            case Characteristic.SecuritySystemTargetState.AWAY_ARM:
                this.device.arm(function() {
                    callback(null);
                    this.device.emit(Arlo.ARMED);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.DISARM:
                this.device.disarm(function() {
                    callback(null);
                    this.device.emit(Arlo.DISARMED);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.STAY_ARM:
                this.device.setMode(this.STAY_ARM, function() {
                    callback(null);
                    this.device.emit(this.STAY_ARM);
                }.bind(this));
                break;
            case Characteristic.SecuritySystemTargetState.NIGHT_ARM:
                this.device.setMode(this.NIGHT_ARM, function() {
                    callback(null);
                    this.device.emit(this.NIGHT_ARM);
                }.bind(this));
                break;
        }
    }

    updateInfo(info) {
        if (info === undefined) {
            return;
        }

        let service = this.accessory.getService(Service.AccessoryInformation);

        if (info.modelId) {
            service.getCharacteristic(Characteristic.Model).updateValue(info.modelId);
        }

        if (info.serialNumber) {
            service.getCharacteristic(Characteristic.SerialNumber).updateValue(info.serialNumber);
        }

        if (info.swVersion) {
            service.getCharacteristic(Characteristic.FirmwareRevision).updateValue(info.swVersion);
        }

        if (info.hwVersion) {
            service.getCharacteristic(Characteristic.HardwareRevision).updateValue(info.hwVersion);
        }
    }

    updateConnectionState(connectionState) {
        if (connectionState === undefined) {
            return;
        }

        let online = connectionState === 'available';
        this.log("%s: Camera %s [%s]", (online ? 'Online' : 'Offline'), this.accessory.displayName, this.device.id);
    }

    updateMotionDetected(motionDetected) {
        if (motionDetected === undefined) {
            return;
        }

        this.accessory
            .getService(Service.MotionSensor)
            .getCharacteristic(Characteristic.MotionDetected)
            .updateValue(motionDetected);
    }

    updateImageMirroring(mirror) {
        if (mirror === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageMirroring)
            .updateValue(mirror);
    }

    updateImageRotation(flip) {
        if (flip === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.ImageRotation)
            .updateValue(flip === true ? 180 : 0);
    }

    updateNightVision(nightVisionMode) {
        if (nightVisionMode === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.NightVision)
            .updateValue(nightVisionMode === 1);
    }

    updatePrivacyActive(privacyActive) {
        if (privacyActive === undefined) {
            return;
        }

        this.accessory
            .getService(Service.CameraControl)
            .getCharacteristic(Characteristic.On)
            .updateValue(privacyActive == false);
    }
}