just drying someting

Add npm shield tag

.gitattributes

@@ -1,17 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto
-
-# Custom for Visual Studio
-*.cs     diff=csharp
-
-# Standard to msysgit
-*.doc	 diff=astextplain
-*.DOC	 diff=astextplain
-*.docx diff=astextplain
-*.DOCX diff=astextplain
-*.dot  diff=astextplain
-*.DOT  diff=astextplain
-*.pdf  diff=astextplain
-*.PDF	 diff=astextplain
-*.rtf	 diff=astextplain
-*.RTF	 diff=astextplain

.github/workflows/npm.yml

@@ -0,0 +1,19 @@
+name: npm
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    # Setup .npmrc file to publish to npm
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '12.x'
+        registry-url: 'https://registry.npmjs.org'
+    - run: npm install
+    - run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -1,47 +1,75 @@
-# Windows image file caches
-Thumbs.db
-ehthumbs.db
+# Logs
+logs
+*.log
+npm-debug.log*
 
-# Folder config file
-Desktop.ini
+# Runtime data
+pids
+*.pid
+*.seed
 
-# Recycle Bin used on file shares
-$RECYCLE.BIN/
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
 
-# Windows Installer files
-*.cab
-*.msi
-*.msm
-*.msp
+# Coverage directory used by tools like istanbul
+coverage
 
-# Windows shortcuts
-*.lnk
+# nyc test coverage
+.nyc_output
 
-# =========================
-# Operating System Files
-# =========================
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
 
-# OSX
-# =========================
+# node-waf configuration
+.lock-wscript
 
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules
+jspm_packages
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# compiled output
+/dist
+/dist-server
+/dist-e2e
+/tmp
+/out-tsc
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+*.iml
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# misc
+/.sass-cache
+/connect.lock
+/libpeerconnection.log
+yarn-error.log
+testem.log
+/typings
+
+# System Files
 .DS_Store
-.AppleDouble
-.LSOverride
-
-# Thumbnails
-._*
-
-# Files that might appear in the root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-
-# Directories potentially created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
+Thumbs.db
+package-lock.json

CHANGELOG.md

@@ -4,4 +4,132 @@
 * Added return to base
 * Added enable and disable schedule
 * Added enable and disable eco mode
