homebridge-nanoleaf-multi 1.0.0

package/src/WaveEffect.ts

@@ -0,0 +1,95 @@
+import {
+  ColorHSV,
+  colorToColorHSV,
+  ColorType as CoreColorType,
+} from '@manganese/palette-kit-core';
+import { ClientColorType } from '@manganese/palette-kit-client';
+
+import {
+  Context,
+  WaveEffectConfiguration,
+  EffectColorConfiguration,
+  ConstantEffectColorConfiguration,
+  DynamicEffectColorConfiguration,
+  RemoteEffectColorConfiguration,
+  NativeEffectType,
+  NativeEffectOption,
+} from './types';
+import { EFFECT_SPEED_COEFFICIENT, NATIVE_EFFECT_BASE } from './constants';
+import {
+  colorToNanoleafColor,
+  nativeEffectTypeToPluginUuid,
+} from './utilities';
+import Effect from './Effect';
+import Device from './Device';
+
+export default class WaveEffect extends Effect<WaveEffectConfiguration> {
+  private colors = new Map<string /* color ID */, ColorHSV>();
+
+  constructor(configuration: WaveEffectConfiguration, context: Context) {
+    super(configuration, context);
+  }
+
+  public async initialize() {}
+
+  private getColor(colorConfiguration: EffectColorConfiguration) {
+    switch (colorConfiguration.type) {
+      case CoreColorType.Constant:
+        return colorToColorHSV(
+          (colorConfiguration as ConstantEffectColorConfiguration).color
+        );
+      case CoreColorType.Dynamic:
+      case ClientColorType.Remote:
+        return this.colors.get(
+          (
+            colorConfiguration as
+              | DynamicEffectColorConfiguration
+              | RemoteEffectColorConfiguration
+          ).id
+        );
+    }
+  }
+
+  public getNativeEffectForDevice(device: Device) {
+    const colorsPerFrame =
+      1 + Math.ceil(device.size / this.configuration.colorSize);
+
+    return {
+      ...NATIVE_EFFECT_BASE,
+      ...this.nativeEffectBase,
+      pluginUuid: nativeEffectTypeToPluginUuid(NativeEffectType.Wheel),
+      pluginOptions: [
+        {
+          name: 'linDirection',
+          value: this.configuration.direction,
+        } as NativeEffectOption,
+        {
+          name: 'loop',
+          value: true,
+        } as NativeEffectOption,
+        {
+          name: 'nColorsPerFrame',
+          value: colorsPerFrame,
+        } as NativeEffectOption,
+        {
+          name: 'transTime',
+          value: this.configuration.transitionTime / colorsPerFrame,
+        } as NativeEffectOption,
+      ],
+      palette: this.configuration.colors.map((colorConfiguration) => {
+        const color = this.getColor(colorConfiguration);
+
+        return colorToNanoleafColor(color, colorConfiguration.probability);
+      }),
+    };
+  }
+
+  public getColors() {
+    return this.configuration.colors;
+  }
+
+  public setColor(colorId: string, color: ColorHSV) {
+    this.colors.set(colorId, color);
+    this.handleChange();
+  }
+}

package/src/Zone.ts

