eslint compliance

.eslintrc

@@ -0,0 +1,39 @@
+{
+    "parser": "@typescript-eslint/parser",
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended" // uses the recommended rules from the @typescript-eslint/eslint-plugin
+    ],
+    "parserOptions": {
+      "ecmaVersion": 2018,
+      "sourceType": "module"
+    },
+    "ignorePatterns": [
+      "dist"
+    ],
+    "rules": {
+      "quotes": ["warn", "single"],
+      "indent": ["warn", 2, { "SwitchCase": 1 }],
+      "semi": ["off"],
+      "comma-dangle": ["warn", "always-multiline"],
+      "dot-notation": "off",
+      "eqeqeq": "warn",
+      "curly": ["warn", "all"],
+      "brace-style": ["warn"],
+      "prefer-arrow-callback": ["warn"],
+      "max-len": ["warn", 140],
+      "no-console": ["warn"], // use the provided Homebridge log method instead
+      "no-non-null-assertion": ["off"],
+      "comma-spacing": ["error"],
+      "no-multi-spaces": ["warn", { "ignoreEOLComments": true }],
+      "no-trailing-spaces": ["warn"],
+      "lines-between-class-members": ["warn", "always", {"exceptAfterSingleLine": true}],
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/no-non-null-assertion": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/semi": ["warn"],
+      "@typescript-eslint/member-delimiter-style": ["warn"]
+    }
+  }
+  

.gitignore

@@ -1,75 +1,120 @@
+# Ignore compiled code
+dist
+
+# ------------- Defaults ------------- #
+
 # Logs
 logs
 *.log
 npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 
 # Runtime data
 pids
 *.pid
 *.seed
+*.pid.lock
 
 # Directory for instrumented libs generated by jscoverage/JSCover
 lib-cov
 
 # Coverage directory used by tools like istanbul
 coverage
+*.lcov
 
 # nyc test coverage
 .nyc_output
 
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
 .grunt
 
+# Bower dependency directory (https://bower.io/)
+bower_components
+
 # node-waf configuration
 .lock-wscript
 
-# Compiled binary addons (http://nodejs.org/api/addons.html)
+# Compiled binary addons (https://nodejs.org/api/addons.html)
 build/Release
 
 # Dependency directories
-node_modules
+node_modules/
-jspm_packages
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
 
 # Optional npm cache directory
 .npm
 
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
 # Optional REPL history
 .node_repl_history
-# See http://help.github.com/ignore-files/ for more about ignoring files.
 
-# compiled output
+# Output of 'npm pack'
-/dist
+*.tgz
-/dist-server
-/dist-e2e
-/tmp
-/out-tsc
 
-# IDEs and editors
+# Yarn Integrity file
-/.idea
+.yarn-integrity
-.project
-.classpath
-.c9/
-*.launch
-.settings/
-*.sublime-workspace
-*.iml
 