-* Added battery info
+* Added battery info
+
+## 0.2.0
+
+* Added dock info
+* Improved logging to use a debug library
+
+## 0.2.1
+
+* Improved the go to dock command
+
+## 0.3.0
+
+* Added periodic refresh of robot state while cleaning
+* Added optional periodic refresh of robot state while not cleaning
+* Added error messages when cant login or get robot
+* Improved go to dock switch to be enabled as soon as possible without manual refresh
+* Improved switches to indicate the time an action needs to complete
+* Improved eco mode to not be overwritten by robot state update
+
+## 0.3.1
+
+* Added support for Neato BotVac D5 Connected
+
+## 0.3.2
+
+* Fixed a bug that refresh is not disabled when set to 0
+
+## 0.4.0
+
+* Added support for multiple robots
+* Added log output when user requests accessory identify
+* Changed plugin to platform instead of single accessory
+* Removed parameter name from config
+
+## 0.4.1
+
+* Added config parameter for extraCareNavigation
+
+## 0.4.2
+
+* Added config parameter to disable switches/sensors
+
+## 0.4.4
+
+* Fixed config parameter to disable switches/sensors not optional
+
+## 0.4.5
+
+* Fixed compatibility with homebridge 0.4.23 (occupancy sensor not working)
+
+## 0.4.6
+
+* Added error log while refreshing robot state
+* Fixed a rare bug where the robot stops after some seconds of cleaning
+
+## 0.4.7
+
+* Fixed an exception when no robot is associated with the account
+
+## 0.5.0
+
+* Added noGo lines button
+* Added extra care navigation button
+* Added syncing cleaning options from last run
+* Added option to disable background state update completely
+* Changed goto dock button is now always off
+* Changed error handling
+* Changed debug messages
+* Updated node-botvac dependency to 0.1.6
+* Removed extra care navigation option parameter (is now a button)
+
+## 0.5.1
+
+* Updated node-botvac dependency to 0.1.7
+
+## 0.5.2
+
+* Added schema file for use with homebridge-config-ui-x
+
+## 0.6.0
+
+* Added support for zone cleaning
+
+## 0.6.1
+
+* Fixed homebridge startup failed when robot does not support zone cleaning
+
+## 0.6.2
+
+* Fixed homebridge startup failed when robot does not support mapping
+
+## 0.6.3
+
+* Fixed homebridge crash when robot has a map without zones
+* Fixed homebridge crash when homebridge has no internet connection or the neato servers are offline
+* Fixed homebridge crash when 2 zones have the same name
+
+## 0.7.0
+
+* Added find me function
+* Added spot cleaning function with individual spot size and repeat option
+* Added model and firmware information to homekit
+* Added logic to be able to change the currently cleaned room
+* Improved number of requests when having multiple rooms
+* Fixed room switches not taking eco and extraCare mode into account
+* Fixed room switches not supporting pause/resume
+
+## 0.7.1
+* Fixed robot not shown before setting up a floor plan
+
+## 0.7.2
+* Fixed homebridge crash with multiple robots per account
+
+## 0.8.0
+* Add German plugin language (for example, this gives you a "Sauge Küche" Siri command for a zone called "Küche")
+* Added possibility to toggle between languages (English/German) in Homebridge UI Plugin Settings
+
+## 0.8.1
+* Include Robot name in Homekit battery service name
+
+## 0.8.2
+* Eliminate warnings on Homebridge >= 1.3.0 (77945f8 and 877c3d7 on `naofireblade/homebridge-neato`)
+
+## 0.8.3
+* Add French plugin language (for example, this gives you a "Aspirer la cuisine" Siri command for a zone called "La cuisine")
+
+## 0.8.4
+* Link to token getter tool in homebridge UI 

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Arne Blumentritt
+Copyright (c) 2020 Luis Riegger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,40 +1,131 @@
-# homebridge-neato
+[![Latest NPM release](https://img.shields.io/npm/v/homebridge-kobold.svg)](https://www.npmjs.com/package/homebridge-kobold)
+[![NPM Downloads](https://img.shields.io/npm/dt/homebridge-kobold.svg)](https://www.npmjs.com/package/homebridge-kobold?activeTab=versions)
 
-This is a plugin to control your [Neato](https://www.neatorobotics.com/) vacuum robot.
 
-# Installation
+# homebridge-kobold
 
-1. Install homebridge using: npm install -g homebridge
-2. Install this plugin using: npm install -g homebridge-neato
+This is a plugin for [homebridge](https://github.com/nfarina/homebridge) to control your [Vorwerk Kobold](https://kobold.vorwerk.de/saugroboter/) VR300 vacuum robot. You can download it via [npm](https://www.npmjs.com/package/homebridge-kobold).
+
+It is based on a fork of naofireblade's [homebridge-neato](https://github.com/naofireblade/homebridge-neato), merged with the oAuth authentication mechanism from nicoh88's [homebridge-vorwerk](https://github.com/nicoh88/homebridge-vorwerk).
+
+The interaction with the Server is handled by the underlying [node-kobold-control](https://github.com/himbeles/node-kobold-control) module.
+
+## Features
+
+- House Cleaning
+  - Eco mode
+  - Extra care navigation
+  - Nogo lines
+- Zone cleaning <sup>[1](#change-room)</sup>
+- Spot cleaning
+  - Individual spot size <sup>[2](#eve)</sup>
+  - Clean twice <sup>[2](#eve)</sup>
+- Return to dock
+- Find the robot
+- Schedule (de)activation
+- Robot information
+  - Battery level
+  - Charging state
+  - Dock occupancy
+  - Model and firmware version
+- Automatic or periodic refresh of robot state
+- Multiple robots
+
+- German, English or French Language Setting
+
+> <b name="change-room">2</b> You can send the robot from one room to another as well. He will return to the base, wait there some seconds and then starts cleaning the next room.
+
+> <b name="eve">3</b> You need a third party app like eve to access these features.
+
+
+
+## Installation
+
+1. Install homebridge using: `npm install -g homebridge`
+2. Install this plugin using: `npm install -g homebridge-kobold`
 3. Update your configuration file. See the sample below.
 
-# Configuration
+## Configuration
 
-Configuration sample:
+Add the following information to your config file. Adapt the value for `token`.
 
-Add the following information to your config file. Change the values for name, email and password.
+### Simple
 
 ```json
-"accessories": [
-		{
-			"accessory": "NeatoVacuumRobot",
-			"name": "YourRobot",
-			"email": "YourEmail",
-			"password": "YourPassword"
-		}
-    ]
+"platforms": [
+  {
+    "platform": "KoboldVacuumRobot",
+    "token": "YourToken",
+    "language": "de"
+  }
+]
 ```
 
-# Features
+You can get a token using the GUI tool [Kobold Token Getter](https://github.com/himbeles/kobold-token-get) or using the following two curl commands:
 
-- Atart and pause cleaning
-- Return to base
-- Enable and disable schedule
-- Enable and disable eco mode
-- Get battery info
+```bash
+# This will trigger the email sending
+curl -X "POST" "https://mykobold.eu.auth0.com/passwordless/start" \
+     -H 'Content-Type: application/json' \
+     -d '{
+  "send": "code",
+  "email": "ENTER_YOUR_EMAIL_HERE",
+  "client_id": "KY4YbVAvtgB7lp8vIbWQ7zLk3hssZlhR",
+  "connection": "email"
+}'
+```
+==== wait for the email to be received ====
 
-# Tested robots
+```bash
+# this will generate a token using the numbers you received via email
+# replace the value of otp 123456 with the value you received from the email
+curl -X "POST" "https://mykobold.eu.auth0.com/oauth/token" \
+     -H 'Content-Type: application/json' \
+     -d '{
+  "prompt": "login",
+  "grant_type": "http://auth0.com/oauth/grant-type/passwordless/otp",
+  "scope": "openid email profile read:current_user",
+  "locale": "en",
+  "otp": "123456",
+  "source": "vorwerk_auth0",
+  "platform": "ios",
+  "audience": "https://mykobold.eu.auth0.com/userinfo",
+  "username": "ENTER_YOUR_EMAIL_HERE",
+  "client_id": "KY4YbVAvtgB7lp8vIbWQ7zLk3hssZlhR",
+  "realm": "email",
+  "country_code": "DE"
+}'
+```
 
-- BotVac Connected Firmware 2.2.0
+From the output, you want to copy the `id_token` value.
 
-if you have another connected neato robot, please [tell me](https://github.com/naofireblade/homebridge-neato/issues/new) your experience with this plugin.
+The `language` can be `de` for German, `en` for English, or `fr` for French.
+
+### Advanced
+
+Below are explanations for advanced parameters to adjust the plugin to your needs. All parameters are *optional*.
+
+**refresh**  
+Timer for periodic refresh of robot state. The default is `auto`. The options are:  
+`auto` Updates the robot state when a cleaning was started via homekit so that you can activate automations based on a successful cleaning.  
+`120` Or any other time in seconds (minimum `60`) is required if you want to receive robot state updates after starting the cleaning from outside of homekit (e.g. neato app or schedule).  
+`0` Disables background updates completely.
+
+**hidden**  
+List of plugin features that you don't want to use in homekit (e.g. `dock`, `dockstate`, `eco`, `nogolines`, `extracare`, `schedule`, `find`, `spot`).
+
+```json
+"platforms": [
+  {
+    "platform": "KoboldVacuumRobot",
+    "token": "YourToken",
+    "refresh": "120",
+    "hidden": ["dock", "dockstate", "eco", "nogolines", "extracare", "schedule", "find", "spot"],
+    "language": "de"
+  }
+]
+```
+
+## Tested robots
+
+- Vorwerk Kobold VR300

accessories/koboldVacuumRobot.js

@@ -0,0 +1,726 @@
+const debug = require('debug')('homebridge-kobold');
+const colors = require('colors');
+
+const CustomUUID = {
+	SpotCleanWidth: 'A7889A9A-2F27-4293-BEF8-3FE805B36F4E',
+	SpotCleanHeight: 'CA282DB2-62BF-4325-A1BE-F8BB5478781A',
+	SpotCleanRepeat: '1E79C603-63B8-4E6A-9CE1-D31D67981831'
+};
+
+let Service,
+	Characteristic,
+	SpotWidthCharacteristic,
+	SpotHeightCharacteristic,
+	SpotRepeatCharacteristic;
+
+module.exports = function (_Service, _Characteristic)
+{
+	Service = _Service;
+	Characteristic = _Characteristic;
+	SpotWidthCharacteristic = require('../characteristics/spotWidth')(Characteristic, CustomUUID);
+	SpotHeightCharacteristic = require('../characteristics/spotHeight')(Characteristic, CustomUUID);
+	SpotRepeatCharacteristic = require('../characteristics/spotRepeat')(Characteristic, CustomUUID);
+
+	return KoboldVacuumRobotAccessory;
+};
+
+function KoboldVacuumRobotAccessory(platform, robotObject)
+{
+	this.platform = platform;
+	this.log = platform.log;
+	this.refresh = platform.refresh;
+	this.hiddenServices = platform.hiddenServices;
+	this.nextRoom = platform.nextRoom;
+
+	this.robotObject = robotObject;
+	this.robot = robotObject.device;
+	this.meta = robotObject.meta;
+	this.spotPlusFeatures = ((typeof robotObject.availableServices.spotCleaning !== 'undefined') && robotObject.availableServices.spotCleaning.includes("basic"));
+	this.boundary = (typeof robotObject.boundary === 'undefined') ? null : robotObject.boundary;
+
+	this.dict = {
+		'en': {
+			"clean": "Clean",
+			"clean the": "Clean the",
+			"goToDock": "Go to Dock",
+			"dockState": "Dock",
+			"eco": "Eco Mode",
+			"noGoLines": "NoGo Lines",
+			"extraCare": "Extra Care",
+			"schedule": "Schedule",
+			"findMe": "Find me",
+			"cleanSpot": "Clean Spot",
+			"battery": "Battery"
+		},
+		'de': {
+			"clean": "Sauge",
+			"clean the": "Sauge",
+			"goToDock": "Zur Basis",
+			"dockState": "In der Basis",
+			"eco": "Eco Modus",
+			"noGoLines": "NoGo Linien",
+			"extraCare": "Extra Care",
+			"schedule": "Zeitplan",
+			"findMe": "Finde mich",
+			"cleanSpot": "Spot Reinigung",
+			"battery": "Batterie"
+		},
+		'fr': {
+			"clean": "Aspirer",
+			"clean the": "Aspirer",
+			"goToDock": "Retour à la base",
+			"dockState": "Sur la base",
+			"eco": "Eco mode",
+			"noGoLines": "Lignes NoGo",
+			"extraCare": "Extra Care",
+			"schedule": "Planifier",
+			"findMe": "Me retrouver",
+			"cleanSpot": "Nettoyage local",
+			"battery": "Batterie"
+		}
+	}[this.platform.language]
+
+	if (this.boundary == null)
+	{
+		this.name = this.robot.name;
+	}
+	else
+	{
+		// if boundary name already exists
+		if (platform.boundaryNames.includes(this.boundary.name))
+		{
+			let lastChar = this.boundary.name.slice(-1);
+			// boundary name already contains a count number
+			if (!isNaN(lastChar))
+			{
+				// Increment existing count number
+				this.boundary.name = this.boundary.name.slice(0, -1) + (parseInt(lastChar) + 1);
+			}
+			else
+			{
+				// Add a new count number
+				this.boundary.name = this.boundary.name + " 2";
+			}
+		}
+		platform.boundaryNames.push(this.boundary.name);
+		this.name = this.robot.name + ' - ' + this.boundary.name;
+	}
+
+	this.batteryService = new Service.BatteryService(this.name + " " + this.dict["battery"], "battery");
+
+	if (this.boundary == null)
+	{
+		this.cleanService = new Service.Switch(this.name + " " + this.dict["clean"], "clean");
+		this.goToDockService = new Service.Switch(this.name + " " + this.dict["goToDock"], "goToDock");
+		this.dockStateService = new Service.OccupancySensor(this.name + " " + this.dict["dockState"], "dockState");
+		this.ecoService = new Service.Switch(this.name + " " + this.dict["eco"], "eco");
+		this.noGoLinesService = new Service.Switch(this.name + " " + this.dict["noGoLines"], "noGoLines");
+		this.extraCareService = new Service.Switch(this.name + " " + this.dict["extraCare"], "extraCare");
+		this.scheduleService = new Service.Switch(this.name + " " + this.dict["schedule"], "schedule");
+		this.findMeService = new Service.Switch(this.name + " " + this.dict["findMe"], "findMe");
+
+		this.spotCleanService = new Service.Switch(this.name + " " + this.dict["cleanSpot"], "cleanSpot");
+		this.spotCleanService.addCharacteristic(SpotRepeatCharacteristic);
+		if (this.spotPlusFeatures)
+		{
+			this.spotCleanService.addCharacteristic(SpotWidthCharacteristic);
+			this.spotCleanService.addCharacteristic(SpotHeightCharacteristic);
+		}
+	}
+	else
+	{
+		const splitName = this.boundary.name.split(' ');
+		let serviceName = this.dict["clean the"] + " " + this.boundary.name;
+		if (splitName.length >= 2 && splitName[splitName.length - 2].match(/[']s$/g))
+		{
+			serviceName = this.dict["clean"] + " " + this.boundary.name;
+		}
+		this.cleanService = new Service.Switch(serviceName, "cleanBoundary:" + this.boundary.id);
+		this.cleanService = new Service.Switch(serviceName + "1", "cleanBoundary:" + this.boundary.id)
+	}
+
+	this.log("Added cleaning device named: " + this.name);
+}
+
+KoboldVacuumRobotAccessory.prototype = {
+	identify: function (callback)
+	{
+		this.robot.getState((error, result) =>
+		{
+			if (error)
+			{
+				this.log.error("Error getting robot information: " + error + ": " + result);
+			}
+			else
+			{
+				this.log("### Robot information ###");
+				this.log(result);
+			}
+			callback();
+		});
+	},
+
+	getServices: function ()
+	{
+		this.informationService = new Service.AccessoryInformation();
+		this.informationService
+		.setCharacteristic(Characteristic.Manufacturer, "Vorwerk Deutschland Stiftung & Co. KG")
+		.setCharacteristic(Characteristic.Model, this.meta.modelName)
+		.setCharacteristic(Characteristic.SerialNumber, this.robot._serial)
+		.setCharacteristic(Characteristic.FirmwareRevision, this.meta.firmware)
+		.setCharacteristic(Characteristic.Name, this.robot.name + (this.boundary == null ? '' : ' - ' + this.boundary.name));
+
+		this.cleanService.getCharacteristic(Characteristic.On).on('set', this.setClean.bind(this));
+		this.cleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
+
+		this.services = [this.informationService, this.cleanService];
+
+		if (this.boundary == null)
+		{
+			this.batteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
+			this.batteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
+			this.services.push(this.batteryService);
+
+			this.goToDockService.getCharacteristic(Characteristic.On).on('set', this.setGoToDock.bind(this));
+			this.goToDockService.getCharacteristic(Characteristic.On).on('get', this.getGoToDock.bind(this));
+
+			this.dockStateService.getCharacteristic(Characteristic.OccupancyDetected).on('get', this.getDock.bind(this));
+
+			this.ecoService.getCharacteristic(Characteristic.On).on('set', this.setEco.bind(this));
+			this.ecoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
+
+			this.noGoLinesService.getCharacteristic(Characteristic.On).on('set', this.setNoGoLines.bind(this));
+			this.noGoLinesService.getCharacteristic(Characteristic.On).on('get', this.getNoGoLines.bind(this));
+
+			this.extraCareService.getCharacteristic(Characteristic.On).on('set', this.setExtraCare.bind(this));
+			this.extraCareService.getCharacteristic(Characteristic.On).on('get', this.getExtraCare.bind(this));
+
+			this.scheduleService.getCharacteristic(Characteristic.On).on('set', this.setSchedule.bind(this));
+			this.scheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
+
+			this.findMeService.getCharacteristic(Characteristic.On).on('set', this.setFindMe.bind(this));
+			this.findMeService.getCharacteristic(Characteristic.On).on('get', this.getFindMe.bind(this));
+
+			this.spotCleanService.getCharacteristic(Characteristic.On).on('set', this.setSpotClean.bind(this));
+			this.spotCleanService.getCharacteristic(Characteristic.On).on('get', this.getSpotClean.bind(this));
+			this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).on('set', this.setSpotRepeat.bind(this));
+			this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).on('get', this.getSpotRepeat.bind(this));
+
+			if (this.spotPlusFeatures)
+			{
+				this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).on('set', this.setSpotWidth.bind(this));
+				this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).on('get', this.getSpotWidth.bind(this));
+				this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).on('set', this.setSpotHeight.bind(this));
+				this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).on('get', this.getSpotHeight.bind(this));
+			}
+
+			if (this.hiddenServices.indexOf('spot') === -1)
+			{
+				this.services.push(this.spotCleanService);
+			}
+
+			// Add optional services
+			if (this.hiddenServices.indexOf('dock') === -1)
+				this.services.push(this.goToDockService);
+			if (this.hiddenServices.indexOf('dockstate') === -1)
+				this.services.push(this.dockStateService);
+			if (this.hiddenServices.indexOf('eco') === -1)
+				this.services.push(this.ecoService);
+			if (this.hiddenServices.indexOf('nogolines') === -1)
+				this.services.push(this.noGoLinesService);
+			if (this.hiddenServices.indexOf('extracare') === -1)
+				this.services.push(this.extraCareService);
+			if (this.hiddenServices.indexOf('schedule') === -1)
+				this.services.push(this.scheduleService);
+			if (this.hiddenServices.indexOf('find') === -1)
+				this.services.push(this.findMeService);
+		}
+
+		return this.services;
+	},
+
+
+	getClean: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			let cleaning;
+			if (this.boundary == null)
+			{
+				cleaning = this.robot.canPause;
+			}
+			else
+			{
+				cleaning = this.robot.canPause && (this.robot.cleaningBoundaryId === this.boundary.id)
+			}
+
+			debug(this.name + ": Cleaning is " + (cleaning ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, cleaning);
+		});
+	},
+
+	setClean: function (on, callback)
+	{
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Clean " + (this.boundary ? JSON.stringify(this.boundary) : ''));
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			// Start
+			if (on)
+			{
+				// No room given or same room
+				if (this.boundary == null || this.robot.cleaningBoundaryId === this.boundary.id)
+				{
+					// Resume cleaning
+					if (this.robot.canResume)
+					{
+						debug(this.name + ": ## Resume cleaning");
+						this.robot.resumeCleaning((error) =>
+						{
+							callback(error);
+						});
+					}
+					// Start cleaning
+					else if (this.robot.canStart)
+					{
+						debug(this.name + ": ## Start cleaning");
+						this.clean(callback);
+					}
+					// Cannot start
+					else
+					{
+						debug(this.name + ": Cannot start, maybe already cleaning (expected)");
+						callback();
+					}
+				}
+				// Different room given
+				else
+				{
+					// Return to dock
+					if (this.robot.canPause || this.robot.canResume)
+					{
+						debug(this.name + ": ## Returning to dock to start cleaning of new room");
+						this.setGoToDock(true, (error, result) =>
+						{
+							this.nextRoom = this.boundary.id;
+							callback();
+						});
+					}
+					// Start new cleaning of new room
+					else
+					{
+						debug(this.name + ": ## Start cleaning of new room");
+						this.clean(callback);
+					}
+				}
+			}
+			// Stop
+			else
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning");
+					this.robot.pauseCleaning((error) =>
+					{
+						callback(error);
+					});
+				}
+				else
+				{
+					debug(this.name + ": Already paused");
+					callback();
+				}
+			}
+		});
+	},
+
+	clean: function (callback, spot)
+	{
+		// Start automatic update while cleaning
+		if (this.refresh === 'auto')
+		{
+			setTimeout(() =>
+			{
+				this.platform.updateRobotTimer(this.robot._serial);
+			}, 60 * 1000);
+		}
+
+		let eco = this.robotObject.mainAccessory.ecoService.getCharacteristic(Characteristic.On).value;
+		let extraCare = this.robotObject.mainAccessory.extraCareService.getCharacteristic(Characteristic.On).value;
+		let nogoLines = this.robotObject.mainAccessory.noGoLinesService.getCharacteristic(Characteristic.On).value;
+		let room = (this.boundary == null) ? '' : this.boundary.name;
+		debug(this.name + ": ## Start cleaning (" + (room !== '' ? room + " " : '') + "eco: " + eco + ", extraCare: " + extraCare + ", nogoLines: " + nogoLines + ", spot: " + JSON.stringify(spot) + ")");
+
+		// Normal cleaning
+		if (this.boundary == null && (typeof spot === 'undefined'))
+		{
+			this.robot.startCleaning(eco, extraCare ? 2 : 1, nogoLines, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+		// Room cleaning
+		else if (room !== '')
+		{
+			this.robot.startCleaningBoundary(eco, extraCare, this.boundary.id, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start room cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+		// Spot cleaning
+		else
+		{
+			this.robot.startSpotCleaning(eco, spot.width, spot.height, spot.repeat, extraCare ? 2 : 1, (error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot start spot cleaning. " + error + ": " + JSON.stringify(result));
+				}
+				callback(error);
+			});
+		}
+	},
+
+	getGoToDock: function (callback)
+	{
+		callback(false, false);
+	},
+
+	setGoToDock: function (on, callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			if (on)
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning to go to dock");
+					this.robot.pauseCleaning((error, result) =>
+					{
+						setTimeout(() =>
+						{
+							debug(this.name + ": ## Go to dock");
+							this.robot.sendToBase(() =>
+							{
+								callback();
+							});
+						}, 1000);
+					});
+				}
+				else if (this.robot.canGoToBase)
+				{
+					debug(this.name + ": ## Go to dock");
+					this.robot.sendToBase(() =>
+					{
+						callback();
+					});
+				}
+				else
+				{
+					this.log.warn(this.name + ": Can't go to dock at the moment");
+					callback();
+				}
+			}
+			else
+			{
+				callback();
+			}
+		});
+	},
+
+	getEco: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Eco Mode is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.eco);
+		});
+	},
+
+	setEco: function (on, callback)
+	{
+		this.robot.eco = on;
+		debug(this.name + ": " + (on ? "Enabled ".red : "Disabled".red) + " Eco Mode ");
+		callback();
+	},
+
+	getNoGoLines: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": NoGoLine is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.noGoLines ? 1 : 0);
+		});
+	},
+
+	setNoGoLines: function (on, callback)
+	{
+		this.robot.noGoLines = on;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " NoGoLine ");
+		callback();
+	},
+
+	getExtraCare: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Care Nav is " + (this.robot.navigationMode === 2 ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.navigationMode === 2 ? 1 : 0);
+		});
+	},
+
+	setExtraCare: function (on, callback)
+	{
+		this.robot.navigationMode = on ? 2 : 1;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Care Nav ");
+		callback();
+	},
+
+	getSchedule: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Schedule is " + (this.robot.eco ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.isScheduleEnabled);
+		});
+	},
+
+	setSchedule: function (on, callback)
+	{
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			if (on)
+			{
+				debug(this.name + ": " + "Enabled".brightGreen + " Schedule");
+				this.robot.enableSchedule((error) =>
+				{
+					callback(error);
+				});
+			}
+			else
+			{
+				debug(this.name + ": " + "Disabled".red + " Schedule");
+				this.robot.disableSchedule((error) =>
+				{
+					callback(error);
+				});
+			}
+		});
+	},
+
+	getFindMe: function (callback)
+	{
+		callback(false, false);
+	},
+
+	setFindMe: function (on, callback)
+	{
+		if (on)
+		{
+			debug(this.name + ": ## Find me");
+			setTimeout(() =>
+			{
+				this.findMeService.setCharacteristic(Characteristic.On, false);
+			}, 1000);
+
+			this.robot.findMe((error) =>
+			{
+				callback(error);
+			});
+		}
+	},
+
+	getSpotClean: function (callback)
+	{
+		callback(false, this.spotCleanService.getCharacteristic(Characteristic.On).value);
+	},
+
+	setSpotClean: function (on, callback)
+	{
+		let spot = {
+			width: this.spotPlusFeatures ? this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).value : null,
+			height: this.spotPlusFeatures ? this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).value : null,
+			repeat: this.spotCleanService.getCharacteristic(SpotRepeatCharacteristic).value
+		};
+
+		this.platform.updateRobot(this.robot._serial, (error, result) =>
+		{
+			// Start
+			if (on)
+			{
+				// Resume cleaning
+				if (this.robot.canResume)
+				{
+					debug(this.name + ": ## Resume (spot) cleaning");
+					this.robot.resumeCleaning(callback);
+				}
+				// Start cleaning
+				else if (this.robot.canStart)
+				{
+					this.clean(callback, spot);
+				}
+				// Cannot start
+				else
+				{
+					debug(this.name + ": Cannot start spot cleaning, maybe already cleaning");
+					callback();
+				}
+			}
+			// Stop
+			else
+			{
+				if (this.robot.canPause)
+				{
+					debug(this.name + ": ## Pause cleaning");
+					this.robot.pauseCleaning((error) =>
+					{
+						callback(error);
+					});
+				}
+				else
+				{
+					debug(this.name + ": Already paused");
+					callback();
+				}
+			}
+		});
+	},
+
+	getSpotWidth: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot width  is " + this.robot.spotWidth + "cm");
+			callback(false, this.robot.spotWidth);
+		});
+	},
+
+	setSpotWidth: function (width, callback)
+	{
+		this.robot.spotWidth = width;
+		debug(this.name + ": Set spot width to " + width + "cm");
+		callback();
+	},
+
+	getSpotHeight: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot height is " + this.robot.spotHeight + "cm");
+			callback(false, this.robot.spotHeight);
+		});
+	},
+
+	setSpotHeight: function (height, callback)
+	{
+		this.robot.spotHeight = height;
+		debug(this.name + ": Set spot height to " + height + "cm");
+		callback();
+	},
+
+	getSpotRepeat: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Spot repeat is " + (this.robot.spotRepeat ? 'ON'.brightGreen : 'OFF'.red));
+			callback(false, this.robot.spotRepeat);
+		});
+	},
+
+	setSpotRepeat: function (on, callback)
+	{
+		this.robot.spotRepeat = on;
+		debug(this.name + ": " + (on ? "Enabled ".brightGreen : "Disabled".red) + " Spot repeat");
+		callback();
+	},
+
+	getDock: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": The Dock is " + (this.robot.isDocked ? "OCCUPIED".brightGreen : "NOT OCCUPIED".red));
+			callback(false, this.robot.isDocked ? 1 : 0);
+		});
+	},
+
+	getBatteryLevel: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Battery  is " + this.robot.charge + "%");
+			callback(false, this.robot.charge);
+		});
+	},
+
+	getBatteryChargingState: function (callback)
+	{
+		this.platform.updateRobot(this.robot._serial, () =>
+		{
+			debug(this.name + ": Battery  is " + (this.robot.isCharging ? "CHARGING".brightGreen : "NOT CHARGING".red));
+			callback(false, this.robot.isCharging);
+		});
+	},
+
+	updated: function ()
+	{
+		if (this.boundary == null)
+		{
+			// only update these values if the state is different from the current one, otherwise we might accidentally start an action
+			if (this.cleanService.getCharacteristic(Characteristic.On).value !== this.robot.canPause)
+			{
+				this.cleanService.setCharacteristic(Characteristic.On, this.robot.canPause);
+			}
+
+			// dock switch is on (dock not seen before) and dock has just been seen -> turn switch off
+			if (this.goToDockService.getCharacteristic(Characteristic.On).value == true && this.robot.dockHasBeenSeen)
+			{
+				this.goToDockService.setCharacteristic(Characteristic.On, false);
+			}
+
+			if (this.scheduleService.getCharacteristic(Characteristic.On).value !== this.robot.isScheduleEnabled)
+			{
+				this.scheduleService.setCharacteristic(Characteristic.On, this.robot.isScheduleEnabled);
+			}
+
+			// no commands here, values can be updated without problems
+			this.dockStateService.setCharacteristic(Characteristic.OccupancyDetected, this.robot.isDocked ? 1 : 0);
+
+			this.ecoService.setCharacteristic(Characteristic.On, this.robot.eco);
+			this.noGoLinesService.setCharacteristic(Characteristic.On, this.robot.noGoLines);
+			this.extraCareService.setCharacteristic(Characteristic.On, this.robot.navigationMode == 2 ? true : false);
+
+			this.spotCleanService.setCharacteristic(SpotRepeatCharacteristic, this.robot.spotRepeat);
+
+			if (this.spotPlusFeatures)
+			{
+				let widthProps = this.spotCleanService.getCharacteristic(SpotWidthCharacteristic).props;
+				let heightProps = this.spotCleanService.getCharacteristic(SpotHeightCharacteristic).props;
+
+				this.spotCleanService.setCharacteristic(SpotWidthCharacteristic,
+					this.robot.spotWidth >= widthProps.minValue && this.robot.spotWidth <= widthProps.maxValue ? this.robot.spotWidth : widthProps.minValue);
+				this.spotCleanService.setCharacteristic(SpotHeightCharacteristic,
+					this.robot.spotHeight >= heightProps.minValue && this.robot.spotHeight <= heightProps.maxValue ? this.robot.spotHeight : heightProps.minValue);
+			}
+		}
+
+		this.batteryService.setCharacteristic(Characteristic.BatteryLevel, this.robot.charge);
+		this.batteryService.setCharacteristic(Characteristic.ChargingState, this.robot.isCharging);
+
+		// Robot has a next room to clean in queue
+		if (this.nextRoom != null && this.robot.isDocked)
+		{
+			this.clean((error, result) =>
+			{
+				this.nextRoom = null;
+				debug("## Starting cleaning of next room");
+			});
+		}
+	}
+};

