homebridge-ecobee-security 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.0.1
+
+- **Comfort Setting** is now one TV-style tile with an input per comfort setting, instead of a switch per
+  setting. Picking an input holds that setting, switching the tile off goes back to your schedule, and the
+  tile shows the scheduled setting while off. It is its own HomeKit accessory, added to the Home app with
+  the bridge's setup code, with a streaming-device icon; settings can be hidden in the Home app's input list
+  (remembered) and follow ecobee's order. Breaking: the old switches are removed, so automations built on them need
+  rebuilding with the tile (Home app scenes can set the input).
+- README: new Automation ideas section, and updated header and devices images.
+
 ## 1.0.0
 
 - New setting **Quick Responses** (`quickResponses`, `quickResponseMessages`) in the Doorbell camera card:

package/README.md

@@ -54,6 +54,7 @@ GraphQL at `federated-api.prod.federated-graph.generacapis.com`), which ecobee c
 - [Home Occupied switch](#home-occupied-switch)
 - [Vacation Mode switch](#vacation-mode-switch)
 - [Smoke alarm and air quality](#smoke-alarm-and-air-quality)
+- [Automation ideas](#automation-ideas)
 - [Troubleshooting](#troubleshooting)
 - [API notes](#api-notes)
 - [License](#license)
@@ -171,7 +172,7 @@ Sign-in: see [Sign-in](#sign-in).
 | `vacationSwitch` | `false` | Adds a **Vacation Mode** switch that is on while an ecobee vacation is running (see [Vacation Mode switch](#vacation-mode-switch)). |
 | `vacationWhenEmpty` | `false` | Starts a vacation when Home Occupied has been off for `vacationEmptyHours` (default 24; see [Vacations that follow Home Occupied](#vacations-that-follow-home-occupied)). |
 | `vacationEndOnArrival` | `false` | Ends running vacations when Home Occupied turns on. |
-| `comfortSetting` | `false` | Adds a **Comfort Setting** accessory with a switch per ecobee comfort setting (see [Comfort Setting](#comfort-setting)). |
+| `comfortSetting` | `false` | Adds a **Comfort Setting** accessory, a TV-style tile with an input per ecobee comfort setting (see [Comfort Setting](#comfort-setting)). |
 | `comfortHoldType` | `"nextTransition"` | How long a comfort setting turned on is held: `"nextTransition"` or `"indefinite"`. |
 | `smokeSensor` | `true` | Adds a separate **Smoke Alarm** accessory (a Smoke Sensor) that detects smoke while ecobee has a smoke-alarm incident open, for automations and Home app smoke notifications. Set to `false` to remove it. |
 | `airQuality` | `true` | For each thermostat with an air quality sensor: an accessory "<thermostat> Air Quality" with an **Air Quality Sensor** (overall level; VOC as ecobee reports it, in ppb, which the Home app labels µg/m³) and a **Carbon Dioxide Sensor** (ppm). Read every 5 minutes. The level follows the ecobee app's Clean–Poor bar: its first two segments are Excellent, then Good, Fair, Inferior, Poor; Unknown while the sensor calibrates. |
@@ -559,30 +560,48 @@ they forget, the Home app's security notification shows the disarm, and you can
 
 ## Comfort Setting
 
-Turn on **Add Comfort Setting switches** (`comfortSetting`) and the plugin adds one accessory,
-**Comfort Setting**, with a switch for each of your ecobee comfort settings (Home, Away, Sleep and your own,
-read from the thermostats' program; with several thermostats, a setting any of them has). It is for
-automations such as "Home Occupied off → Away on".
-
-- Turning a switch **on** holds that comfort setting on the thermostats that have it, and the others
-  turn off. How long: `comfortHoldType`, `"nextTransition"` (default, until the next scheduled change)
-  or `"indefinite"` (until you change it).
-- Turning the active switch **off** goes back to your schedule, so all off means following the schedule.
-- A hold set in the ecobee app or on the thermostat lights the matching switch (read every minute). A
-  temperature-only hold lights none.
-- During an ecobee vacation all switches are off and changes are refused (the log says so).
-- Like the other sensors, the switches show No Response while ecobee can't be reached. Restart the
-  bridge after changing the setting.
-
-> [!NOTE]
-> The Home app shows the switches as one tile, and tapping the tile toggles all of them. Open the tile
-> and pick one, or use **Show as Separate Tiles** in the accessory's settings.
+Turn on **Add Comfort Setting** (`comfortSetting`) and the plugin adds one accessory, **Comfort Setting**: a
+single tile in the Home app (a HomeKit television) with an input for each of your ecobee comfort settings
+(Home, Away, Sleep and your own, read from the thermostats' program; with several thermostats, a setting
+any of them has).
+
+- Picking a setting **holds** it on the thermostats that have it. How long: `comfortHoldType`,
+  `"nextTransition"` (default, until the next scheduled change) or `"indefinite"` (until you change it).
+- Switching the tile **off** goes back to your schedule. The tile is on while a comfort hold runs; while
+  the thermostats follow their schedule it is off and shows the setting the schedule is on now.
+  Switching it on holds the setting it shows.
+- A hold set in the ecobee app or on the thermostat shows on the tile (read every minute). A
+  temperature-only hold counts as following the schedule.
+- During an ecobee vacation the tile is off and changes are refused (the log says so).
+- Like the other sensors, the tile shows No Response while ecobee can't be reached.
+- HomeKit allows one television per bridge, so the tile is its own accessory: add it to the Home app
+  with the bridge's setup code (the log says so when it is published, once ecobee has been read).
+  Restart the bridge after changing the setting.
+- Home app scenes and automations can pick a comfort setting: add the tile and choose the setting
+  as its input.
+- The Home app can't start an automation when the comfort setting changes (TV tiles aren't offered as
+  triggers).
+- The tile appears with a streaming-device icon. In the Home app's
+  input list you can hide settings you don't use (remembered); the order follows the ecobee app.
+- It replaces the one-switch-per-setting accessory of earlier versions, which is removed from the Home
+  app at the next restart; automations built on those switches have to be rebuilt with the tile.
 
 ## Smoke alarm and air quality
 
 - **Smoke Alarm** (`smokeSensor`, on by default) is its own accessory, a Smoke Sensor that detects smoke while ecobee has a smoke-alarm incident open. It is separate from the security tile (the Home app would otherwise merge it into the tile with a cloud icon).
 - **Air quality** (`airQuality`, on by default) adds, for each thermostat with an air quality sensor (ecobee Premium), an Air Quality Sensor and a Carbon Dioxide Sensor, read every 5 minutes; `co2Alert` sets the CO2 level (ppm) that reports abnormal levels. Details are in the settings table above. Temperature and humidity come from ecobee's own HomeKit integration.
 
+## Automation ideas
+
+A few Home app automations built on this plugin's accessories:
+
+| When | Do |
+|---|---|
+| **Vacation Mode** turns on | Close the blinds |
+| **Doorbell** rings | Pause the Apple TV |
+| 6:00 AM every day, if someone is home | Set the **security system** to Off |
+| **Doorbell** detects motion, after sunset | Turn on the porch and entryway lights |
+
 ## Troubleshooting
 
 - **No Response** in the Home app: the security tile, Smoke Alarm and air quality sensors show it

package/config.schema.json

@@ -188,10 +188,10 @@
         }
       },
       "comfortSetting": {
-        "title": "Add Comfort Setting switches",
+        "title": "Add Comfort Setting",
         "type": "boolean",
         "default": false,
-        "description": "One switch per ecobee comfort setting (Home, Away, Sleep and your own). Turning one on holds it; turning it off goes back to your schedule. Restart the bridge after changing this."
+        "description": "One tile in the Home app with a picker for your ecobee comfort settings (Home, Away, Sleep and your own). Picking one holds it; switching the tile off goes back to your schedule. It is added to the Home app on its own with the bridge's setup code. Restart the bridge after changing this."
       },
       "comfortHoldType": {
         "title": "Comfort setting hold",

package/homebridge-ui/public/index.html

@@ -279,9 +279,9 @@
     <h6 class="mb-1">Comfort Setting</h6>
     <div class="form-check form-switch mb-1">
       <input class="form-check-input" type="checkbox" role="switch" id="s-comfortSetting" data-key="comfortSetting" data-type="bool" data-default="false">
-      <label class="form-check-label" for="s-comfortSetting">Add Comfort Setting switches</label>
+      <label class="form-check-label" for="s-comfortSetting">Add Comfort Setting</label>
     </div>
-    <p class="hint mb-2">One switch per ecobee comfort setting (Home, Away, Sleep and your own). Turning one on holds it; turning it off goes back to your schedule. Restart the bridge after changing this.
+    <p class="hint mb-2">One tile with a picker for your ecobee comfort settings (Home, Away, Sleep and your own). Picking one holds it; switching the tile off goes back to your schedule. Added to the Home app on its own with the bridge's setup code, and it replaces the earlier switches (automations on them need rebuilding). Restart the bridge after changing this.
       <a href="https://github.com/seanfletchr/homebridge-ecobee-security#comfort-setting" target="_blank" rel="noopener">Learn more…</a></p>
     <div id="comfort-box" hidden>
       <label for="s-comfortHoldType" class="form-label mb-1">Hold</label>

package/lib/comfort.js

@@ -1,12 +1,34 @@
-// "Comfort Setting" accessory: one switch per ecobee comfort setting (climate: Home, Away, Sleep and
-// your own), on for the one that is held. Turning one on holds it, turning the active one off goes back
-// to the schedule. Mirrors holds set in the ecobee app or on the thermostat. Reading is driven from
-// outside: the platform's shared tick calls handle() with each read of the thermostats.
+// "Comfort Setting" accessory: one HomeKit Television tile with an input per ecobee comfort setting
+// (climate: Home, Away, Sleep and your own). Active is on while a comfort hold runs and off while the
+// thermostats follow their schedule; the selected input is the held setting, or the one the schedule is
+// on now. Picking an input holds it, switching the tile off goes back to the schedule. Holds set in the
+// ecobee app or on the thermostat show up too. HomeKit allows one television per bridge, so this is its
+// own accessory, published once after the first successful read (so the inputs exist when it is added).
+// Reading is driven from outside: the platform's shared tick calls handle() with each read of the thermostats.
 import { SignInRequiredError, vacationsOf } from './ecobee.js';
 
 const FAULT_AFTER = 3;
 const REVERT_DELAY = 1000;
 const CONFIRM_DELAY = 3000;
+const DEBOUNCE_DELAY = 300;
+
+// Fixed input identifiers for ecobee's built-in settings; others are hashed from the climateRef.
+const FIXED = { home: 1, away: 2, sleep: 3 };
+
+function wantedId(ref) {
+  if (ref in FIXED) {
+    return FIXED[ref];
+  }
+  const smart = /^smart(\d+)$/.exec(ref);
+  if (smart && Number(smart[1]) < 900) {
+    return 10 + Number(smart[1]);
+  }
+  let hash = 2166136261;
+  for (const ch of ref) {
+    hash = Math.imul(hash ^ ch.charCodeAt(0), 16777619) >>> 0;
+  }
+  return 1000 + (hash % 998999);
+}
 
 export class ComfortSetting {
   /**
@@ -16,52 +38,44 @@ export class ComfortSetting {
    * @param {import('./ecobee.js').EcobeeCloud} options.cloud
    * @param {string} options.homeId
    * @param {string} options.holdType nextTransition or indefinite
-   * @param {import('homebridge').PlatformAccessory | undefined} options.cached
    * @param {string} options.version
    * @param {() => boolean} options.cloudDown the security system can't reach ecobee
-   * @param {(uuid: string, name: string) => import('homebridge').PlatformAccessory} options.create
-   * @param {(accessories: import('homebridge').PlatformAccessory[]) => void} options.register
-   * @param {(accessories: import('homebridge').PlatformAccessory[]) => void} options.update
+   * @param {(accessories: import('homebridge').PlatformAccessory[]) => void} options.publish as its own HomeKit accessory
+   * @param {() => string[]} options.hidden climateRefs hidden in the Home app's input list
+   * @param {(refs: string[]) => void} options.setHidden
    * @param {number} [options.confirmDelay]
+   * @param {number} [options.debounceDelay]
    */
-  constructor({ api, log, cloud, homeId, holdType, cached, version, cloudDown, create, register, update, confirmDelay = CONFIRM_DELAY }) {
-    Object.assign(this, { api, log, cloud, homeId, holdType, cached, version, cloudDown, create, register, update, confirmDelay });
+  constructor({ api, log, cloud, homeId, holdType, version, cloudDown, publish, hidden = () => [], setHidden = () => {},
+    confirmDelay = CONFIRM_DELAY, debounceDelay = DEBOUNCE_DELAY }) {
+    Object.assign(this, { api, log, cloud, homeId, holdType, version, cloudDown, publish, hidden, setHidden, confirmDelay, debounceDelay });
     this.C = api.hap.Characteristic;
-    this.switches = new Map();   // climateRef -> { service, name, ids }
-    this.active = undefined;     // climateRef of the running hold
+    this.climates = new Map();   // climateRef -> { name, ids } (the union over the thermostats)
+    this.inputs = new Map();     // climateRef -> { service, id, name }
+    this.ids = new Map();        // climateRef -> identifier, never reassigned while running
+    this.active = undefined;     // climateRef of the running hold, as last read
+    this.scheduled = undefined;  // climateRef the schedule is on now
+    this.requested = undefined;  // { want, seq }: the latest change sent and not yet confirmed
+    this.seq = 0;
+    this.confirms = 0;           // confirmations in progress; reads wait until they are done
+    this.queue = Promise.resolve();
     this.onVacation = false;
     this.failures = 0;
     this.unreachable = false;
     this.stopped = false;
     this.known = false;          // a first read has succeeded
-    this.confirming = false;     // a change is being confirmed; the switches keep what the user set
-    this.registered = false;
+    this.published = false;
+    this.pending = undefined;    // { active?, id? } written by HomeKit, acted on once it stops writing
     this.waits = new Set();
   }
 
-  start() {
-    const { Service } = this.api.hap;
-    const C = this.C;
-    const uuid = this.api.hap.uuid.generate(`ecobee-security:comfort:${this.homeId}`);
-    this.accessory = this.cached ?? this.create(uuid, 'Comfort Setting');
-    this.accessory.getService(Service.AccessoryInformation)
-      .setCharacteristic(C.Manufacturer, 'ecobee')
-      .setCharacteristic(C.Model, 'Comfort Setting')
-      .setCharacteristic(C.SerialNumber, `${this.homeId}-comfort`)
-      .setCharacteristic(C.FirmwareRevision, this.version);
-    // Switches restored by Homebridge answer No Response until the first read.
-    for (const service of this.accessory.services.filter(s => s.UUID === Service.Switch.UUID && s.subtype)) {
-      this.bind(service, service.subtype, service.displayName);
-    }
-    if (this.cached) {
-      this.registered = true;
-      this.update([this.accessory]);
-    }
-  }
+  start() {}
 
   stop() {
     this.stopped = true;
     clearTimeout(this.revertTimer);
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = undefined;
     for (const t of this.waits) {
       clearTimeout(t);
     }
@@ -86,51 +100,140 @@ export class ComfortSetting {
     });
   }
 
-  bind(service, ref, name) {
-    const { On } = this.C;
-    const entry = this.switches.get(ref) ?? { service, name, ids: [] };
-    entry.service = service;
-    entry.name = name;
-    entry.labelled = undefined;
-    this.switches.set(ref, entry);
-    service.getCharacteristic(On)
-      .onGet(() => {
-        if (this.isOut() || !this.known) {
-          throw this.noResponse();
-        }
-        return this.isOn(ref);
-      })
-      .onSet(value => this.set(ref, Boolean(value)));
-    return entry;
+  idFor(ref) {
+    let id = this.ids.get(ref);
+    if (id === undefined) {
+      const used = new Set(this.ids.values());
+      id = wantedId(ref);
+      while (used.has(id)) {
+        id += 1;
+      }
+      this.ids.set(ref, id);
+    }
+    return id;
   }
 
-  /** Name and ConfiguredName: with several switches of one type, the Home app labels them by ConfiguredName. */
-  label(entry, name) {
-    const { Name, ConfiguredName } = this.C;
-    entry.service.setCharacteristic(Name, name);
-    if (!entry.service.testCharacteristic(ConfiguredName)) {
-      entry.service.addOptionalCharacteristic(ConfiguredName);
+  refFor(id) {
+    for (const [ref, entry] of this.inputs) {
+      if (entry.id === id) {
+        return ref;
+      }
     }
-    entry.service.setCharacteristic(ConfiguredName, name);
-    entry.name = name;
-    entry.labelled = name;
+    return undefined;
   }
 
-  isOn(ref) {
-    return !this.onVacation && this.active === ref;
+  nameOf(ref) {
+    return ref === undefined ? 'the schedule' : (this.climates.get(ref)?.name ?? ref);
   }
 
-  /** Shows each switch: No Response while ecobee can't be reached, otherwise its state. */
-  show() {
-    const { On } = this.C;
-    for (const [ref, { service }] of this.switches) {
-      service.updateCharacteristic(On, this.isOut() || !this.known ? this.noResponse() : this.isOn(ref));
+  /** The held setting: the latest change not yet confirmed, otherwise what ecobee last said. */
+  heldRef() {
+    return this.requested ? this.requested.want : this.active;
+  }
+
+  holdRunning() {
+    return !this.onVacation && this.heldRef() !== undefined;
+  }
+
+  /** The input shown: the held setting, otherwise the one the schedule is on now. */
+  shownId() {
+    const ref = [this.heldRef(), this.scheduled].find(r => r && this.inputs.has(r)) ?? this.inputs.keys().next().value;
+    return ref === undefined ? 0 : this.inputs.get(ref).id;
+  }
+
+  /** Builds the accessory with its Television service the first time a read has climates. */
+  ensure() {
+    if (this.accessory) {
+      return;
     }
+    const { api, homeId, version, C } = this;
+    const { Service } = api.hap;
+    const uuid = api.hap.uuid.generate(`ecobee-security:comfort-tv:${homeId}`);
+    this.accessory = new api.platformAccessory('Comfort Setting', uuid, api.hap.Categories.TV_STREAMING_STICK);
+    this.accessory.getService(Service.AccessoryInformation)
+      .setCharacteristic(C.Manufacturer, 'ecobee')
+      .setCharacteristic(C.Model, 'Comfort Setting')
+      .setCharacteristic(C.SerialNumber, `${homeId}-comfort`)
+      .setCharacteristic(C.FirmwareRevision, version);
+    const tv = this.accessory.addService(new Service.Television('Comfort Setting'));
+    this.tv = tv;
+    tv.setCharacteristic(C.ConfiguredName, 'Comfort Setting');
+    tv.setCharacteristic(C.SleepDiscoveryMode, C.SleepDiscoveryMode.ALWAYS_DISCOVERABLE);
+    tv.getCharacteristic(C.RemoteKey).onSet(() => {});
+    tv.getCharacteristic(C.Active)
+      .onGet(() => this.read(() => (this.holdRunning() ? 1 : 0)))
+      .onSet(value => this.write({ active: value === C.Active.ACTIVE }));
+    tv.getCharacteristic(C.ActiveIdentifier)
+      .onGet(() => this.read(() => this.shownId()))
+      .onSet(value => this.write({ id: Number(value) }));
   }
 
-  /** Reads the thermostats: climates (the union), the running hold and a vacation. Logs a changed setting. */
-  apply(thermostats) {
+  read(value) {
+    if (this.isOut() || !this.known) {
+      throw this.noResponse();
+    }
+    return value();
+  }
+
+  /** Adds, removes and renames the inputs to match the climates. */
+  reconcile(climates) {
+    if (!climates.size && !this.accessory) {
+      return;
+    }
+    this.ensure();
     const { Service } = this.api.hap;
+    const C = this.C;
+    for (const [ref, entry] of this.inputs) {
+      if (!climates.has(ref)) {
+        this.tv.removeLinkedService(entry.service);
+        this.accessory.removeService(entry.service);
+        this.inputs.delete(ref);
+      }
+    }
+    for (const [ref, { name }] of climates) {
+      let entry = this.inputs.get(ref);
+      if (!entry) {
+        const service = new Service.InputSource(name, ref);
+        const id = this.idFor(ref);
+        const visibility = this.hidden().includes(ref) ? C.TargetVisibilityState.HIDDEN : C.TargetVisibilityState.SHOWN;
+        service
+          .setCharacteristic(C.Identifier, id)
+          .setCharacteristic(C.IsConfigured, C.IsConfigured.CONFIGURED)
+          .setCharacteristic(C.InputSourceType, C.InputSourceType.OTHER)
+          .setCharacteristic(C.CurrentVisibilityState, visibility)
+          .setCharacteristic(C.TargetVisibilityState, visibility);
+        // The Home app's show/hide toggle in the input list: follow it and remember it.
+        service.getCharacteristic(C.TargetVisibilityState).onSet(value => {
+          service.updateCharacteristic(C.CurrentVisibilityState, value);
+          const hidden = new Set(this.hidden());
+          hidden[value === C.TargetVisibilityState.HIDDEN ? 'add' : 'delete'](ref);
+          this.setHidden([...hidden]);
+        });
+        this.accessory.addService(service);
+        this.tv.addLinkedService(service);
+        entry = { service, id, name: undefined };
+        this.inputs.set(ref, entry);
+      }
+      // New, or renamed in the ecobee app.
+      if (entry.name !== name) {
+        entry.service.setCharacteristic(C.Name, name).setCharacteristic(C.ConfiguredName, name);
+        entry.name = name;
+      }
+    }
+    // The inputs in ecobee's order (the climates as the thermostats list them).
+    const order = Buffer.concat([...climates.keys()].flatMap((ref, i) => {
+      const id = Buffer.alloc(4);
+      id.writeUInt32LE(this.inputs.get(ref).id);
+      return [...(i ? [Buffer.from([0x00, 0x00])] : []), Buffer.from([0x01, 0x04]), id];
+    })).toString('base64');
+    if (this.order !== order) {
+      this.order = order;
+      this.tv.updateCharacteristic(C.DisplayOrder, order);
+    }
+  }
+
+  /** Reads the thermostats: climates (the union), the running hold, the scheduled climate and a vacation. Logs a changed setting. */
+  apply(thermostats) {
     const climates = new Map();
     for (const t of thermostats) {
       for (const c of t.program?.climates ?? []) {
@@ -142,30 +245,9 @@ export class ComfortSetting {
         climates.set(c.climateRef, entry);
       }
     }
-    let changed = false;
-    for (const [ref, entry] of this.switches) {
-      if (!climates.has(ref)) {
-        this.accessory.removeService(entry.service);
-        this.switches.delete(ref);
-        changed = true;
-      }
-    }
-    for (const [ref, { name, ids }] of climates) {
-      let entry = this.switches.get(ref);
-      if (!entry) {
-        const service = new Service.Switch(name, ref);
-        this.accessory.addService(service);
-        entry = this.bind(service, ref, name);
-        changed = true;
-      }
-      // New, restored from cache without a ConfiguredName, or renamed in the ecobee app.
-      if (entry.labelled !== name) {
-        this.label(entry, name);
-        changed = true;
-      }
-      entry.ids = ids;
-    }
-    // A temperature-only hold has no climate: all off, the same as following the schedule.
+    this.reconcile(climates);
+    this.climates = climates;
+    // A temperature-only hold has no climate: the same as following the schedule.
     let active;
     for (const t of thermostats) {
       const hold = (t.events ?? []).find(e => e.type === 'hold' && e.running && e.holdClimateRef);
@@ -174,6 +256,7 @@ export class ComfortSetting {
         break;
       }
     }
+    this.scheduled = thermostats.map(t => t.program?.currentClimateRef).find(ref => ref && climates.has(ref));
     const was = this.known ? this.active : undefined;
     const wasKnown = this.known;
     this.active = active;
@@ -181,20 +264,20 @@ export class ComfortSetting {
     this.known = true;
     if (wasKnown && active !== was) {
       this.log.info(active
-        ? `Comfort setting now: ${this.switches.get(active).name} (hold ${this.holdType === 'indefinite' ? 'until you change it' : 'until the next scheduled change'})`
+        ? `Comfort setting now: ${climates.get(active).name} (hold ${this.holdType === 'indefinite' ? 'until you change it' : 'until the next scheduled change'})`
         : 'Comfort setting now: following the schedule');
     }
-    if (!this.registered && this.switches.size) {
-      this.registered = true;
-      this.register([this.accessory]);
-    } else if (changed && this.registered) {
-      this.update([this.accessory]);
+    if (!this.published && this.inputs.size) {
+      this.published = true;
+      this.publish([this.accessory]);
+      this.log.info('"Comfort Setting" is published as its own HomeKit accessory. If it isn\'t in the Home app yet, '
+        + 'add it with the setup code shown above.');
     }
   }
 
   /** One shared read of the thermostats (or its error) from the platform's tick. */
   handle(thermostats, error) {
-    if (this.confirming) {
+    if (this.confirms > 0) {
       return;
     }
     if (error) {
@@ -216,65 +299,137 @@ export class ComfortSetting {
     this.show();
   }
 
-  /** Shows the switches as they really are shortly after HomeKit's own update has landed. */
+  /** The tile: No Response while ecobee can't be reached, otherwise its state (including a change not yet confirmed). */
+  show() {
+    if (!this.tv || !this.published || this.debounceTimer) {
+      return;   // not published yet, or HomeKit is still writing
+    }
+    const { Active, ActiveIdentifier } = this.C;
+    const out = this.isOut() || !this.known;
+    this.tv.updateCharacteristic(Active, out ? this.noResponse() : (this.holdRunning() ? 1 : 0));
+    this.tv.updateCharacteristic(ActiveIdentifier, out ? this.noResponse() : this.shownId());
+  }
+
+  /** Shows the state as it really is shortly after HomeKit's own update has landed. */
   revert() {
     clearTimeout(this.revertTimer);
     this.revertTimer = setTimeout(() => this.show(), REVERT_DELAY);
   }
 
-  /** After a change, re-reads (fresh) and shows the real state; warns when it isn't what was asked for. */
-  async confirm(want) {
-    this.confirming = true;
+  /** After a change, re-reads (fresh) and shows the real state; warns when it isn't what was asked for. Only the latest change is judged. */
+  async confirm(want, seq) {
+    this.confirms += 1;
     try {
       await this.wait(this.confirmDelay);
-      if (this.stopped) {
-        return;
+      if (this.stopped || this.requested?.seq !== seq) {
+        return;   // superseded by a newer change, which confirms for itself
       }
       try {
         this.apply(await this.cloud.getThermostats(this.homeId, 0));
       } catch (error) {
         this.log.debug(`Could not re-read the ecobee comfort setting (${error.message}).`);
       }
+      if (this.requested?.seq !== seq) {
+        return;
+      }
+      this.requested = undefined;
       if (this.active !== want) {
-        this.log.warn('ecobee did not apply the comfort setting; showing its real state.');
+        this.log.warn(`ecobee did not apply the comfort setting (asked for ${this.nameOf(want)}, ecobee has ${this.nameOf(this.active)}); showing its real state.`);
       }
     } finally {
-      this.confirming = false;
+      this.confirms -= 1;
+    }
+    if (this.confirms === 0) {
+      this.show();
     }
+  }
+
+  /** Holds a comfort setting (climateRef), or goes back to the schedule (undefined). Callers check() first. */
+  change(want) {
+    const seq = ++this.seq;
+    this.requested = { want, seq };
     this.show();
+    const run = this.queue.then(async () => {
+      try {
+        if (want) {
+          await this.cloud.setComfortHold(this.climates.get(want).ids, want, this.holdType);
+        } else {
+          await this.cloud.resumeProgram([...new Set([...this.climates.values()].flatMap(e => e.ids))]);
+        }
+      } catch (error) {
+        this.log.warn(`Could not change the ecobee comfort setting (${error.message}).`);
+        if (this.requested?.seq === seq) {
+          this.requested = undefined;
+        }
+        this.revert();
+        throw error;
+      }
+      this.confirm(want, seq);
+    });
+    this.queue = run.catch(() => {});
+    return run;
   }
 
-  async set(ref, on) {
-    const { On } = this.C;
+  /** Whether a change may go ahead: throws No Response while ecobee can't be reached, false (and says why) on vacation. */
+  check() {
     if (this.isOut()) {
       throw this.noResponse();
     }
     if (this.onVacation) {
       this.log.info('ecobee is on vacation; end the vacation to change the comfort setting.');
+      this.revert();
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * HomeKit writes Active and ActiveIdentifier separately (often both when an input is picked while the
+   * tile is off); the last values win and are acted on together once the writes stop.
+   */
+  write(part) {
+    this.log.debug(`Comfort Setting: HomeKit set ${Object.entries(part).map(([k, v]) => `${k === 'active' ? 'Active' : 'ActiveIdentifier'}=${typeof v === 'boolean' ? Number(v) : v}`).join(' ')}`);
+    if (this.isOut() || !this.known) {
+      throw this.noResponse();
+    }
+    this.pending = { ...this.pending, ...part };
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = undefined;
+      const intent = this.pending;
+      this.pending = undefined;
+      this.flush(intent).catch(error => this.log.debug(`Comfort setting change failed (${error.message}).`));
+    }, this.debounceDelay);
+  }
+
+  async flush({ active, id }) {
+    if (this.stopped) {
+      return;
+    }
+    if (this.isOut()) {
       this.revert();
       return;
     }
-    if (on === (this.active === ref)) {
+    if (!this.check()) {
       return;
     }
-    const entry = this.switches.get(ref);
-    try {
-      if (on) {
-        await this.cloud.setComfortHold(entry.ids, ref, this.holdType);
-      } else {
-        await this.cloud.resumeProgram([...new Set([...this.switches.values()].flatMap(e => e.ids))]);
+    // Picking an input means holding it; Active off wins and goes back to the schedule.
+    const on = active ?? (id !== undefined ? true : this.holdRunning());
+    const ref = on ? this.refFor(id === undefined ? this.shownId() : id) : undefined;
+    this.log.debug(`Comfort Setting: flush ${JSON.stringify({ active, id })} -> ${on ? `hold ${ref === undefined ? '(unknown input)' : this.nameOf(ref)}` : 'schedule'}`);
+    if (!on) {
+      if (this.heldRef() !== undefined) {
+        await this.change(undefined);
       }
-    } catch (error) {
-      this.log.warn(`Could not change the ecobee comfort setting (${error.message}).`);
+      return;
+    }
+    if (!ref) {
+      this.log.warn('That comfort setting is no longer in ecobee; showing its real state.');
       this.revert();
-      throw this.noResponse();
+      return;
     }
-    // The others go off at once; ecobee's own answer follows.
-    for (const [other, { service }] of this.switches) {
-      if (other !== ref || !on) {
-        service.updateCharacteristic(On, false);
-      }
+    if (this.heldRef() !== ref) {
+      await this.change(ref);
     }
-    this.confirm(on ? ref : undefined);
   }
 }

package/lib/platform.js

@@ -27,7 +27,6 @@ const AIR_QUALITY = 'airQuality';
 const SMOKE = 'smoke';
 const VACATION = 'vacation';
 const PRESENCE = 'presence';
-const COMFORT = 'comfort';
 const QUICK_RESPONSE = 'quickResponse';
 const MEMBERS_POLL = 30 * 1000;
 const ARM_NOW = 'armAwayNow';
@@ -173,15 +172,13 @@ export class EcobeeSecurityPlatform {
     const wantArmNow = this.config.allowHolds === true && this.config.armAwayNowSwitch === true;
     const occupancyUuid = this.api.hap.uuid.generate(`ecobee-security:occupancy:${home.id}`);
     const wantOccupancy = this.config.occupancySwitch === true;
-    const comfortUuid = this.api.hap.uuid.generate(`ecobee-security:comfort:${home.id}`);
-    const wantComfort = this.config.comfortSetting === true;
     // Member presence sensors stay for the members ticked in the settings (none while it's off).
     this.presenceIds = this.config.memberPresence === true && Array.isArray(this.config.presenceMembers)
       ? [...new Set(this.config.presenceMembers.filter(id => typeof id === 'string' && id))] : [];
     const presenceUuids = new Set(this.presenceIds.map(id => this.api.hap.uuid.generate(`ecobee-security:presence:${home.id}:${id}`)));
     const stale = this.cached.filter(a => a.UUID !== uuid && a.context.kind !== AIR_QUALITY && a.context.kind !== VACATION && a.context.kind !== HAP_BRIDGED
       && !(wantSmoke && a.UUID === smokeUuid) && !(wantArmNow && a.UUID === armNowUuid)
-      && !(wantOccupancy && a.UUID === occupancyUuid) && !(wantComfort && a.UUID === comfortUuid)
+      && !(wantOccupancy && a.UUID === occupancyUuid)
       && !(a.context.kind === PRESENCE && presenceUuids.has(a.UUID))
       // Quick Responses are reconciled with the messages once the doorbell camera has started (startCameras).
       && !(a.context.kind === QUICK_RESPONSE && this.config.quickResponses === true));
@@ -255,7 +252,7 @@ export class EcobeeSecurityPlatform {
     }
     this.startAirQuality(home.id);
     this.startVacation(home.id);
-    this.startComfort(home.id, comfortUuid);
+    this.startComfort(home.id);
     this.startThermostatTick(home.id);
     this.startMembers(home.id);
     this.startKeypad();
@@ -933,8 +930,8 @@ export class EcobeeSecurityPlatform {
     }
   }
 
-  /** The Comfort Setting accessory (a switch per ecobee comfort setting); failures here never affect the security system. */
-  startComfort(homeId, uuid) {
+  /** The Comfort Setting accessory (one TV-style tile with an input per ecobee comfort setting); failures here never affect the security system. */
+  startComfort(homeId) {
     if (this.comfort || this.config.comfortSetting !== true) {
       return;
     }
@@ -944,16 +941,14 @@ export class EcobeeSecurityPlatform {
       cloud: this.cloud,
       homeId,
       holdType: this.config.comfortHoldType === 'indefinite' ? 'indefinite' : 'nextTransition',
-      cached: this.cached.find(a => a.UUID === uuid),
       version: VERSION,
       cloudDown: () => this.system?.cloudDown === true,
-      create: (id, name) => {
-        const accessory = new this.api.platformAccessory(name, id);
-        accessory.context.kind = COMFORT;
-        return accessory;
+      publish: accessories => this.api.publishExternalAccessories(PLUGIN_NAME, accessories),
+      hidden: () => this.store.comfortHidden ?? [],
+      setHidden: refs => {
+        this.store.comfortHidden = refs;
+        this.save();
       },
-      register: accessories => this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, accessories),
-      update: accessories => this.api.updatePlatformAccessories(accessories),
     });
     this.comfort.start();
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-ecobee-security",
   "displayName": "ecobee Smart Security",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "ecobee Smart Security as a HomeKit security system: arm Stay / Away, disarm, alarm state (unofficial, ecobee cloud)",
   "type": "module",
   "main": "index.js",