@switchbot/homebridge-switchbot 2.11.1-beta.0 → 2.12.0

package/src/irdevice/light.ts

@@ -10,10 +10,16 @@ import { Devices, irDevicesConfig, irdevice } from '../settings';
  */
 export class Light {
   // Services
-  lightBulbService!: Service;
+  lightBulbService?: Service;
+  ProgrammableSwitchServiceOn?: Service;
+  ProgrammableSwitchServiceOff?: Service;
 
   // Characteristic Values
   On!: CharacteristicValue;
+  ProgrammableSwitchEventOn?: CharacteristicValue;
+  ProgrammableSwitchOutputStateOn?: CharacteristicValue;
+  ProgrammableSwitchEventOff?: CharacteristicValue;
+  ProgrammableSwitchOutputStateOff?: CharacteristicValue;
   FirmwareRevision!: CharacteristicValue;
 
   // Config
@@ -41,19 +47,74 @@ export class Light {
       .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId)
       .setCharacteristic(this.platform.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
 
-    // get the Light service if it exists, otherwise create a new Light service
-    // you can create multiple services for each accessory
-    const lightBulbService = `${accessory.displayName} ${device.remoteType}`;
-    (this.lightBulbService = accessory.getService(this.platform.Service.Lightbulb)
-      || accessory.addService(this.platform.Service.Lightbulb)), lightBulbService;
+    if (!device.irlight?.stateless) {
+      // get the Light service if it exists, otherwise create a new Light service
+      // you can create multiple services for each accessory
+      const lightBulbService = `${accessory.displayName} ${device.remoteType}`;
+      (this.lightBulbService = accessory.getService(this.platform.Service.Lightbulb)
+        || accessory.addService(this.platform.Service.Lightbulb)), lightBulbService;
 
-    this.lightBulbService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
-    if (!this.lightBulbService.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
-      this.lightBulbService.addCharacteristic(this.platform.Characteristic.ConfiguredName, accessory.displayName);
+
+      this.lightBulbService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+      if (!this.lightBulbService.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
+        this.lightBulbService.addCharacteristic(this.platform.Characteristic.ConfiguredName, accessory.displayName);
+      }
+
+      // handle on / off events using the On characteristic
+      this.lightBulbService.getCharacteristic(this.platform.Characteristic.On).onSet(this.OnSet.bind(this));
+    } else {
+
+      // create a new Stateful Programmable Switch service
+      const ProgrammableSwitchServiceOn = `${accessory.displayName} ${device.remoteType} On`;
+      (this.ProgrammableSwitchServiceOn = accessory.getService(this.platform.Service.StatefulProgrammableSwitch)
+        || accessory.addService(this.platform.Service.StatefulProgrammableSwitch)), ProgrammableSwitchServiceOn;
+
+
+      this.ProgrammableSwitchServiceOn.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} On`);
+      if (!this.ProgrammableSwitchServiceOn.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
+        this.ProgrammableSwitchServiceOn.addCharacteristic(this.platform.Characteristic.ConfiguredName, `${accessory.displayName} On`);
+      }
+
+      this.ProgrammableSwitchServiceOn.getCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent).setProps({
+        validValueRanges: [0, 0],
+        minValue: 0,
+        maxValue: 0,
+        validValues: [0],
+      })
+        .onGet(() => {
+          return this.ProgrammableSwitchEventOn!;
+        });
+
+      this.ProgrammableSwitchServiceOn.getCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState)
+        .onSet(this.ProgrammableSwitchOutputStateSetOn.bind(this));
+
+
+
+      // create a new Stateful Programmable Switch service
+      const ProgrammableSwitchServiceOff = `${accessory.displayName} ${device.remoteType} Off`;
+      (this.ProgrammableSwitchServiceOff = accessory.getService(this.platform.Service.StatefulProgrammableSwitch)
+        || accessory.addService(this.platform.Service.StatefulProgrammableSwitch)), ProgrammableSwitchServiceOff;
+
+
+      this.ProgrammableSwitchServiceOff.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Off`);
+      if (!this.ProgrammableSwitchServiceOff.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
+        this.ProgrammableSwitchServiceOff.addCharacteristic(this.platform.Characteristic.ConfiguredName, `${accessory.displayName} Off`);
+      }
+
+      this.ProgrammableSwitchServiceOff.getCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent).setProps({
+        validValueRanges: [0, 0],
+        minValue: 0,
+        maxValue: 0,
+        validValues: [0],
+      })
+        .onGet(() => {
+          return this.ProgrammableSwitchEventOff!;
+        });
+
+      this.ProgrammableSwitchServiceOff.getCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState)
+        .onSet(this.ProgrammableSwitchOutputStateSetOff.bind(this));
     }
 
