homebridge-openrgb-multi 6.4.0

package/src/Device.ts

@@ -0,0 +1,175 @@
+import ReadWriteLock from 'rwlock';
+import { Vector2 } from 'three';
+import { utils as openRgbUtils } from 'openrgb-sdk';
+import OpenRGBDevice from 'openrgb-sdk/types/device';
+import {
+  colorToString,
+  ColorHSV,
+  ColorRGB,
+  DEFAULT_COLOR,
+  convertColorSpace,
+  ColorSpace,
+} from '@manganese/palette-kit-core';
+import { Controller, ApplyParameters } from '@manganese/effect-kit';
+import { Context, DeviceConfiguration } from './types';
+import { logBoolean } from 'helpers-for-homebridge';
+
+export class Device implements Controller {
+  private openRgbDeviceId: number = -1;
+  private lock = new ReadWriteLock();
+  private colors: ColorHSV[];
+  private size: number;
+
+  constructor(
+    private readonly configuration: DeviceConfiguration,
+    private readonly context: Context
+  ) {}
+
+  public get name() {
+    return this.configuration.name;
+  }
+
+  private get position(): Vector2 {
+    return new Vector2(
+      this.configuration.position.x,
+      this.configuration.position.y
+    );
+  }
+
+  private get virtual() {
+    return this.configuration.virtual ?? false;
+  }
+
+  public async initialize() {
+    if (this.virtual) {
+      this.context.log.info(
+        `Initialized virtual device <${this.configuration.name}>`
+      );
+    } else {
+      const openRgbDevices =
+        await (this.context.openRgbClient.getAllControllerData() as unknown as Promise<
+          OpenRGBDevice[]
+        >);
+      const openRgbDevice = openRgbDevices.find(
+        (openRgb) =>
+          (openRgb as any).serial.replace(/\s+$/g, '') ===
+          this.configuration.serial
+      );
+
+      if (!openRgbDevice) {
+        this.context.log.warn(
+          `Could not resolve device <${this.name}> to OpenRGB controller`
+        );
+      } else {
+        this.openRgbDeviceId = openRgbDevice.deviceId;
+        this.size = openRgbDevice.leds.length;
+        this.colors = new Array(this.size).fill(DEFAULT_COLOR);
+        this.context.log.info(
+          `Resolved device <${this.name}> to OpenRGB controller ID [${this.openRgbDeviceId}] with size ${this.size}`
+        );
+      }
+    }
+  }
+
+  private async withWriteLock(callback: () => Promise<void>) {
+    if (!this.virtual && this.openRgbDeviceId < 0) {
+      this.context.log.warn(
+        `Ignoring write lock request because device <${this.name}> was not initialized`
+      );
+
+      return;
+    }
+
+    return this.lock.writeLock(async (release) => {
+      try {
+        await callback();
+      } catch (error) {
+        this.context.log.error('Error while holding write lock', error);
+      } finally {
+        release();
+      }
+    });
+  }
+
+  public getSize() {
+    return this.size;
+  }
+
+  public getIndexPosition(index: number) {
+    const { segments } = this.configuration;
+
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+      const segment = segments[segmentIndex];
+      const segmentLength = segment.toIndex - segment.fromIndex;
+
+      if (index < segmentLength) {
+        const ratio = index / segmentLength;
+
+        return new Vector2(
+          this.position.x +
+            segment.fromPosition.x +
+            (segment.toPosition.x - segment.fromPosition.x) * ratio,
+          this.position.y +
+            segment.fromPosition.y +
+            (segment.toPosition.y - segment.fromPosition.y) * ratio
+        );
+      } else {
+        index -= segmentLength;
+      }
+    }
+
+    return this.position;
+  }
+
+  public async setActive(active: boolean) {
+    await this.withWriteLock(async () => {
+      if (this.virtual) return;
+
+      this.context.log.debug(
+        `Applied <${this.name}>.active = ${logBoolean(active)}`
+      );
+    });
+  }
+
+  public async applyRange(
+    fromIndex: number,
+    toIndex: number,
+    colors: ColorHSV[],
+    parameters?: ApplyParameters
+  ) {
+    await this.withWriteLock(async () => {
+      if (!this.virtual) {
+        this.context.openRgbClient.updateLeds(
+          this.openRgbDeviceId,
+          new Array(this.size)
+            .fill(DEFAULT_COLOR)
+            .map((defaultColor, index) => {
+              if (index >= fromIndex && index < toIndex) {
+                return colors[index - fromIndex];
+              } else {
+                return this.colors[index];
+              }
+            })
+            .map((colorHsv) => {
+              return openRgbUtils.HSVColor(
+                colorHsv.hue * 360,
+                colorHsv.saturation,
+                colorHsv.value
+              );
+            })
+        );
+
+        for (let index = fromIndex; index < toIndex; index++) {
+          this.colors[index] = colors[index - fromIndex];
+        }
+      }
+
+      this.context.log.debug(
+        `Applied <${this.name}>[${fromIndex}-${toIndex}] = [\n${colors
+          .map(colorToString)
+          .map((colorString) => '  ' + colorString)
+          .join(',\n')}\n]`
+      );
+    });
+  }
+}