-# IDE - VSCode
+# dotenv environment variables file
-.vscode/*
+.env
-!.vscode/settings.json
+.env.test
-!.vscode/tasks.json
-!.vscode/launch.json
-!.vscode/extensions.json
 
-# misc
+# parcel-bundler cache (https://parceljs.org/)
-/.sass-cache
+.cache
-/connect.lock
+.parcel-cache
-/libpeerconnection.log
-yarn-error.log
-testem.log
-/typings
 
-# System Files
+# Next.js build output
-.DS_Store
+.next
-Thumbs.db
+
-package-lock.json
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.pnp.*

CHANGELOG.md

@@ -133,3 +133,21 @@
 
 ## 0.8.4
 * Link to token getter tool in homebridge UI 
+
+## 1.0.0
+Changes adapted from [homebridge-neato](https://github.com/naofireblade/homebridge-neato) to the Vorwerk API:
+
+* Added bin full sensor
+* Added config-ui support for all options
+* Added config parameter **prefix** to use robot name as prefix for service names
+* Retrying mechanism if a robot is not available on homebridge launch
+* Changed service names to not include robot name as prefix by default
+* Changed background update to use better default intervals (1 minute while cleaning, 30 minutes while idle)
+* Changed config parameter **refresh**. Renamed to **backgroundUpdate**, unit changed to minute and will only be used during idle
+* Changed config parameter **hidden**. Renamed to **services**, now takes list of services that should be _visible_. Default are all available services.
+* Fixed robots no longer disappear or change the room after connection issues with the Vorwerk API
+* Fixed plugin no longer crashes if non smart robot is assigned in Vorwerk account
+* Fixed options for eco, nogo lines, extra care, spot repeat, spot size are now saved in homebridge and will no longer be overridden by Vorwerk API
+
+## TODO until 1.0.0 release
+ * Room cleaning

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Luis Riegger
+Copyright (c) 2021 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,6 +1,4 @@
 [![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)
-
 
 # homebridge-kobold
 

archive/accessories/koboldVacuumRobot.js

@@ -136,7 +136,6 @@ function KoboldVacuumRobotAccessory(platform, robotObject)
 			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);

config.schema.json

@@ -1,42 +1,120 @@
 {
   "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)",
+  "singular": true,
+  "headerDisplay": "homebridge-kobold plugin details [on github](https://github.com/himbeles/homebridge-kobold#readme)",
   "schema": {
     "type": "object",
     "properties": {
       "token": {
-            "title": "token",
+        "title": "Vorwerk Kobold Token",
         "type": "string",
         "required": true,
-            "description": "Your Kobold Token (https://git.io/J3g1b)"
+        "description": "How to get your Vorwerk Kobold Token (https://git.io/J3g1b)"
       },
       "language": {
-          "title": "language",
+        "title": "Services Language",
+        "description": "The displayed language of the registered services (and associated Siri commands)",
         "type": "string",
         "default": "en",
         "oneOf": [
           {
             "title": "English",
-              "enum": [
+            "enum": ["en"]
-                "en"
-              ]
           },
           {
             "title": "German",
-              "enum": [
+            "enum": ["de"]
-                "de"
-              ]
           },
           {
             "title": "French",
-              "enum": [
+            "enum": ["fr"]
-                "fr"
-              ]
           }
         ],
         "required": true
+      },
+      "prefix": {
+        "title": "Prefix with Robot Name",
+        "description": "Display the name of the robot in front of every service.",
+        "type": "boolean",
+        "default": false
+      },
+      "backgroundUpdate": {
+        "title": "Background Update Interval",
+        "description": "Interval for background updates while the robot is not cleaning (in minutes). During cleaning, the robot will automatically update at a faster rate.",
+        "type": "integer",
+        "minimum": 1,
+        "default": 30
+      },
+      "services": {
+        "type": "array",
+        "title": "Displayed Services",
+        "description": "The services to be made available for Homekit",
+        "uniqueItems": true,
+        "items": {
+          "type": "string",
+          "enum": [
+            "clean",
+            "cleanZone",
+            "cleanSpot",
+            "goToDock",
+            "dockState",
+            "binFull",
+            "eco",
+            "noGoLines",
+            "extraCare",
+            "schedule",
+            "findMe",
+            "battery"
+          ],
+          "enumNames": [
+            "Clean",
+            "Clean Zone",
+            "Clean Spot",
+            "Go to Dock",
+            "Docked State",
+            "Bin Full",
+            "Eco Mode",
+            "NoGo Lines",
+            "Extra Care",
+            "Schedule",
+            "Find me",
+            "Battery"
+          ]
+        },
+        "default": [
+          "clean",
+          "cleanZone",
+          "goToDock",
+          "dockState",
+          "binFull",
+          "eco",
+          "noGoLines",
+          "extraCare",
+          "schedule",
+          "findMe",
+          "cleanSpot",
+          "battery"
+        ]
       }
     }
+  },
+  "layout" : [
+    "language",
+    "token",
+    "prefix",
+    "backgroundUpdate",
+    {
+      "type": "fieldset",
+      "title": "Displayed Services",
+      "description": "<i>Services to be displayed in Homekit</i>",
+      "expandable": true,
+      "items": [
+        {
+          "key": "services",
+          "notitle": false
         }
+      ]
+    }
+  ]
 }

nodemon.json

@@ -0,0 +1,12 @@
+{
+  "watch": [
+    "src"
+  ],
+  "ext": "ts",
+  "ignore": [],
+  "exec": "tsc",
+  "signal": "SIGTERM",
+  "env": {
+    "NODE_OPTIONS": "--trace-warnings"
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-kobold",
-  "version": "0.8.4",
+  "version": "1.0.0",
   "description": "A Vorwerk Kobold vacuum robot plugin for homebridge.",
   "license": "MIT",
   "keywords": [
@@ -9,8 +9,14 @@
     "kobold"
   ],
   "engines": {
-    "node": ">=0.12.0",
+    "node": ">=10.17.0",
-    "homebridge": ">=0.2.0"
+    "homebridge": ">=1.3.0"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "lint": "eslint src/**.ts --max-warnings=0",
+    "build": "rimraf ./dist && tsc",
+    "watch": "npm run build && npm link && nodemon"
   },
   "author": {
     "name": "Luis R.",
@@ -26,10 +32,24 @@
     "type": "git",
     "url": "git://github.com/himbeles/homebridge-kobold.git"
   },
+  "bugs": {
+    "url": "https://github.com/himbeles/homebridge-kobold/issues"
+  },
   "dependencies": {
     "colors": "^1.4.0",
     "debug": "^4.1.1",
-    "node-kobold-control": ">=0.4.2",
+    "node-kobold-control": ">=0.5.0",
     "uuid": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^14.14.31",
+    "@typescript-eslint/eslint-plugin": "^4.16.1",
+    "@typescript-eslint/parser": "^4.16.1",
+    "eslint": "^7.21.0",
+    "homebridge": "^1.3",
+    "nodemon": "^2.0.7",
+    "rimraf": "^3.0.2",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.2.2"
   }
 }

src/accessories/koboldVacuumRobot.ts

@@ -0,0 +1,818 @@
+import {
+  CharacteristicValue,
+  Logger,
+  PlatformAccessory,
+  PlatformAccessoryEvent,
+  PlatformConfig,
+  Service,
+  WithUUID,
+} from 'homebridge';
+import { HomebridgeKoboldPlatform } from '../homebridgeKoboldPlatform';
+import spotRepeat from '../characteristics/spotRepeat';
+import spotWidth from '../characteristics/spotWidth';
+import spotHeight from '../characteristics/spotHeight';
+import { Options } from '../models/options';
+
+import { RobotService, CleanType } from '../models/services';
+import { ALL_SERVICES, BACKGROUND_INTERVAL, LOCALE, PREFIX } from '../defaults';
+import { availableLocales, localize } from '../localization';
+import { CharacteristicHandler } from '../characteristics/characteristicHandler';
+
+/**
+ * Platform Accessory
+ * An instance of this class is created for each accessory your platform registers
+ * Each accessory may expose multiple services of different service types.
+ */
+export class KoboldVacuumRobotAccessory {
+  // Homebridge
+  private log: Logger;
+  private readonly batteryService?: Service;
+  private readonly cleanService?: Service;
+  private readonly findMeService?: Service;
+  private readonly goToDockService?: Service;
+  private readonly dockStateService?: Service;
+  private readonly binFullService?: Service;
+  private readonly ecoService?: Service;
+  private readonly noGoLinesService?: Service;
+  private readonly extraCareService?: Service;
+  private readonly scheduleService?: Service;
+  private readonly spotCleanService?: Service;
+  private spotPlusFeatures: boolean;
+
+  // Context
+  private robot: any;
+  private readonly options: Options;
+
+  // Config
+  private readonly backgroundUpdateInterval: number;
+  private readonly locale: availableLocales;
+  private readonly prefix: boolean;
+  private readonly availableServices: Set<RobotService>;
+
+  // Transient
+  private isSpotCleaning: boolean;
+  private timer: any;
+
+  /**
+   * These are just used to create a working example
+   * You should implement your own code to track the state of your accessory
+   */
+
+  constructor(
+    private readonly platform: HomebridgeKoboldPlatform,
+    private readonly accessory: PlatformAccessory,
+    private readonly config: PlatformConfig,
+  ) {
+    this.log = platform.log;
+
+    this.robot = accessory.context.robot;
+    this.options = accessory.context.options || new Options();
+    this.spotPlusFeatures = false;
+
+    this.backgroundUpdateInterval =
+      KoboldVacuumRobotAccessory.parseBackgroundUpdateInterval(
+        this.config['backgroundUpdate'],
+      );
+    this.prefix = this.config['prefix'] || PREFIX;
+    this.locale = this.config['language'] || LOCALE;
+    this.availableServices = new Set(this.config['services']) || ALL_SERVICES;
+
+    this.isSpotCleaning = false;
+
+    // Information
+    this.accessory
+      .getService(this.platform.Service.AccessoryInformation)!
+      .setCharacteristic(
+        this.platform.Characteristic.Manufacturer,
+        'Vorwerk Deutschland Stiftung & Co. KG',
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.Model,
+        this.robot.meta.modelName,
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.SerialNumber,
+        this.robot._serial,
+      )
+      .setCharacteristic(
+        this.platform.Characteristic.FirmwareRevision,
+        this.robot.meta.firmware,
+      )
+      .setCharacteristic(this.platform.Characteristic.Name, this.robot.name);
+
+    // Identify
+    this.accessory.on(PlatformAccessoryEvent.IDENTIFY, () => {
+      this.robot.findMe();
+
+      this.robot.getState((error, result) => {
+        this.log.info('[' + this.robot.name + '] Identified');
+        if (error) {
+          this.debug(DebugType.INFO, JSON.stringify('Error: ' + error));
+        }
+        this.debug(DebugType.INFO, 'Status: ' + JSON.stringify(result));
+        this.debug(
+          DebugType.INFO,
+          'Config: Background Update Interval: ' +
+            this.backgroundUpdateInterval +
+            ', Prefix: ' +
+            this.prefix +
+            ', Enabled services: ' +
+            JSON.stringify(this.availableServices),
+        );
+      });
+    });
+
+    [
+      this.getClean,
+      this.setClean,
+      this.getSpotClean,
+      this.setSpotClean,
+      this.getGoToDock,
+      this.setGoToDock,
+      this.getDocked,
+      this.getBinFull,
+      this.getFindMe,
+      this.setFindMe,
+      this.getSchedule,
+      this.setSchedule,
+      this.getEco,
+      this.setEco,
+      this.getNoGoLines,
+      this.setNoGoLines,
+      this.getExtraCare,
+      this.setExtraCare,
+    ].forEach((f) => {
+      f = f.bind(this);
+    });
+
+    // Services
+    this.cleanService = this.registerService(
+      RobotService.CLEAN,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getClean,
+          setCharacteristicHandler: this.setClean,
+        },
+      ],
+    );
+    this.spotCleanService = this.registerService(
+      RobotService.CLEAN_SPOT,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getSpotClean,
+          setCharacteristicHandler: this.setSpotClean,
+        },
+      ],
+    );
+    this.goToDockService = this.registerService(
+      RobotService.GO_TO_DOCK,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getGoToDock,
+          setCharacteristicHandler: this.setGoToDock,
+        },
+      ],
+    );
+    this.dockStateService = this.registerService(
+      RobotService.DOCKED,
+      this.platform.Service.OccupancySensor,
+      [
+        {
+          characteristic:
+            this.platform.Characteristic.OccupancyDetected.OccupancyDetected,
+          getCharacteristicHandler: this.getDocked,
+        },
+      ],
+    );
+    this.binFullService = this.registerService(
+      RobotService.BIN_FULL,
+      this.platform.Service.OccupancySensor,
+      [
+        {
+          characteristic:
+            this.platform.Characteristic.OccupancyDetected.OccupancyDetected,
+          getCharacteristicHandler: this.getBinFull,
+        },
+      ],
+    );
+    this.findMeService = this.registerService(
+      RobotService.FIND_ME,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getFindMe,
+          setCharacteristicHandler: this.setFindMe,
+        },
+      ],
+    );
+    this.scheduleService = this.registerService(
+      RobotService.SCHEDULE,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getSchedule,
+          setCharacteristicHandler: this.setSchedule,
+        },
+      ],
+    );
+    this.ecoService = this.registerService(
+      RobotService.ECO,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getEco,
+          setCharacteristicHandler: this.setEco,
+        },
+      ],
+    );
+    this.noGoLinesService = this.registerService(
+      RobotService.NOGO_LINES,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getNoGoLines,
+          setCharacteristicHandler: this.setNoGoLines,
+        },
+      ],
+    );
+    this.extraCareService = this.registerService(
+      RobotService.EXTRA_CARE,
+      this.platform.Service.Switch,
+      [
+        {
+          characteristic: this.platform.Characteristic.On,
+          getCharacteristicHandler: this.getExtraCare,
+          setCharacteristicHandler: this.setExtraCare,
+        },
+      ],
+    );
+    this.batteryService = this.registerService(
+      RobotService.BATTERY,
+      this.platform.Service.Battery,
+    );
+
+    // This should be the main switch if the accessory is grouped in homekit
+    if (this.cleanService) {
+      this.cleanService.setPrimaryService(true);
+    }
+
+    // Start background update
+    this.updateRobotPeriodically().then(() => {
+      // Add special characteristics to set spot cleaning options
+      this.spotPlusFeatures =
+        typeof this.robot.availableServices.spotCleaning !== 'undefined' &&
+        this.robot.availableServices.spotCleaning.includes('basic');
+      this.addSpotCleanCharacteristics();
+
+      // Save/Load options
+      if (!accessory.context.options) {
+        this.options.eco = this.robot.eco;
+        this.options.noGoLines = this.robot.noGoLines;
+        this.options.extraCare = this.robot.navigationMode === 2;
+        this.debug(
+          DebugType.INFO,
+          'Options initially set to eco: ' +
+            this.options.eco +
+            ', noGoLines: ' +
+            this.options.noGoLines +
+            ', extraCare: ' +
+            this.options.extraCare,
+        );
+        accessory.context.options = this.options;
+      } else {
+        this.debug(
+          DebugType.INFO,
+          'Options loaded from cache eco: ' +
+            this.options.eco +
+            ', noGoLines: ' +
+            this.options.noGoLines +
+            ', extraCare: ' +
+            this.options.extraCare,
+        );
+      }
+    });
+  }
+
+  private addSpotCleanCharacteristics() {
+    // Only add characteristics of service is available ond characteristics are not added yet
+    if (this.spotCleanService && !this.options.spotCharacteristics) {
+      this.spotCleanService
+        .addCharacteristic(spotRepeat(this.platform.Characteristic))
+        .onGet(this.getSpotRepeat.bind(this))
+        .onSet(this.setSpotRepeat.bind(this));
+
+      // Add these only if the robot supports them
+      if (this.spotPlusFeatures) {
+        this.spotCleanService
+          .addCharacteristic(spotWidth(this.platform.Characteristic))
+          .onGet(this.getSpotWidth.bind(this))
+          .onSet(this.setSpotWidth.bind(this));
+        this.spotCleanService
+          .addCharacteristic(spotHeight(this.platform.Characteristic))
+          .onGet(this.getSpotHeight.bind(this))
+          .onSet(this.setSpotHeight.bind(this));
+      }
+      this.options.spotCharacteristics = true;
+    } else if (this.spotCleanService === null) {
+      this.options.spotCharacteristics = false;
+    }
+  }
+
+  private registerService(
+    serviceName: RobotService,
+    serviceType: WithUUID<typeof Service>,
+    characteristicHandlers: CharacteristicHandler[] = [],
+  ): Service | undefined {
+    const displayName =
+      (this.prefix ? this.robot.name + ' ' : '') +
+      localize(serviceName, this.locale);
+
+    // query existing service by type and subtype
+    const existingService = this.accessory.getServiceById(
+      serviceType,
+      serviceName,
+    );
+
+    if (this.availableServices.has(serviceName)) {
+      let service: Service;
+      if (existingService && existingService.displayName === displayName) {
+        service = existingService;
+      } else {
+        if (existingService) {
+          this.accessory.removeService(existingService);
+        } // delete to reset display name in case of locale or prefix change
+        service = this.accessory.addService(
+          serviceType,
+          displayName,
+          serviceName,
+        );
+      }
+      characteristicHandlers.forEach((ch) => {
+        const char = service.getCharacteristic(ch.characteristic);
+        if (ch.getCharacteristicHandler) {
+          char.onGet(ch.getCharacteristicHandler);
+        }
+        if (ch.setCharacteristicHandler) {
+          char.onSet(ch.setCharacteristicHandler);
+        }
+      });
+      return service;
+    } else {
+      if (existingService) {
+        this.accessory.removeService(existingService);
+      }
+    }
+  }
+
+  private static parseBackgroundUpdateInterval(configValue: any) {
+    // Parse as number
+    let backgroundUpdateInterval = parseInt(configValue) || BACKGROUND_INTERVAL;
+
+    // must be integer and positive
+    backgroundUpdateInterval =
+      backgroundUpdateInterval % 1 !== 0 || backgroundUpdateInterval < 0
+        ? BACKGROUND_INTERVAL
+        : backgroundUpdateInterval;
+
+    return backgroundUpdateInterval;
+  }
+
+  async getClean(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.canPause && !this.isSpotCleaning;
+    } catch (error) {
+      this.log.error('Cannot get cleaning status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setClean(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set CLEAN HOUSE: ' + on);
+    try {
+      await this.updateRobot();
+
+      // Start
+      if (on) {
+        // Resume cleaning
+        if (this.robot.canResume) {
+          this.debug(DebugType.ACTION, 'Resume cleaning');
+          await this.robot.resumeCleaning();
+        }
+        // Start cleaning
+        else if (this.robot.canStart) {
+          await this.clean(CleanType.ALL);
+        }
+        // Cannot start
+        else {
+          this.debug(
+            DebugType.INFO,
+            'Cannot start, maybe already cleaning (expected)',
+          );
+        }
+      }
+      // Stop
+      else {
+        if (this.robot.canPause) {
+          this.debug(DebugType.ACTION, 'Pause cleaning');
+          await this.robot.pauseCleaning();
+        } else {
+          this.debug(DebugType.INFO, 'Already paused');
+        }
+      }
+    } catch (error) {
+      this.log.error('Error setting cleaning to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getSpotClean(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.canPause && this.isSpotCleaning;
+    } catch (error) {
+      this.log.error('Cannot get spot cleaning status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setSpotClean(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT CLEAN: ' + on);
+    try {
+      if (on) {
+        await this.clean(CleanType.SPOT);
+      } else {
+        // TODO stop/pause
+      }
+    } catch (error) {
+      this.log.error('Error setting spot cleaning to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  getGoToDock() {
+    return false;
+  }
+
+  async setGoToDock(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set GO TO DOCK: ' + on);
+    if (on) {
+      await this.updateRobot();
+
+      setTimeout(() => {
+        if (this.goToDockService) {
+          this.goToDockService.updateCharacteristic(
+            this.platform.Characteristic.On,
+            false,
+          );
+        }
+      }, 10000);
+
+      try {
+        if (this.robot.canPause) {
+          this.debug(DebugType.ACTION, 'Pause cleaning to go to dock');
+          await this.robot.pauseCleaning();
+          setTimeout(async () => {
+            await this.robot.sendToBase();
+          }, 1000);
+        } else if (this.robot.canGoToBase) {
+          this.debug(DebugType.ACTION, 'Going to dock');
+          await this.robot.sendToBase();
+        } else {
+          this.log.warn(
+            '[' + this.robot.name + '] Can\'t go to dock at the moment',
+          );
+        }
+      } catch (error) {
+        this.log.error('Error setting go to dock to: ' + on + '. ' + error);
+        throw new this.platform.api.hap.HapStatusError(
+          this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+        );
+      }
+    }
+  }
+
+  async getDocked(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isDocked;
+    } catch (error) {
+      this.log.error('Cannot get docked status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getBinFull(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isBinFull;
+    } catch (error) {
+      this.log.error('Cannot get bin full status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async getSchedule(): Promise<CharacteristicValue> {
+    try {
+      await this.updateRobot();
+      return this.robot.isScheduleEnabled;
+    } catch (error) {
+      this.log.error('Cannot get schedule status: ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  async setSchedule(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SCHEDULE: ' + on);
+    try {
+      if (on) {
+        await this.robot.enableSchedule();
+      } else {
+        await this.robot.disableSchedule();
+      }
+    } catch (error) {
+      this.log.error('Error setting schedule to: ' + on + '. ' + error);
+      throw new this.platform.api.hap.HapStatusError(
+        this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+      );
+    }
+  }
+
+  getEco() {
+    return this.options.eco;
+  }
+
+  setEco(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set ECO: ' + on);
+    this.options.eco = <boolean>on;
+  }
+
+  getExtraCare() {
+    return this.options.extraCare;
+  }
+
+  setExtraCare(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set EXTRA CARE: ' + on);
+    this.options.extraCare = <boolean>on;
+  }
+
+  getNoGoLines() {
+    return this.options.noGoLines;
+  }
+
+  setNoGoLines(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set NOGO LINES: ' + on);
+    this.options.noGoLines = <boolean>on;
+  }
+
+  getSpotRepeat() {
+    return this.options.spotRepeat;
+  }
+
+  setSpotRepeat(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT REPEAT: ' + on);
+    this.options.spotRepeat = <boolean>on;
+  }
+
+  getSpotWidth() {
+    return this.options.spotWidth;
+  }
+
+  setSpotWidth(length: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT WIDTH: ' + length + ' cm');
+    this.options.spotWidth = <number>length;
+  }
+
+  getSpotHeight() {
+    return this.options.spotHeight;
+  }
+
+  setSpotHeight(length: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set SPOT HEIGHT: ' + length + ' cm');
+    this.options.spotHeight = <number>length;
+  }
+
+  getFindMe() {
+    return false;
+  }
+
+  async setFindMe(on: CharacteristicValue) {
+    this.debug(DebugType.STATUS, 'Set FIND ME: ' + on);
+    if (on) {
+      this.debug(DebugType.ACTION, 'Find me');
+      setTimeout(() => {
+        if (this.findMeService) {
+          this.findMeService.updateCharacteristic(
+            this.platform.Characteristic.On,
+            false,
+          );
+        }
+      }, 1000);
+
+      try {
+        await this.robot.findMe();
+      } catch (error) {
+        this.log.error(this.robot.name + ' ## Cannot start find me. ' + error);
+        throw new this.platform.api.hap.HapStatusError(
+          this.platform.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+        );
+      }
+    }
+  }
+
+  async clean(cleanType: CleanType) {
+    // Enable shorter background update while cleaning
+    setTimeout(() => {
+      this.updateRobotPeriodically();
+    }, 2 * 60 * 1000);
+
+    this.log.info(
+      '[' +
+        this.robot.name +
+        '] > Start cleaning with options type: ' +
+        CleanType[cleanType] +
+        ', eco: ' +
+        this.options.eco +
+        ', noGoLines: ' +
+        this.options.noGoLines +
+        ', extraCare: ' +
+        this.options.extraCare,
+    );
+
+    try {
+      switch (cleanType) {
+        case CleanType.ALL:
+          await this.robot.startCleaning(
+            this.options.eco,
+            this.options.extraCare ? 2 : 1,
+            this.options.noGoLines,
+          );
+          break;
+        case CleanType.SPOT:
+          await this.robot.startSpotCleaning(
+            this.options.eco,
+            this.options.spotWidth,
+            this.options.spotHeight,
+            this.options.spotRepeat,
+            this.options.extraCare ? 2 : 1,
+          );
+          break;
+      }
+    } catch (error) {
+      this.log.error('Cannot start cleaning. ' + error);
+    }
+  }
+
+  async updateRobot() {
+    // Data is outdated
+    if (
+      typeof this.robot.lastUpdate === 'undefined' ||
+      new Date().getTime() - this.robot.lastUpdate > 2000
+    ) {
+      this.robot.lastUpdate = new Date().getTime();
+      try {
+        this.robot.getState((error, result) => {
+          this.isSpotCleaning = result !== null && result.action === 2;
+
+          // Battery
+          this.batteryService?.updateCharacteristic(
+            this.platform.Characteristic.BatteryLevel,
+            this.robot.charge,
+          );
+          this.batteryService?.updateCharacteristic(
+            this.platform.Characteristic.ChargingState,
+            this.robot.isCharging,
+          );
+        });
+      } catch (error) {
+        this.log.error(
+          'Cannot update robot ' +
+            this.robot.name +
+            '. Check if robot is online. ' +
+            error,
+        );
+        return false;
+      }
+    }
+  }
+
+  async updateRobotPeriodically() {
+    this.debug(DebugType.INFO, 'Performing background update');
+
+    await this.updateRobot();
+    await this.updateCharacteristics();
+
+    // Clear any other overlapping timers for this robot
+    clearTimeout(this.timer);
+
+    // Tell all accessories of this robot (mainAccessory and roomAccessories) that updated robot data is available
+    // this.robot.mainAccessory.updated();
+    // this.robot.roomAccessories.forEach(accessory => {
+    // 	accessory.updated();
+    // });
+
+    // Periodic refresh interval set in config
+    let interval;
+    if (this.robot.canPause) {
+      interval = 1;
+    } else {
+      interval = this.backgroundUpdateInterval;
+    }
+
+    this.debug(
+      DebugType.INFO,
+      'Background update done. Next update in ' +
+        interval +
+        ' minute' +
+        (interval === 1 ? '' : 's') +
+        (this.robot.canPause ? ', robot is currently cleaning.' : '.'),
+    );
+    this.timer = setTimeout(
+      this.updateRobotPeriodically.bind(this),
+      interval * 60 * 1000,
+    );
+  }
+
+  async updateCharacteristics() {
+    if (this.cleanService) {
+      this.cleanService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getClean(),
+      );
+    }
+    if (this.spotCleanService) {
+      this.spotCleanService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getSpotClean(),
+      );
+    }
+    if (this.goToDockService) {
+      this.goToDockService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getGoToDock(),
+      );
+    }
+    if (this.dockStateService) {
+      this.dockStateService.updateCharacteristic(
+        this.platform.Characteristic.OccupancyDetected,
+        await this.getDocked(),
+      );
+    }
+    if (this.binFullService) {
+      this.binFullService.updateCharacteristic(
+        this.platform.Characteristic.OccupancyDetected,
+        await this.getBinFull(),
+      );
+    }
+    if (this.scheduleService) {
+      this.scheduleService.updateCharacteristic(
+        this.platform.Characteristic.On,
+        await this.getSchedule(),
+      );
+    }
+  }
+
+  private debug(debugType: DebugType, message: string) {
+    switch (debugType) {
+      case DebugType.ACTION:
+        this.log.debug('[' + this.robot.name + '] > ' + message);
+        break;
+      case DebugType.STATUS:
+        this.log.debug('[' + this.robot.name + '] ' + message);
+        break;
+      case DebugType.INFO:
+        this.log.debug('[' + this.robot.name + '] ' + message);
+        break;
+    }
+  }
+}
+
+enum DebugType {
+  ACTION,
+  STATUS,
+  INFO,
+}

src/accessories/room.ts

@@ -0,0 +1,37 @@
+// import {CharacteristicValue, Logger, PlatformAccessory, PlatformConfig, Service} from 'homebridge';
+// import {HomebridgeNeatoPlatform} from '../homebridgeNeatoPlatform';
+//
+// const debug = require('debug')('my-app:my-module');
+//
+// /**
+//  * Platform Accessory
+//  * An instance of this class is created for each accessory your platform registers
+//  * Each accessory may expose multiple services of different service types.
+//  */
+// export class Room
+// {
+//
+// 	private robot: any;
+// 	private log: Logger;
+// 	private readonly refresh: any;
+//	
+//
+// 	/**
+// 	 * These are just used to create a working example
+// 	 * You should implement your own code to track the state of your accessory
+// 	 */
+//
+// 	constructor(
+// 			private readonly platform: HomebridgeNeatoPlatform,
+// 			private readonly accessory: PlatformAccessory,
+// 			private readonly isNew: Boolean,
+// 			private readonly config: PlatformConfig)
+// 	{
+//		
+// 	}
+//	
+// 	async setCleanRoom()
+// 	{
+//		
+// 	}
+// }

src/characteristics/characteristicHandler.ts

@@ -0,0 +1,7 @@
+import { Characteristic, CharacteristicGetHandler, CharacteristicSetHandler, WithUUID } from 'homebridge';
+
+export declare interface CharacteristicHandler{
+    characteristic: WithUUID<new () => Characteristic>;
+    getCharacteristicHandler?: CharacteristicGetHandler;
+    setCharacteristicHandler?: CharacteristicSetHandler;
+}

src/characteristics/spotHeight.ts

@@ -0,0 +1,21 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotHeight(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotHeight extends CustomCharacteristic {
+    static readonly UUID = 'CA282DB2-62BF-4325-A1BE-F8BB5478781A';
+
+    constructor() {
+      super('Spot ↕', SpotHeight.UUID, {
+        format: Formats.INT,
+        unit: 'cm',
+        maxValue: 400,
+        minValue: 100,
+        minStep: 50,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}

src/characteristics/spotRepeat.ts

@@ -0,0 +1,17 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotRepeat(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotRepeat extends CustomCharacteristic {
+    static readonly UUID = '1E79C603-63B8-4E6A-9CE1-D31D67981831';
+
+    constructor() {
+      super('Spot 2x', SpotRepeat.UUID, {
+        format: Formats.BOOL,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}

src/characteristics/spotWidth.ts

@@ -0,0 +1,21 @@
+import type { Characteristic, WithUUID } from 'homebridge';
+import { Formats, Perms } from 'homebridge';
+
+export default function spotWidth(
+  CustomCharacteristic: typeof Characteristic,
+): WithUUID<new () => Characteristic> {
+  return class SpotWidth extends CustomCharacteristic {
+    static readonly UUID = 'A7889A9A-2F27-4293-BEF8-3FE805B36F4E';
+
+    constructor() {
+      super('Spot ↔', SpotWidth.UUID, {
+        format: Formats.INT,
+        unit: 'cm',
+        maxValue: 400,
+        minValue: 100,
+        minStep: 50,
+        perms: [Perms.PAIRED_READ, Perms.PAIRED_WRITE],
+      });
+    }
+  };
+}

src/defaults.ts

@@ -0,0 +1,6 @@
+import { RobotService } from './models/services';
+
+export const BACKGROUND_INTERVAL = 30;
+export const PREFIX = false;
+export const ALL_SERVICES = new Set(Object.values(RobotService));
+export const LOCALE = 'en';

src/homebridgeKoboldPlatform.ts

@@ -0,0 +1,273 @@
+import {
+  API,
+  Characteristic,
+  DynamicPlatformPlugin,
+  Logger,
+  PlatformAccessory,
+  PlatformConfig,
+  Service,
+} from 'homebridge';
+import KoboldApi from 'node-kobold-control';
+import { PLATFORM_NAME, PLUGIN_NAME } from './settings';
+import { KoboldVacuumRobotAccessory } from './accessories/koboldVacuumRobot';
+
+/**
+ * HomebridgePlatform
+ * This class is the main constructor for your plugin, this is where you should
+ * parse the user config and discover/register accessories with Homebridge.
+ */
+export class HomebridgeKoboldPlatform implements DynamicPlatformPlugin {
+  public readonly Service: typeof Service = this.api.hap.Service;
+  public readonly Characteristic: typeof Characteristic =
+    this.api.hap.Characteristic;
+
+  // this is used to track restored cached accessories
+  public readonly cachedRobotAccessories: PlatformAccessory[] = [];
+
+  constructor(
+    public readonly log: Logger,
+    public readonly config: PlatformConfig,
+    public readonly api: API,
+  ) {
+    this.api.on('didFinishLaunching', () => {
+      this.discoverRobots();
+    });
+  }
+
+  /**
+   * This function is invoked when homebridge restores cached accessories from disk at startup.
+   * It should be used to setup event handlers for characteristics and update respective values.
+   */
+  configureAccessory(accessory: PlatformAccessory) {
+    // add the restored accessory to the accessories cache so we can track if it has already been registered
+    this.cachedRobotAccessories.push(accessory);
+  }
+
+  discoverRobots() {
+    const client = new KoboldApi.Client();
+
+    try {
+      // Login
+      client.authorize(this.config['token'], (error) => {
+        if (error) {
+          this.log.error(
+            `Cannot connect to Vorwerk server. 
+			No new robots will be found and existing robots will be unresponsive. 
+			Retrying in 5 minutes.`,
+          );
+          this.log.error('Error: ' + error);
+
+          setTimeout(() => {
+            this.discoverRobots();
+          }, 5 * 60 * 1000);
+          return;
+        }
+
+        // Get all robots from account
+        client.getRobots((error, robots) => {
+          if (error) {
+            this.log.error(
+              'Successful login but can\'t list the robots in your Vorwerk robots. Retrying in 5 minutes.',
+            );
+            this.log.error('Error: ' + error);
+
+            setTimeout(() => {
+              this.discoverRobots();
+            }, 5 * 60 * 1000);
+            return;
+          }
+
+          // Vorwerk robots in account
+          if (robots.length === 0) {
+            this.log.error('Vorwerk account has no robots.');
+          } else {
+            this.log.info(
+              'Vorwerk account has ' +
+                robots.length +
+                ' robot' +
+                (robots.length === 1 ? '' : 's'),
+            );
+          }
+
+          // Vorwerk robots in cache
+          this.log.debug(
+            'Plugin Cache has ' +
+              this.cachedRobotAccessories.length +
+              ' robot' +
+              (this.cachedRobotAccessories.length === 1 ? '' : 's'),
+          );
+          for (const cachedRobot of this.cachedRobotAccessories) {
+            const accountRobot = robots.find(
+              (robot) =>
+                this.api.hap.uuid.generate(robot._serial) === cachedRobot.UUID,
+            );
+            if (accountRobot) {
+              this.log.debug(
+                '[' +
+                  cachedRobot.displayName +
+                  '] Cached robot found in Vorwerk account.',
+              );
+            } else {
+              this.log.error(
+                '[' +
+                  cachedRobot.displayName +
+                  '] Cached robot not found in Vorwerk account. Robot will now be removed from homebridge.',
+              );
+              this.api.unregisterPlatformAccessories(
+                PLUGIN_NAME,
+                PLATFORM_NAME,
+                [cachedRobot],
+              );
+            }
+          }
+
+          // Add / Update homebridge accessories with robot information from Vorwerk.
+          // This must be done for new and existing robots to reflect changes in the name, firmware, pluginconfig etc.
+          for (const robot of robots) {
+            // Check if robot already exists as an accessory
+            const uuid = this.api.hap.uuid.generate(robot._serial);
+            const cachedRobot = this.cachedRobotAccessories.find(
+              (accessory) => accessory.UUID === uuid,
+            );
+
+            if (cachedRobot) {
+              this.log.debug(
+                '[' +
+                  robot.name +
+                  '] Connecting to cached robot and updating information.',
+              );
+            } else {
+              this.log.debug(
+                '[' +
+                  robot.name +
+                  '] Connecting to new robot and updating information.',
+              );
+            }
+
+            robot.getState((error, state) => {
+              if (error) {
+                this.log.error(
+                  '[' +
+                    robot.name +
+                    '] Cannot connect to robot. Is the robot connected to the internet? Retrying in 5 minutes.',
+                );
+                this.log.error('Error: ' + error);
+                setTimeout(() => {
+                  this.discoverRobots();
+                }, 5 * 60 * 1000);
+              } else {
+                try {
+                  robot.meta = state.meta;
+                  robot.availableServices = state.availableServices;
+
+                  // Update existing robot accessor
+                  if (cachedRobot) {
+                    // TODO update maps
+
+                    cachedRobot.context.robot = robot;
+                    this.api.updatePlatformAccessories([cachedRobot]);
+                    new KoboldVacuumRobotAccessory(
+                      this,
+                      cachedRobot,
+                      this.config,
+                    );
+                    this.log.info(
+                      '[' +
+                        robot.name +
+                        '] Successfully loaded robot from cache',
+                    );
+                  } else {
+                    // Create new robot accessory
+                    // TODO get maps
+
+                    const newRobot = new this.api.platformAccessory(
+                      robot.name,
+                      uuid,
+                    );
+                    newRobot.context.robot = robot;
+                    new KoboldVacuumRobotAccessory(this, newRobot, this.config);
+                    this.api.registerPlatformAccessories(
+                      PLUGIN_NAME,
+                      PLATFORM_NAME,
+                      [newRobot],
+                    );
+                    this.log.info(
+                      '[' + robot.name + '] Successfully created as new robot',
+                    );
+                  }
+                } catch (error) {
+                  this.log.error(
+                    '[' +
+                      robot.name +
+                      '] Creating accessory failed. Error: ' +
+                      error,
+                  );
+                  throw new this.api.hap.HapStatusError(
+                    this.api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE,
+                  );
+                }
+              }
+
+              // // 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.robotAccessories.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.robotAccessories.push({device: robot, meta: state.meta, availableServices: state.availableServices});
+              // 					loadedRobots++;
+              // 					if (loadedRobots === robots.length)
+              // 					{
+              // 						callback();
+              // 					}
+              // 				}
+              // 			})
+              // 		});
+              // 	}
+              // });
+            });
+          }
+        });
+      });
+    } catch (error) {
+      this.log.error(
+        `Can't log on to Vorwerk cloud. Please check your internet connection and your credentials.
+		Try again later if the neato servers have issues. Error: ` +
+          error,
+      );
+    }
+  }
+}

src/index.ts

@@ -0,0 +1,11 @@
+import { API } from 'homebridge';
+
+import { PLATFORM_NAME } from './settings';
+import { HomebridgeKoboldPlatform } from './homebridgeKoboldPlatform';
+
+/**
+ * This method registers the platform with Homebridge
+ */
+export = (api: API) => {
+  api.registerPlatform(PLATFORM_NAME, HomebridgeKoboldPlatform);
+};

src/localization.ts

@@ -0,0 +1,57 @@
+export enum availableLocales {
+    EN = "en",
+    DE = "de",
+    FR = "fr",
+}
+
+const localizationDicts = {
+    'en': {
+        "clean": "Clean",
+        "cleanZone": "Clean Zone",
+        "cleanThe": "Clean the",
+        "goToDock": "Go to Dock",
+        "dockState": "Docked",
+        "binFull": "Bin Full",
+        "eco": "Eco Mode",
+        "noGoLines": "NoGo Lines",
+        "extraCare": "Extra Care",
+        "schedule": "Schedule",
+        "findMe": "Find me",
+        "cleanSpot": "Clean Spot",
+        "battery": "Battery"
+    },
+    'de': {
+        "clean": "Sauge",
+        "cleanZone": "Sauge Zone",
+        "cleanThe": "Sauge",
+        "goToDock": "Zur Basis",
+        "dockState": "In der Basis",
+        "binFull": "Behälter voll",
+        "eco": "Eco Modus",
+        "noGoLines": "NoGo Linien",
+        "extraCare": "Extra Care",
+        "schedule": "Zeitplan",
+        "findMe": "Finde mich",
+        "cleanSpot": "Spot Reinigung",
+        "battery": "Batterie"
+    },
+    'fr': {
+        "clean": "Aspirer",
+        "cleanZone": "Aspirer Zone",
+        "cleanThe": "Aspirer",
+        "goToDock": "Retour à la base",
+        "dockState": "Sur la base",
+        "binFull": "Conteneur plein",
+        "eco": "Eco mode",
+        "noGoLines": "Lignes NoGo",
+        "extraCare": "Extra Care",
+        "schedule": "Planifier",
+        "findMe": "Me retrouver",
+        "cleanSpot": "Nettoyage local",
+        "battery": "Batterie"
+    }
+}
+
+export function localize(label: string, locale: availableLocales) : string {
+    return localizationDicts[locale][label] ?? label
+}

src/models/options.ts

@@ -0,0 +1,19 @@
+export class Options {
+  public eco: boolean;
+  public extraCare: boolean;
+  public noGoLines: boolean;
+  public spotCharacteristics: boolean;
+  public spotRepeat: boolean;
+  public spotWidth: number;
+  public spotHeight: number;
+
+  constructor() {
+    this.eco = false;
+    this.extraCare = false;
+    this.noGoLines = false;
+    this.spotCharacteristics = false;
+    this.spotRepeat = false;
+    this.spotWidth = 200;
+    this.spotHeight = 200;
+  }
+}

src/models/services.ts

@@ -0,0 +1,19 @@
+export enum CleanType {
+  ALL,
+  SPOT,
+}
+
+export enum RobotService {
+  CLEAN = 'clean',
+  CLEAN_SPOT = 'cleanSpot',
+  CLEAN_ZONE = 'cleanZone',
+  GO_TO_DOCK = 'goToDock',
+  DOCKED = 'dockState',
+  BIN_FULL = 'binFull',
+  FIND_ME = 'findMe',
+  SCHEDULE = 'schedule',
+  ECO = 'eco',
+  NOGO_LINES = 'noGoLines',
+  EXTRA_CARE = 'extraCare',
+  BATTERY = 'battery',
+}

src/settings.ts

@@ -0,0 +1,9 @@
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export const PLATFORM_NAME = "KoboldVacuumRobot";
+
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export const PLUGIN_NAME = "homebridge-kobold";

tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2018", // ~node10
+    "module": "commonjs",
+    "lib": [
+      "es2015",
+      "es2016",
+      "es2017",
+      "es2018"
+    ],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "noImplicitAny": false
+  },
+  "include": [
+    "src/"
+  ],
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}