@@ -0,0 +1,151 @@
+import {
+  Context,
+  ZoneConfiguration,
+  EffectType,
+  EffectConfiguration,
+  EffectConfigurationBase,
+  SolidEffectConfiguration,
+  WaveEffectConfiguration,
+  RandomEffectConfiguration,
+} from './types';
+import { EFFECT_CHANGE_EVENT } from './constants';
+
+import Device from './Device';
+import Effect from './Effect';
+import SolidEffect from './SolidEffect';
+import WaveEffect from './WaveEffect';
+import RandomEffect from './RandomEffect';
+
+export default class Zone {
+  public readonly configuration: ZoneConfiguration;
+  private context: Context;
+
+  constructor(configuration: ZoneConfiguration, context: Context) {
+    this.configuration = configuration;
+    this.context = context;
+
+    configuration.devices.forEach((deviceConfiguration) => {
+      const device = new Device(deviceConfiguration, context);
+
+      this.devices.add(device);
+    });
+
+    this.configuration.effects?.forEach((effectConfiguration) => {
+      const effect = this.createEffect(effectConfiguration);
+      effect.on(EFFECT_CHANGE_EVENT, () => {
+        if (this.activeEffectId !== effect.id) return;
+
+        // TODO log
+
+        this.setActiveEffect(effect);
+      });
+
+      this.effects.set(effect.id, effect);
+    });
+  }
+
+  public get name() {
+    return this.configuration.name;
+  }
+
+  public get id() {
+    return this.configuration.id;
+  }
+
+  public createEffect(configuration: EffectConfiguration) {
+    switch (configuration.type) {
+      case EffectType.Solid:
+        return new SolidEffect(
+          configuration as SolidEffectConfiguration,
+          this.context
+        );
+      case EffectType.Wave:
+        return new WaveEffect(
+          configuration as WaveEffectConfiguration,
+          this.context
+        );
+      case EffectType.Random:
+        return new RandomEffect(
+          configuration as RandomEffectConfiguration,
+          this.context
+        );
+    }
+  }
+
+  // Initialization
+  public async initialize() {
+    await Promise.all(
+      this.devicesArray.map(async (device) => {
+        try {
+          await device.initialize();
+        } catch (error) {
+          this.context.log.error(
+            `Failed to initialize device <${device.name}>`,
+            error
+          );
+        }
+      })
+    );
+  }
+
+  // Devices
+  private devices = new Set<Device>();
+
+  private get devicesArray() {
+    return Array.from(this.devices);
+  }
+
+  public async setActive(active: boolean) {
+    await Promise.all(
+      this.devicesArray.map(async (device) => {
+        await device.setActive(active);
+      })
+    );
+  }
+
+  // Effects
+  private effects = new Map<string, Effect<any>>();
+  private activeEffectId: string;
+
+  public getEffects() {
+    return this.effects;
+  }
+
+  public getEffect<T extends Effect<any> = Effect<EffectConfigurationBase>>(
+    effectId: string
+  ): T | null {
+    const effect = this.effects.get(effectId);
+
+    return (effect as T) || null;
+  }
+
+  public get activeEffect() {
+    return this.getEffect(this.activeEffectId);
+  }
+
+  public getDefaultActiveEffectId() {
+    if (this.effects.size === 0) {
+      return null;
+    }
+
+    return Array.from(this.effects.values())[0].id;
+  }
+
+  public async setActiveEffectById(effectId: string) {
+    this.activeEffectId = effectId;
+
+    await this.setActiveEffect(this.activeEffect);
+  }
+
+  public async setActiveEffect(effect: Effect<any>) {
+    await Promise.all(
+      Array.from(this.devices).map((device) => {
+        device.setActiveEffect(effect);
+      })
+    );
+  }
+
+  public getActiveEffectId() {
+    return this.activeEffectId;
+  }
+}

package/src/accessories/DynamicEffectColorAccessory.ts

@@ -0,0 +1,19 @@
+import { LocalPaletteColorAccessory } from 'helpers-for-homebridge';
+import { Context, DynamicEffectColorConfiguration } from '../types';
+
+export default class DynamicEffectColorAccessory extends LocalPaletteColorAccessory {
+  constructor(
+    colorConfiguration: DynamicEffectColorConfiguration,
+    context: Context
+  ) {
+    super(
+      context.palette,
+      {
+        ...colorConfiguration,
+        name: colorConfiguration.name,
+        colorId: colorConfiguration.id,
+      },
+      context
+    );
+  }
+}

package/src/accessories/ZoneAccessory.ts

@@ -0,0 +1,46 @@
+import { SelectionAccessory } from 'helpers-for-homebridge';
+import { Context } from '../types';
+import Zone from '../Zone';
+
+export default class ZoneAccessory extends SelectionAccessory {
+  constructor(private readonly zone: Zone, context: Context) {
+    super(
+      {
+        name: zone.name,
+        options: zone.configuration.effects.map((effectConfiguration) => {
+          return {
+            name: effectConfiguration.name,
+            id: effectConfiguration.id,
+            hapIdentifier: effectConfiguration.hapIdentifier,
+          };
+        }),
+      },
+      context
+    );
+
+    this.activeOptionId = this.configuration.options[0].id;
+  }
+
+  private active: boolean = false;
+  private activeOptionId: string;
+
+  protected override async getActiveOptionId() {
+    return this.activeOptionId;
+  }
+
+  protected override async setActiveOptionId(effectId: string) {
+    this.activeOptionId = effectId;
+
+    await this.zone.setActiveEffectById(effectId);
+  }
+
+  protected override async getActive() {
+    return this.active;
+  }
+
+  protected override async setActive(active: boolean) {
+    this.active = active;
+
+    await this.zone.setActive(active);
+  }
+}