package/src/Zone.ts

@@ -0,0 +1,82 @@
+import { Context, ZoneConfiguration } from './types';
+import { Device } from './Device';
+import {
+  logAccessoryName,
+  logBoolean,
+  logPercent,
+} from 'helpers-for-homebridge';
+import { Effect, Zone as EffectKitZone } from '@manganese/effect-kit';
+
+export class Zone extends EffectKitZone {
+  constructor(
+    protected override configuration: ZoneConfiguration,
+    protected override context: Context
+  ) {
+    const devices = new Set(
+      configuration.devices.map((deviceConfiguration) => {
+        return new Device(deviceConfiguration, context);
+      })
+    );
+
+    super(configuration, devices, context);
+
+    this.devices = devices;
+  }
+
+  // Initialization
+  public async initialize() {
+    await super.initialize();
+
+    if (this.context.persistence) {
+      const active = await this.context.persistence.getZoneActive(this.id);
+      const brightness = await this.context.persistence.getZoneBrightness(
+        this.id
+      );
+      const effectId = await this.context.persistence.getZoneEffectId(this.id);
+
+      if (effectId) {
+        const effect = this.getEffect<Effect<any>>(effectId);
+
+        this.context.log.debug(
+          `Restoring persisted zone ${logAccessoryName(
+            this.name
+          )} effect ID = [${effect.name}]`
+        );
+
+        await this.setEffectId(effectId);
+      }
+
+      this.context.log.debug(
+        `Restoring persisted zone ${logAccessoryName(
+          this.name
+        )} active = ${logBoolean(active)}, brightness = ${logPercent(
+          brightness
+        )}`
+      );
+
+      await this.setBrightness(brightness);
+      await this.setActive(active);
+    }
+
+    this.on('updateActive', async (active: boolean) => {
+      await this.context.persistence.setZoneActive(this.id, active);
+    });
+
+    this.on('updateBrightness', async (brightness: number) => {
+      await this.context.persistence.setZoneBrightness(this.id, brightness);
+    });
+
+    this.on('updateEffect', async (effectId: string | null) => {
+      if (effectId) {
+        await this.context.persistence.setZoneEffectId(this.id, effectId);
+      }
+    });
+  }
+
+  // Devices
+  private devices: Set<Device>;
+
+  private get devicesArray() {
+    return Array.from(this.devices);
+  }
+}

package/src/accessories/ZoneBrightnessAccessory.ts

@@ -0,0 +1,27 @@
+import { BrightnessAccessory } from 'helpers-for-homebridge';
+import { Context } from '../types';
+import { Zone } from '../Zone';
+
+export class ZoneBrightnessAccessory extends BrightnessAccessory {
+  constructor(
+    private readonly zone: Zone,
+    context: Context
+  ) {
+    super(
+      {
+        name: zone.name + ' Brightness',
+        serial: zone.id + '_brightness',
+        model: 'OpenRGB Multi Zone Brightness',
+      },
+      context
+    );
+  }
+
+  public override async getBrightness(): Promise<number> {
+    return this.zone.getBrightness();
+  }
+
+  public override async setBrightness(brightness: number): Promise<void> {
+    return this.zone.setBrightness(brightness);
+  }
+}

package/src/accessories/ZoneEffectAccessory.ts

