homebridge-kobold-Homaassistant-Flavour/index.js

"use strict";
var inherits = require('util').inherits,
	debug = require('debug')('homebridge-neato'),
	botvac = require('node-botvac'),

	Service,
	Characteristic

module.exports = function (homebridge) {
	Service = homebridge.hap.Service;
	Characteristic = homebridge.hap.Characteristic;
	homebridge.registerPlatform("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobotPlatform);
}

function NeatoVacuumRobotPlatform(log, config) {
	this.log = log;
	this.serial = "1-3-3-7";
	this.email = config['email'];
	this.password = config['password'];
	this.hiddenServices = ('disabled' in config ? config['disabled'] : '');

	if ('refresh' in config && config['refresh'] !== 'auto') {
		// parse config parameter
		this.refresh = parseInt(config['refresh']);
		// must be integer and positive
		this.refresh = (typeof this.refresh !== 'number' || (this.refresh % 1) !== 0 || this.refresh < 0) ? 60 : this.refresh;
		// minimum 60s to save some load on the neato servers
		this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
	}
	// default auto
	else {
		this.refresh = 'auto';
	}
	debug("Refresh is set to: " + this.refresh);
}

NeatoVacuumRobotPlatform.prototype = {
	accessories: function (callback) {
		let accessories = [];

		let that = this;
		this.getRobots(function () {
			for (var i = 0; i < that.robots.length; i++) {
				that.log("Found robot #" + (i + 1) + " named \"" + that.robots[i].name + "\" with serial \"" + that.robots[i]._serial + "\"");
				var robotAccessory = new NeatoVacuumRobotAccessory(that.robots[i], that);
				accessories.push(robotAccessory);
				that.robots[i].maps.forEach((map) => {
					map.boundaries.forEach((boundary) => {
						if (boundary.type === "polygon") {
							accessories.push(new NeatoVacuumRobotAccessory(that.robots[i], that, boundary))
						}
					})
				})
			}
			callback(accessories);
		});
	},

	getRobots: function (callback) {
		debug("Loading your robots");
		let client = new botvac.Client();
		let that = this;
		client.authorize(this.email, this.password, false, (error) => {
			if (error) {
				that.log(error);
				that.log.error("Can't log on to neato cloud. Please check your credentials.");
				callback();
			}
			else {
				client.getRobots((error, robots) => {
					if (error) {
						that.log(error);
						that.log.error("Successful login but can't connect to your neato robot.");
						callback();
					}
					else {
						if (robots.length === 0) {
							that.log.error("Successful login but no robots associated with your account.");
							that.robots = [];
							callback();
						}
						else {
							debug("Found " + robots.length + " robots");
							let updatedRobotCount = 0;
						    that.robots = robots;
						    that.robots.forEach((robot) => {
								robot.getPersistentMaps((error, result) => {
									if (error) {
										that.log("Error updating persistent maps: " + error + ": " + result);
										callback();
										return;
									}
									robot.maps = result;
									let processedMapCount = 0
									robot.maps.forEach((map) => {
										robot.getMapBoundaries(map.id, (error, result) => {
											if(error) {
												this.log("error getting boundaries: " + error + ": " + result)
											} else {
												map.boundaries = result.boundaries;
											}
											processedMapCount++;
											if(processedMapCount == robot.maps.length) {
												updatedRobotCount++
												if (updatedRobotCount === that.robots.length) {
													callback();
												}
											}
										})
									})
								})
							})
						}
					}
				});
			}
		});
	}
}

function NeatoVacuumRobotAccessory(robot, platform, boundary) {
	this.platform = platform;
	this.boundary = boundary;
	this.log = platform.log;
	this.refresh = platform.refresh;
	this.hiddenServices = platform.hiddenServices;
	this.robot = robot;
	if(!this.boundary) {
		this.name = robot.name;
	} else {
		this.name =  this.robot.name + ' - ' + this.boundary.name;
	}
	this.lastUpdate = null;

	this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");

	if(!this.boundary) {
		this.vacuumRobotCleanService = new Service.Switch("Clean", "clean");
		this.vacuumRobotGoToDockService = new Service.Switch(this.name + " Go to Dock", "goToDock");
		this.vacuumRobotDockStateService = new Service.OccupancySensor(this.name + " Dock", "dockState");
		this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
		this.vacuumRobotNoGoLinesService = new Service.Switch(this.name + " NoGo Lines", "noGoLines");
		this.vacuumRobotExtraCareService = new Service.Switch(this.name + " Extra Care", "extraCare");
		this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
	} else {
		const splitName = boundary.name.split(' ');
		let serviceName = "Clean the " + boundary.name;
		if(splitName.length >= 2 && splitName[splitName.length-2].match(/[']s$/g)){
			serviceName = "Clean " + boundary.name;
		}
	    this.vacuumRobotCleanBoundaryService =
			new Service.Switch(serviceName, "cleanBoundary:" + boundary.id);
		this.log("Adding zone cleaning for: " + boundary.name);
	}

	this.updateRobotTimer();
}


NeatoVacuumRobotAccessory.prototype = {
	identify: function (callback) {
		let that = this;
		this.updateRobot(function () {
			// hide serial and secret in log
			let _serial = that.robot._serial;
			let _secret = that.robot._secret;
			that.robot._serial = "*****";
			that.robot._secret = "*****";
			that.log(that.robot);
			that.robot._serial = _serial;
			that.robot._secret = _secret;
		});
	},

	getServices: function () {
	    this.informationService = new Service.AccessoryInformation();
	    this.informationService
		.setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
		.setCharacteristic(Characteristic.Model, "Coming soon")
		.setCharacteristic(Characteristic.SerialNumber, this.robot._serial);
		if(!this.boundary) {
			this.informationService
			.setCharacteristic(Characteristic.Name, this.robot.name)
		} else {
			this.informationService
			.setCharacteristic(Characteristic.Name, this.robot.name + ' - ' + this.boundary.name)
		}

	    this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
	    this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));

	    this.services = [this.informationService, this.vacuumRobotBatteryService];

	    if(!this.boundary) {
		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', this.setClean.bind(this));
		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));

		this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
		this.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));

		this.vacuumRobotDockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));

		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));

		this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
		this.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));

		this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
		this.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));

		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));

		this.services.push(this.vacuumRobotCleanService);

		if (this.hiddenServices.indexOf('dock') === -1)
		    this.services.push(this.vacuumRobotGoToDockService);
		if (this.hiddenServices.indexOf('dockstate') === -1)
		    this.services.push(this.vacuumRobotDockStateService);
		if (this.hiddenServices.indexOf('eco') === -1)
		    this.services.push(this.vacuumRobotEcoService);
		if (this.hiddenServices.indexOf('nogolines') === -1)
		    this.services.push(this.vacuumRobotNoGoLinesService);
		if (this.hiddenServices.indexOf('extracare') === -1)
		    this.services.push(this.vacuumRobotExtraCareService);
		if (this.hiddenServices.indexOf('schedule') === -1)
		    this.services.push(this.vacuumRobotScheduleService);
	    }

	    if(this.boundary){
		this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('set', (on, serviceCallback) => {
		    this.setCleanBoundary(this.boundary.id, on, serviceCallback)
		})
		this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).on('get', (serviceCallback) => {
		    this.getCleanBoundary(this.boundary.id, serviceCallback);
		})
		this.services.push(this.vacuumRobotCleanBoundaryService);
	    }

	    return this.services;
	},

	setCleanBoundary: function (boundaryId, on, callback) {
	    this.updateRobot((error, result) => {
		if(on){
		    if(this.robot.canStart) {
			this.log("Starting to clean: "+boundaryId);
			this.robot.startCleaningBoundary(this.eco, this.extraCare, boundaryId, (error, result) => {
			    if (error){
				this.log(error+": "+JSON.stringify(result));
			    }
			    callback();
			})
			return
		    } else {
			this.log("Error, robot is already cleaning");
		    }
		} else {
		    if (this.robot.canPause) {
			debug(this.name + ": Pause cleaning");
			this.robot.pauseCleaning(callback);
			return;
		    }
		    else {
			debug(this.name + ": Already stopped");
		    }
		}
		callback();
	    });
	},

	getCleanBoundary: function (boundaryId, callback) {
	    this.updateRobot((error, result) => {
		callback(false, this.robot.canPause && (this.robot.cleaningBoundaryId == boundaryId));
	    });
	},

	setClean: function (on, callback) {
		let that = this;
		this.updateRobot(function (error, result) {
		    if (on) {
			if (that.robot.canResume || that.robot.canStart) {

			    // start extra update robot timer if refresh is set to "auto"
			    if (that.refresh === 'auto') {
				setTimeout(function () {
				    clearTimeout(that.timer);
				    that.updateRobotTimer();
				}, 60 * 1000);
			    }

			    if (that.robot.canResume) {
				debug(that.name + ": Resume cleaning");
				that.robot.resumeCleaning(callback);
			    }
			    else {
				let eco = that.vacuumRobotEcoService.getCharacteristic(Characteristic.On).value;
				let extraCare = that.vacuumRobotExtraCareService.getCharacteristic(Characteristic.On).value;
				let nogoLines = that.vacuumRobotNoGoLinesService.getCharacteristic(Characteristic.On).value;
				debug(that.name + ": Start cleaning (eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ")");
				that.robot.startCleaning(
				    eco,
				    extraCare ? 2 : 1,
				    nogoLines,
				    function (error, result) {
					if (error) {
					    that.log.error(error + ": " + result);
					    callback(true);
					}
					else {
					    callback();
					}
				    });
			    }
			}
			else {
			    debug(that.name + ": Cant start, maybe already cleaning");
			    callback();
			}
		    }
		    else {
			if (that.robot.canPause) {
			    debug(that.name + ": Pause cleaning");
			    that.robot.pauseCleaning(callback);
			}
			else {
			    debug(that.name + ": Already stopped");
			    callback();
			}
		    }
		});
	},

	setGoToDock: function (on, callback) {
		let that = this;
		this.updateRobot(function (error, result) {
			if (on) {
				if (that.robot.canPause) {
					debug(that.name + ": Pause cleaning to go to dock");
					that.robot.pauseCleaning(function (error, result) {
						setTimeout(function () {
							debug("Go to dock");
							that.robot.sendToBase(callback);
						}, 1000);
					});
				}
				else if (that.robot.canGoToBase) {
					debug(that.name + ": Go to dock");
					that.robot.sendToBase(callback);
				}
				else {
					that.log.warn(that.name + ": Can't go to dock at the moment");
					callback();
				}
			} else {
				callback();
			}
		});
	},

	setEco: function (on, callback) {
		debug(this.name + ": " + (on ? "Enable eco mode" : "Disable eco mode"));
		this.robot.eco = on;
		callback();
	},

	setNoGoLines: function (on, callback) {
		debug(this.name + ": " + (on ? "Enable nogo lines" : "Disable nogo lines"));
		this.robot.noGoLines = on;
		callback();
	},

	setExtraCare: function (on, callback) {
		debug(this.name + ": " + (on ? "Enable extra care navigation" : "Disable extra care navigation"));
		this.robot.navigationMode = on ? 2 : 1;
		callback();
	},

	setSchedule: function (on, callback) {
		let that = this;
		this.updateRobot(function (error, result) {
			if (on) {
				debug(that.name + ": Enable schedule");
				that.robot.enableSchedule(callback);
			}
			else {
				debug(that.name + ": Disable schedule");
				that.robot.disableSchedule(callback);
			}
		});
	},

	getClean: function (callback) {
		let that = this;
		this.updateRobot(function (error, result) {
			debug(that.name + ": Is cleaning: " + that.robot.canPause);
			callback(false, that.robot.canPause);
		});
	},

	getGoToDock: function (callback) {
		callback(false, false);
	},

	getDock: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is docked: " + that.robot.isDocked);
			callback(false, that.robot.isDocked ? 1 : 0);
		});
	},

	getEco: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is eco: " + that.robot.eco);
			callback(false, that.robot.eco);
		});
	},

	getNoGoLines: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is nogo lines: " + that.robot.noGoLines);
			callback(false, that.robot.noGoLines ? 1 : 0);
		});
	},

	getExtraCare: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is extra care navigation: " + (that.robot.navigationMode == 2 ? true : false));
			callback(false, that.robot.navigationMode == 2 ? 1 : 0);
		});
	},

	getSchedule: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is schedule: " + that.robot.isScheduleEnabled);
			callback(false, that.robot.isScheduleEnabled);
		});
	},


	getBatteryLevel: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Battery: " + that.robot.charge + "%");
			callback(false, that.robot.charge);
		});
	},

	getBatteryChargingState: function (callback) {
		let that = this;
		this.updateRobot(function () {
			debug(that.name + ": Is charging: " + that.robot.isCharging);
			callback(false, that.robot.isCharging);
		});
	},

	updateRobot: function (callback) {
		let that = this;
		if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000) {
			callback();
		}
		else {
			debug(this.name + ": Updating robot state");
			this.robot.getState(function (error, result) {
				if (error) {
					that.log.error(error + ": " + result);
				}
				that.lastUpdate = new Date();
				callback();
			});
		}
	},

	updateRobotTimer: function () {
	    let that = this;
	    this.updateRobot((error, result) => {

		if (!this.boundary) {
		    // only update these values if the state is different from the current one, otherwise we might accidentally start an action
		    if (that.vacuumRobotCleanService.getCharacteristic(Characteristic.On).value !== that.robot.canPause) {
			that.vacuumRobotCleanService.setCharacteristic(Characteristic.On, that.robot.canPause);
		    }

		    // dock switch is on (dock not seen before) and dock has just been seen -> turn switch off
		    if (that.vacuumRobotGoToDockService.getCharacteristic(Characteristic.On).value == true && that.robot.dockHasBeenSeen) {
			that.vacuumRobotGoToDockService.setCharacteristic(Characteristic.On, false);
		    }

		    if (that.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).value !== that.robot.isScheduleEnabled) {
			that.vacuumRobotScheduleService.setCharacteristic(Characteristic.On, that.robot.isScheduleEnabled);
		    }

		    // no commands here, values can be updated without problems
		    that.vacuumRobotDockStateService.setCharacteristic(Characteristic.OccupancyDetected, that.robot.isDocked ? 1 : 0);
		    that.vacuumRobotEcoService.setCharacteristic(Characteristic.On, that.robot.eco);
		    that.vacuumRobotNoGoLinesService.setCharacteristic(Characteristic.On, that.robot.noGoLines);
		    that.vacuumRobotExtraCareService.setCharacteristic(Characteristic.On, that.robot.navigationMode == 2 ? true : false);

		} else {
		    if(this.vacuumRobotCleanBoundaryService.getCharacteristic(Characteristic.On).value !== that.robot.canPause) {
			this.vacuumRobotCleanBoundaryService.setCharacteristic(Characteristic.On, that.robot.canPause);
		    }
		}

		that.vacuumRobotBatteryService.setCharacteristic(Characteristic.BatteryLevel, that.robot.charge);
		that.vacuumRobotBatteryService.setCharacteristic(Characteristic.ChargingState, that.robot.isCharging);

		// robot is currently cleaning, update if refresh is set to auto or a specific interval
		if (that.robot.canPause && that.refresh !== 0) {
		    let refreshTime = that.refresh === 'auto' ? 60 : that.refresh
		    debug("Updating state in background every " + refreshTime + " seconds while cleaning");
		    that.timer = setTimeout(that.updateRobotTimer.bind(that), refreshTime * 1000);
		}
		// robot is not cleaning, but a specific refresh interval is set
		else if (that.refresh !== 'auto' && that.refresh !== 0) {
		    debug("Updating state in background every " + that.refresh + " seconds (user setting)");
		    that.timer = setTimeout(that.updateRobotTimer.bind(that), that.refresh * 1000);
		}
		else {
		    debug("Updating state in background disabled");
		}
	    });
	},
}