package/src/accessories/index.ts

@@ -0,0 +1,4 @@
+import DynamicEffectColorAccessory from './DynamicEffectColorAccessory';
+import ZoneAccessory from './ZoneAccessory';
+
+export { DynamicEffectColorAccessory, ZoneAccessory };

package/src/constants.ts

@@ -0,0 +1,32 @@
+import { ColorHSV, ColorSpace } from '@manganese/palette-kit-core';
+import { NativeEffect, NativeEffectType } from './types';
+
+export const OFF_COLOR: ColorHSV = {
+  space: ColorSpace.HSV,
+  hue: 0,
+  saturation: 0,
+  value: 0,
+};
+export const DEFAULT_DEVICE_SIZE = 50;
+export const EFFECT_CHANGE_EVENT = 'change';
+export const EFFECT_SPEED_COEFFICIENT = 300;
+export const DEFAULT_NATIVE_EFFECT_NAME = 'Dynamic Effect';
+export const NATIVE_EFFECT_TYPE_UUIDS = new Map<NativeEffectType, string>([
+  [NativeEffectType.Wheel, '6970681a-20b5-4c5e-8813-bdaebc4ee4fa'],
+  [NativeEffectType.Flow, '027842e4-e1d6-4a4c-a731-be74a1ebd4cf'],
+  [NativeEffectType.Explode, '713518c1-d560-47db-8991-de780af71d1e'],
+  [NativeEffectType.Fade, 'b3fd723a-aae8-4c99-bf2b-087159e0ef53'],
+  [NativeEffectType.Random, 'ba632d3e-9c2b-4413-a965-510c839b3f71'],
+  [NativeEffectType.Highlight, '70b7c636-6bf8-491f-89c1-f4103508d642'],
+]);
+export const NATIVE_EFFECT_BASE: NativeEffect = {
+  version: '2.0',
+  animName: DEFAULT_NATIVE_EFFECT_NAME,
+  animType: 'plugin',
+  colorType: 'HSB',
+  palette: [],
+  pluginType: 'color',
+  pluginUuid: NATIVE_EFFECT_TYPE_UUIDS.get(NativeEffectType.Fade),
+  pluginOptions: [],
+  hasOverlay: false,
+};

package/src/index.ts

@@ -0,0 +1,11 @@
+import platformFactory from './platformFactory';
+
+export default (homebridge: any) => {
+  const Platform = platformFactory(homebridge);
+
+  homebridge.registerPlatform(
+    'homebridge-nanoleaf-multi',
+    'NanoleafMulti',
+    Platform
+  );
+};

package/src/platformFactory.ts

@@ -0,0 +1,88 @@
+import { createSimpleLogger, Logger } from 'simple-node-logger';
+import { HomebridgeLogAppender } from 'helpers-for-homebridge';
+import { Palette } from '@manganese/palette-kit-core';
+import { PaletteClient } from '@manganese/palette-kit-client';
+
+import { PlatformConfiguration, Context } from './types';
+import { DynamicEffectColorAccessory, ZoneAccessory } from './accessories';
+import Zone from './Zone';
+
+export default (homebridge: any) => {
+  class Platform {
+    context: Context;
+    zones = new Map<string /* zone ID */, Zone>();
+
+    get allEffects() {
+      return Array.from(this.zones.values()).flatMap((zone) =>
+        Array.from(zone.getEffects().values())
+      );
+    }
+
+    constructor(homebridgeLog, readonly configuration: PlatformConfiguration) {
+      const log = createSimpleLogger({
+        loggers: [
+          new Logger({
+            appenders: [new HomebridgeLogAppender(homebridgeLog)],
+          }),
+        ],
+      });
+
+      const palette = new Palette({}, { log });
+      palette.onAnyColorChange((event) => {
+        this.allEffects.forEach((effect) => {
+          if (!effect.hasColor(event.colorId)) return;
+
+          effect.setColor(event.colorId, event.colorHsv);
+        });
+      });
+
+      const paletteClient = new PaletteClient(
+        configuration.paletteClient,
+        {
+          log,
+        },
+        palette
+      );
+
+      this.context = {
+        homebridge,
+        log,
+        palette,
+        paletteClient,
+      };
+
+      this.configuration.zones.forEach((zoneConfiguration) => {
+        const zone = new Zone(zoneConfiguration, this.context);
+
+        this.zones.set(zoneConfiguration.id, zone);
+      });
+    }
+
+    public async accessories(callback) {
+      await this.context.paletteClient.connect();
+
+      const zoneAccessories = await Promise.all(
+        Array.from(this.zones.values()).map(async (zone) => {
+          await zone.initialize();
+
+          return new ZoneAccessory(zone, this.context);
+        })
+      );
+
+      const effectAccessories = this.allEffects.flatMap((effect) => {
+        return effect.getDynamicColors().map((colorConfiguration) => {
+          return new DynamicEffectColorAccessory(
+            colorConfiguration,
+            this.context
+          );
+        });
+      });
+
+      const accessories = [...zoneAccessories, ...effectAccessories];
+
+      callback(accessories);
+    }
+  }
+
+  return Platform;
+};