@@ -0,0 +1,44 @@
+import { SelectionAccessory } from 'helpers-for-homebridge';
+import { Context } from '../types';
+import { Zone } from '../Zone';
+import { ZONE_EFFECT_SELECTION_ACCESSORY_MODE } from '../constants';
+
+export class ZoneEffectAccessory extends SelectionAccessory {
+  constructor(
+    private readonly zone: Zone,
+    context: Context
+  ) {
+    super(
+      {
+        name: zone.name + ' Effect',
+        serial: zone.id + '_effect',
+        model: 'OpenRGB Multi Zone Effect',
+        mode: ZONE_EFFECT_SELECTION_ACCESSORY_MODE,
+        options: Array.from(zone.getEffects().values()).map((effect) => {
+          return {
+            name: effect.name,
+            id: effect.id,
+            hapIdentifier: effect.hapIdentifier,
+          };
+        }),
+      },
+      context
+    );
+  }
+
+  protected override async getActiveOptionId() {
+    return this.zone.getEffectIdOrDefault();
+  }
+
+  protected override async setActiveOptionId(effectId: string) {
+    await this.zone.setActiveEffectId(effectId);
+  }
+
+  protected override async getActive() {
+    return this.zone.active;
+  }
+
+  protected override async setActive(active: boolean) {
+    await this.zone.setActive(active);
+  }
+}

package/src/accessories/ZoneSceneTransitionAccessory.ts

@@ -0,0 +1,29 @@
+import { SwitchAccessory } from 'helpers-for-homebridge';
+import { Context } from '../types';
+import { Zone } from '../Zone';
+
+export class ZoneSceneTransitionAccessory extends SwitchAccessory {
+  constructor(
+    private readonly zone: Zone,
+    context: Context
+  ) {
+    super(
+      {
+        name: zone.name + ' Scene Transition',
+        serial: zone.id + '_scene_transition',
+        model: 'OpenRGB Multi Zone Scene Transition',
+      },
+      context
+    );
+  }
+
+  public override async getOn(): Promise<boolean> {
+    return this.zone.sceneTransitionActive;
+  }
+
+  public override async setOn(on: boolean): Promise<void> {
+    if (!on) return;
+
+    this.zone.sceneTransition();
+  }
+}

package/src/accessories/index.ts

@@ -0,0 +1,3 @@
+export * from './ZoneEffectAccessory';
+export * from './ZoneBrightnessAccessory';
+export * from './ZoneSceneTransitionAccessory';

package/src/constants.ts

@@ -0,0 +1,11 @@
+import SimpleLogger from 'simple-node-logger';
+import { SelectionAccessoryMode } from 'helpers-for-homebridge';
+
+export const DEFAULT_PERSISTENCE_FILENAME = 'openrgb.json';
+export const DEFAULT_OPENRGB_HOST = 'localhost';
+export const DEFAULT_OPENRGB_PORT = 6742;
+export const DEFAULT_LOG_LEVEL: SimpleLogger.STANDARD_LEVELS = 'info';
+export const DEFAULT_DURATION = 1000;
+export const EFFECT_TRANSITION_DURATION = 500;
+export const ZONE_EFFECT_SELECTION_ACCESSORY_MODE: SelectionAccessoryMode =
+  'outlet';

package/src/index.ts

@@ -0,0 +1,16 @@
+import { createPlatform } from './platformFactory';
+
+export * from './types';
+export * from './constants';
+export * from './Zone';
+export * from './Device';
+
+export default (homebridge: any) => {
+  const Platform = createPlatform(homebridge);
+
+  homebridge.registerPlatform(
+    'homebridge-openrgb-multi',
+    'OpenRGBMulti',
+    Platform
+  );
+};

package/src/platformFactory.ts

