homebridge-dahua-vto 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# homebridge-dahua-vto
+
+Homebridge plugin for **Dahua VTO** door stations (tested with VTO2111D):
+
+- Live camera (H.264 via ffmpeg)
+- Doorbell button events
+- Motion
+- Door lock / unlock (`accessControl.cgi`)
+- **Two-way audio** — same path as Scrypted Amcrest (`audio.cgi` G.711A, 1024-byte chunks @ 8 kHz)
+- Optional **HomeKit Secure Video** (HKSV)
+
+## Requirements
+
+- [Homebridge](https://homebridge.io/) `^1.8` (or v2 beta)
+- **ffmpeg with `libfdk_aac`** for talkback (AAC-ELD). Recommended: [ffmpeg-for-homebridge](https://github.com/homebridge/ffmpeg-for-homebridge)
+- Network access from the Homebridge host to the VTO (HTTP CGI + RTSP)
+
+## Install
+
+```bash
+hb-service add homebridge-dahua-vto
+# or
+npm install -g homebridge-dahua-vto
+```
+
+Then restart Homebridge and add the platform in the UI, or edit `config.json`.
+
+## Config example
+
+```json
+{
+  "platforms": [
+    {
+      "platform": "DahuaVTO",
+      "name": "Dahua VTO",
+      "cameras": [
+        {
+          "name": "Front Door",
+          "host": "192.168.80.8",
+          "username": "admin",
+          "password": "YOUR_PASSWORD",
+          "doorChannel": 1,
+          "unlockSeconds": 5,
+          "twoWayAudio": true,
+          "hksv": true,
+          "ffmpegPath": "/usr/local/bin/ffmpeg"
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Optional fields
+
+| Field | Default | Notes |
+|---|---|---|
+| `rtspUrl` | auto | Full RTSP URL override |
+| `rtspSubtype` | `0` | Main/sub stream if `rtspUrl` not set |
+| `ssl` | `false` | HTTPS for CGI |
+| `ffmpegPath` | `ffmpeg` | Path to ffmpeg-for-homebridge binary |
+| `twoWayAudio` | `true` | Mic in Home → VTO speaker |
+| `hksv` | `true` | Secure Video recording |
+| `motionTimeoutMs` | `10000` | Auto-clear motion |
+
+## Two-way audio
+
+Uses the Dahua/Amcrest CGI (same as Scrypted **Doorbell Type = Dahua**):
+
+```text
+POST /cgi-bin/audio.cgi?action=postAudio&httptype=singlepart&channel=1
+Content-Type: Audio/G.711A
+```
+
+In the Home app: open the camera → hold the microphone button.
+
+## Unlock
+
+```text
+GET /cgi-bin/accessControl.cgi?action=openDoor&channel=1&UserID=101&Type=Remote
+```
+
+## Notes for publishing
+
+1. Replace `roysbike` in `package.json` `repository` / `bugs` / `homepage`
+2. Set `"author"`
+3. `npm login` && `npm publish`
+4. Optional: request [Homebridge verified](https://github.com/homebridge/plugins) listing after the plugin is stable
+
+## License
+
+MIT

package/config.schema.json

@@ -0,0 +1,113 @@
+{
+  "pluginAlias": "DahuaVTO",
+  "pluginType": "platform",
+  "singular": true,
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "title": "Platform Name",
+        "type": "string",
+        "default": "Dahua VTO",
+        "description": "Internal platform name (Homebridge UI)."
+      },
+      "cameras": {
+        "title": "Door stations",
+        "type": "array",
+        "description": "One or more Dahua VTO / Amcrest-compatible door stations.",
+        "items": {
+          "type": "object",
+          "required": ["host", "password"],
+          "properties": {
+            "name": {
+              "title": "Name",
+              "type": "string",
+              "default": "Dahua VTO",
+              "description": "Name shown in the Home app."
+            },
+            "host": {
+              "title": "Host / IP",
+              "type": "string",
+              "format": "hostname",
+              "placeholder": "192.168.1.30",
+              "description": "VTO IP address or hostname."
+            },
+            "username": {
+              "title": "Username",
+              "type": "string",
+              "default": "admin"
+            },
+            "password": {
+              "title": "Password",
+              "type": "string",
+              "format": "password"
+            },
+            "ssl": {
+              "title": "Use HTTPS for CGI",
+              "type": "boolean",
+              "default": false
+            },
+            "doorChannel": {
+              "title": "Door channel",
+              "type": "integer",
+              "default": 1,
+              "minimum": 0,
+              "description": "accessControl / audio.cgi channel (usually 1)."
+            },
+            "unlockSeconds": {
+              "title": "Unlock duration (seconds)",
+              "type": "integer",
+              "default": 5,
+              "minimum": 1,
+              "maximum": 60
+            },
+            "rtspUrl": {
+              "title": "RTSP URL override",
+              "type": "string",
+              "description": "Optional. Default: rtsp://user:pass@host:554/cam/realmonitor?channel=1&subtype=0"
+            },
+            "rtspSubtype": {
+              "title": "RTSP subtype (if no rtspUrl)",
+              "type": "integer",
+              "default": 0,
+              "description": "0 = main stream, 1 = sub stream."
+            },
+            "ffmpegPath": {
+              "title": "ffmpeg path",
+              "type": "string",
+              "default": "ffmpeg",
+              "description": "Use ffmpeg-for-homebridge for AAC-ELD talkback (libfdk_aac)."
+            },
+            "twoWayAudio": {
+              "title": "Two-way audio",
+              "type": "boolean",
+              "default": true,
+              "description": "Home mic → VTO speaker via audio.cgi (G.711A), Scrypted Amcrest style."
+            },
+            "hksv": {
+              "title": "HomeKit Secure Video",
+              "type": "boolean",
+              "default": true,
+              "description": "Requires HomePod / Apple TV hub and iCloud+."
+            },
+            "motionTimeoutMs": {
+              "title": "Motion clear timeout (ms)",
+              "type": "integer",
+              "default": 10000
+            },
+            "manufacturer": {
+              "title": "Manufacturer",
+              "type": "string",
+              "default": "Dahua"
+            },
+            "model": {
+              "title": "Model",
+              "type": "string",
+              "default": "VTO"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const { PLATFORM_NAME, PLUGIN_NAME } = require("./src/settings");
+const { setHap } = require("./src/hap");
+
+module.exports = (api) => {
+  setHap(api.hap);
+  const { DahuaVtoPlatform } = require("./src/platform");
+  api.registerPlatform(PLUGIN_NAME, PLATFORM_NAME, DahuaVtoPlatform);
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "homebridge-dahua-vto",
+  "displayName": "Dahua VTO",
+  "version": "1.0.0",
+  "description": "Homebridge plugin for Dahua VTO door stations — camera, lock, doorbell, two-way audio (Amcrest audio.cgi) and optional HKSV",
+  "main": "index.js",
+  "scripts": {
+    "test": "node -e \"require('./index.js');\""
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "homebridge",
+    "dahua",
+    "vto",
+    "doorbell",
+    "camera",
+    "intercom",
+    "two-way-audio",
+    "hksv"
+  ],
+  "engines": {
+    "node": "^18.20.4 || ^20.16.0 || ^22.5.1",
+    "homebridge": "^1.8.0 || ^2.0.0-beta.0"
+  },
+  "dependencies": {
+    "rtp-packet": "^0.1.1"
+  },
+  "peerDependencies": {
+    "homebridge": "^1.8.0 || ^2.0.0-beta.0"
+  },
+  "author": "Artem Goncharenko",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/roysbike/homebridge-dahua-vto.git"
+  },
+  "bugs": {
+    "url": "https://github.com/roysbike/homebridge-dahua-vto/issues"
+  },
+  "homepage": "https://github.com/roysbike/homebridge-dahua-vto#readme",
+  "files": [
+    "index.js",
+    "config.schema.json",
+    "LICENSE",
+    "README.md",
+    "src"
+  ]
+}

package/src/accessory.js

@@ -0,0 +1,230 @@
+"use strict";
+
+const { DahuaClient } = require("./dahua/client");
+const { VtoCameraDelegate, buildDoorbellController } = require("./homekit/camera");
+
+function normalizeDeviceConfig(raw) {
+  const host = raw.host;
+  const username = raw.username || "admin";
+  const password = raw.password || "";
+  const ssl = Boolean(raw.ssl);
+  const proto = ssl ? "https" : "http";
+  const doorChannel = Number(raw.doorChannel || raw.channel || 1) || 1;
+  const unlockSeconds = Number(raw.unlockSeconds || 5) || 5;
+  const ffmpegPath = raw.ffmpegPath || raw.videoProcessor || "ffmpeg";
+  const twoWayAudio = raw.twoWayAudio !== false;
+  const hksv = raw.hksv !== false;
+
+  const rtspUrl =
+    raw.rtspUrl ||
+    `rtsp://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${host}:554/cam/realmonitor?channel=1&subtype=${raw.rtspSubtype ?? 0}`;
+
+  return {
+    name: raw.name || `Dahua VTO ${host}`,
+    manufacturer: raw.manufacturer || "Dahua",
+    model: raw.model || "VTO",
+    firmware: raw.firmware || "1.0.0",
+    ffmpegPath,
+    rtspUrl,
+    twoWayAudio,
+    dahua: {
+      host,
+      username,
+      password,
+      ssl,
+      baseUrl: `${proto}://${host}/cgi-bin/`,
+      doorChannel,
+      unlockSeconds,
+      eventCodes: raw.eventCodes || "All",
+    },
+    hksv: {
+      enabled: hksv,
+      prebufferMs: Number(raw.hksvPrebufferMs || 4000),
+      fragmentMs: Number(raw.hksvFragmentMs || 4000),
+      motionTimeoutMs: Number(raw.motionTimeoutMs || 10000),
+    },
+  };
+}
+
+/**
+ * One VIDEO_DOORBELL accessory: camera + lock + motion + two-way (Amcrest talkback).
+ */
+class DahuaVtoAccessory {
+  constructor(log, deviceConfig, api, accessory) {
+    this.log = log;
+    this.api = api;
+    this.accessory = accessory;
+    this.config = normalizeDeviceConfig(deviceConfig);
+    this.hap = api.hap;
+
+    const { Service, Characteristic, Categories } = this.hap;
+
+    accessory
+      .getService(Service.AccessoryInformation)
+      .setCharacteristic(Characteristic.Manufacturer, this.config.manufacturer)
+      .setCharacteristic(Characteristic.Model, this.config.model)
+      .setCharacteristic(Characteristic.SerialNumber, this.config.dahua.host)
+      .setCharacteristic(Characteristic.FirmwareRevision, this.config.firmware);
+
+    // Prefer doorbell category
+    accessory.category = Categories.VIDEO_DOORBELL;
+
+    this.motionActive = false;
+    this.motionTimer = null;
+    this.lockTimeout = null;
+    this.unlocking = false;
+    this.targetState = Characteristic.LockTargetState.SECURED;
+    this.currentState = Characteristic.LockCurrentState.SECURED;
+
+    this.dahua = new DahuaClient(this.config.dahua, this._logger());
+    this.delegate = new VtoCameraDelegate({
+      config: this.config,
+      log: this._logger(),
+      dahua: this.dahua,
+      getMotionActive: () => this.motionActive,
+    });
+
+    this.controller = buildDoorbellController(this.delegate, this.config);
+    this.delegate.controller = this.controller;
+    accessory.configureController(this.controller);
+
+    this._setupLock();
+    this._wireEvents();
+    this.dahua.startEventStream();
+
+    this.log.info(
+      `Ready ${this.config.name} @ ${this.config.dahua.host} ` +
+        `(twoWay=${this.config.twoWayAudio}, hksv=${this.config.hksv.enabled})`
+    );
+  }
+
+  _logger() {
+    return {
+      info: (...a) => this.log.info(...a),
+      warn: (...a) => this.log.warn(...a),
+      error: (...a) => this.log.error(...a),
+      debug: (...a) => this.log.debug(...a),
+    };
+  }
+
+  _setupLock() {
+    const { Service, Characteristic } = this.hap;
+    let lockService = this.accessory.getService(Service.LockMechanism);
+    if (!lockService) {
+      lockService = this.accessory.addService(Service.LockMechanism, "Door Lock");
+    }
+    this.lockService = lockService;
+
+    const doorbellService = this.accessory.getService(Service.Doorbell);
+    if (doorbellService) {
+      try {
+        doorbellService.addLinkedService(lockService);
+      } catch {
+        /* already linked */
+      }
+    }
+
+    const pushLockState = (target, current) => {
+      setTimeout(() => {
+        lockService.updateCharacteristic(Characteristic.LockTargetState, target);
+        lockService.updateCharacteristic(Characteristic.LockCurrentState, current);
+      }, 150);
+    };
+
+    lockService
+      .getCharacteristic(Characteristic.LockCurrentState)
+      .onGet(() => this.currentState);
+
+    lockService
+      .getCharacteristic(Characteristic.LockTargetState)
+      .onGet(() => this.targetState)
+      .onSet(async (value) => {
+        this.targetState = value;
+        if (value !== Characteristic.LockTargetState.UNSECURED) {
+          return;
+        }
+        if (this.unlocking) {
+          this.log.info("Lock SET ignored (unlock in progress)");
+          return;
+        }
+
+        this.unlocking = true;
+        try {
+          await this.dahua.openDoor(this.config.dahua.doorChannel);
+          this.currentState = Characteristic.LockCurrentState.UNSECURED;
+          pushLockState(Characteristic.LockTargetState.UNSECURED, this.currentState);
+
+          if (this.lockTimeout) {
+            clearTimeout(this.lockTimeout);
+          }
+          this.lockTimeout = setTimeout(() => {
+            this.targetState = Characteristic.LockTargetState.SECURED;
+            this.currentState = Characteristic.LockCurrentState.SECURED;
+            pushLockState(this.targetState, this.currentState);
+            this.unlocking = false;
+            this.log.info("Door re-secured");
+          }, this.config.dahua.unlockSeconds * 1000);
+        } catch (err) {
+          this.unlocking = false;
+          this.log.error(`Unlock failed: ${err.message}`);
+          this.targetState = Characteristic.LockTargetState.SECURED;
+          this.currentState = Characteristic.LockCurrentState.SECURED;
+          pushLockState(this.targetState, this.currentState);
+        }
+      });
+  }
+
+  setMotion(active, reason = "") {
+    const { Service, Characteristic } = this.hap;
+    this.motionActive = Boolean(active);
+    const motionService = this.accessory.getService(Service.MotionSensor);
+    motionService?.updateCharacteristic(Characteristic.MotionDetected, this.motionActive);
+    this.log.info(`Motion=${this.motionActive}${reason ? ` (${reason})` : ""}`);
+    if (this.motionTimer) {
+      clearTimeout(this.motionTimer);
+      this.motionTimer = null;
+    }
+    if (this.motionActive) {
+      this.motionTimer = setTimeout(() => {
+        this.motionActive = false;
+        motionService?.updateCharacteristic(Characteristic.MotionDetected, false);
+        this.log.info("Motion auto-cleared");
+      }, this.config.hksv.motionTimeoutMs);
+    }
+  }
+
+  _wireEvents() {
+    this.dahua.on("motion", (active, event) => {
+      this.setMotion(active, event?.Code || "motion");
+    });
+
+    this.dahua.on("doorbell", (event) => {
+      this.log.info(`Doorbell ring (${event?.Code || "unknown"})`);
+      this.setMotion(true, "doorbell");
+      try {
+        this.controller.ringDoorbell();
+      } catch (err) {
+        this.log.warn(`ringDoorbell failed: ${err.message}`);
+      }
+    });
+  }
+
+  teardown() {
+    try {
+      this.dahua.stop();
+    } catch {
+      /* ignore */
+    }
+    if (this.motionTimer) {
+      clearTimeout(this.motionTimer);
+    }
+    if (this.lockTimeout) {
+      clearTimeout(this.lockTimeout);
+    }
+  }
+}
+
+module.exports = {
+  DahuaVtoAccessory,
+  normalizeDeviceConfig,
+};