-    // handle on / off events using the On characteristic
-    this.lightBulbService.getCharacteristic(this.platform.Characteristic.On).onSet(this.OnSet.bind(this));
   }
 
   async OnSet(value: CharacteristicValue): Promise<void> {
@@ -71,6 +132,36 @@ export class Light {
      */
   }
 
+  async ProgrammableSwitchOutputStateSetOn(value: CharacteristicValue): Promise<void> {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
+
+    this.ProgrammableSwitchOutputStateOn = value;
+    if (this.ProgrammableSwitchOutputStateOn === 1) {
+      this.On = true;
+      await this.pushLightOnChanges();
+    }
+    /**
+     * pushLightOnChanges and pushLightOffChanges above assume they are measuring the state of the accessory BEFORE
+     * they are updated, so we are only updating the accessory state after calling the above.
+     */
+  }
+
+  async ProgrammableSwitchOutputStateSetOff(value: CharacteristicValue): Promise<void> {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${value}`);
+
+    this.ProgrammableSwitchOutputStateOff = value;
+    if (this.ProgrammableSwitchOutputStateOff === 1) {
+      this.On = false;
+      await this.pushLightOffChanges();
+    }
+    /**
+     * pushLightOnChanges and pushLightOffChanges above assume they are measuring the state of the accessory BEFORE
+     * they are updated, so we are only updating the accessory state after calling the above.
+     */
+  }
+
+
+
   /**
    * Pushes the requested changes to the SwitchBot API
    * deviceType	commandType     Command	          command parameter	         Description
@@ -113,7 +204,7 @@ export class Light {
     }
   }
 
-  async pushLightBrightnessUpChanges(): Promise<void> {
+  /*async pushLightBrightnessUpChanges(): Promise<void> {
     const bodyChange = JSON.stringify({
       command: 'brightnessUp',
       parameter: 'default',
@@ -129,7 +220,7 @@ export class Light {
       commandType: 'command',
     });
     await this.pushChanges(bodyChange);
-  }
+  }*/
 
   async pushChanges(bodyChange: any): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushChanges`);
@@ -173,13 +264,38 @@ export class Light {
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
-    // On
-    if (this.On === undefined) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.On}`);
+    if (this.device.irlight?.stateless) {
+      // On
+      if (this.On === undefined) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} On: ${this.On}`);
+      } else {
+        this.accessory.context.On = this.On;
+        this.lightBulbService?.updateCharacteristic(this.platform.Characteristic.On, this.On);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+      }
     } else {
-      this.accessory.context.On = this.On;
-      this.lightBulbService?.updateCharacteristic(this.platform.Characteristic.On, this.On);
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+      // On Stateful Programmable Switch
+      if (this.ProgrammableSwitchOutputStateOn === undefined) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+          + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOutputStateOn}`);
+      } else {
+        this.accessory.context.ProgrammableSwitchOutputStateOn = this.ProgrammableSwitchOutputStateOn;
+        this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState,
+          this.ProgrammableSwitchOutputStateOn);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+          + ` ProgrammableSwitchOutputStateOn: ${this.ProgrammableSwitchOutputStateOn}`);
+      }
+      // Off Stateful Programmable Switch
+      if (this.ProgrammableSwitchOutputStateOff === undefined) {
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+          + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOutputStateOff}`);
+      } else {
+        this.accessory.context.ProgrammableSwitchOutputStateOff = this.ProgrammableSwitchOutputStateOff;
+        this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState,
+          this.ProgrammableSwitchOutputStateOff);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic`
+          + ` ProgrammableSwitchOutputStateOff: ${this.ProgrammableSwitchOutputStateOff}`);
+      }
     }
   }
 
@@ -270,7 +386,14 @@ export class Light {
   }
 
   async apiError(e: any): Promise<void> {
-    this.lightBulbService.updateCharacteristic(this.platform.Characteristic.On, e);
+    if (this.device.irlight?.stateless) {
+      this.lightBulbService?.updateCharacteristic(this.platform.Characteristic.On, e);
+    } else {
+      this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent, e);
+      this.ProgrammableSwitchServiceOn?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState, e);
+      this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchEvent, e);
+      this.ProgrammableSwitchServiceOff?.updateCharacteristic(this.platform.Characteristic.ProgrammableSwitchOutputState, e);
+    }
   }
 
   async context() {

package/src/settings.ts

@@ -179,7 +179,7 @@ export interface irDevicesConfig extends irdevice {
   irair?: irair;
   irpur?: Record<any, any>;
   ircam?: Record<any, any>;
-  irlight?: Record<any, any>;
+  irlight?: irlight;
   irvc?: Record<any, any>;
   irwh?: Record<any, any>;
   irtv?: Record<any, any>;
@@ -194,6 +194,10 @@ export type irfan = {
   set_min?: number; //set_min
 };
 
+export type irlight = {
+  stateless?: boolean;
+};
+
 export type irair = {
   hide_automode?: boolean;
   meterType?: string;

package/.github/npm-version-script.js

@@ -1,81 +0,0 @@
-#!/bin/env node
-
-/**
- * This scripts queries the npm registry to pull out the latest version for a given tag.
- */
-
-const fs = require("fs");
-const semver = require("semver");
-const child_process = require("child_process");
-const assert = require("assert");
-
-const BRANCH_VERSION_PATTERN = /^([A-Za-z]*)-(\d+.\d+.\d+)$/
-
-// Load the contents of the package.json file
-const packageJSON = JSON.parse(fs.readFileSync("package.json", "utf8"));
-
-let refArgument = process.argv[2];
-let tagArgument = process.argv[3] || "latest";
-
-if (refArgument == null) {
-  console.error("ref argument is missing");
-  console.error("Usage: npm-version-script.js <ref> [tag]");
-  process.exit(1);
-}
-
-/**
- * Queries the NPM registry for the latest version for the provided tag.
- * @param tag The tag to query for.
- * @returns {string} Returns the version.
- */
-function getTagVersionFromNpm(tag) {
-  try {
-    return child_process.execSync(`npm info ${packageJSON.name} version --tag="${tag}"`).toString("utf8").trim();
-  } catch (e) {
-    throw e;
-  }
-}
-
-function desiredTargetVersion(ref) {
-  // ref is a GitHub action ref string
-  if (ref.startsWith("refs/pull/")) {
-    throw Error("The version script was executed inside a PR!");
-  }
-
-  assert(ref.startsWith("refs/heads/"))
-  let branchName = ref.slice("refs/heads/".length);
-
-  let results = branchName.match(BRANCH_VERSION_PATTERN);
-  if (results != null) {
-    if (results[1] !== tagArgument) {
-      console.warn(`The base branch name (${results[1]}) differs from the tag name ${tagArgument}`);
-    }
-
-    return results[2];
-  }
-
-  // legacy mode were we use the `betaVersion` property in the package.json
-  if (branchName === "beta" && packageJSON.betaVersion) {
-    return packageJSON.betaVersion
-  }
-
-  throw new Error("Malformed branch name for ref: " + ref + ". Can't derive the base version. Use a branch name like: beta-x.x.x!");
-}
-
-// derive the base version from the branch ref
-const baseVersion = desiredTargetVersion(refArgument);
-
-// query the npm registry for the latest version of the provided tag name
-const latestReleasedVersion = getTagVersionFromNpm(tagArgument); // e.g. 0.7.0-beta.12
-const latestReleaseBase = semver.inc(latestReleasedVersion, "patch"); // will produce 0.7.0 (removing the preid, needed for the equality check below)
-
-let publishTag;
-if (semver.eq(baseVersion, latestReleaseBase)) { // check if we are releasing another version for the latest beta
-  publishTag = latestReleasedVersion; // set the current latest beta to be incremented
-} else {
-  publishTag = baseVersion; // start of with a new beta version
-}
-
-// save the package.json
-packageJSON.version = publishTag;
-fs.writeFileSync("package.json", JSON.stringify(packageJSON, null, 2));