@@ -0,0 +1,116 @@
+import { Logger } from 'simple-node-logger';
+import { Client as OpenRGBClient } from 'openrgb-sdk';
+import { API, Logging } from 'homebridge';
+import { HomebridgeLogAppender } from 'helpers-for-homebridge';
+import { Palette } from '@manganese/palette-kit-core';
+import { PaletteClient } from '@manganese/palette-kit-client';
+
+import { Context, PlatformConfiguration } from './types';
+import { PersistenceService } from './services';
+import {
+  ZoneBrightnessAccessory,
+  ZoneEffectAccessory,
+  ZoneSceneTransitionAccessory,
+} from './accessories';
+import { Zone } from './Zone';
+import { DEFAULT_OPENRGB_HOST, DEFAULT_OPENRGB_PORT } from './constants';
+
+export const createPlatform = (homebridge: API) => {
+  class Platform {
+    context: Context;
+    zones = new Map<string /* zone ID */, Zone>();
+
+    constructor(
+      homebridgeLog: Logging,
+      readonly configuration: PlatformConfiguration
+    ) {
+      const log = new Logger({
+        level: 'debug',
+        appenders: [new HomebridgeLogAppender(homebridgeLog)],
+      });
+      const persistence = new PersistenceService({
+        homebridge,
+        log,
+      });
+
+      const openRgbClient = new OpenRGBClient(
+        'default',
+        configuration.openRgbPort ?? DEFAULT_OPENRGB_PORT,
+        configuration.openRgbHost ?? DEFAULT_OPENRGB_HOST
+      );
+
+      const palette = new Palette({}, { log });
+      const paletteClient = configuration.paletteClient
+        ? new PaletteClient(
+            configuration.paletteClient,
+            {
+              log,
+            },
+            palette
+          )
+        : null;
+
+      this.context = {
+        homebridge,
+        openRgbClient,
+        palette,
+        paletteClient,
+        log,
+        persistence,
+      };
+
+      configuration.zones.forEach((zoneConfiguration) => {
+        const zone = new Zone(zoneConfiguration, this.context);
+
+        this.zones.set(zone.id, zone);
+      });
+    }
+
+    public async accessories(callback) {
+      await this.context.openRgbClient.connect();
+      await this.context.paletteClient.connect();
+      await Promise.all(
+        Array.from(this.zones.values()).map(async (zone) => {
+          return await zone.initialize();
+        })
+      );
+
+      const zoneAccessories = Array.from(this.zones.values()).flatMap(
+        (zone) => {
+          const zoneEffectAccessory = new ZoneEffectAccessory(
+            zone,
+            this.context
+          );
+          const zoneBrightnessAccessory = new ZoneBrightnessAccessory(
+            zone,
+            this.context
+          );
+          const zoneSceneTransitionAccessory = new ZoneSceneTransitionAccessory(
+            zone,
+            this.context
+          );
+
+          zone.on('updateBrightness', (brightness) => {
+            zoneBrightnessAccessory.updateBrightness(brightness);
+          });
+
+          zone.on('updateSceneTransitionActive', (sceneTransitionActive) => {
+            zoneSceneTransitionAccessory.update(sceneTransitionActive);
+          });
+
+          return [
+            zoneEffectAccessory,
+            zoneBrightnessAccessory,
+            zoneSceneTransitionAccessory,
+          ];
+        }
+      );
+
+      const accessories = [...zoneAccessories];
+
+      callback(accessories);
+    }
+  }
+
+  return Platform;
+};

package/src/services/PersistenceService.ts

