homebridge-ratgdo 0.2.0 → 1.1.0

package/dist/ratgdo-device.js

@@ -1,13 +1,22 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ratgdoAccessory = void 0;
-const settings_js_1 = require("./settings.js");
-const ratgdo_options_js_1 = require("./ratgdo-options.js");
-const node_util_1 = __importDefault(require("node:util"));
-class ratgdoAccessory {
+import { RATGDO_MOTION_DURATION, RATGDO_OCCUPANCY_DURATION, RATGDO_TRANSITION_DURATION } from "./settings.js";
+import { RatgdoReservedNames } from "./ratgdo-types.js";
+import { getOptionFloat, getOptionNumber, getOptionValue, isOptionEnabled } from "./ratgdo-options.js";
+import util from "node:util";
+export class RatgdoAccessory {
+    accessory;
+    api;
+    config;
+    device;
+    doorOccupancyTimer;
+    doorTimer;
+    hap;
+    hints;
+    log;
+    motionOccupancyTimer;
+    motionTimer;
+    obstructionTimer;
+    platform;
+    status;
     // The constructor initializes key variables and calls configureDevice().
     constructor(platform, accessory, device) {
         this.accessory = accessory;
@@ -20,10 +29,10 @@ class ratgdoAccessory {
         this.device = device;
         this.platform = platform;
         this.log = {
-            debug: (message, ...parameters) => platform.debug(node_util_1.default.format(this.name + ": " + message, ...parameters)),
-            error: (message, ...parameters) => platform.log.error(node_util_1.default.format(this.name + ": " + message, ...parameters)),
-            info: (message, ...parameters) => platform.log.info(node_util_1.default.format(this.name + ": " + message, ...parameters)),
-            warn: (message, ...parameters) => platform.log.warn(node_util_1.default.format(this.name + ": " + message, ...parameters))
+            debug: (message, ...parameters) => platform.debug(util.format(this.name + ": " + message, ...parameters)),
+            error: (message, ...parameters) => platform.log.error(util.format(this.name + ": " + message, ...parameters)),
+            info: (message, ...parameters) => platform.log.info(util.format(this.name + ": " + message, ...parameters)),
+            warn: (message, ...parameters) => platform.log.warn(util.format(this.name + ": " + message, ...parameters))
         };
         // Initialize our internal state.
         this.status.availability = false;
@@ -32,9 +41,10 @@ class ratgdoAccessory {
         this.status.lock = this.hap.Characteristic.LockCurrentState.UNSECURED;
         this.status.motion = false;
         this.status.obstruction = false;
+        this.doorOccupancyTimer = null;
+        this.motionOccupancyTimer = null;
         this.motionTimer = null;
         this.obstructionTimer = null;
-        this.occupancyTimer = null;
         this.configureDevice();
     }
     // Configure a garage door accessory for HomeKit.
@@ -45,40 +55,108 @@ class ratgdoAccessory {
         this.configureHints();
         this.configureInfo();
         this.configureGarageDoor();
+        this.configureMqtt();
+        this.configureAutomationSwitch();
+        this.configureDoorOpenOccupancySensor();
         this.configureLight();
         this.configureMotionSensor();
-        // this.configureSwitch();
-        // this.configureOccupancySensor();
+        this.configureMotionOccupancySensor();
     }
     // Configure device-specific settings.
     configureHints() {
         this.hints.automationSwitch = this.hasFeature("Opener.Switch");
-        this.hints.occupancySensor = this.hasFeature("Opener.OccupancySensor");
-        // this.hints.occupancyDuration = this.getFeatureNumber("Opener.OccupancySensor.Duration") ?? RATGDO_OCCUPANCY_DURATION;
+        this.hints.doorOpenOccupancySensor = this.hasFeature("Opener.OccupancySensor");
+        this.hints.doorOpenOccupancyDuration = this.getFeatureNumber("Opener.OccupancySensor.Duration") ?? RATGDO_OCCUPANCY_DURATION;
+        this.hints.light = this.hasFeature("Light");
+        this.hints.motionOccupancySensor = this.hasFeature("Motion.OccupancySensor");
+        this.hints.motionOccupancyDuration = this.getFeatureNumber("Motion.OccupancySensor.Duration") ?? RATGDO_OCCUPANCY_DURATION;
+        this.hints.motionSensor = this.hasFeature("Motion");
         this.hints.readOnly = this.hasFeature("Opener.ReadOnly");
-        this.hints.syncNames = this.hasFeature("Device.SyncNames");
+        this.hints.syncName = this.hasFeature("Device.SyncName");
+        if (this.hints.readOnly) {
+            this.log.info("Garage door opener is read-only. The opener will not respond to open and close requests from HomeKit.");
+        }
+        if (this.hints.syncName) {
+            this.log.info("Syncing Ratgdo device name to HomeKit.");
+        }
         return true;
     }
     // Configure the device information for HomeKit.
     configureInfo() {
-        var _a, _b, _c, _d;
         // Update the manufacturer information for this device.
-        (_a = this.accessory.getService(this.hap.Service.AccessoryInformation)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(this.hap.Characteristic.Manufacturer, "Liftmaster");
+        this.accessory.getService(this.hap.Service.AccessoryInformation)?.updateCharacteristic(this.hap.Characteristic.Manufacturer, "github.com/hjdhjd");
         // Update the model information for this device.
-        (_b = this.accessory.getService(this.hap.Service.AccessoryInformation)) === null || _b === void 0 ? void 0 : _b.updateCharacteristic(this.hap.Characteristic.Model, "Ratgdo");
+        this.accessory.getService(this.hap.Service.AccessoryInformation)?.updateCharacteristic(this.hap.Characteristic.Model, "Ratgdo");
         // Update the serial number for this device.
-        (_c = this.accessory.getService(this.hap.Service.AccessoryInformation)) === null || _c === void 0 ? void 0 : _c.updateCharacteristic(this.hap.Characteristic.SerialNumber, this.device.mac.replace(/:/g, ""));
+        this.accessory.getService(this.hap.Service.AccessoryInformation)?.updateCharacteristic(this.hap.Characteristic.SerialNumber, this.device.mac);
         // Update the firmware information for this device.
-        (_d = this.accessory.getService(this.hap.Service.AccessoryInformation)) === null || _d === void 0 ? void 0 : _d.updateCharacteristic(this.hap.Characteristic.FirmwareRevision, this.device.firmwareVersion);
+        this.accessory.getService(this.hap.Service.AccessoryInformation)?.updateCharacteristic(this.hap.Characteristic.FirmwareRevision, this.device.firmwareVersion);
+        return true;
+    }
+    // Configure MQTT services.
+    configureMqtt() {
+        // Return our garage door state.
+        this.platform.mqtt?.subscribeGet(this, "garagedoor", "Garage Door", () => {
+            // Return our current status using our HomeKit current state decoder ring.
+            return this.translateCurrentDoorState(this.status.door);
+        });
+        // Set our garage door state.
+        this.platform.mqtt?.subscribeSet(this, "garagedoor", "Garage Door", (value) => {
+            let command;
+            switch (value) {
+                case "close":
+                    command = this.hap.Characteristic.TargetDoorState.CLOSED;
+                    break;
+                case "open":
+                    command = this.hap.Characteristic.TargetDoorState.OPEN;
+                    break;
+                default:
+                    this.log.error("Invalid command.");
+                    return;
+                    break;
+            }
+            // Set our door state accordingly.
+            this.setDoorState(command);
+        });
+        // Return our obstruction state.
+        this.platform.mqtt?.subscribeGet(this, "obstruction", "Obstruction", () => {
+            return this.status.obstruction.toString();
+        });
+        // Return our door open occupancy state if configured to do so.
+        if (this.hints.doorOpenOccupancySensor) {
+            this.platform.mqtt?.subscribeGet(this, "dooropenoccupancy", "Door Open Indicator Occupancy", () => {
+                return (this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_DOOR_OPEN)
+                    ?.getCharacteristic(this.hap.Characteristic.OccupancyDetected).value ?? "false").toString();
+            });
+        }
+        // Return our light state if configured to do so.
+        if (this.hints.light) {
+            this.platform.mqtt?.subscribeGet(this, "light", "Light", () => {
+                return this.status.light.toString();
+            });
+        }
+        // Return our motion occupancy state if configured to do so.
+        if (this.hints.motionOccupancySensor) {
+            this.platform.mqtt?.subscribeGet(this, "occupancy", "Occupancy", () => {
+                return (this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_MOTION)
+                    ?.getCharacteristic(this.hap.Characteristic.OccupancyDetected).value ?? "false").toString();
+            });
+        }
+        // Return our motion state if configured to do so.
+        if (this.hints.motionSensor) {
+            this.platform.mqtt?.subscribeGet(this, "motion", "Motion", () => {
+                return this.status.motion.toString();
+            });
+        }
         return true;
     }
     // Configure the garage door service for HomeKit.
     configureGarageDoor() {
-        var _a;
         let garageDoorService = this.accessory.getService(this.hap.Service.GarageDoorOpener);
         // Add the garage door opener service to the accessory, if needed.
         if (!garageDoorService) {
             garageDoorService = new this.hap.Service.GarageDoorOpener(this.name);
+            garageDoorService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
             this.accessory.addService(garageDoorService);
         }
         // Set the initial current and target door states to closed since ratgdo doesn't tell us initial state over MQTT on startup.
@@ -92,23 +170,30 @@ class ratgdoAccessory {
         garageDoorService.getCharacteristic(this.hap.Characteristic.CurrentDoorState).onGet(() => this.status.door);
         // Inform HomeKit of any obstructions.
         garageDoorService.getCharacteristic(this.hap.Characteristic.ObstructionDetected).onGet(() => this.status.obstruction === true);
-        // Add the lock garage door lock current and target state characteristics.
-        garageDoorService.addOptionalCharacteristic(this.hap.Characteristic.LockCurrentState);
-        garageDoorService.addOptionalCharacteristic(this.hap.Characteristic.LockTargetState);
+        // Configure the lock garage door lock current and target state characteristics.
         garageDoorService.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.status.lock);
         garageDoorService.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.lockTargetStateBias(this.status.lock));
-        // Add the configured name for this device.
-        garageDoorService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
-        // switchService.updateCharacteristic(this.hap.Characteristic.ConfiguredName, switchName);
         // Update our configured name, if requested.
-        if (this.hints.syncNames) {
-            garageDoorService.updateCharacteristic(this.hap.Characteristic.ConfiguredName, this.device.name);
-            if (this.hints.occupancySensor) {
-                (_a = this.accessory.getService(this.hap.Service.OccupancySensor)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(this.hap.Characteristic.ConfiguredName, this.device.name + " Open");
+        if (this.hints.syncName) {
+            this.setServiceName(garageDoorService, this.device.name);
+            if (this.hints.automationSwitch) {
+                this.setServiceName(this.accessory.getServiceById(this.hap.Service.Switch, RatgdoReservedNames.SWITCH_OPENER_AUTOMATION), this.device.name + " Automation Switch");
+            }
+            if (this.hints.doorOpenOccupancySensor) {
+                this.setServiceName(this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_DOOR_OPEN), this.device.name + " Open");
+            }
+            if (this.hints.light) {
+                this.setServiceName(this.accessory.getService(this.hap.Service.Lightbulb), this.device.name);
             }
+            if (this.hints.motionSensor) {
+                this.setServiceName(this.accessory.getService(this.hap.Service.MotionSensor), this.device.name);
+            }
+            if (this.hints.motionOccupancySensor) {
+                this.setServiceName(this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_MOTION), this.device.name);
+            }
+            // Finally, update the accessory name.
+            this.accessoryName = this.device.name;
         }
-        // Add our status active characteristic.
-        garageDoorService.addOptionalCharacteristic(this.hap.Characteristic.StatusActive);
         garageDoorService.getCharacteristic(this.hap.Characteristic.StatusActive).onGet(() => this.status.availability);
         garageDoorService.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
         // Let HomeKit know that this is the primary service on this accessory.
@@ -117,9 +202,16 @@ class ratgdoAccessory {
     }
     // Configure the light for HomeKit.
     configureLight() {
-        var _a, _b;
         // Find the service, if it exists.
         let lightService = this.accessory.getService(this.hap.Service.Lightbulb);
+        // Have we disabled the light?
+        if (!this.hints.light) {
+            if (lightService) {
+                this.accessory.removeService(lightService);
+                this.log.info("Disabling light.");
+            }
+            return false;
+        }
         // Add the service to the accessory, if needed.
         if (!lightService) {
             lightService = new this.hap.Service.Lightbulb(this.name);
@@ -127,24 +219,33 @@ class ratgdoAccessory {
                 this.log.error("Unable to add the light.");
                 return false;
             }
+            lightService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
+            lightService.updateCharacteristic(this.hap.Characteristic.Name, this.name);
+            this.setServiceName(lightService, this.name);
             this.accessory.addService(lightService);
             this.log.info("Enabling light.");
         }
+        // Initialize the light.
+        lightService.updateCharacteristic(this.hap.Characteristic.On, this.status.light);
         // Turn the light on or off.
-        (_a = lightService.getCharacteristic(this.hap.Characteristic.On)) === null || _a === void 0 ? void 0 : _a.onGet(() => this.status.light);
-        (_b = lightService.getCharacteristic(this.hap.Characteristic.On)) === null || _b === void 0 ? void 0 : _b.onSet((value) => {
+        lightService.getCharacteristic(this.hap.Characteristic.On)?.onGet(() => this.status.light);
+        lightService.getCharacteristic(this.hap.Characteristic.On)?.onSet((value) => {
             this.command("light", value === true ? "on" : "off");
         });
-        // Initialize the light.
-        lightService.displayName = this.name;
-        lightService.updateCharacteristic(this.hap.Characteristic.Name, this.name);
-        lightService.updateCharacteristic(this.hap.Characteristic.On, this.status.light);
         return true;
     }
     // Configure the motion sensor for HomeKit.
     configureMotionSensor() {
         // Find the motion sensor service, if it exists.
         let motionService = this.accessory.getService(this.hap.Service.MotionSensor);
+        // Have we disabled the motion sensor?
+        if (!this.hints.motionSensor) {
+            if (motionService) {
+                this.accessory.removeService(motionService);
+                this.log.info("Disabling motion sensor.");
+            }
+            return false;
+        }
         // We don't have a motion sensor, let's add it to the device.
         if (!motionService) {
             // We don't have it, add the motion sensor to the device.
@@ -153,43 +254,154 @@ class ratgdoAccessory {
                 this.log.error("Unable to add the motion sensor.");
                 return false;
             }
+            motionService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
+            motionService.updateCharacteristic(this.hap.Characteristic.Name, this.name);
+            this.setServiceName(motionService, this.name);
             this.accessory.addService(motionService);
             this.log.info("Enabling motion sensor.");
         }
         // Initialize the state of the motion sensor.
-        motionService.displayName = this.name;
-        motionService.updateCharacteristic(this.hap.Characteristic.Name, this.name);
         motionService.updateCharacteristic(this.hap.Characteristic.MotionDetected, false);
         motionService.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
         motionService.getCharacteristic(this.hap.Characteristic.StatusActive).onGet(() => this.status.availability);
         return true;
     }
+    // Configure a switch to automate open and close events in HomeKit beyond what HomeKit might allow for a garage opener service that gets treated as a secure service.
+    configureAutomationSwitch() {
+        // Find the switch service, if it exists.
+        let switchService = this.accessory.getServiceById(this.hap.Service.Switch, RatgdoReservedNames.SWITCH_OPENER_AUTOMATION);
+        // The switch is disabled by default and primarily exists for automation purposes.
+        if (!this.hints.automationSwitch) {
+            if (switchService) {
+                this.accessory.removeService(switchService);
+                this.log.info("Disabling automation switch.");
+            }
+            return false;
+        }
+        // Add the switch to the opener, if needed.
+        if (!switchService) {
+            switchService = new this.hap.Service.Switch(this.name + " Automation Switch", RatgdoReservedNames.SWITCH_OPENER_AUTOMATION);
+            if (!switchService) {
+                this.log.error("Unable to add automation switch.");
+                return false;
+            }
+            switchService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
+            this.setServiceName(switchService, this.name + " Automation Switch");
+            this.accessory.addService(switchService);
+        }
+        // Return the current state of the opener.
+        switchService.getCharacteristic(this.hap.Characteristic.On)?.onGet(() => {
+            // We're on if we are in any state other than closed (specifically open or stopped).
+            return this.doorCurrentStateBias(this.status.door) !== this.hap.Characteristic.CurrentDoorState.CLOSED;
+        });
+        // Open or close the opener.
+        switchService.getCharacteristic(this.hap.Characteristic.On)?.onSet((value) => {
+            // Inform the user.
+            this.log.info("Automation switch: %s.", value ? "open" : "close");
+            // Send the command.
+            if (!this.setDoorState(value ? this.hap.Characteristic.TargetDoorState.OPEN : this.hap.Characteristic.TargetDoorState.CLOSED)) {
+                // Something went wrong. Let's make sure we revert the switch to it's prior state.
+                setTimeout(() => {
+                    switchService?.updateCharacteristic(this.hap.Characteristic.On, !value);
+                }, 50);
+            }
+        });
+        // Initialize the switch.
+        switchService.updateCharacteristic(this.hap.Characteristic.On, this.doorCurrentStateBias(this.status.door) !== this.hap.Characteristic.CurrentDoorState.CLOSED);
+        this.log.info("Enabling automation switch.");
+        return true;
+    }
+    // Configure the door open occupancy sensor for HomeKit.
+    configureDoorOpenOccupancySensor() {
+        // Find the occupancy sensor service, if it exists.
+        let occupancyService = this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_DOOR_OPEN);
+        // The occupancy sensor is disabled by default and primarily exists for automation purposes.
+        if (!this.hints.doorOpenOccupancySensor) {
+            if (occupancyService) {
+                this.accessory.removeService(occupancyService);
+                this.log.info("Disabling door open indicator occupancy sensor.");
+            }
+            return false;
+        }
+        // We don't have an occupancy sensor, let's add it to the device.
+        if (!occupancyService) {
+            // We don't have it, add the occupancy sensor to the device.
+            occupancyService = new this.hap.Service.OccupancySensor(this.name + " Open", RatgdoReservedNames.OCCUPANCY_SENSOR_DOOR_OPEN);
+            if (!occupancyService) {
+                this.log.error("Unable to add door open occupancy sensor.");
+                return false;
+            }
+            occupancyService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
+            this.setServiceName(occupancyService, this.name + " Open");
+            this.accessory.addService(occupancyService);
+        }
+        // Initialize the state of the occupancy sensor.
+        occupancyService.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, false);
+        occupancyService.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+        occupancyService.getCharacteristic(this.hap.Characteristic.StatusActive).onGet(() => {
+            return this.status.availability;
+        });
+        this.log.info("Enabling door open indicator occupancy sensor. Occupancy will be triggered when the opener has been continuously open for more than %s seconds.", this.hints.doorOpenOccupancyDuration);
+        return true;
+    }
+    // Configure the motion occupancy sensor for HomeKit.
+    configureMotionOccupancySensor() {
+        // Find the occupancy sensor service, if it exists.
+        let occupancyService = this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_MOTION);
+        // The occupancy sensor is disabled by default and primarily exists for automation purposes.
+        if (!this.hints.motionOccupancySensor) {
+            if (occupancyService) {
+                this.accessory.removeService(occupancyService);
+                this.log.info("Disabling occupancy sensor.");
+            }
+            return false;
+        }
+        // We don't have an occupancy sensor, let's add it to the device.
+        if (!occupancyService) {
+            // We don't have it, add the occupancy sensor to the device.
+            occupancyService = new this.hap.Service.OccupancySensor(this.name, RatgdoReservedNames.OCCUPANCY_SENSOR_MOTION);
+            if (!occupancyService) {
+                this.log.error("Unable to add occupancy sensor.");
+                return false;
+            }
+            occupancyService.addOptionalCharacteristic(this.hap.Characteristic.ConfiguredName);
+            this.setServiceName(occupancyService, this.name);
+            this.accessory.addService(occupancyService);
+        }
+        // Initialize the state of the occupancy sensor.
+        occupancyService.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, false);
+        occupancyService.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+        occupancyService.getCharacteristic(this.hap.Characteristic.StatusActive).onGet(() => {
+            return this.status.availability;
+        });
+        this.log.info("Enabling occupancy sensor. Occupancy event duration set to %s seconds.", this.hints.motionOccupancyDuration);
+        return true;
+    }
     // Open or close the garage door.
     setDoorState(value) {
-        const actionExisting = this.status.door === this.hap.Characteristic.CurrentDoorState.OPENING ? "opening" : "closing";
         const actionAttempt = value === this.hap.Characteristic.TargetDoorState.CLOSED ? "close" : "open";
         // If this garage door is read-only, we won't process any requests to set state.
         if (this.hints.readOnly) {
             this.log.info("Unable to %s door. The door has been configured to be read only.", actionAttempt);
             // Tell HomeKit that we haven't in fact changed our state so we don't end up in an inadvertent opening or closing state.
             setImmediate(() => {
-                var _a;
-                (_a = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(this.hap.Characteristic.TargetDoorState, value === this.hap.Characteristic.TargetDoorState.CLOSED ? this.hap.Characteristic.TargetDoorState.OPEN : this.hap.Characteristic.TargetDoorState.CLOSED);
+                this.accessory.getService(this.hap.Service.GarageDoorOpener)?.updateCharacteristic(this.hap.Characteristic.TargetDoorState, value === this.hap.Characteristic.TargetDoorState.CLOSED ? this.hap.Characteristic.TargetDoorState.OPEN : this.hap.Characteristic.TargetDoorState.CLOSED);
             });
             return false;
         }
-        // If we are already opening or closing the garage door, we error out. As a precaution, we ensure we complete the current action before allowing a new one. This behavior may
-        // change in the future, but for now, we manage this edge case by eliminating the possibility of doing so.
+        // If we are already opening or closing the garage door, we assume the user wants to stop the garage door opener at it's current location.
         if ((this.status.door === this.hap.Characteristic.CurrentDoorState.OPENING) || (this.status.door === this.hap.Characteristic.CurrentDoorState.CLOSING)) {
-            this.log.error("Unable to %s door while currently attempting to complete %s. The existing action must be allowed to complete before attempting a new one.", actionAttempt, actionExisting);
-            return false;
+            this.log.debug("Stop requested from user while transitioning between open and close states.");
+            // Execute the stop command.
+            this.command("door", "stop");
+            return true;
         }
         // Close the garage door.
         if (value === this.hap.Characteristic.TargetDoorState.CLOSED) {
             // HomeKit is asking us to close the garage door, but let's make sure it's not already closed first.
             if (this.status.door !== this.hap.Characteristic.CurrentDoorState.CLOSED) {
                 // Execute the command.
-                this.command("door", "close", "closing");
+                this.command("door", "close");
             }
             return true;
         }
@@ -198,7 +410,7 @@ class ratgdoAccessory {
             // HomeKit is informing us to open the door, but we don't want to act if it's already open.
             if (this.status.door !== this.hap.Characteristic.CurrentDoorState.OPEN) {
                 // Execute the command.
-                this.command("door", "open", "opening");
+                this.command("door", "open");
             }
             return true;
         }
@@ -208,18 +420,31 @@ class ratgdoAccessory {
     }
     // Update the state of the accessory.
     updateState(event, payload) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const camelCase = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+        const doorOccupancyService = this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_DOOR_OPEN);
+        const garageDoorService = this.accessory.getService(this.hap.Service.GarageDoorOpener);
+        const lightBulbService = this.accessory.getService(this.hap.Service.Lightbulb);
+        const motionOccupancyService = this.accessory.getServiceById(this.hap.Service.OccupancySensor, RatgdoReservedNames.OCCUPANCY_SENSOR_MOTION);
+        const motionService = this.accessory.getService(this.hap.Service.MotionSensor);
+        const switchService = this.accessory.getServiceById(this.hap.Service.Switch, RatgdoReservedNames.SWITCH_OPENER_AUTOMATION);
+        // We continuously rebroadcast our device information.
+        this.configureInfo();
         switch (event) {
             case "availability":
                 this.status.availability = payload === "online";
                 // Update our availability.
-                (_a = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
-                (_b = this.accessory.getService(this.hap.Service.MotionSensor)) === null || _b === void 0 ? void 0 : _b.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+                garageDoorService?.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+                doorOccupancyService?.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+                motionOccupancyService?.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
+                motionService?.updateCharacteristic(this.hap.Characteristic.StatusActive, this.status.availability);
                 // Inform the user:
                 this.log.info("Device %s.", this.status.availability ? "connected" : "disconnected");
                 break;
             case "door":
+                // If we're already in the state we're updating to, we're done.
+                if (this.translateCurrentDoorState(this.status.door) === payload) {
+                    break;
+                }
                 // Clear out our door transition timer, if we have one.
                 if (this.doorTimer) {
                     clearTimeout(this.doorTimer);
@@ -231,28 +456,37 @@ class ratgdoAccessory {
                         break;
                     case "closing":
                         this.status.door = this.hap.Characteristic.CurrentDoorState.CLOSING;
-                        // As a safety measure for occasionally unreliable MQTT message delivery, let's ensure we generate a closed state after a reasonable transition period. If we receive
-                        // an actual state update before this, this safety measure won't be triggered.
+                        // As a safety measure for occasionally unreliable MQTT message delivery, let's ensure we generate a closed state after a reasonable transition period. If we
+                        // receive an actual state update before this, this safety measure won't be triggered.
                         this.doorTimer = setTimeout(() => {
                             // Mark the door as closed.
                             this.log.debug("Generating a close event to complete the state transition.");
                             this.updateState("door", "closed");
                             this.doorTimer = null;
-                        }, settings_js_1.RATGDO_TRANSITION_DURATION * 1000);
+                        }, RATGDO_TRANSITION_DURATION * 1000);
                         break;
                     case "open":
                         this.status.door = this.hap.Characteristic.CurrentDoorState.OPEN;
+                        // Trigger our occupancy timer, if configured to do so and we don't have one yet.
+                        if (this.hints.doorOpenOccupancySensor && !this.doorOccupancyTimer) {
+                            this.doorOccupancyTimer = setTimeout(() => {
+                                doorOccupancyService?.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, true);
+                                this.log.info("Garage door open occupancy detected.");
+                                // Publish to MQTT, if the user has configured it.
+                                this.platform.mqtt?.publish(this, "dooropenoccupancy", "true");
+                            }, this.hints.doorOpenOccupancyDuration * 1000);
+                        }
                         break;
                     case "opening":
                         this.status.door = this.hap.Characteristic.CurrentDoorState.OPENING;
-                        // As a safety measure for occasionally unreliable MQTT message delivery, let's ensure we generate an open state after a reasonable transition period. If we receive
-                        // an actual state update before this, this safety measure won't be triggered.
+                        // As a safety measure for occasionally unreliable MQTT message delivery, let's ensure we generate an open state after a reasonable transition period. If we
+                        // receive an actual state update before this, this safety measure won't be triggered.
                         this.doorTimer = setTimeout(() => {
                             // Mark the door as open.
                             this.log.debug("Generating an open event to complete the state transition.");
                             this.updateState("door", "open");
                             this.doorTimer = null;
-                        }, settings_js_1.RATGDO_TRANSITION_DURATION * 1000);
+                        }, RATGDO_TRANSITION_DURATION * 1000);
                         break;
                     case "stopped":
                         this.status.door = this.hap.Characteristic.CurrentDoorState.STOPPED;
@@ -264,26 +498,53 @@ class ratgdoAccessory {
                 // We are only going to update the target state if our current state is NOT stopped. If we are stopped, we are at the target state by definition. We also want to
                 // ensure we update TargetDoorState before updating CurrentDoorState in order to work around some notification quirks HomeKit occasionally has.
                 if (this.status.door !== this.hap.Characteristic.CurrentDoorState.STOPPED) {
-                    (_c = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _c === void 0 ? void 0 : _c.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.doorTargetStateBias(this.status.door));
+                    garageDoorService?.updateCharacteristic(this.hap.Characteristic.TargetDoorState, this.doorTargetStateBias(this.status.door));
                 }
-                (_d = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _d === void 0 ? void 0 : _d.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.status.door);
+                garageDoorService?.updateCharacteristic(this.hap.Characteristic.CurrentDoorState, this.status.door);
+                // Update our automation switch, if configured.
+                switchService?.updateCharacteristic(this.hap.Characteristic.On, this.doorTargetStateBias(this.status.door) === this.hap.Characteristic.TargetDoorState.OPEN);
                 // Inform the user:
                 this.log.info("%s.", camelCase(payload));
+                // If we have an open occupancy sensor configured and our door state is anything other than open, clear our occupancy state.
+                if (this.hints.doorOpenOccupancySensor && this.doorOccupancyTimer && (payload !== "open")) {
+                    clearTimeout(this.doorOccupancyTimer);
+                    this.doorOccupancyTimer = null;
+                    if (doorOccupancyService?.getCharacteristic(this.hap.Characteristic.OccupancyDetected).value) {
+                        doorOccupancyService?.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, false);
+                        this.log.info("Garage door open occupancy no longer detected.");
+                        // Publish to MQTT, if the user has configured it.
+                        this.platform.mqtt?.publish(this, "dooropenoccupancy", "false");
+                    }
+                }
+                // Publish to MQTT, if the user has configured it.
+                this.platform.mqtt?.publish(this, "garagedoor", payload);
                 break;
             case "light":
-                this.status.light = payload === "on";
-                (_e = this.accessory.getService(this.hap.Service.Lightbulb)) === null || _e === void 0 ? void 0 : _e.updateCharacteristic(this.hap.Characteristic.On, this.status.light);
-                // Inform the user:
-                this.log.info("Light %s.", payload);
+                // Only act if we're not already at the state we're updating to.
+                if (this.status.light !== (payload === "on")) {
+                    this.status.light = payload === "on";
+                    lightBulbService?.updateCharacteristic(this.hap.Characteristic.On, this.status.light);
+                    // Inform the user:
+                    this.log.info("Light %s.", payload);
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "light", this.status.light.toString());
+                }
                 break;
             case "lock":
-                // Determine our current and target lock states.
+                // If we're already in the state we're updating to, we're done.
+                if (this.status.lock === (payload === "locked" ? this.hap.Characteristic.LockCurrentState.SECURED : this.hap.Characteristic.LockCurrentState.UNSECURED)) {
+                    break;
+                }
+                // Determine our lock state.
                 this.status.lock = payload === "locked" ? this.hap.Characteristic.LockCurrentState.SECURED : this.hap.Characteristic.LockCurrentState.UNSECURED;
                 // Update our lock state.
-                (_f = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _f === void 0 ? void 0 : _f.updateCharacteristic(this.hap.Characteristic.LockTargetState, payload === "locked" ? this.hap.Characteristic.LockTargetState.SECURED : this.hap.Characteristic.LockTargetState.UNSECURED);
-                (_g = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _g === void 0 ? void 0 : _g.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.status.lock);
+                garageDoorService?.updateCharacteristic(this.hap.Characteristic.LockTargetState, payload === "locked" ?
+                    this.hap.Characteristic.LockTargetState.SECURED : this.hap.Characteristic.LockTargetState.UNSECURED);
+                garageDoorService?.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.status.lock);
                 // Inform the user:
                 this.log.info("%s.", camelCase(payload));
+                // Publish to MQTT, if the user has configured it.
+                this.platform.mqtt?.publish(this, "lock", this.status.lock.toString());
                 break;
             case "motion":
                 this.status.motion = payload === "detected";
@@ -294,30 +555,92 @@ class ratgdoAccessory {
                     break;
                 }
                 // Update the motion sensor state.
-                (_h = this.accessory.getService(this.hap.Service.MotionSensor)) === null || _h === void 0 ? void 0 : _h.updateCharacteristic(this.hap.Characteristic.MotionDetected, this.status.motion);
-                // If we already have an inflight motion sensor timer, clear it out since we're restarting the timer. Also, if it's our first time detecting motion for this event cycle,
-                // let the user know.
-                this.motionTimer ? clearTimeout(this.motionTimer) : this.log.info("Motion detected.");
+                motionService?.updateCharacteristic(this.hap.Characteristic.MotionDetected, this.status.motion);
+                // If we already have an inflight motion sensor timer, clear it out since we're restarting the timer. Also, if it's our first time detecting motion for this event
+                // cycle, let the user know.
+                if (this.motionTimer) {
+                    clearTimeout(this.motionTimer);
+                }
+                else {
+                    this.log.info("Motion detected.");
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "motion", this.status.motion.toString());
+                }
                 // Set a timer for the motion event.
                 this.motionTimer = setTimeout(() => {
-                    var _a;
                     this.status.motion = false;
-                    (_a = this.accessory.getService(this.hap.Service.MotionSensor)) === null || _a === void 0 ? void 0 : _a.updateCharacteristic(this.hap.Characteristic.MotionDetected, this.status.motion);
-                }, settings_js_1.RATGDO_MOTION_DURATION * 1000);
+                    motionService?.updateCharacteristic(this.hap.Characteristic.MotionDetected, this.status.motion);
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "motion", this.status.motion.toString());
+                }, RATGDO_MOTION_DURATION * 1000);
+                // Kill any inflight occupancy sensor.
+                if (this.motionOccupancyTimer) {
+                    clearTimeout(this.motionOccupancyTimer);
+                    this.motionOccupancyTimer = null;
+                }
+                // If the motion occupancy sensor isn't already triggered, let's do so now.
+                if (motionOccupancyService?.getCharacteristic(this.hap.Characteristic.OccupancyDetected).value !== true) {
+                    // Trigger the occupancy event in HomeKit.
+                    motionOccupancyService?.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, true);
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "occupancy", "true");
+                    // Log the event.
+                    this.log.info("Occupancy detected.");
+                }
+                // Reset our occupancy state after occupancyDuration.
+                this.motionOccupancyTimer = setTimeout(() => {
+                    // Reset the occupancy sensor.
+                    motionOccupancyService?.updateCharacteristic(this.hap.Characteristic.OccupancyDetected, false);
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "occupancy", "false");
+                    // Log the event.
+                    this.log.info("Occupancy no longer detected.");
+                    // Delete the timer.
+                    this.motionOccupancyTimer = null;
+                }, this.hints.motionOccupancyDuration * 1000);
                 break;
             case "obstruction":