characteristics/spotHeight.js

@@ -0,0 +1,21 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotHeight = function ()
+	{
+		Characteristic.call(this, 'Spot ↕', CustomUUID.SpotCleanHeight);
+		this.setProps({
+			format: Characteristic.Formats.INT,
+			unit: 'cm',
+			maxValue: 400,
+			minValue: 100,
+			minStep: 50,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotHeight, Characteristic);
+
+	return SpotHeight;
+};

characteristics/spotRepeat.js

@@ -0,0 +1,17 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotRepeat = function ()
+	{
+		Characteristic.call(this, 'Spot 2x', CustomUUID.SpotCleanRepeat);
+		this.setProps({
+			format: Characteristic.Formats.BOOL,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotRepeat, Characteristic);
+
+	return SpotRepeat;
+};

characteristics/spotWidth.js

@@ -0,0 +1,21 @@
+const inherits = require('util').inherits;
+
+module.exports = function (Characteristic, CustomUUID)
+{
+	let SpotWidth = function ()
+	{
+		Characteristic.call(this, 'Spot ↔', CustomUUID.SpotCleanWidth);
+		this.setProps({
+			format: Characteristic.Formats.INT,
+			unit: 'cm',
+			maxValue: 400,
+			minValue: 100,
+			minStep: 50,
+			perms: [Characteristic.Perms.READ, Characteristic.Perms.WRITE]
+		});
+		this.value = this.getDefaultValue();
+	};
+	inherits(SpotWidth, Characteristic);
+
+	return SpotWidth;
+};

config.schema.json

@@ -0,0 +1,42 @@
+{
+    "pluginAlias": "KoboldVacuumRobot",
+    "pluginType": "platform",
+    "headerDisplay": "For Advanced settings like the refresh time interval or disabled switches/sensors. [Check Here](https://github.com/himbeles/homebridge-kobold#readme)",
+    "schema": {
+      "type": "object",
+      "properties": {
+        "token": {
+            "title": "token",
+            "type": "string",
+            "required": true,
+            "description": "Your Kobold Token (https://git.io/J3g1b)"
+        },
+        "language": {
+          "title": "language",
+          "type": "string",
+          "default": "en",
+          "oneOf": [
+            {
+              "title": "English",
+              "enum": [
+                "en"
+              ]
+            },
+            {
+              "title": "German",
+              "enum": [
+                "de"
+              ]
+            },
+            {
+              "title": "French",
+              "enum": [
+                "fr"
+              ]
+            }
+          ],
+          "required": true
+        }
+      }
+    }
+}

index.js

@@ -1,223 +1,305 @@
 "use strict";
-var inherits = require('util').inherits;
-var botvac = require('node-botvac');
+let inherits = require('util').inherits,
+	debug = require('debug')('homebridge-kobold'),
+	control = require('node-kobold-control'),
 
-var Service, Characteristic;
+	Service,
+	Characteristic,
+	KoboldVacuumRobotAccessory;
 
-module.exports = function (homebridge) {
+module.exports = function (homebridge)
+{
 	Service = homebridge.hap.Service;
 	Characteristic = homebridge.hap.Characteristic;
-	homebridge.registerAccessory("homebridge-neato", "NeatoVacuumRobot", NeatoVacuumRobot);
-}
+	KoboldVacuumRobotAccessory = require('./accessories/koboldVacuumRobot')(Service, Characteristic);
+	homebridge.registerPlatform("homebridge-kobold", "KoboldVacuumRobot", KoboldVacuumRobotPlatform);
+};
 
-function NeatoVacuumRobot(log, config) {
+function KoboldVacuumRobotPlatform(log, config)
+{
 	this.log = log;
-	this.name = config['name'];
 	this.serial = "1-3-3-7";
-	this.email = config['email'];
-	this.password = config['password'];
+	this.token = config['token'];
+	this.language = config['language'];
+	this.hiddenServices = '';
+	this.hiddenServices = ('disabled' in config ? config['disabled'] : this.hiddenServices);
+	this.hiddenServices = ('hidden' in config ? config['hidden'] : this.hiddenServices);
 
-	this.lastUpdate = null;
-	this.robot = null;
+	// Array of real robots and associated robot accessories (incl rooms)
+	this.robots = [];
+	this.nextRoom = null;
+
+	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 Vorwerk servers
+		if (this.refresh > 0 && this.refresh < 60)
+		{
+			this.log.warn("Minimum refresh time is 60 seconds to not overload the Vorwerk servers");
+			this.refresh = (this.refresh > 0 && this.refresh < 60) ? 60 : this.refresh;
+		}
+	}
+	// default auto
+	else
+	{
+		this.refresh = 'auto';
+	}
+	this.log("Refresh is set to: " + this.refresh + (this.refresh !== 'auto' ? ' seconds' : ''));
 }
 
-NeatoVacuumRobot.prototype = {
-	identify: function (callback) {
-		this.log("Identify requested");
-		callback();
-	},
+KoboldVacuumRobotPlatform.prototype = {
+	accessories: function (callback)
+	{
+		debug("Get robots");
+		let accessories = [];
+		this.boundaryNames = [];
 
-	getServices: function () {
-		this.informationService = new Service.AccessoryInformation();
-		this.informationService
-		.setCharacteristic(Characteristic.Manufacturer, "Neato Robotics")
-		.setCharacteristic(Characteristic.Model, this.name)
-		.setCharacteristic(Characteristic.SerialNumber, this.serial);
-
-		this.vacuumRobotCleanService = new Service.Switch(this.name + " Clean", "clean");
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('set', this.clean.bind(this));
-		this.vacuumRobotCleanService.getCharacteristic(Characteristic.On).on('get', this.getClean.bind(this));
-
-		this.vacuumRobotDockService = new Service.Switch(this.name + " Dock", "dock");
-		this.vacuumRobotDockService.getCharacteristic(Characteristic.On).on('set', this.dock.bind(this));
-		this.vacuumRobotDockService.getCharacteristic(Characteristic.On).on('get', this.getDock.bind(this));
-
-		this.vacuumRobotEcoService = new Service.Switch(this.name + " Eco Mode", "eco");
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('set', this.eco.bind(this));
-		this.vacuumRobotEcoService.getCharacteristic(Characteristic.On).on('get', this.getEco.bind(this));
-
-		this.vacuumRobotScheduleService = new Service.Switch(this.name + " Schedule", "schedule");
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('set', this.schedule.bind(this));
-		this.vacuumRobotScheduleService.getCharacteristic(Characteristic.On).on('get', this.getSchedule.bind(this));
-
-		this.vacuumRobotBatteryService = new Service.BatteryService("Battery", "battery");
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.BatteryLevel).on('get', this.getBatteryLevel.bind(this));
-		this.vacuumRobotBatteryService.getCharacteristic(Characteristic.ChargingState).on('get', this.getBatteryChargingState.bind(this));
-
-		return [this.informationService, this.vacuumRobotCleanService, this.vacuumRobotDockService, this.vacuumRobotEcoService,
-			this.vacuumRobotScheduleService, this.vacuumRobotBatteryService];
-	},
-
-	clean: function (on, callback) {
-		let that = this;
-		if (on) {
-			this.getState(function (error, result) {
-				that.log(that.robot);
-				if (that.robot.canResume === true) {
-					that.log("Resume cleaning");
-					that.robot.resumeCleaning(function (error, result) {
-						that.log(result);
-					});
-				}
-				else {
-					that.log("Start cleaning");
-					that.robot.startCleaning(that.robot.eco, function (error, result) {
-						that.log(result);
-					});
-				}
-			});
-		}
-		else {
-			this.log("Pause cleaning");
-			this.robot.pauseCleaning(false, function (error, result) {
-				that.log(result);
-			});
-		}
-		callback();
-	},
-
-	dock: function (on, callback) {
-		let that = this;
-		that.log(that.robot);
-		if (on) {
-			that.log("Send to dock");
-			that.robot.sendToBase(false, function (error, result) {
-				that.log(result);
-			});
-		}
-		callback();
-	},
-
-	eco: function (on, callback) {
-		this.log(on ? "Enable eco mode" : "Disable eco mode");
-		this.robot.eco = on;
-		callback();
-	},
-
-	schedule: function (on, callback) {
-		if (on) {
-			this.log("Enable schedule");
-			this.robot.enableSchedule(false, function (error, result) {
-				onsole.log(result);
-			}); 
-		}
-		else {
-			this.log("Disable schedule");
-			this.robot.disableSchedule(false, function (error, result) {
-				onsole.log(result);
-			}); 
-		}
-		callback();
-	},
-
-	getClean: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Is cleaning: " + that.robot.canPause);
-			callback(false, that.robot.canPause);
-		});
-	},
-
-	getDock: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Can go to dock: " + that.robot.canGoToBase);
-			that.log("Is docked: " + that.robot.isDocked);
-			callback(false, that.robot.isDocked);
-		});
-	},
-
-	getEco: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Eco mode: " + that.robot.eco);
-			callback(false, that.robot.eco);
-		});
-	},
-
-	getSchedule: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Schedule: " + that.robot.isScheduleEnabled);
-			callback(false, that.robot.isScheduleEnabled);
-		});
-	},
-
-
-	getBatteryLevel: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Battery: " + that.robot.charge);
-			callback(false, that.robot.charge);
-		});
-	},
-
-	getBatteryChargingState: function(callback) {
-		let that = this;
-		this.getState(function (error, result) {
-			that.log("Is charging: " + that.robot.isCharging);
-			callback(false, that.robot.isCharging);
-		});
-	},
-
-	getState: function(callback) {
-		let that = this;
-		if (this.robot === null)
+		this.getRobots(() =>
 		{
-			this.getRobot(function (error, result) {
-				that._getState(callback);
-			});
-		}
-		else {
-			that._getState(callback);
-		}	
+			// // MOCK MULTIPLE ROBOTS START
+			// let client = new control.Client();
+			// client.authorize(this.token, (error) =>
+			// {
+			// 	client.getRobots((error, robs) =>
+			// 	{
+			// 		let testRobot = robs[0];
+			// 		testRobot.getState((error, result) =>
+			// 		{
+			// 			testRobot.name = "Testrobot";
+			// 			this.robots.push({device: testRobot, meta: result.meta, availableServices: result.availableServices});
+			// 			// MOCK MULTIPLE ROBOTS END
+
+						this.robots.forEach((robot, i) =>
+						{
+							this.log("Found robot #" + (i + 1) + " named \"" + robot.device.name + "\" with serial \"" + robot.device._serial.substring(0, 9) + "XXXXXXXXXXXX\"");
+
+							let mainAccessory = new KoboldVacuumRobotAccessory(this, robot);
+							accessories.push(mainAccessory);
+
+							robot.mainAccessory = mainAccessory;
+							robot.roomAccessories = [];
+
+							// Start Update Intervall
+							this.updateRobotTimer(robot.device._serial);
+
+							// // MOCK ZONE CLEANING START
+							// robot.boundary = {name: "Testroom", id: "1"};
+							// let roomAccessory = new KoboldVacuumRobotAccessory(this, robot);
+							// accessories.push(roomAccessory);
+							// robot.roomAccessories.push(roomAccessory);
+							// // MOCK ZONE CLEANING END
+
+							if (robot.device.maps)
+							{
+								robot.device.maps.forEach((map) =>
+								{
+									if (map.boundaries)
+									{
+										map.boundaries.forEach((boundary) =>
+										{
+											if (boundary.type === "polygon")
+											{
+												robot.boundary = boundary;
+												let roomAccessory = new KoboldVacuumRobotAccessory(this, robot);
+												accessories.push(roomAccessory);
+
+												robot.roomAccessories.push(roomAccessory);
+											}
+										})
+									}
+								})
+							}
+						});
+						callback(accessories);
+
+			// 			// MOCK MULTIPLE ROBOTS START
+			// 		});
+			// 	});
+			// });
+			// // MOCK MULTIPLE ROBOTS END
+		});
 	},
 