package/src/types/Context.ts

@@ -0,0 +1,10 @@
+import { PaletteClient } from '@manganese/palette-kit-client';
+import { Palette } from '@manganese/palette-kit-core';
+import SimpleLogger from 'simple-node-logger';
+
+export default interface Context {
+  homebridge: any;
+  palette: Palette;
+  paletteClient: PaletteClient;
+  log: SimpleLogger.Logger;
+}

package/src/types/PlatformConfiguration.ts

@@ -0,0 +1,7 @@
+import { ClientConfiguration } from '@manganese/palette-kit-client';
+import { ZoneConfiguration } from './devices';
+
+export default interface PlatformConfiguration {
+  paletteClient: ClientConfiguration;
+  zones: ZoneConfiguration[];
+}

package/src/types/devices/DeviceConfiguration.ts

@@ -0,0 +1,7 @@
+export default interface DeviceConfiguration {
+  id: string;
+  name: string;
+  ip: string;
+  token: string;
+  size?: number;
+}

package/src/types/devices/ZoneConfiguration.ts

@@ -0,0 +1,9 @@
+import DeviceConfiguration from './DeviceConfiguration';
+import EffectConfiguration from '../effects/EffectConfiguration';
+
+export default interface ZoneConfiguration {
+  id: string;
+  name: string;
+  devices: DeviceConfiguration[];
+  effects: EffectConfiguration[];
+}

package/src/types/devices/index.ts

@@ -0,0 +1,4 @@
+import ZoneConfiguration from './ZoneConfiguration';
+import DeviceConfiguration from './DeviceConfiguration';
+
+export { ZoneConfiguration, DeviceConfiguration };

package/src/types/effects/ConstantEffectColorConfiguration.ts

@@ -0,0 +1,9 @@
+import { ConstantColorConfiguration } from '@manganese/palette-kit-core';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+
+type ConstantEffectColorConfiguration<AdditionalConfigurationType = {}> =
+  ConstantColorConfiguration<
+    EffectColorConfigurationBase & AdditionalConfigurationType
+  >;
+
+export default ConstantEffectColorConfiguration;

package/src/types/effects/DynamicEffectColorConfiguration.ts

@@ -0,0 +1,12 @@
+import { DynamicColorConfiguration } from '@manganese/palette-kit-core';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+
+type DynamicEffectColorConfiguration<AdditionalConfigurationType = {}> =
+  DynamicColorConfiguration<
+    EffectColorConfigurationBase &
+      AdditionalConfigurationType & {
+        name: string;
+      }
+  >;
+
+export default DynamicEffectColorConfiguration;

package/src/types/effects/EffectColorConfiguration.ts

@@ -0,0 +1,10 @@
+import ConstantEffectColorConfiguration from './ConstantEffectColorConfiguration';
+import DynamicEffectColorConfiguration from './DynamicEffectColorConfiguration';
+import RemoteEffectColorConfiguration from './RemoteEffectColorConfiguration';
+
+type EffectColorConfiguration =
+  | ConstantEffectColorConfiguration
+  | DynamicEffectColorConfiguration
+  | RemoteEffectColorConfiguration;
+
+export default EffectColorConfiguration;

package/src/types/effects/EffectColorConfigurationBase.ts

@@ -0,0 +1,3 @@
+export default interface EffectColorConfigurationBase {
+  probability?: number;
+}

package/src/types/effects/EffectColorType.ts

