watsonb8/homebridge-harmony-control
1
1
Fork 0
Code Issues 2 Pull Requests Actions Projects Releases Wiki Activity

Update to use homebridge types

Browse Source
This commit is contained in:
watsonb8
2020-12-11 21:59:29 -05:00
parent c28de00928
commit 38ffdec2db
15 changed files with 1101 additions and 1509 deletions
Download Patch File Download Diff File Expand all files Collapse all files

556
src/Accessories/ControlUnit.ts
View File

@ -1,286 +1,286 @@
import * as Config from "../Models/Config"
import callbackify from '../Util/Callbackify';
import HarmonyDataProvider from '../DataProviders/HarmonyDataProvider';
import { API, Logging, AccessoryPlugin, PlatformAccessory } from "homebridge";
import { Characteristic, Service, Accessory, RemoteController } from "hap-nodejs";
import { PlatformAccessory, RemoteController, Service } from "homebridge";
import HarmonyDataProvider from "../DataProviders/HarmonyDataProvider";
import { IActivity } from "../Models/Config";
import { Platform } from "../platform";
import callbackify from "../Util/Callbackify";
/**
* Enum describing remote key presses from homebridge.
*/
export enum RemoteKey {
REWIND = 0,
FAST_FORWARD = 1,
NEXT_TRACK = 2,
PREVIOUS_TRACK = 3,
ARROW_UP = 4,
ARROW_DOWN = 5,
ARROW_LEFT = 6,
ARROW_RIGHT = 7,
SELECT = 8,
BACK = 9,
EXIT = 10,
PLAY_PAUSE = 11,
INFORMATION = 15,
REWIND = 0,
FAST_FORWARD = 1,
NEXT_TRACK = 2,
PREVIOUS_TRACK = 3,
ARROW_UP = 4,
ARROW_DOWN = 5,
ARROW_LEFT = 6,
ARROW_RIGHT = 7,
SELECT = 8,
BACK = 9,
EXIT = 10,
PLAY_PAUSE = 11,
INFORMATION = 15,
}
export interface IControlUnitProps {
dataProvider: HarmonyDataProvider,
displayName: string,
activities: Array<Config.IActivity>,
api: API,
log: Logging,
export class ControlUnit {
constructor(
private readonly _platform: Platform,
private readonly _accessory: PlatformAccessory,
private _dataProvider: HarmonyDataProvider,
private _activities: Array<IActivity>
) {
this._accessory
.getService(this._platform.Service.AccessoryInformation)!
.setCharacteristic(
this._platform.Characteristic.Manufacturer,
"Brandon Watson"
)
.setCharacteristic(
this._platform.Characteristic.Model,
"Matrix Output Television"
)
.setCharacteristic(
this._platform.Characteristic.SerialNumber,
"123-456-789"
);
const televisionUUID = this._platform.api.hap.uuid.generate(
`${this._accessory.displayName} Television`
);
//Init services
const televisionService =
this._accessory.getService(this._platform.Service.Television) ||
this._accessory.addService(
this._platform.Service.Television,
"Television",
televisionUUID
);
this.configureTvService(televisionService);
const televisionSpeakerUUID = this._platform.api.hap.uuid.generate(
`${this._accessory.displayName} Television Speaker`
);
const televisionSpeakerService =
this._accessory.getService(this._platform.Service.TelevisionSpeaker) ||
this._accessory.addService(
this._platform.Service.TelevisionSpeaker,
"Television Speaker",
televisionSpeakerUUID
);
this.configureTvSpeakerService(televisionService, televisionSpeakerService);
this.configureInputSourceService(televisionService);
}
/*************
*
* Tv Service
*
*************/
/**
* Configure television service
*/
private configureTvService(televisionService: Service): void {
televisionService.setCharacteristic(
this._platform.Characteristic.ConfiguredName,
this._accessory.displayName
);
//@ts-ignore
televisionService.setCharacteristic(
this._platform.Characteristic.SleepDiscoveryMode,
this._platform.Characteristic.SleepDiscoveryMode.ALWAYS_DISCOVERABLE
);
televisionService.setCharacteristic(
this._platform.Characteristic.ActiveIdentifier,
1
);
televisionService.setCharacteristic(
this._platform.Characteristic.Active,
false
);
//setup listeners
televisionService
.getCharacteristic(this._platform.Characteristic.Active)
//@ts-ignore
.on("set", callbackify(this.onSetAccessoryActive))
//@ts-ignore
.on("get", callbackify(this.onGetAccessoryActive));
//Set remote characteristics if is external
televisionService
.getCharacteristic(this._platform.Characteristic.RemoteKey)
//@ts-ignore
.on("set", callbackify(this.onSetRemoteKey));
televisionService
.getCharacteristic(this._platform.Characteristic.ActiveIdentifier)
//@ts-ignore
.on("set", callbackify(this.onSetActiveIdentifier))
//@ts-ignore
.on("get", callbackify(this.onGetActiveIdentifier));
}
/**
* Event handler for SET active characteristic
*/
private onSetAccessoryActive = async (value: any) => {
switch (value) {
case 0:
this._dataProvider.powerOff(this._accessory.displayName);
break;
//Turn on with first activity
case 1:
this._dataProvider.powerOn(
this._accessory.displayName,
this._activities[0]
);
break;
}
};
/**
* Event handler for GET active characteristic
*/
private onGetAccessoryActive = async () => {
//@ts-ignore
return this._dataProvider.getIsActive(this._accessory.displayName)
? this._platform.Characteristic.Active.ACTIVE
: this._platform.Characteristic.Active.INACTIVE;
};
/**
* Event handler for SET remote key
*/
private onSetRemoteKey = async (key: any) => {
this._dataProvider.sendKeyPress(this._accessory.displayName, key);
};
/**
* Event handler for SET active identifier characteristic
*/
private onSetActiveIdentifier = async (identifier: any) => {
this._dataProvider.startActivity(
this._accessory.displayName,
this._activities[identifier]
);
};
/**
* Event handler for GET active identifier characteristic
*/
private onGetActiveIdentifier = async () => {
let currentActivity: IActivity = this._dataProvider.getIsActive(
this._accessory.displayName
)!;
let identifier: number = 0;
if (currentActivity) {
identifier = this._activities.findIndex(
(e) => e.DisplayName === currentActivity.DisplayName
);
}
return identifier;
};
/******************
*
* Speaker Service
*
*****************/
/**
* Configure Speaker Service
*/
private configureTvSpeakerService(
televisionService: Service,
televisionSpeakerService: Service
): void {
televisionSpeakerService.setCharacteristic(
this._platform.Characteristic.Name,
this._accessory.displayName
);
//@ts-ignore
televisionSpeakerService.setCharacteristic(
this._platform.Characteristic.Active,
this._platform.Characteristic.Active.ACTIVE
);
//@ts-ignore
televisionSpeakerService.setCharacteristic(
this._platform.Characteristic.VolumeControlType,
this._platform.Characteristic.VolumeControlType.ABSOLUTE
);
televisionSpeakerService.subtype = this._accessory.displayName + "Volume";
if (televisionService) {
//@ts-ignore
televisionService.addLinkedService(televisionSpeakerService);
}
//Setup listeners
televisionSpeakerService
.getCharacteristic(this._platform.Characteristic.VolumeSelector)
//@ts-ignore
.on("set", callbackify(this.onSetVolumeSelector));
}
/**
* Event handler for SET volume characteristic
*/
private onSetVolumeSelector = async (value: any) => {
switch (value) {
case 0:
this._dataProvider.volumeUp(this._accessory.displayName);
break;
case 1:
this._dataProvider.volumeDown(this._accessory.displayName);
break;
}
};
/*****************
*
* Input services
*
*****************/
/**
* Configure input service
*/
private configureInputSourceService(televisionService: Service): void {
let inputs: Array<Service> = [];
this._activities.forEach((activity: IActivity, index: number) => {
const inputUUID = this._platform.api.hap.uuid.generate(
`${activity.DisplayName} Input`
);
let inputService =
this._accessory.getService(activity.DisplayName) ||
this._accessory.addService(
this._platform.Service.InputSource,
activity.DisplayName,
inputUUID
);
inputService
.setCharacteristic(this._platform.Characteristic.Identifier, index)
.setCharacteristic(
this._platform.Characteristic.ConfiguredName,
activity.DisplayName
)
.setCharacteristic(
this._platform.Characteristic.IsConfigured,
//@ts-ignore
this._platform.Characteristic.IsConfigured.CONFIGURED
)
//@ts-ignore
.setCharacteristic(
this._platform.Characteristic.InputSourceType,
this._platform.Characteristic.InputSourceType.HDMI
);
//@ts-ignore
televisionService!.addLinkedService(inputService);
inputs.push(inputService);
});
}
}
/**
* ControlUnit accessory
*/
export class ControlUnit implements AccessoryPlugin {
//fields
private log: Logging;
private displayName: string = "";
private _api: API;
private _name: string;
//Service fields
private _platformAccessory: PlatformAccessory;
private _televisionService: Service = new Service.Television(
this.displayName,
'tvService'
);
private _televisionSpeakerService: Service = new Service.TelevisionSpeaker(
this.displayName,
'tvSpeakerService'
);
private _infoService: Service;
private _inputServices: Array<Service> = [];
//Harmony fields
private _activities: Array<Config.IActivity> = [];
private _dataProvider: HarmonyDataProvider;
/**
* Constructor
* @param props Input properties
*/
constructor(props: IControlUnitProps) {
//Assign class variables
this.log = props.log;
this._api = props.api;
this._name = props.displayName;
this.displayName = props.displayName;
this._activities = props.activities;
this._dataProvider = props.dataProvider;
this._platformAccessory = new PlatformAccessory(this.displayName, this.generateUUID(), Accessory.Categories.TELEVISION);
this._platformAccessory.configureController(new RemoteController());
//@ts-ignore
this._infoService = new this._api.hap.Service.AccessoryInformation();
this._infoService.setCharacteristic(Characteristic.Manufacturer, "Brandon Watson")
this._infoService.setCharacteristic(Characteristic.Model, "Matrix Output Television")
this._infoService.setCharacteristic(Characteristic.SerialNumber, "123-456-789");
//Configure services
this.configureTvService();
this.configureTvSpeakerService();
// this.configureAccessoryInformation();
this.configureInputSourceService();
//Configure external services
this.getServices().forEach(service => {
try {
this._platformAccessory.addService(service);
} catch (error) { }
//@ts-ignore
if (service.linked) {
//@ts-ignore
this._televisionService!.addLinkedService(service);
}
});
}
public get platformAccessory(): PlatformAccessory {
return this._platformAccessory;
}
/*************
*
* Tv Service
*
*************/
/**
* Configure television service
*/
private configureTvService(): void {
this._televisionService.setCharacteristic(Characteristic.ConfiguredName, this.displayName);
//@ts-ignore
this._televisionService.setCharacteristic(Characteristic.SleepDiscoveryMode, Characteristic.SleepDiscoveryMode.ALWAYS_DISCOVERABLE);
this._televisionService.setCharacteristic(Characteristic.ActiveIdentifier, 1);
this._televisionService.setCharacteristic(Characteristic.Active, false);
//setup listeners
this._televisionService.getCharacteristic(Characteristic.Active)
//@ts-ignore
.on("set", callbackify(this.onSetAccessoryActive))
//@ts-ignore
.on("get", callbackify(this.onGetAccessoryActive));
//Set remote characteristics if is external
this._televisionService.getCharacteristic(Characteristic.RemoteKey)
//@ts-ignore
.on("set", callbackify(this.onSetRemoteKey));
this._televisionService.getCharacteristic(Characteristic.ActiveIdentifier)
//@ts-ignore
.on("set", callbackify(this.onSetActiveIdentifier))
//@ts-ignore
.on("get", callbackify(this.onGetActiveIdentifier));
}
/**
* Event handler for SET active characteristic
*/
private onSetAccessoryActive = async (value: any) => {
switch (value) {
case 0: this._dataProvider.powerOff(this._name); break;
//Turn on with first activity
case 1: this._dataProvider.powerOn(this._name, this._activities[0]); break;
}
}
/**
* Event handler for GET active characteristic
*/
private onGetAccessoryActive = async () => {
//@ts-ignore
return this._dataProvider.getIsActive(this._name) ? Characteristic.Active.Active : Characteristic.Active.Inactive
}
/**
* Event handler for SET remote key
*/
private onSetRemoteKey = async (key: any) => {
this._dataProvider.sendKeyPress(this._name, key);
}
/**
* Event handler for SET active identifier characteristic
*/
private onSetActiveIdentifier = async (identifier: any) => {
this._dataProvider.startActivity(this._name, this._activities[identifier]);
}
/**
* Event handler for GET active identifier characteristic
*/
private onGetActiveIdentifier = async () => {
let currentActivity: Config.IActivity = this._dataProvider.getIsActive(this._name)!;
let identifier: number = 0;
if (currentActivity) {
identifier = this._activities.findIndex(e => e.DisplayName === currentActivity.DisplayName);
}
return identifier;
}
/******************
*
* Speaker Service
*
*****************/
/**
* Configure Speaker Service
*/
private configureTvSpeakerService(): void {
this._televisionSpeakerService.setCharacteristic(Characteristic.Name, this.displayName);
//@ts-ignore
this._televisionSpeakerService.setCharacteristic(Characteristic.Active, Characteristic.Active.ACTIVE);
//@ts-ignore
this._televisionSpeakerService.setCharacteristic(Characteristic.VolumeControlType, Characteristic.VolumeControlType.ABSOLUTE);
this._televisionSpeakerService.subtype = this.displayName + "Volume";
if (this._televisionService) {
//@ts-ignore
this._televisionService.addLinkedService(this._televisionSpeakerService);
}
//Setup listeners
this._televisionSpeakerService.getCharacteristic(Characteristic.VolumeSelector)
//@ts-ignore
.on("set", callbackify(this.onSetVolumeSelector));
}
/**
* Event handler for SET volume characteristic
*/
private onSetVolumeSelector = async (value: any) => {
switch (value) {
case 0: this._dataProvider.volumeUp(this._name); break;
case 1: this._dataProvider.volumeDown(this._name); break;
}
}
/*****************
*
* Input services
*
*****************/
/**
* Configure input service
*/
private configureInputSourceService(): void {
let inputs: Array<Service> = [];
this._activities.forEach((activity: Config.IActivity, index: number) => {
let inputService = new Service.InputSource(activity.DisplayName, 'activity' + activity.DisplayName);
inputService
.setCharacteristic(Characteristic.Identifier, index)
.setCharacteristic(
Characteristic.ConfiguredName,
activity.DisplayName)
.setCharacteristic(
Characteristic.IsConfigured,
//@ts-ignore
Characteristic.IsConfigured.CONFIGURED
)
//@ts-ignore
.setCharacteristic(Characteristic.InputSourceType, Characteristic.InputSourceType.HDMI);
//@ts-ignore
this._televisionService!.addLinkedService(inputService);
inputs.push(inputService);
});
this._inputServices = inputs;
}
private generateUUID(): string { // Public Domain/MIT
var d = new Date().getTime();
if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
d += performance.now(); //use high-precision timer if available
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
}
/**
* Called by homebridge to gather services for this accessory.
*/
getServices(): Array<Service> {
let services: Array<Service> = [this._infoService, this._televisionService!, this._televisionSpeakerService!];
this._inputServices.forEach((service: Service) => {
services.push(service!);
});
return (services);
}
}

249
src/Accessories/DeviceButton.ts
View File

@ -1,148 +1,111 @@
import { PlatformAccessory, Service } from "homebridge";
import HarmonyDataProvider from "../DataProviders/HarmonyDataProvider";
import { IDeviceButton } from "../Models/Config";
import { ICommand } from "../Models";
import { HarmonyDevice } from "../Models/HarmonyDevice";
import { Service, PlatformAccessory, AccessoryPlugin, API, Characteristic } from "homebridge";
import { Platform } from "../platform";
export interface IDeviceButtonProps {
dataProvider: HarmonyDataProvider,
buttonName: string,
displayName: string,
deviceInfo: IDeviceButton,
api: API,
log: any,
export class DeviceButton {
private _buttonState: boolean;
private _device!: HarmonyDevice;
private _switchService: Service;
constructor(
private readonly _platform: Platform,
private readonly _accessory: PlatformAccessory,
private _dataProvider: HarmonyDataProvider,
private _deviceInfo: IDeviceButton
) {
this._buttonState = false;
if (this._deviceInfo.NumberOfKeyPresses && this._deviceInfo.IsStateful) {
throw new Error(
"A button cannot be stateful and be pressed more than once"
);
}
this._accessory
.getService(this._platform.Service.AccessoryInformation)!
.setCharacteristic(
this._platform.Characteristic.Manufacturer,
"Brandon Watson"
)
.setCharacteristic(this._platform.Characteristic.Model, "Device Button")
.setCharacteristic(
this._platform.Characteristic.SerialNumber,
"123-456-789"
);
const switchUUID = this._platform.api.hap.uuid.generate(
`${this._accessory.displayName} Switch`
);
this._switchService =
this._accessory.getService(this._platform.Service.Switch) ||
this._accessory.addService(
this._platform.Service.Switch,
this._accessory.displayName,
switchUUID
);
this._switchService
.getCharacteristic(this._platform.Characteristic.On)
//@ts-ignore
.on("set", this.onSwitchSet)
.updateValue(this._buttonState)
.on("get", this.onSwitchGet);
}
/**
* Handler for switch set event
* @param callback The callback function to call when complete
*/
private onSwitchSet = async (
newState: boolean,
callback: (error?: Error | null | undefined) => void
) => {
if (!this._deviceInfo.IsStateful && newState === this._buttonState) {
return callback();
}
//Get device command if we don't have it
if (!this._device) {
this._device = this._dataProvider.getDeviceFromName(
this._deviceInfo.DeviceName
);
}
//Execute command
if (this._device) {
//change state if stateful
if (this._deviceInfo.IsStateful && this._buttonState != newState) {
this._buttonState = newState;
await this._device.sendCommand(this._deviceInfo.ButtonName);
} else if (!this._deviceInfo.IsStateful) {
//Send the number of configured key presses
for (let i = 0; i < this._deviceInfo.NumberOfKeyPresses; i++) {
await this._device.sendCommand(this._deviceInfo.ButtonName);
}
this._switchService
.getCharacteristic(this._platform.Characteristic.On)
.updateValue(false);
return callback(new Error("Normal Response"));
}
}
return callback();
};
/**
* Handler for switch get event
* @param callback The callback function to call when complete
*/
private onSwitchGet = (
callback: (error: Error | null, value: boolean) => void
) => {
//Only return state if button is stateful
if (this._deviceInfo.IsStateful) {
return callback(null, this._buttonState);
} else {
return callback(null, false);
}
};
}
export class DeviceButton implements AccessoryPlugin {
private _api: API;
private _homebridge: any;
private _log: any = {};
//Service fields
private _switchService: Service;
private _infoService: Service;
private _buttonInfo: IDeviceButton;
private _dataProvider: HarmonyDataProvider;
private _device!: HarmonyDevice;
private _buttonState: boolean;
constructor(props: IDeviceButtonProps) {
//Assign class variables
this._log = props.log;
this._api = props.api;
this.name = props.displayName;
this._buttonInfo = props.deviceInfo;
this._dataProvider = props.dataProvider;
this._buttonState = false;
if (this._buttonInfo.NumberOfKeyPresses && this._buttonInfo.IsStateful) {
throw new Error("A button cannot be stateful and be pressed more than once");
}
//Assign default number of key presses
if (!this._buttonInfo.NumberOfKeyPresses) {
this._buttonInfo.NumberOfKeyPresses = 1;
}
this.platformAccessory = new this._homebridge.platformAccessory(this.name, this.generateUUID(), this._homebridge.hap.Accessory.Categories.SWITCH);
//@ts-ignore
this._infoService = new Service.AccessoryInformation();
this._infoService.setCharacteristic(Characteristic.Manufacturer, "Brandon Watson")
this._infoService.setCharacteristic(Characteristic.Model, "Device Button")
this._infoService.setCharacteristic(Characteristic.SerialNumber, "123-456-789");
this._switchService = new Service.Switch(
this.name,
'switchService'
)
this._switchService.getCharacteristic(Characteristic.On)
//@ts-ignore
.on("set", this.onSwitchSet)
.updateValue(this._buttonState)
.on("get", this.onSwitchGet);
}
/**
* Required by homebridge.
*/
public name: string;
public platformAccessory: any;
/**
* Called by homebridge to gather services.
*/
public getServices = (): Array<Service> => {
return [this._infoService, this._switchService!];
}
/**
* Handler for switch set event
* @param callback The callback function to call when complete
*/
private onSwitchSet = async (newState: boolean, callback: (error?: Error | null | undefined) => void) => {
if (!this._buttonInfo.IsStateful && newState === this._buttonState) {
return callback();
}
//Get device command if we don't have it
if (!this._device) {
this._device = this._dataProvider.getDeviceFromName(this._buttonInfo.DeviceName);
}
//Execute command
if (this._device) {
//change state if stateful
if (this._buttonInfo.IsStateful && this._buttonState != newState) {
this._buttonState = newState
await this._device.sendCommand(this._buttonInfo.ButtonName);
} else if (!this._buttonInfo.IsStateful) {
//Send the number of configured key presses
for (let i = 0; i < this._buttonInfo.NumberOfKeyPresses; i++) {
await this._device.sendCommand(this._buttonInfo.ButtonName);
}
this._switchService.getCharacteristic(Characteristic.On).updateValue(false);
return callback(new Error("Normal Response"));
}
}
return callback();
}
/**
* Handler for switch get event
* @param callback The callback function to call when complete
*/
private onSwitchGet = (callback: (error: Error | null, value: boolean) => void) => {
//Only return state if button is stateful
if (this._buttonInfo.IsStateful) {
return callback(null, this._buttonState);
} else {
return callback(null, false)
}
}
/**
* Helper function to generate a UUID
*/
private generateUUID(): string { // Public Domain/MIT
var d = new Date().getTime();
if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
d += performance.now(); //use high-precision timer if available
}
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = (d + Math.random() * 16) % 16 | 0;
d = Math.floor(d / 16);
return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
});
}
}

