Use onUpdate and onSet from base

Author: mpatfield

src/accessory/abstract/base.ts

@@ -84,7 +84,7 @@ export abstract class MQTTAccessory<C extends AccessoryConfig> {
     return this.config.info.name;
   }
 
-  protected getRawValue(property :keyof C, assert: boolean = true): string | undefined {
+  protected getRawValue(property: keyof C, assert: boolean = true): string | undefined {
 
     if (!property.toString().startsWith('value')) {
       throw new Error(`Trying to fetch value with unexpected property name '${property.toString()}'`);
@@ -122,17 +122,21 @@ export abstract class MQTTAccessory<C extends AccessoryConfig> {
     return assert(this.log, this.name, this.config, ...keys);
   }
 
-  protected async onUpdate(key: CharacteristicKey, value: PrimitiveTypes, logString: string) {
+  protected onUpdate(key: CharacteristicKey, value: CharacteristicValue, logString: string | undefined = undefined): boolean {
 
     if (value === this.get(key)) {
-      return;
+      return false;
     }
 
     this.set(key, value);
 
     this.accessoryService.updateCharacteristic(this.Characteristic[key], value);
 
-    this.logIfDesired(logString, value.toString());
+    if (logString) {
+      this.logIfDesired(logString, value.toString());
+    }
+
+    return true;
   }
 
   protected onSet(key: CharacteristicKey, value: CharacteristicValue, topic: keyof C, logString: string) {
@@ -141,9 +145,11 @@ export abstract class MQTTAccessory<C extends AccessoryConfig> {
       return;
     }
 
-    this.set(key, value);
+    if (value !== this.get(key)) {
+      this.logIfDesired(logString, value.toString());
+    }
 
-    this.logIfDesired(logString, value.toString());
+    this.set(key, value);
 
     this.accessoryService.updateCharacteristic(this.Characteristic[key], value);
 

src/accessory/abstract/statusActive.ts

@@ -4,17 +4,18 @@ import { MQTTAccessory } from './base.js';
 
 import { strings } from '../../i18n/i18n.js';
 
+import { CharacteristicKey } from '../../model/enums.js';
 import { CharacteristicType, StatusActiveConfig, ServiceType } from '../../model/types.js';
 
 import { Log } from '../../tools/log.js';
 
 export abstract class StatusActiveAccessory<C extends StatusActiveConfig = StatusActiveConfig> extends MQTTAccessory<C> {
 
-  private statusActive: CharacteristicValue = true;
-
   constructor(Service: ServiceType, Characteristic: CharacteristicType, accessory: PlatformAccessory, config: C, log: Log, className: string) {
     super(Service, Characteristic, accessory, config, log, className);
 
+    this.set(CharacteristicKey.StatusActive, true);
+
     this.accessoryService.getCharacteristic(Characteristic.StatusActive)
       .onGet(this.getStatusActive.bind(this));
   }
@@ -23,24 +24,21 @@ export abstract class StatusActiveAccessory<C extends StatusActiveConfig = Statu
     this.addTopicHandler('topicGetStatusActive', this.onStatusActiveUpdate.bind(this), false);
   }
 
+  private async getStatusActive(): Promise<CharacteristicValue> {
+    return this.get(CharacteristicKey.StatusActive);
+  }
+
   private async onStatusActiveUpdate(topic: string, value: PrimitiveTypes): Promise<void> {
 
     const statusActive = value === this.getPrimitiveValue('valueStatusActive');
-    if (statusActive === this.statusActive) {
+    if (!this.onUpdate(CharacteristicKey.StatusActive, statusActive)) {
       return;
     }
 
-    this.statusActive = statusActive;
-    this.accessoryService.updateCharacteristic(this.Characteristic.StatusActive, this.statusActive);
-
-    if (this.statusActive) {
+    if (statusActive) {
       this.logIfDesired(strings.accessory.statusActive);
     } else {
       this.log.warning(strings.accessory.statusInactive, this.name);
     }
   }
-
-  private async getStatusActive(): Promise<CharacteristicValue> {
-    return this.statusActive;
-  }
 }

src/accessory/lock.ts

@@ -4,27 +4,25 @@ import { StatusActiveAccessory } from './abstract/statusActive.js';
 
 import { strings } from '../i18n/i18n.js';
 
+import { CharacteristicKey } from '../model/enums.js';
 import { CharacteristicType, LockMechanismConfig, ServiceType } from '../model/types.js';
 
 import { Log } from '../tools/log.js';
 
 export class LockMechanismAccessory extends StatusActiveAccessory<LockMechanismConfig> {
 
-  private currentState: CharacteristicValue;
-  private targetState: CharacteristicValue;
-
   constructor(Service: ServiceType, Characteristic: CharacteristicType, accessory: PlatformAccessory, config: LockMechanismConfig, log: Log) {
     super(Service, Characteristic, accessory, config, log, LockMechanismAccessory.name);
 
-    this.currentState = this.Characteristic.LockCurrentState.UNKNOWN;
-    this.targetState = this.Characteristic.LockTargetState.SECURED;
+    this.set(CharacteristicKey.LockCurrentState, Characteristic.LockCurrentState.UNKNOWN);
+    this.set(CharacteristicKey.LockTargetState, Characteristic.LockTargetState.SECURED);
 
     this.accessoryService.getCharacteristic(this.Characteristic.LockCurrentState)
       .onGet(this.getCurrentState.bind(this));
 
     this.accessoryService.getCharacteristic(this.Characteristic.LockTargetState)
       .onGet(this.getTargetState.bind(this))
-      .onSet(this.setTargetState.bind(this));
+      .onSet(this.onSetTargetState.bind(this));
   }
 
   protected getAccessoryService(): Service {
@@ -38,79 +36,42 @@ export class LockMechanismAccessory extends StatusActiveAccessory<LockMechanismC
   }
 
   private async getCurrentState(): Promise<CharacteristicValue> {
-    return this.currentState;
+    return this.get(CharacteristicKey.LockCurrentState);
   }
 
   private async getTargetState(): Promise<CharacteristicValue> {
-    return this.targetState;
+    return this.get(CharacteristicKey.LockTargetState);
   }
 
   private async onCurrentStateUpdate(topic: string, value: PrimitiveTypes): Promise<void> {
 
     const current = this.currentStateFromValue(value);
-    if (current === this.currentState) {
+    this.onUpdate(CharacteristicKey.LockTargetState, current);
+
+    if (!this.onUpdate(CharacteristicKey.LockCurrentState, current)) {
       return;
     }
 
-    this.currentState = current;
-    this.accessoryService.updateCharacteristic(this.Characteristic.LockCurrentState, this.currentState);
-
-    this.targetState = this.currentState;
-    this.accessoryService.updateCharacteristic(this.Characteristic.LockTargetState, this.targetState);
-
-    if (this.currentState === this.Characteristic.LockCurrentState.JAMMED) {
-      this.log.error(this.stringForState(this.currentState), this.name);
+    if (current === this.Characteristic.LockCurrentState.JAMMED) {
+      this.log.error(this.stringForState(current), this.name);
     } else {
-      this.logIfDesired(this.stringForState(this.currentState));
+      this.logIfDesired(this.stringForState(current));
     }
   }
 
   private async onTargetStateUpdate(topic: string, value: PrimitiveTypes): Promise<void> {
-
     const target = this.targetStateFromValue(value);
-    if (target === this.targetState) {
-      return;
-    }
-
-    this.targetState = target;
-    this.accessoryService.updateCharacteristic(this.Characteristic.LockTargetState, this.targetState);
-
-    this.logIfDesired(this.stringForState(this.targetState, true));
+    this.onUpdate(CharacteristicKey.LockTargetState, target, this.stringForState(target, true));
   }
 
-  private async setTargetState(value: CharacteristicValue) {
-
-    if (!this.assert('topicSetTargetState')) {
-      return;
-    }
+  private async onSetTargetState(value: CharacteristicValue) {
 
     const target = this.valueFromTargetState(value);
     if (target === undefined) {
-      this.log.error(strings.lock.badTarget, this.name, value);
       return;
     }
 
-    if (this.targetState !== value) {
-      this.logIfDesired(this.stringForState(value, true));
-    }
-
-    this.targetState = value;
-
-    this.accessoryService.updateCharacteristic(this.Characteristic.LockTargetState, this.targetState);
-
-    this.publish(this.config.topicSetTargetState, target);
-  }
-
-  private valueFromTargetState(value: CharacteristicValue): PrimitiveTypes | undefined {
-
-    switch (value) {
-    case this.Characteristic.LockTargetState.SECURED:
-      return this.getPrimitiveValue('valueLockStateSecured');
-    case this.Characteristic.LockTargetState.UNSECURED:
-      return this.getPrimitiveValue('valueLockStateUnsecured');
-    default:
-      return undefined;
-    }
+    this.onSet(CharacteristicKey.LockTargetState, target, 'topicSetTargetState', this.stringForState(value, true));
   }
 
   private currentStateFromValue(value: PrimitiveTypes | undefined): CharacteristicValue {
@@ -146,6 +107,18 @@ export class LockMechanismAccessory extends StatusActiveAccessory<LockMechanismC
     }
   }
 
+  private valueFromTargetState(value: CharacteristicValue): PrimitiveTypes | undefined {
+    switch (value) {
+    case this.Characteristic.LockTargetState.SECURED:
+      return this.getPrimitiveValue('valueLockStateSecured');
+    case this.Characteristic.LockTargetState.UNSECURED:
+      return this.getPrimitiveValue('valueLockStateUnsecured');
+    default:
+      this.log.error(strings.lock.badTarget, this.name, value);
+      return undefined;
+    }
+  }
+
   private stringForState(state: CharacteristicValue, future: boolean = false): string {
     switch(state) {
     case this.Characteristic.LockCurrentState.SECURED:

src/accessory/onoff/onoff.ts

@@ -4,59 +4,42 @@ import { StatusActiveAccessory } from '../abstract/statusActive.js';
 
 import { strings } from '../../i18n/i18n.js';
 
+import { CharacteristicKey } from '../../model/enums.js';
 import { CharacteristicType, OnOffConfig, ServiceType } from '../../model/types.js';
 
 import { Log } from '../../tools/log.js';
 
 export abstract class OnOffAccessory<C extends OnOffConfig = OnOffConfig> extends StatusActiveAccessory<C> {
 
-  private on: CharacteristicValue = false;
-
   constructor(Service: ServiceType, Characteristic: CharacteristicType, accessory: PlatformAccessory, config: C, log: Log, className: string) {
     super(Service, Characteristic, accessory, config, log, className);
 
+    this.set(CharacteristicKey.On, false);
+
     this.accessoryService.getCharacteristic(Characteristic.On)
       .onGet(this.getOn.bind(this))
-      .onSet(this.setOn.bind(this));
+      .onSet(this.onSetOn.bind(this));
   }
 
   override addTopicHandlers(): void {
     super.addTopicHandlers();
     this.addTopicHandler('topicGetOn', this.onOnUpdate.bind(this));
   }
 
+  private async getOn(): Promise<CharacteristicValue> {
+    return this.get(CharacteristicKey.On);
+  }
 
   private async onOnUpdate(topic: string, value: PrimitiveTypes): Promise<void> {
     const on = value === this.getPrimitiveValue('valueOn');
-    if (on === this.on) {
-      return;
-    }
-
-    this.on = on;
-    this.accessoryService.updateCharacteristic(this.Characteristic.On, this.on);
-
-    this.logIfDesired(this.stringForState(this.on));
-  }
-
-  private async getOn(): Promise<CharacteristicValue> {
-    return this.on;
+    this.onUpdate(CharacteristicKey.On, on, this.stringForState(on));
   }
 
-  private async setOn(value: CharacteristicValue) {
-
-    if (!this.assert('topicSetOn')) {
-      return;
-    }
-
+  private async onSetOn(value: CharacteristicValue) {
     const on = value ? this.getRawValue('valueOn') : this.getRawValue('valueOff');
-
-    this.on = value;
-
-    this.logIfDesired(this.stringForState(this.on, true));
-
-    this.accessoryService.updateCharacteristic(this.Characteristic.On, this.on);
-
-    this.publish(this.config.topicSetOn, on);
+    if (on !== undefined) {
+      this.onSet(CharacteristicKey.On, on, 'topicSetOn', this.stringForState(on, true));
+    }
   }
 
   private stringForState(on: CharacteristicValue, future: boolean = false): string {

src/accessory/onoff/outlet.ts

@@ -4,21 +4,21 @@ import { OnOffAccessory } from './onoff.js';
 
 import { strings } from '../../i18n/i18n.js';
 
+import { CharacteristicKey } from '../../model/enums.js';
 import { CharacteristicType, OutletConfig, ServiceType } from '../../model/types.js';
 
 import { Log } from '../../tools/log.js';
 
 export class OutletAccessory extends OnOffAccessory<OutletConfig> {
 
-  private inUse: CharacteristicValue = false;
-
-
   constructor(Service: ServiceType, Characteristic: CharacteristicType, accessory: PlatformAccessory, config: OutletConfig, log: Log) {
     super(Service, Characteristic, accessory, config, log, OutletAccessory.name);
 
+    this.set(CharacteristicKey.OutletInUse, false);
+
     this.accessoryService.getCharacteristic(this.Characteristic.OutletInUse)
       .onGet(this.getInUse.bind(this))
-      .onSet(this.setInUse.bind(this));
+      .onSet(this.onSetInUse.bind(this));
   }
 
   protected getAccessoryService(): Service {
@@ -31,40 +31,22 @@ export class OutletAccessory extends OnOffAccessory<OutletConfig> {
   }
 
   private async getInUse(): Promise<CharacteristicValue> {
-    return this.inUse;
+    return this.get(CharacteristicKey.OutletInUse);
   }
 
   private async onInUseUpdate(topic: string, value: PrimitiveTypes): Promise<void> {
-
     const inUse = value === this.getPrimitiveValue('valueOutletInUse');
-    if (inUse === this.inUse) {
-      return;
-    }
-
-    this.inUse = inUse;
-    this.accessoryService.updateCharacteristic(this.Characteristic.OutletInUse, this.inUse);
-
-    this.logIfDesired(this.stringForInUse(this.inUse));
+    this.onUpdate(CharacteristicKey.OutletInUse, inUse, this.stringForInUse(inUse));
   }
 
-  private async setInUse(value: CharacteristicValue) {
-
-    if (!this.assert('topicSetOutletInUse')) {
-      return;
-    }
+  private async onSetInUse(value: CharacteristicValue) {
 
     const inUse = value ? this.getRawValue('valueOutletInUse') : this.getRawValue('valueOutletNotInUse');
     if (!inUse) {
       return;
     }
 
-    this.inUse = value;
-
-    this.logIfDesired(this.stringForInUse(this.inUse, true));
-
-    this.accessoryService.updateCharacteristic(this.Characteristic.OutletInUse, this.inUse);
-
-    this.publish(this.config.topicSetOutletInUse!, inUse!);
+    this.onSet(CharacteristicKey.OutletInUse, inUse,'topicSetOutletInUse', this.stringForInUse(inUse, true));
   }
 
   private stringForInUse(inUse: CharacteristicValue, future: boolean = false): string {