@@ -0,0 +1,9 @@
+import { ClientColorType } from '@manganese/palette-kit-client';
+
+enum NativeColorType {
+  Native = 'native',
+}
+
+type EffectColorType = ClientColorType | NativeColorType;
+
+export default EffectColorType;

package/src/types/effects/EffectConfiguration.ts

@@ -0,0 +1,10 @@
+import { RandomEffectConfiguration } from './random-effect';
+import { SolidEffectConfiguration } from './solid-effect';
+import { WaveEffectConfiguration } from './wave-effect';
+
+type EffectConfiguration =
+  | SolidEffectConfiguration
+  | WaveEffectConfiguration
+  | RandomEffectConfiguration;
+
+export default EffectConfiguration;

package/src/types/effects/EffectConfigurationBase.ts

@@ -0,0 +1,9 @@
+import EffectType from './EffectType';
+
+export default interface EffectConfigurationBase {
+  type: EffectType;
+  name: string;
+  id: string;
+  nativeName?: string;
+  hapIdentifier: number;
+}

package/src/types/effects/EffectType.ts

@@ -0,0 +1,7 @@
+enum EffectType {
+  Solid = 'solid',
+  Wave = 'wave',
+  Random = 'random',
+}
+
+export default EffectType;

package/src/types/effects/RemoteEffectColorConfiguration.ts

@@ -0,0 +1,9 @@
+import { RemoteColorConfiguration } from '@manganese/palette-kit-client';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+
+type RemoteEffectColorConfiguration<AdditionalConfigurationType = {}> =
+  RemoteColorConfiguration<
+    EffectColorConfigurationBase & AdditionalConfigurationType
+  >;
+
+export default RemoteEffectColorConfiguration;

package/src/types/effects/index.ts

@@ -0,0 +1,25 @@
+import EffectType from './EffectType';
+import EffectConfiguration from './EffectConfiguration';
+import EffectConfigurationBase from './EffectConfigurationBase';
+import EffectColorType from './EffectColorType';
+import EffectColorConfiguration from './EffectColorConfiguration';
+import EffectColorConfigurationBase from './EffectColorConfigurationBase';
+import ConstantEffectColorConfiguration from './ConstantEffectColorConfiguration';
+import DynamicEffectColorConfiguration from './DynamicEffectColorConfiguration';
+import RemoteEffectColorConfiguration from './RemoteEffectColorConfiguration';
+
+export * from './native';
+export * from './solid-effect';
+export * from './wave-effect';
+export * from './random-effect';
+export {
+  EffectType,
+  EffectConfiguration,
+  EffectConfigurationBase,
+  EffectColorType,
+  EffectColorConfiguration,
+  EffectColorConfigurationBase,
+  ConstantEffectColorConfiguration,
+  DynamicEffectColorConfiguration,
+  RemoteEffectColorConfiguration,
+};

package/src/types/effects/native/NativeDirection.ts

@@ -0,0 +1,8 @@
+enum NativeDirection {
+  Left = 'left',
+  Right = 'right',
+  Up = 'up',
+  Down = 'down',
+}
+
+export default NativeDirection;

package/src/types/effects/native/NativeEffect.ts

@@ -0,0 +1,14 @@
+import NativeEffectColor from './NativeEffectColor';
+import NativeEffectOption from './NativeEffectOption';
+
+export default interface NativeEffect {
+  version: '2.0';
+  animName: string;
+  animType: 'plugin';
+  colorType: 'HSB';
+  palette: NativeEffectColor[];
+  pluginType: 'color';
+  pluginUuid: string;
+  pluginOptions: NativeEffectOption[];
+  hasOverlay: false;
+}

package/src/types/effects/native/NativeEffectColor.ts

@@ -0,0 +1,6 @@
+export default interface NativeEffectColor {
+  hue: number;
+  saturation: number;
+  brightness: number;
+  probability: number;
+}

package/src/types/effects/native/NativeEffectOption.ts

@@ -0,0 +1,25 @@
+import NativeDirection from './NativeDirection';
+
+type NativeEffectOption =
+  | {
+      name: 'delayTime';
+      value: number;
+    }
+  | {
+      name: 'transTime';
+      value: number;
+    }
+  | {
+      name: 'linDirection';
+      value: NativeDirection;
+    }
+  | {
+      name: 'loop';
+      value: boolean;
+    }
+  | {
+      name: 'nColorsPerFrame';
+      value: number;
+    };
+
+export default NativeEffectOption;