@@ -0,0 +1,74 @@
+import {
+  BasicPersistenceService,
+  Context,
+  logAccessoryName,
+} from 'helpers-for-homebridge';
+import { PlatformPersistence, ZonePersistence } from '../types';
+import { DEFAULT_PERSISTENCE_FILENAME } from '../constants';
+
+export class PersistenceService extends BasicPersistenceService<PlatformPersistence> {
+  constructor(context: Context) {
+    super(
+      {
+        fileName: DEFAULT_PERSISTENCE_FILENAME,
+        defaultValue: {
+          zones: {},
+        },
+      },
+      context
+    );
+  }
+
+  async getZonePersistence(zoneId: string): Promise<ZonePersistence | null> {
+    const persistence = await this.readPersistence();
+
+    return persistence.zones?.[zoneId] ?? null;
+  }
+
+  async getZoneActive(zoneId: string): Promise<boolean> {
+    const zonePersistence = await this.getZonePersistence(zoneId);
+
+    return zonePersistence?.active || false;
+  }
+
+  async getZoneBrightness(zoneId: string): Promise<number> {
+    const zonePersistence = await this.getZonePersistence(zoneId);
+
+    return zonePersistence?.brightness ?? 1;
+  }
+
+  async getZoneEffectId(zoneId: string): Promise<string | null /* effect ID*/> {
+    const zonePersistence = await this.getZonePersistence(zoneId);
+
+    return zonePersistence?.effectId ?? null;
+  }
+
+  async mergeZonePersistence(
+    zoneId: string,
+    zonePersistence: Partial<ZonePersistence>
+  ): Promise<void> {
+    await this.mergePersistence({
+      zones: {
+        [zoneId]: zonePersistence,
+      },
+    });
+  }
+
+  async setZoneActive(zoneId: string, active: boolean): Promise<void> {
+    await this.mergeZonePersistence(zoneId, {
+      active,
+    });
+  }
+
+  async setZoneBrightness(zoneId: string, brightness: number): Promise<void> {
+    await this.mergeZonePersistence(zoneId, {
+      brightness,
+    });
+  }
+
+  async setZoneEffectId(zoneId: string, effectId: string): Promise<void> {
+    await this.mergeZonePersistence(zoneId, {
+      effectId,
+    });
+  }
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from './PersistenceService';

package/src/test.ts

@@ -0,0 +1,44 @@
+import { Client as OpenRGBClient } from 'openrgb-sdk';
+
+(async () => {
+  const openRgbClient = new OpenRGBClient(
+    'default',
+    6742,
+    'living-room-node.local.mangane.se'
+  );
+
+  await openRgbClient.connect();
+
+  const openRgbDevices = await openRgbClient.getAllControllerData();
+
+  console.log(openRgbDevices);
+  const openRgbDevice = (openRgbDevices as any).find(
+    (openRgbDevice) =>
+      (openRgbDevice as any).serial.replace(/\s+$/g, '') === '282039U09401607'
+  );
+
+  console.log(JSON.stringify((openRgbDevices[0] as any).serial));
+  console.log(
+    JSON.stringify((openRgbDevices[0] as any).serial.replace(/\s/g, ''))
+  );
+  console.log(openRgbDevice);
+
+  // openRgbClient.updateLeds(
+  //   openRgbDevice.deviceId,
+  //   openRgbDevice.colors.map((color, index) => {
+  //     if (index !== 8) return color;
+
+  //     return {
+  //       red: 255,
+  //       green: 0,
+  //       blue: 255,
+  //     };
+  //   })
+  // );
+
+  // // const openRgbDevices = await Promise.all(
+  // //   openRgbClient.getAllControllerData()
+  // // );
+
+  // // console.log(openRgbDevices);
+})();

package/src/types/Context.ts

@@ -0,0 +1,15 @@
+import { API } from 'homebridge';
+import { Logger } from 'simple-node-logger';
+import OpenRGBClient from 'openrgb-sdk/types/client';
+import { PaletteClient } from '@manganese/palette-kit-client';
+import { Palette } from '@manganese/palette-kit-core';
+import { PersistenceService } from '../services';
+
+export interface Context {
+  homebridge: API;
+  openRgbClient: OpenRGBClient;
+  palette: Palette;
+  paletteClient: PaletteClient | null;
+  log: Logger;
+  persistence: PersistenceService;
+}

package/src/types/configuration/ConfigurationVector2.ts

@@ -0,0 +1,4 @@
+export interface ConfigurationVector2 {
+  x: number;
+  y: number;
+}

package/src/types/configuration/DeviceConfiguration.ts

@@ -0,0 +1,9 @@
+import { ConfigurationVector2, SegmentConfiguration } from '.';
+
+export interface DeviceConfiguration {
+  name: string;
+  serial: string;
+  position: ConfigurationVector2;
+  segments: SegmentConfiguration[];
+  virtual?: boolean;
+}

package/src/types/configuration/PlatformConfiguration.ts

@@ -0,0 +1,11 @@
+import { ClientConfiguration } from '@manganese/palette-kit-client';
+import { ZoneConfiguration } from '.';
+
+export interface PlatformConfiguration {
+  discoveryInterval?: number;
+  networkInterfaces?: string[];
+  openRgbHost: string;
+  openRgbPort: number;
+  paletteClient?: ClientConfiguration;
+  zones: ZoneConfiguration[];
+}

package/src/types/configuration/SegmentConfiguration.ts

@@ -0,0 +1,8 @@
+import { ConfigurationVector2 } from '.';
+
+export interface SegmentConfiguration {
+  fromIndex: number;
+  toIndex: number;
+  fromPosition: ConfigurationVector2;
+  toPosition: ConfigurationVector2;
+}

package/src/types/configuration/ZoneConfiguration.ts

@@ -0,0 +1,7 @@
+import { ZoneConfiguration as EffectKitZoneConfiguration } from '@manganese/effect-kit';
+import { DeviceConfiguration } from './DeviceConfiguration';
+
+export interface ZoneConfiguration extends EffectKitZoneConfiguration {
+  trueOff?: boolean;
+  devices: DeviceConfiguration[];
+}