508 lines
20 KiB
TypeScript
508 lines
20 KiB
TypeScript
import { Activity } from "../Models/Activity";
|
|
import { DeviceSetupItem } from "../Models/DeviceSetupItem";
|
|
import { Input, Matrix, Output } from "../Models/Matrix";
|
|
import { IDevice } from './IDevice';
|
|
import { RemoteKey } from '../Accessories/ControlUnit';
|
|
import { sleep } from '../Util/Sleep';
|
|
import { hub } from "..";
|
|
import fetch from 'node-fetch';
|
|
|
|
let Characteristic: HAPNodeJS.Characteristic;
|
|
|
|
const Harmony = require("harmony-websocket");
|
|
|
|
interface IActivityState {
|
|
currentActivity: Activity
|
|
}
|
|
|
|
interface IHubDataProviderProps {
|
|
harmonyHubAddress: string,
|
|
neeoHubAddress: string,
|
|
log: any,
|
|
matrix: Matrix
|
|
}
|
|
|
|
interface INeeoMacro {
|
|
roomKey: string,
|
|
macroKey: string,
|
|
deviceKey: string,
|
|
}
|
|
|
|
class HubDataProvider {
|
|
//Harmony Fields
|
|
private harmonyHubAddress: string;
|
|
private harmonyConnected: boolean = false;
|
|
|
|
//Neeo Fields
|
|
private neeoHubAddress: string;
|
|
|
|
//Common Fields
|
|
private log: any;
|
|
|
|
private devices: { [name: string]: IDevice; } = {};
|
|
private states: { [controlUnitName: string]: (IActivityState | undefined) } = {};
|
|
|
|
private matrix: Matrix;
|
|
|
|
constructor(props: IHubDataProviderProps) {
|
|
this.log = props.log;
|
|
this.harmonyHubAddress = props.harmonyHubAddress;
|
|
this.neeoHubAddress = props.neeoHubAddress;
|
|
this.matrix = props.matrix;
|
|
|
|
if (this.harmonyHubAddress) {
|
|
try {
|
|
Promise.resolve(this.connectHarmony(this.harmonyHubAddress));
|
|
} catch (err) {
|
|
this.log(`Error connecting to harmony hub at ${this.harmonyHubAddress}: ${err}`);
|
|
}
|
|
}
|
|
if (this.neeoHubAddress) {
|
|
try {
|
|
Promise.resolve(this.connectNeeo(this.neeoHubAddress));
|
|
} catch (err) {
|
|
this.log(`Error connecting to neeo hub at ${this.neeoHubAddress}: ${err}`)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Power on all devices in an activity.
|
|
*/
|
|
public powerOn = async (controlUnitName: string, activity: Activity) => {
|
|
//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<IDevice> = this.states[controlUnitName]!.currentActivity.deviceSetupItems
|
|
.map((value: DeviceSetupItem): IDevice => {
|
|
return this.getDeviceFromName(value.deviceName, value.hubType);
|
|
});
|
|
|
|
//Resolve device conflicts with other controlUnits
|
|
devicesToTurnOff = this.sanitizeDeviceList(devicesToTurnOff, controlUnitName);
|
|
|
|
await Promise.all(
|
|
//Turn off devices
|
|
devicesToTurnOff.map(async (device: IDevice) => {
|
|
if (device) {
|
|
await device.powerOff();
|
|
}
|
|
})
|
|
);
|
|
|
|
|
|
this.states[controlUnitName] = undefined;
|
|
}
|
|
|
|
/**
|
|
* Start an activity
|
|
*/
|
|
public startActivity = async (controlUnitName: string, activity: Activity) => {
|
|
this.log(`Starting activity ${activity.displayName} for controlUnit: ${controlUnitName}`)
|
|
let lastActivity: Activity | undefined = undefined;
|
|
if (this.states[controlUnitName]) {
|
|
lastActivity = this.states[controlUnitName]!.currentActivity;
|
|
}
|
|
|
|
//Build potential list of devices to to turn on
|
|
let devicesToTurnOn: Array<IDevice> = activity.deviceSetupItems.map((value: DeviceSetupItem): IDevice => {
|
|
return this.getDeviceFromName(value.deviceName, value.hubType);
|
|
});
|
|
|
|
//Resolve device conflicts with other controlUnits
|
|
devicesToTurnOn = this.sanitizeDeviceList(devicesToTurnOn, controlUnitName);
|
|
|
|
//Turn on devices
|
|
await Promise.all(devicesToTurnOn.map(async (device: IDevice) => {
|
|
if (device && device.name) {
|
|
if (!device.on) {
|
|
this.log(`Turning on device ${device.name}`)
|
|
await device.powerOn();
|
|
}
|
|
}
|
|
}));
|
|
|
|
//Assign correct input
|
|
await Promise.all(
|
|
activity.deviceSetupItems.map(async (value: DeviceSetupItem) => {
|
|
let device: IDevice = this.getDeviceFromName(value.deviceName, value.hubType);
|
|
|
|
if (device && device.supportsCommand(`Input ${value.input}`)) {
|
|
let command: string = device.getCommand(`Input ${value.input}`);
|
|
await device.sendCommand(command);
|
|
}
|
|
})
|
|
);
|
|
|
|
if (activity.useMatrix) {
|
|
//get input and output
|
|
let input: Input = this.matrix.inputs.filter(e => e.inputDevice === activity.controlDeviceId)[0];
|
|
let output: Output = this.matrix.outputs.filter(e => e.outputDevice === activity.outputDeviceId)[0];
|
|
|
|
let inputCommandName: string = `In ${input.inputNumber}`;
|
|
let outputCommandName: string = `Out ${output.outputLetter}`;
|
|
|
|
let matrixDevice: IDevice = this.getDeviceFromName(this.matrix.deviceName, this.matrix.hubType);
|
|
|
|
//Route hdmi
|
|
if (matrixDevice.supportsCommand(inputCommandName) && matrixDevice.supportsCommand(outputCommandName)) {
|
|
await matrixDevice.sendCommand(matrixDevice.getCommand(inputCommandName));
|
|
await matrixDevice.sendCommand(matrixDevice.getCommand(outputCommandName));
|
|
}
|
|
}
|
|
|
|
//Build potential list of devices to turn off
|
|
if (lastActivity) {
|
|
let devicesToTurnOff: Array<IDevice> = lastActivity.deviceSetupItems.map((value: DeviceSetupItem): IDevice => {
|
|
return this.getDeviceFromName(value.deviceName, value.hubType);
|
|
});
|
|
|
|
//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: IDevice, index: number) => {
|
|
if (device && device.name && activity.deviceSetupItems.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: IDevice) => {
|
|
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"
|
|
let currentActivity: Activity = this.states[controlUnitName]!.currentActivity;
|
|
let deviceSetupItem: DeviceSetupItem = currentActivity.deviceSetupItems.filter(e => e.deviceName == currentActivity.volumeDeviceId)[0];
|
|
|
|
if (this.states[controlUnitName]) {
|
|
let volumeDevice: IDevice = this.getDeviceFromName(currentActivity.volumeDeviceId, deviceSetupItem.hubType);
|
|
if (volumeDevice.supportsCommand(volumeUpCommand)) {
|
|
volumeDevice.sendCommand(volumeDevice.getCommand(volumeUpCommand));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Volume down for current running activity.
|
|
*/
|
|
public volumeDown = async (controlUnitName: string) => {
|
|
let volumeDownCommand: string = "Volume Down"
|
|
let currentActivity: Activity = this.states[controlUnitName]!.currentActivity;
|
|
let deviceSetupItem: DeviceSetupItem = currentActivity.deviceSetupItems.filter(e => e.deviceName == currentActivity.volumeDeviceId)[0];
|
|
|
|
if (this.states[controlUnitName]) {
|
|
let volumeDevice: IDevice = this.getDeviceFromName(currentActivity.volumeDeviceId, deviceSetupItem.hubType);
|
|
if (volumeDevice.supportsCommand(volumeDownCommand)) {
|
|
volumeDevice.sendCommand(volumeDevice.getCommand(volumeDownCommand));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return if a control unit is active
|
|
* @param controlUnitName
|
|
*/
|
|
public getIsActive(controlUnitName: string): Activity | undefined {
|
|
return this.states[controlUnitName] ? this.states[controlUnitName]!.currentActivity : undefined;
|
|
}
|
|
|
|
/**
|
|
* 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<IDevice>, controlUnitName: string): Array<IDevice> {
|
|
for (let controlUnitKey in this.states) {
|
|
//Skip self
|
|
if (controlUnitKey === controlUnitName) {
|
|
continue;
|
|
}
|
|
let currentOtherState: IActivityState = this.states[controlUnitKey]!;
|
|
|
|
if (currentOtherState) {
|
|
currentOtherState.currentActivity.deviceSetupItems.forEach((value: DeviceSetupItem) => {
|
|
//there are devices to remove
|
|
if (devicesToTurnOn.some(e => e && e.name === value.deviceName)) {
|
|
let deviceToRemove: IDevice = devicesToTurnOn.filter(i => i.name === value.deviceName)[0];
|
|
delete devicesToTurnOn[devicesToTurnOn.indexOf(deviceToRemove)];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
return devicesToTurnOn;
|
|
}
|
|
|
|
/**
|
|
* 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 currentActivity: Activity = this.states[controlUnitName]!.currentActivity;
|
|
let deviceSetupItem: DeviceSetupItem = currentActivity.deviceSetupItems.filter(e => e.deviceName == currentActivity.volumeDeviceId)[0];
|
|
|
|
let device: IDevice = this.getDeviceFromName(this.states[controlUnitName]!.currentActivity.controlDeviceId, deviceSetupItem.hubType);
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (device && device.supportsCommand(commandName)) {
|
|
device.sendCommand(device.getCommand(commandName));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the IDevice by name.
|
|
* @param deviceName The device to retrieve.
|
|
*/
|
|
private getDeviceFromName(deviceName: string, hubType: hub): IDevice {
|
|
return this.devices[`${hubType}-${deviceName}`];
|
|
}
|
|
|
|
/**
|
|
* Connect to harmony hub and receive device info.
|
|
*/
|
|
private connectHarmony = async (address: string): Promise<void> => {
|
|
let harmony: any = new Harmony();
|
|
//Listeners
|
|
harmony.on('open', () => {
|
|
this.harmonyConnected = true;
|
|
});
|
|
harmony.on('close', () => {
|
|
this.harmonyConnected = false;
|
|
});
|
|
await harmony.connect(address);
|
|
let self = this;
|
|
|
|
setTimeout(async function () {
|
|
if (self.harmonyConnected) {
|
|
let devices: any = await harmony.getDevices();
|
|
try {
|
|
await Promise.all(
|
|
//Add each to dictionary
|
|
devices.map(async (dev: any) => {
|
|
//get commands
|
|
let commands: { [name: string]: string } = {};
|
|
let deviceCommands: any = await harmony.getDeviceCommands(dev.id);
|
|
deviceCommands.forEach((command: any) => {
|
|
commands[command.label] = command.action;
|
|
});
|
|
self.devices[`Harmony-${dev.label}`] = {
|
|
id: dev.id,
|
|
name: dev.label,
|
|
commands: commands,
|
|
harmony: harmony,
|
|
hubType: "Harmony",
|
|
log: self.log,
|
|
on: false,
|
|
//Define device methods
|
|
supportsCommand(commandName: string): boolean {
|
|
let command = commands[commandName];
|
|
return (command) ? true : false;
|
|
},
|
|
getCommand(commandName: string): string {
|
|
return commands[commandName];
|
|
},
|
|
async powerOn(): Promise<void> {
|
|
let powerOnCommand: string = "Power On";
|
|
let powerToggleCommand: string = "Power Toggle";
|
|
if (this.supportsCommand(powerOnCommand)) {
|
|
await this.sendCommand(this.getCommand(powerOnCommand));
|
|
this.on = true;
|
|
} else if (this.supportsCommand(powerToggleCommand)) {
|
|
await this.sendCommand(this.getCommand(powerToggleCommand));
|
|
this.on = true;
|
|
}
|
|
},
|
|
async powerOff(): Promise<void> {
|
|
let powerOffCommand: string = "Power Off";
|
|
let powerToggleCommand: string = "Power Toggle";
|
|
if (this.supportsCommand(powerOffCommand)) {
|
|
await this.sendCommand(this.getCommand(powerOffCommand));
|
|
this.on = false;
|
|
} else if (this.supportsCommand(powerToggleCommand)) {
|
|
await this.sendCommand(this.getCommand(powerToggleCommand));
|
|
this.on = false;
|
|
}
|
|
},
|
|
async sendCommand(command: string): Promise<void> {
|
|
try {
|
|
//Execute command
|
|
let response = await this.harmony.sendCommand(JSON.stringify(command));
|
|
|
|
//Sleep
|
|
await sleep(800);
|
|
} catch (err) {
|
|
this.log(`ERROR - error sending command to harmony: ${err}`);
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
self.log(`Harmony data provider ready`);
|
|
|
|
} catch (err) {
|
|
self.log(`ERROR - error connecting to harmony: ${err}`);
|
|
}
|
|
}
|
|
}, 1000);
|
|
}
|
|
|
|
private connectNeeo = async (address: string): Promise<void> => {
|
|
|
|
let baseUrl = `http://${address}:3000/v1/projects/home`;
|
|
|
|
let response: any = await fetch(`${baseUrl}/rooms`);
|
|
let rooms: { [key: string]: any } = await response.json();
|
|
|
|
function regularizeString(str: string) {
|
|
str = str.toLowerCase();
|
|
return str.replace(/(?:^|\s)\S/g, function (a) { return a.toUpperCase(); });
|
|
}
|
|
|
|
for (let key in rooms) {
|
|
let devices: { [key: string]: any } = rooms[key].devices;
|
|
for (let deviceKey in devices) {
|
|
let device = devices[deviceKey];
|
|
|
|
//shape commands from macros
|
|
let commands: { [item: string]: any } = {};
|
|
for (let macroKey in device.macros) {
|
|
let macro: any = device.macros[macroKey];
|
|
commands[regularizeString(macro.name)] = {
|
|
deviceKey: macro.deviceKey,
|
|
macroKey: macro.key,
|
|
roomKey: macro.roomKey,
|
|
};
|
|
}
|
|
|
|
this.devices[`Neeo-${deviceKey}`] = {
|
|
id: device.key,
|
|
name: device.name,
|
|
log: this.log,
|
|
hubType: "Neeo",
|
|
commands: commands,
|
|
on: false,
|
|
supportsCommand(commandName: string): boolean {
|
|
let command = this.commands[commandName];
|
|
return (command) ? true : false;
|
|
},
|
|
|
|
getCommand(commandName: string): string {
|
|
return this.commands[commandName];
|
|
},
|
|
|
|
async sendCommand(command: string): Promise<void> {
|
|
if (this.supportsCommand(command)) {
|
|
let macro: INeeoMacro = this.commands[command];
|
|
let url: string = `${baseUrl}/rooms/${macro.roomKey}/devices/${macro.deviceKey}/macros/${macro.macroKey}/trigger`;
|
|
this.log(`Sending command ${url}`);
|
|
fetch(`${baseUrl}/rooms/${macro.roomKey}/devices/${macro.deviceKey}/macros/${macro.macroKey}/trigger`);
|
|
}
|
|
},
|
|
|
|
async powerOn(): Promise<void> {
|
|
let powerOnCommand: string = "Power On";
|
|
let powerToggleCommand: string = "Power Toggle";
|
|
if (this.supportsCommand(powerOnCommand)) {
|
|
await this.sendCommand(powerOnCommand);
|
|
this.on = true;
|
|
} else if (this.supportsCommand(powerToggleCommand)) {
|
|
await this.sendCommand(powerToggleCommand);
|
|
this.on = true;
|
|
}
|
|
},
|
|
async powerOff(): Promise<void> {
|
|
let powerOffCommand: string = "Power Off";
|
|
let powerToggleCommand: string = "Power Toggle";
|
|
if (this.supportsCommand(powerOffCommand)) {
|
|
await this.sendCommand(powerOffCommand);
|
|
this.on = false;
|
|
} else if (this.supportsCommand(powerToggleCommand)) {
|
|
await this.sendCommand(powerToggleCommand);
|
|
this.on = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
export default HubDataProvider; |