-                this.status.obstruction = payload === "obstructed";
-                (_j = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _j === void 0 ? void 0 : _j.updateCharacteristic(this.hap.Characteristic.ObstructionDetected, this.status.obstruction);
-                this.log.info("Obstruction %sdetected.", this.status.obstruction ? "" : "no longer ");
+                garageDoorService?.updateCharacteristic(this.hap.Characteristic.ObstructionDetected, payload === "obstructed");
+                // Only act if we're not already at the state we're updating to.
+                if (this.status.obstruction !== (payload === "obstructed")) {
+                    this.status.obstruction = payload === "obstructed";
+                    this.log.info("Obstruction %sdetected.", this.status.obstruction ? "" : "no longer ");
+                    // Publish to MQTT, if the user has configured it.
+                    this.platform.mqtt?.publish(this, "obstruction", this.status.obstruction.toString());
+                }
                 break;
             case "default":
                 break;
         }
     }
+    // Utility function to translate HomeKit's current door state values into human-readable form.
+    translateCurrentDoorState(value) {
+        // HomeKit state decoder ring.
+        switch (value) {
+            case this.hap.Characteristic.CurrentDoorState.CLOSED:
+                return "closed";
+                break;
+            case this.hap.Characteristic.CurrentDoorState.CLOSING:
+                return "closing";
+                break;
+            case this.hap.Characteristic.CurrentDoorState.OPEN:
+                return "open";
+                break;
+            case this.hap.Characteristic.CurrentDoorState.OPENING:
+                return "opening";
+                break;
+            case this.hap.Characteristic.CurrentDoorState.STOPPED:
+                return "stopped";
+                break;
+            default:
+                break;
+        }
+        return "unknown";
+    }
     // Utility function to return our bias for what the current door state should be. This is primarily used for our initial bias on startup.
     doorCurrentStateBias(state) {
-        // Our current door state reflects our opinion on what open or closed means in HomeKit terms. For the obvious states, this is easy. For some of the edge cases, it can be
-        // less so. Our north star is that if we are in an obstructed state, we are open.
+        // Our current door state reflects our opinion on what open or closed means in HomeKit terms. For the obvious states, this is easy. For some of the edge cases, it can
+        // be less so. Our north star is that if we are in an obstructed state, we are open.
         if (this.status.obstruction) {
             return this.hap.Characteristic.CurrentDoorState.OPEN;
         }
@@ -338,9 +661,9 @@ class ratgdoAccessory {
     }
     // Utility function to return our bias for what the target door state should be.
     doorTargetStateBias(state) {
-        // We need to be careful with respect to the target state and we need to make some reasonable assumptions about where we intend to end up. If we are opening or closing, our
-        // target state needs to be the completion of those actions. If we're stopped or obstructed, we're going to assume the desired target state is to be open, since that is the
-        // typical opener behavior, and it's impossible for us to know with reasonable certainty what the original intention of the action was.
+        // We need to be careful with respect to the target state and we need to make some reasonable assumptions about where we intend to end up. If we are opening or
+        // closing, our target state needs to be the completion of those actions. If we're stopped or obstructed, we're going to assume the desired target state is to be
+        // open, since that is the typical opener behavior, and it's impossible for us to know with reasonable certainty what the original intention of the action was.
         if (this.status.obstruction) {
             return this.hap.Characteristic.TargetDoorState.OPEN;
         }
@@ -372,31 +695,52 @@ class ratgdoAccessory {
         }
     }
     // Utility function to transmit a command to Ratgdo.
-    command(topic, payload, updatePayload) {
-        this.platform.broker.publish({ cmd: "publish", dup: false, payload: payload, qos: 2, retain: false, topic: this.device.name + "/command/" + topic }, () => { });
-        // Update our internal state as well.
-        if (updatePayload) {
-            this.updateState(topic, updatePayload);
-        }
+    command(topic, payload) {
+        this.platform.broker.publish({ cmd: "publish", dup: false, payload: payload, qos: 2, retain: false, topic: this.device.name + "/command/" + topic }, (error) => {
+            if (error) {
+                this.log.error("Publish error:");
+                this.log.error(util.inspect(error), { colors: true, depth: null, sorted: true });
+            }
+        });
     }
     // Utility function to return a floating point configuration parameter on a device.
     getFeatureFloat(option) {
-        return (0, ratgdo_options_js_1.getOptionFloat)((0, ratgdo_options_js_1.getOptionValue)(this.platform.configOptions, this.device, option));
+        return getOptionFloat(getOptionValue(this.platform.configOptions, this.device, option));
     }
     // Utility function to return an integer configuration parameter on a device.
     getFeatureNumber(option) {
-        return (0, ratgdo_options_js_1.getOptionNumber)((0, ratgdo_options_js_1.getOptionValue)(this.platform.configOptions, this.device, option));
+        return getOptionNumber(getOptionValue(this.platform.configOptions, this.device, option));
     }
     // Utility for checking feature options on a device.
     hasFeature(option) {
-        return (0, ratgdo_options_js_1.isOptionEnabled)(this.platform.configOptions, this.device, option, this.platform.featureOptionDefault(option));
+        return isOptionEnabled(this.platform.configOptions, this.device, option, this.platform.featureOptionDefault(option));
+    }
+    // Utility function to set the name of a service.
+    setServiceName(service, name) {
+        if (!service) {
+            return;
+        }
+        service.displayName = name;
+        service.updateCharacteristic(this.hap.Characteristic.ConfiguredName, name);
     }
-    // Name utility function.
+    // Utility function to return the name of this device.
     get name() {
-        var _a;
-        const configuredName = (_a = this.accessory.getService(this.hap.Service.GarageDoorOpener)) === null || _a === void 0 ? void 0 : _a.getCharacteristic(this.hap.Characteristic.ConfiguredName).value;
-        return (configuredName === null || configuredName === void 0 ? void 0 : configuredName.length) ? configuredName : this.device.name;
+        // We use the garage door service as the natural proxy for the name.
+        const configuredName = this.accessory.getService(this.hap.Service.GarageDoorOpener)?.getCharacteristic(this.hap.Characteristic.ConfiguredName).value;
+        // If we don't have a name for the garage door service, return the device name from Ratgdo.
+        return configuredName?.length ? configuredName : this.device.name;
+    }
+    // Utility function to return the current accessory name of this device.
+    get accessoryName() {
+        return this.accessory.getService(this.hap.Service.AccessoryInformation)?.getCharacteristic(this.hap.Characteristic.Name).value ?? this.device.name;
+    }
+    // Utility function to set the current accessory name of this device.
+    set accessoryName(name) {
+        // Set all the internally managed names within Homebridge to the new accessory name.
+        this.accessory.displayName = name;
+        this.accessory._associatedHAPAccessory.displayName = name;
+        // Set all the HomeKit-visible names.
+        this.accessory.getService(this.hap.Service.AccessoryInformation)?.updateCharacteristic(this.hap.Characteristic.Name, name);
     }
 }
-exports.ratgdoAccessory = ratgdoAccessory;
 //# sourceMappingURL=ratgdo-device.js.map