657
src/DataProviders/HarmonyDataProvider.ts
View File

@ -1,347 +1,404 @@
import { IActivity } from "../Models/Config/IActivity";
import { IDeviceSetupItem } from "../Models/Config/IDeviceSetupItem";
import { IInput, IMatrix, IOutput } from "../Models/Config/IMatrix";
import { RemoteKey } from '../Accessories/ControlUnit';
import { RemoteKey } from "../Accessories/ControlUnit";
import { EventEmitter } from "events";
import { ICommand } from '../Models/IDevice';
import { IHub } from "../Models/Config/IHub";
import { IDeviceConfig } from "../Models/Config/IDeviceConfig";
import { HarmonyDevice } from "../Models/HarmonyDevice";
import { HarmonyHub } from "../Models/HarmonyHub";
import { Characteristic } from "homebridge";
const Harmony = require("harmony-websocket");
interface IActivityState {
currentActivity: IActivity
currentActivity: IActivity;
}
interface IHarmonyDataProviderProps {
hubs: Array<IHub>;
deviceConfigs: Array<IDeviceConfig>;
log: any,
matrix: IMatrix
hubs: Array<IHub>;
deviceConfigs: Array<IDeviceConfig>;
log: any;
matrix: IMatrix;
}
class HarmonyDataProvider extends EventEmitter {
private _log: any;
private _hubsByDevice: { [deviceName: string]: string } = {};
private _hubs: { [hubName: string]: HarmonyHub } = {};
// private _devicesByHub: { [hubName: string]: { [deviceName: string]: HarmonyDevice } } = {};
private _states: { [controlUnitName: string]: (IActivityState | undefined) } = {};
private _log: any;
private _hubsByDevice: { [deviceName: string]: string } = {};
private _hubs: { [hubName: string]: HarmonyHub } = {};
// private _devicesByHub: { [hubName: string]: { [deviceName: string]: HarmonyDevice } } = {};
private _states: {
[controlUnitName: string]: IActivityState | undefined;
} = {};
private _matrix: IMatrix;
private _matrix: IMatrix;
constructor(props: IHarmonyDataProviderProps) {
super();
this._log = props.log;
this._matrix = props.matrix;
props.deviceConfigs.forEach((deviceConfig: IDeviceConfig) => {
this._hubsByDevice[deviceConfig.Name] = deviceConfig.Hub;
});
// this._deviceConfigs = props.deviceConfigs;
constructor(props: IHarmonyDataProviderProps) {
super();
this._log = props.log;
this._matrix = props.matrix;
props.deviceConfigs.forEach((deviceConfig: IDeviceConfig) => {
this._hubsByDevice[deviceConfig.Name] = deviceConfig.Hub;
});
// this._deviceConfigs = props.deviceConfigs;
this.connect(props.hubs);
this.connect(props.hubs);
}
// public get devicesByHub(): { [hubName: string]: { [deviceName: string]: HarmonyDevice } } {
// return this._devicesByHub;
// }
public get hubs(): { [hubName: string]: HarmonyHub } {
return this._hubs;
}
/**
* Power on all devices in an activity.
*/
public powerOn = async (controlUnitName: string, activity: IActivity) => {
//Only power on if not alread on
let currentActivity = this._states[controlUnitName]
? this._states[controlUnitName]!.currentActivity
: undefined;
if (!currentActivity) {
await this.startActivity(controlUnitName, activity);
}
};
/**
* Power off all devices in an activity that aren't being used.
*/
public powerOff = async (controlUnitName: string) => {
if (!this._states[controlUnitName]) {
return;
}
//Build potential list of devices to turn off
let devicesToTurnOff: Array<HarmonyDevice> = this._states[
controlUnitName
]!.currentActivity.DeviceSetupList.map(
(value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
}
);
//Resolve device conflicts with other controlUnits
devicesToTurnOff = this.sanitizeDeviceList(
devicesToTurnOff,
controlUnitName
);
//Turn off devices
devicesToTurnOff.forEach(async (device: HarmonyDevice) => {
if (device) {
await device.powerOff();
}
});
this._states[controlUnitName] = undefined;
};
/**
* Start an activity
*/
public startActivity = async (
controlUnitName: string,
activity: IActivity
) => {
this._log(
`Starting activity ${activity.DisplayName} for controlUnit: ${controlUnitName}`
);
let lastActivity: IActivity | undefined = undefined;
if (this._states[controlUnitName]) {
lastActivity = this._states[controlUnitName]!.currentActivity;
}
// public get devicesByHub(): { [hubName: string]: { [deviceName: string]: HarmonyDevice } } {
// return this._devicesByHub;
// }
//Build potential list of devices to to turn on
let devicesToTurnOn: Array<HarmonyDevice> = activity.DeviceSetupList.map(
(value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
}
);
public get hubs(): { [hubName: string]: HarmonyHub } {
return this._hubs;
}
//Resolve device conflicts with other controlUnits
devicesToTurnOn = this.sanitizeDeviceList(devicesToTurnOn, controlUnitName);
/**
* Power on all devices in an activity.
*/
public powerOn = async (controlUnitName: string, activity: IActivity) => {
//Only power on if not alread on
let currentActivity = this._states[controlUnitName] ? this._states[controlUnitName]!.currentActivity : undefined;
if (!currentActivity) {
await this.startActivity(controlUnitName, activity);
//Turn on devices
await Promise.all(
devicesToTurnOn.map(async (device: HarmonyDevice) => {
if (device && device.name) {
if (!device.on) {
this._log(`Turning on device ${device.name}`);
await device.powerOn();
}
}
})
);
//Assign correct input
await Promise.all(
activity.DeviceSetupList.map(async (value: IDeviceSetupItem) => {
let device: HarmonyDevice = this.getDeviceFromName(value.DeviceName);
if (device && device.supportsCommand(`Input${value.Input}`)) {
await device.sendCommand(`Input${value.Input}`);
}
})
);
if (activity.UseMatrix) {
//get input and output
let input: IInput = this._matrix.Inputs.filter(
(e) => e.InputDevice === activity.ControlDevice
)[0];
let output: IOutput = this._matrix.Outputs.filter(
(e) => e.OutputDevice === activity.OutputDevice
)[0];
let inputCommandName: string = `In ${input.InputNumber}`;
let outputCommandName: string = `Out ${output.OutputLetter}`;
let matrixDevice: HarmonyDevice = this.getDeviceFromName(
this._matrix.DeviceName
);
//Route hdmi
if (
matrixDevice.supportsCommand(inputCommandName) &&
matrixDevice.supportsCommand(outputCommandName)
) {
await matrixDevice.sendCommand(outputCommandName);
await matrixDevice.sendCommand(inputCommandName);
await matrixDevice.sendCommand(outputCommandName);
await matrixDevice.sendCommand(inputCommandName);
}
}
/**
* Power off all devices in an activity that aren't being used.
*/
public powerOff = async (controlUnitName: string) => {
if (!this._states[controlUnitName]) {
return;
//Build potential list of devices to turn off
if (lastActivity) {
let devicesToTurnOff: Array<HarmonyDevice> = lastActivity.DeviceSetupList.map(
(value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
}
//Build potential list of devices to turn off
let devicesToTurnOff: Array<HarmonyDevice> = this._states[controlUnitName]!.currentActivity.DeviceSetupList
.map((value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
});
);
//Resolve device conflicts with other controlUnits
devicesToTurnOff = this.sanitizeDeviceList(devicesToTurnOff, controlUnitName);
//remove devices that will be used for next activity from list
//delete array[index] is stupid because it just nulls out the index. But now i have to deal with nulls
devicesToTurnOff.forEach((device: HarmonyDevice, index: number) => {
if (
device &&
device.name &&
activity.DeviceSetupList.some((e) => {
return e && e.DeviceName === device.name;
})
) {
delete devicesToTurnOff[index];
}
});
//Resolve device conflicts with other controlUnits
devicesToTurnOff = this.sanitizeDeviceList(
devicesToTurnOff,
controlUnitName
);
this._log(
`Sanatized devices to turn off: ${JSON.stringify(
devicesToTurnOff.map((e) => (e ? e.name : ""))
)}`
);
await Promise.all(
//Turn off devices
devicesToTurnOff.forEach(async (device: HarmonyDevice) => {
if (device) {
await device.powerOff();
devicesToTurnOff.map(async (device: HarmonyDevice) => {
if (device) {
if (device.on) {
this._log(`Turning off device ${device.name}`);
await device.powerOff();
}
});
this._states[controlUnitName] = undefined;
}
})
);
}
/**
* Start an activity
*/
public startActivity = async (controlUnitName: string, activity: IActivity) => {
this._log(`Starting activity ${activity.DisplayName} for controlUnit: ${controlUnitName}`)
let lastActivity: IActivity | undefined = undefined;
if (this._states[controlUnitName]) {
lastActivity = this._states[controlUnitName]!.currentActivity;
//Assign current activity
this._states[controlUnitName] = { currentActivity: activity };
};
/**
* Turn the volume up for the current running activity.
*/
public volumeUp = async (controlUnitName: string) => {
let volumeUpCommand: string = "Volume Up";
if (this._states[controlUnitName]) {
let volumeDevice: HarmonyDevice = this.getDeviceFromName(
this._states[controlUnitName]!.currentActivity.VolumeDevice
);
await volumeDevice.sendCommand(volumeUpCommand);
}
};
/**
* Volume down for current running activity.
*/
public volumeDown = async (controlUnitName: string) => {
let volumeDownCommand: string = "Volume Down";
if (this._states[controlUnitName]) {
let volumeDevice: HarmonyDevice = this.getDeviceFromName(
this._states[controlUnitName]!.currentActivity.VolumeDevice
);
await volumeDevice.sendCommand(volumeDownCommand);
}
};
/**
* Send key press for current activity.
*
* @param controlUnitName The name of the control unit to act on.
* @param key The key to send.
*/
public sendKeyPress = async (controlUnitName: string, key: any) => {
if (this._states[controlUnitName]) {
let commandName: string = "";
let device: HarmonyDevice = this.getDeviceFromName(
this._states[controlUnitName]!.currentActivity.ControlDevice
);
switch (key) {
case RemoteKey.ARROW_UP: {
commandName = "Direction Up";
break;
}
case RemoteKey.ARROW_DOWN: {
commandName = "Direction Down";
break;
}
case RemoteKey.ARROW_LEFT: {
commandName = "Direction Left";
break;
}
case RemoteKey.ARROW_RIGHT: {
commandName = "Direction Right";
break;
}
case RemoteKey.SELECT: {
commandName = "Select";
break;
}
case RemoteKey.PLAY_PAUSE: {
commandName = "Pause";
break;
}
case RemoteKey.INFORMATION: {
commandName = "Menu";
break;
}
case RemoteKey.BACK: {
commandName = "Back";
break;
}
case RemoteKey.EXIT: {
commandName = "Back";
break;
}
}
//Build potential list of devices to to turn on
let devicesToTurnOn: Array<HarmonyDevice> = activity.DeviceSetupList.map((value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
});
await device.sendCommand(commandName);
}
};
//Resolve device conflicts with other controlUnits
devicesToTurnOn = this.sanitizeDeviceList(devicesToTurnOn, controlUnitName);
/**
* Return if a control unit is active
* @param controlUnitName
*/
public getIsActive(controlUnitName: string): IActivity | undefined {
return this._states[controlUnitName]
? this._states[controlUnitName]!.currentActivity
: undefined;
}
//Turn on devices
await Promise.all(devicesToTurnOn.map(async (device: HarmonyDevice) => {
if (device && device.name) {
if (!device.on) {
this._log(`Turning on device ${device.name}`)
await device.powerOn();
}
/**
* Get the IDevice by name.
* @param deviceName The device to retrieve.
*/
public getDeviceFromName(deviceName: string): HarmonyDevice {
let device: HarmonyDevice | undefined;
try {
device = this._hubs[this._hubsByDevice[deviceName]].getDeviceByName(
deviceName
);
} catch (err) {
this._log(`Error retrieving device from hub: ${err}`);
}
return device!;
}
// /**
// * Gets device button commands
// * @param deviceCommandName The device command name
// * @param deviceName The device name
// */
// public getCommand(deviceCommandName: string, deviceName: string): ICommand | undefined {
// const device: HarmonyDevice = this.getDeviceFromName(deviceName);
// if (device && device.supportsCommand(deviceCommandName)) {
// return device.getCommand(deviceCommandName);
// } else {
// return undefined;
// }
// }
private connect = async (hubs: Array<IHub>) => {
let readyCount = 0;
await Promise.all(
hubs.map(
async (hub: IHub): Promise<void> => {
const newHarmonyHub = new HarmonyHub(hub.Name, hub.Ip, this._log);
this._hubs[hub.Name] = newHarmonyHub;
newHarmonyHub.on("Ready", () => {
readyCount++;
if (readyCount === Object.keys(this._hubs).length) {
this.emit("Ready");
}
}));
});
await newHarmonyHub.initialize();
}
)
);
};
//Assign correct input
await Promise.all(
activity.DeviceSetupList.map(async (value: IDeviceSetupItem) => {
let device: HarmonyDevice = this.getDeviceFromName(value.DeviceName);
/**
* Helper function to make sure no control unit depends on device list.
* @param devicesToTurnOn The list of devices to modify.
* @param controlUnitName The name of the control unit in question.
*/
private sanitizeDeviceList(
devicesToTurnOn: Array<HarmonyDevice>,
controlUnitName: string
): Array<HarmonyDevice> {
for (let controlUnitKey in this._states) {
//Skip self
if (controlUnitKey === controlUnitName) {
continue;
}
let currentOtherState: IActivityState = this._states[controlUnitKey]!;
if (device && device.supportsCommand(`Input${value.Input}`)) {
await device.sendCommand(`Input${value.Input}`)
}
})
if (currentOtherState) {
currentOtherState.currentActivity.DeviceSetupList.forEach(
(value: IDeviceSetupItem) => {
//there are devices to remove
if (devicesToTurnOn.some((e) => e && e.name === value.DeviceName)) {
let deviceToRemove: HarmonyDevice = devicesToTurnOn.filter(
(i) => i.name === value.DeviceName
)[0];
delete devicesToTurnOn[devicesToTurnOn.indexOf(deviceToRemove)];
}
}
);
if (activity.UseMatrix) {
//get input and output
let input: IInput = this._matrix.Inputs.filter(e => e.InputDevice === activity.ControlDevice)[0];
let output: IOutput = this._matrix.Outputs.filter(e => e.OutputDevice === activity.OutputDevice)[0];
let inputCommandName: string = `In ${input.InputNumber}`;
let outputCommandName: string = `Out ${output.OutputLetter}`;
let matrixDevice: HarmonyDevice = this.getDeviceFromName(this._matrix.DeviceName);
//Route hdmi
if (matrixDevice.supportsCommand(inputCommandName) && matrixDevice.supportsCommand(outputCommandName)) {
await matrixDevice.sendCommand(outputCommandName);
await matrixDevice.sendCommand(inputCommandName);
await matrixDevice.sendCommand(outputCommandName);
await matrixDevice.sendCommand(inputCommandName);
}
}
//Build potential list of devices to turn off
if (lastActivity) {
let devicesToTurnOff: Array<HarmonyDevice> = lastActivity.DeviceSetupList.map((value: IDeviceSetupItem): HarmonyDevice => {
return this.getDeviceFromName(value.DeviceName);
});
//remove devices that will be used for next activity from list
//delete array[index] is stupid because it just nulls out the index. But now i have to deal with nulls
devicesToTurnOff.forEach((device: HarmonyDevice, index: number) => {
if (device && device.name && activity.DeviceSetupList.some(e => {
return (e && e.DeviceName === device.name)
})) {
delete devicesToTurnOff[index];
}
})
//Resolve device conflicts with other controlUnits
devicesToTurnOff = this.sanitizeDeviceList(devicesToTurnOff, controlUnitName);
this._log(`Sanatized devices to turn off: ${JSON.stringify(devicesToTurnOff.map(e => e ? e.name : ""))}`);
await Promise.all(
//Turn off devices
devicesToTurnOff.map(async (device: HarmonyDevice) => {
if (device) {
if (device.on) {
this._log(`Turning off device ${device.name}`)
await device.powerOff();
}
}
})
);
}
//Assign current activity
this._states[controlUnitName] = { currentActivity: activity };
}
}
/**
* Turn the volume up for the current running activity.
*/
public volumeUp = async (controlUnitName: string) => {
let volumeUpCommand: string = "Volume Up"
if (this._states[controlUnitName]) {
let volumeDevice: HarmonyDevice = this.getDeviceFromName(this._states[controlUnitName]!.currentActivity.VolumeDevice);
await volumeDevice.sendCommand(volumeUpCommand);
}
}
/**
* Volume down for current running activity.
*/
public volumeDown = async (controlUnitName: string) => {
let volumeDownCommand: string = "Volume Down"
if (this._states[controlUnitName]) {
let volumeDevice: HarmonyDevice = this.getDeviceFromName(this._states[controlUnitName]!.currentActivity.VolumeDevice);
await volumeDevice.sendCommand(volumeDownCommand);
}
}
/**
* Send key press for current activity.
*
* @param controlUnitName The name of the control unit to act on.
* @param key The key to send.
*/
public sendKeyPress = async (controlUnitName: string, key: any) => {
if (this._states[controlUnitName]) {
let commandName: string = "";
let device: HarmonyDevice = this.getDeviceFromName(this._states[controlUnitName]!.currentActivity.ControlDevice);
switch (key) {
case RemoteKey.ARROW_UP: {
commandName = "Direction Up";
break;
}
case RemoteKey.ARROW_DOWN: {
commandName = "Direction Down";
break;
}
case RemoteKey.ARROW_LEFT: {
commandName = "Direction Left";
break;
}
case RemoteKey.ARROW_RIGHT: {
commandName = "Direction Right";
break;
}
case RemoteKey.SELECT: {
commandName = "Select";
break;
}
case RemoteKey.PLAY_PAUSE: {
commandName = "Pause";
break;
}
case RemoteKey.INFORMATION: {
commandName = "Menu";
break;
}
case RemoteKey.BACK: {
commandName = "Back";
break;
}
case RemoteKey.EXIT: {
commandName = "Back";
break;
}
}
await device.sendCommand(commandName);
}
}
/**
* Return if a control unit is active
* @param controlUnitName
*/
public getIsActive(controlUnitName: string): IActivity | undefined {
return this._states[controlUnitName] ? this._states[controlUnitName]!.currentActivity : undefined;
}
/**
* Get the IDevice by name.
* @param deviceName The device to retrieve.
*/
public getDeviceFromName(deviceName: string): HarmonyDevice {
let device: HarmonyDevice | undefined;
try {
device = this._hubs[this._hubsByDevice[deviceName]].getDeviceByName(deviceName);
} catch (err) {
this._log(`Error retrieving device from hub: ${err}`);
}
return device!;
}
// /**
// * Gets device button commands
// * @param deviceCommandName The device command name
// * @param deviceName The device name
// */
// public getCommand(deviceCommandName: string, deviceName: string): ICommand | undefined {
// const device: HarmonyDevice = this.getDeviceFromName(deviceName);
// if (device && device.supportsCommand(deviceCommandName)) {
// return device.getCommand(deviceCommandName);
// } else {
// return undefined;
// }
// }
private connect = async (hubs: Array<IHub>) => {
let readyCount = 0;
await Promise.all(
hubs.map(async (hub: IHub): Promise<void> => {
const newHarmonyHub = new HarmonyHub(hub.Name, hub.Ip, this._log);
this._hubs[hub.Name] = newHarmonyHub;
newHarmonyHub.on("Ready", () => {
readyCount++;
if (readyCount === Object.keys(this._hubs).length) {
this.emit("Ready");
}
})
await newHarmonyHub.initialize();
})
)
}
/**
* Helper function to make sure no control unit depends on device list.
* @param devicesToTurnOn The list of devices to modify.
* @param controlUnitName The name of the control unit in question.
*/
private sanitizeDeviceList(devicesToTurnOn: Array<HarmonyDevice>, controlUnitName: string): Array<HarmonyDevice> {
for (let controlUnitKey in this._states) {
//Skip self
if (controlUnitKey === controlUnitName) {
continue;
}
let currentOtherState: IActivityState = this._states[controlUnitKey]!;
if (currentOtherState) {
currentOtherState.currentActivity.DeviceSetupList.forEach((value: IDeviceSetupItem) => {
//there are devices to remove
if (devicesToTurnOn.some(e => e && e.name === value.DeviceName)) {
let deviceToRemove: HarmonyDevice = devicesToTurnOn.filter(i => i.name === value.DeviceName)[0];
delete devicesToTurnOn[devicesToTurnOn.indexOf(deviceToRemove)];
}
});
}
}
return devicesToTurnOn;
}
return devicesToTurnOn;
}
}
export default HarmonyDataProvider;
export default HarmonyDataProvider;

48
src/Util/Callbackify.ts
View File

@ -1,30 +1,32 @@
/**
* Helper function to convert callbacks into promises
* @param func
* @param func
*/
export default function callbackify(func: (...args: any[]) => Promise<any>): Function {
return (...args: any[]) => {
const onlyArgs: any[] = [];
let maybeCallback: Function | null = null;
for (const arg of args) {
if (typeof arg === 'function') {
maybeCallback = arg;
break;
}
export default function callbackify(
func: (...args: any[]) => Promise<any>
): Function {
return (...args: any[]) => {
const onlyArgs: any[] = [];
let maybeCallback: Function | null = null;
onlyArgs.push(arg);
}
for (const arg of args) {
if (typeof arg === "function") {
maybeCallback = arg;
break;
}
if (!maybeCallback) {
throw new Error("Missing callback parameter!");
}
const callback = maybeCallback;
func(...onlyArgs)
.then((data: any) => callback(null, data))
.catch((err: any) => callback(err))
onlyArgs.push(arg);
}
}
if (!maybeCallback) {
throw new Error("Missing callback parameter!");
}
const callback = maybeCallback;
func(...onlyArgs)
.then((data: any) => callback(null, data))
.catch((err: any) => callback(err));
};
}

2
src/Util/index.ts Normal file
View File

@ -0,0 +1,2 @@
export * from "./Callbackify";
export * from "./Sleep";

119
src/index.ts
View File

@ -1,118 +1,11 @@
import * as Accessories from "./Accessories";
import HarmonyDataProvider from "./DataProviders/HarmonyDataProvider";
import * as Config from "./Models/Config";
import { HarmonyDevice } from "./Models/HarmonyDevice";
import { HarmonyHub } from "./Models/HarmonyHub";
import { API, Logging, StaticPlatformPlugin, AccessoryPlugin } from "homebridge";
import { API } from "homebridge";
let Accessory: any;
let Homebridge: API;
import { PLATFORM_NAME } from "./settings";
import { Platform } from "./platform";
/**
* Main entry.
* @param homebridge
* This method registers the platform with Homebridge
*/
export default function (homebridge: API) {
Homebridge = homebridge;
Accessory = homebridge.platformAccessory;
homebridge.registerPlatform(
'homebridge-harmony-watson',
'HarmonyHubMatrix',
HarmonyMatrixPlatform,
);
export = (api: API) => {
api.registerPlatform(PLATFORM_NAME, Platform);
};
class HarmonyMatrixPlatform implements StaticPlatformPlugin {
log: Logging;
config: Config.IConfig;
api: API;
dataProvider: HarmonyDataProvider | null;
accessoryList: Array<AccessoryPlugin> = [];
constructor(logger: Logging, config: any, api: API) {
this.log = logger;
this.config = config;
this.api = api;
this.log.info('INFO - Registering Harmony Matrix Platform');
this.api.on('didFinishLaunching', this.didFinishLaunching.bind(this));
this.dataProvider = null;
if (this.config) {
//construct data provider
this.dataProvider = new HarmonyDataProvider({
hubs: this.config.Hubs,
deviceConfigs: this.config.Devices,
matrix: this.config.Matrix,
log: this.log
});
//Emit devices if requested
this.dataProvider.on("Ready", () => {
this.log("All hubs connected");
if (this.config.EmitDevicesOnStartup) {
const hubs = this.dataProvider!.hubs;
Object.values(hubs).forEach((hub: HarmonyHub) => {
const deviceDictionary = hub.devices;
this.log(`${hub.hubName}`)
Object.values(deviceDictionary).forEach((device: HarmonyDevice) => {
this.log(` ${device.name} : ${device.id}`);
Object.keys(device.commands).forEach((command: string) => {
this.log(` ${command}`);
});
});
});
}
});
}
}
/**
* Handler for didFinishLaunching
* Happens after constructor
*/
didFinishLaunching() {
this.log(`Publishing external accessories`);
//This is required in order to have multiple tv remotes on one platform
this.accessoryList.forEach((accessory: AccessoryPlugin) => {
if (accessory instanceof Accessories.ControlUnit) {
this.api.publishExternalAccessories("HarmonyMatrixPlatform", [accessory.platformAccessory]);
}
})
}
/**
* Called by homebridge to gather accessories.
* @param callback
*/
accessories(callback: (accessories: Array<AccessoryPlugin>) => void) {
//Add control units
this.config.ControlUnits.forEach((unit: Config.IControlUnit) => {
this.accessoryList.push(new Accessories.ControlUnit({
dataProvider: this.dataProvider!,
displayName: unit.DisplayName,
api: this.api,
log: this.log,
activities: unit.Activities,
}));
});
//Add device buttons
this.config.DeviceButtons.forEach((button: Config.IDeviceButton) => {
this.accessoryList.push(new Accessories.DeviceButton({
dataProvider: this.dataProvider!,
buttonName: button.ButtonName,
displayName: button.DisplayName,
deviceInfo: button,
api: this.api,
log: this.log
}))
});
callback(this.accessoryList);
}
}

144
src/platform.ts Normal file
View File

@ -0,0 +1,144 @@
import {
API,
Characteristic,
DynamicPlatformPlugin,
Logger,
PlatformAccessory,
PlatformConfig,
Service,
} from "homebridge";
import { ControlUnit, DeviceButton } from "./Accessories";
import HarmonyDataProvider from "./DataProviders/HarmonyDataProvider";
import { IConfig, IControlUnit, IDeviceButton } from "./Models/Config";
import { HarmonyDevice } from "./Models/HarmonyDevice";
import { HarmonyHub } from "./Models/HarmonyHub";
import { PLATFORM_NAME, PLUGIN_NAME } from "./settings";
export class Platform implements DynamicPlatformPlugin {
constructor(
public readonly log: Logger,
config: PlatformConfig,
public readonly api: API
) {
this.log.debug("Finished initializing platform:", config.name);
this.config = (config as unknown) as IConfig;
//construct data provider
const dataProvider = new HarmonyDataProvider({
hubs: this.config.Hubs,
deviceConfigs: this.config.Devices,
matrix: this.config.Matrix,
log: this.log,
});
this.api.on("didFinishLaunching", async () => {
log.debug("Executed didFinishLaunching callback");
this.discoverDevices(dataProvider);
});
this.dataProvider = null;
if (this.config) {
//construct data provider
this.dataProvider = new HarmonyDataProvider({
hubs: this.config.Hubs,
deviceConfigs: this.config.Devices,
matrix: this.config.Matrix,
log: this.log,
});
//Emit devices if requested
this.dataProvider.on("Ready", () => {
this.log.info("All hubs connected");
if (this.config.EmitDevicesOnStartup) {
const hubs = this.dataProvider!.hubs;
Object.values(hubs).forEach((hub: HarmonyHub) => {
const deviceDictionary = hub.devices;
this.log.info(`${hub.hubName}`);
Object.values(deviceDictionary).forEach((device: HarmonyDevice) => {
this.log.info(` ${device.name} : ${device.id}`);
Object.keys(device.commands).forEach((command: string) => {
this.log.info(` ${command}`);
});
});
});
}
});
}
}
public readonly Service: typeof Service = this.api.hap.Service;
public readonly Characteristic: typeof Characteristic = this.api.hap
.Characteristic;
// this is used to track restored cached accessories
public readonly accessories: PlatformAccessory[] = [];
public config: IConfig;
public dataProvider: HarmonyDataProvider | null;
public discoverDevices(dataProvider: HarmonyDataProvider) {
this.config.ControlUnits.forEach((unit: IControlUnit) => {
const uuid = this.api.hap.uuid.generate(unit.DisplayName);
const existingAccessory = this.accessories.find((e) => e.UUID === uuid);
if (existingAccessory) {
this.log.info(
"Restoring existing accessory from cache: " +
existingAccessory.displayName
);
new ControlUnit(this, existingAccessory, dataProvider, unit.Activities);
this.api.publishExternalAccessories(PLUGIN_NAME, [existingAccessory]);
console.log("Publishing external accessory: " + uuid);
} else {
this.log.info("Adding new accessory: " + unit.DisplayName);
const accessory = new this.api.platformAccessory(
unit.DisplayName,
uuid
);
accessory.context["DeviceName"] = unit.DisplayName;
new ControlUnit(this, accessory, dataProvider, unit.Activities);
this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
console.log("Publishing external accessory: " + uuid);
}
});
this.config.DeviceButtons.forEach((button: IDeviceButton) => {
const uuid = this.api.hap.uuid.generate(button.DisplayName);
const existingAccessory = this.accessories.find((e) => e.UUID === uuid);
if (existingAccessory) {
this.log.info(
"Restoring existing accessory from cache: " +
existingAccessory.displayName
);
new DeviceButton(this, existingAccessory, dataProvider, button);
this.api.updatePlatformAccessories([existingAccessory]);
} else {
this.log.info("Adding new accessory: " + button.DisplayName);
const accessory = new this.api.platformAccessory(
button.DisplayName,
uuid
);
accessory.context["DeviceName"] = button.DisplayName;
new DeviceButton(this, accessory, dataProvider, button);
this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [
accessory,
]);
}
});
}
configureAccessory(accessory: PlatformAccessory<Record<string, any>>): void {
this.log.info("Loading accessory from cache:", accessory.displayName);
// add the restored accessory to the accessories cache so we can track if it has already been registered
this.accessories.push(accessory);
}
}

9
src/settings.ts Normal file
View File

@ -0,0 +1,9 @@
/**
* This is the name of the platform that users will use to register the plugin in the Homebridge config.json
*/
export const PLATFORM_NAME = "HarmonyHubMatrix";
/**
* This must match the name of your plugin as defined the package.json
*/
export const PLUGIN_NAME = "homebridge-harmony-control";