-	_getState: function(callback) {
-		if (this.lastUpdate !== null && new Date() - this.lastUpdate < 2000) {
-			//this.log("Get state (cached)");
+	getRobots: function (callback)
+	{
+		debug("Loading your robots");
+		let client = new control.Client();
+
+		// Login
+		client.authorize(this.token, (error) =>
+		{
+			if (error)
+			{
+				this.log.error("Can't log on to Vorwerk cloud. Please check your internet connection and your token. Try again later if the Vorwerk servers have issues: " + error);
+				callback();
+			}
+			else
+			{
+				// Get all robots
+				client.getRobots((error, robots) =>
+				{
+					if (error)
+					{
+						this.log.error("Successful login but can't connect to your Vorwerk robot: " + error);
+						callback();
+					}
+					else if (robots.length === 0)
+					{
+						this.log.error("Successful login but no robots associated with your account.");
+						this.robots = [];
+						callback();
+					}
+					else
+					{
+						debug("Found " + robots.length + " robots");
+						let loadedRobots = 0;
+
+						robots.forEach((robot) =>
+						{
+							// Get additional information for the robot
+							robot.getState((error, state) =>
+							{
+								if (error)
+								{
+									this.log.error("Error getting robot meta information: " + error + ": " + state);
+									callback();
+								}
+								else
+								{
+									// Get all maps for each robot
+									robot.getPersistentMaps((error, maps) =>
+									{
+										if (error)
+										{
+											this.log.error("Error updating persistent maps: " + error + ": " + maps);
+											callback();
+										}
+										// Robot has no maps
+										else if (maps.length === 0)
+										{
+											robot.maps = [];
+											this.robots.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+											loadedRobots++;
+											if (loadedRobots === robots.length)
+											{
+												callback();
+											}
+										}
+										// Robot has maps
+										else
+										{
+											robot.maps = maps;
+											let loadedMaps = 0;
+											robot.maps.forEach((map) =>
+											{
+												// Save zones in each map
+												robot.getMapBoundaries(map.id, (error, result) =>
+												{
+													if (error)
+													{
+														this.log.error("Error getting boundaries: " + error + ": " + result)
+													}
+													else
+													{
+														map.boundaries = result.boundaries;
+													}
+													loadedMaps++;
+
+													// Robot is completely requested if zones for all maps are loaded
+													if (loadedMaps === robot.maps.length)
+													{
+														this.robots.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+														loadedRobots++;
+														if (loadedRobots === robots.length)
+														{
+															callback();
+														}
+													}
+												})
+											});
+										}
+									});
+								}
+							});
+						});
+					}
+				});
+			}
+		});
+	},
+
+	updateRobot: function (serial, callback)
+	{
+		let robot = this.getRobot(serial);
+
+		// Data is up to date
+		if (typeof (robot.lastUpdate) !== 'undefined' && new Date() - robot.lastUpdate < 2000)
+		{
 			callback();
 		}
-		else {
-			//this.log("Get state (new)");
-			let that = this;
-			this.robot.getState(function (error, result) {
-				that.lastUpdate = new Date();
+		else
+		{
+			debug(robot.device.name + ": ++ Updating robot state");
+			robot.lastUpdate = new Date();
+			robot.device.getState((error, result) =>
+			{
+				if (error)
+				{
+					this.log.error("Cannot update robot. Check if robot is online. " + error);
+				}
 				callback();
 			});
 		}
 	},
 
-	getRobot: function(callback) {
-		//this.log("Get robot");
-		let client = new botvac.Client();
-		let that = this;
-		client.authorize(this.email, this.password, false, function (error) {
-			if (error) {
-				that.log(error);
-			}
-			else {
-				client.getRobots(function (error, robots) {
-					if (error) {
-						that.log(error);
-					}
-					else {
-						that.robot = robots[0];
-						that.log("Found robot: " + that.robot.name);
-						callback();
-					}
-				});
+	getRobot(serial)
+	{
+		let result;
+		this.robots.forEach(function (robot)
+		{
+			if (robot.device._serial === serial)
+			{
+				result = robot;
 			}
 		});
-	}
-}
+		return result;
+	},
+
+	updateRobotTimer: function (serial)
+	{
+		this.updateRobot(serial, () =>
+		{
+			let robot = this.getRobot(serial);
+			// Clear any other overlapping timers for this robot
+			clearTimeout(robot.timer);
+
+			// Tell all accessories of this robot (mainAccessory and roomAccessories) that updated robot data is available
+			robot.mainAccessory.updated();
+			robot.roomAccessories.forEach(accessory =>
+			{
+				accessory.updated();
+			});
+
+			// Periodic refresh interval set in config
+			if (this.refresh !== 'auto' && this.refresh !== 0)
+			{
+				debug(robot.device.name + ": ++ Next background update in " + this.refresh + " seconds");
+				robot.timer = setTimeout(this.updateRobotTimer.bind(this), this.refresh * 1000, serial);
+			}
+			// Auto refresh set in config
+			else if (this.refresh === 'auto' && robot.device.canPause)
+			{
+				debug(robot.device.name + ": ++ Next background update in 60 seconds while cleaning (auto mode)");
+				robot.timer = setTimeout(this.updateRobotTimer.bind(this), 60 * 1000, serial);
+			}
+			// No refresh
+			else
+			{
+				debug(robot.device.name + ": ++ Stopped background updates");
+			}
+		});
+	},
+};

package.json

@@ -1,23 +1,35 @@
 {
-  "name": "homebridge-neato",
-  "version": "0.1.0",
-  "description": "control your neato vacuum robot",
+  "name": "homebridge-kobold",
+  "version": "0.8.4",
+  "description": "A Vorwerk Kobold vacuum robot plugin for homebridge.",
   "license": "MIT",
   "keywords": [
-    "homebridge-plugin"
+    "homebridge-plugin",
+    "vorwerk",
+    "kobold"
   ],
   "engines": {
     "node": ">=0.12.0",
     "homebridge": ">=0.2.0"
   },
   "author": {
-    "name": "Arne Blumentritt"
+    "name": "Luis R.",
+    "url2": "https://github.com/himbeles"
   },
+  "contributors": [
+    {
+      "name": "Alexandre L.",
+      "url": "https://github.com/aluini"
+    }
+  ],
   "repository": {
     "type": "git",
-    "url": "git://github.com/naofireblade/homebridge-neato.git"
+    "url": "git://github.com/himbeles/homebridge-kobold.git"
   },
   "dependencies": {
-    "node-botvac": ">=0.1.4"
+    "colors": "^1.4.0",
+    "debug": "^4.1.1",
+    "node-kobold-control": ">=0.4.2",
+    "uuid": "^3.3.2"
   }
 }