motion-master-client 0.0.11 → 0.0.13

package/src/lib/hardware-description.ts

@@ -0,0 +1,84 @@
+import { isEqual } from 'lodash';
+
+export interface HardwareComponent {
+  name: string;
+  version: string;
+  serialNumber: string;
+}
+
+export type AssemblyComponent = HardwareComponent;
+export type DeviceComponent = HardwareComponent;
+
+export interface Assembly {
+  name: string;
+  id: string;
+  version: string;
+  serialNumber: string;
+  components: AssemblyComponent[];
+}
+
+export interface HardwareDevice {
+  name: string;
+  id: string;
+  version: string;
+  keyId: string;
+  serialNumber: string;
+  macAddress: string;
+  components: DeviceComponent[];
+}
+
+/**
+ * @link https://docs.google.com/document/d/1N00-ZjxHkjoWNIsnoTtza9CUHrxm8-e54298DXLuD94
+ */
+export interface HardwareDescription {
+  fileVersion: string;
+  assembly?: Assembly;
+  device: HardwareDevice;
+}
+
+export function getIdFromHardwareDescription(hd: HardwareDescription): string {
+  return hd.assembly
+    ? hd.assembly.id
+    : hd.device.id;
+}
+
+export function getApiIdentifierFromHardwareDescription(hd: HardwareDescription, skipKeyId = false): string {
+  let apiId = hd.assembly
+    ? `${hd.assembly.id}-${hd.assembly.version}`
+    : `${hd.device.id}-${hd.device.version}`;
+
+  if (!skipKeyId && hd.device.keyId) {
+    apiId += `-${hd.device.keyId}`;
+  }
+
+  return apiId;
+}
+
+export function getNameFromHardwareDescription(hd: HardwareDescription): string {
+  return hd.assembly
+    ? hd.assembly.name
+    : hd.device.name;
+}
+
+export function getSerialNumberFromHardwareDescription(hd: HardwareDescription): string {
+  return hd.assembly
+    ? hd.assembly.serialNumber
+    : hd.device.serialNumber;
+}
+
+export function getAllComponentsFromHardwareDescription(hd: HardwareDescription): HardwareComponent[] {
+  return hd.assembly
+    ? [...hd.assembly.components, ...hd.device.components]
+    : hd.device.components;
+}
+
+export function hardwareComponentsMatch(a: HardwareComponent[], b: HardwareComponent[]): boolean {
+  if (a.length === 0 && b.length === 0) {
+    return false; // edge case: when both components are empty they don't match since there are no components to compare
+  }
+
+  const ac = a.map((c) => `${c.name}-${c.version[0]}`.replace(/\s/g, '').toLocaleLowerCase()).sort();
+  const bc = b.map((c) => `${c.name}-${c.version[0]}`.replace(/\s/g, '').toLocaleLowerCase()).sort();
+
+  return isEqual(ac, bc);
+}

package/src/lib/logger.ts

@@ -0,0 +1,5 @@
+import { Roarr } from 'roarr';
+
+export const logger = Roarr.child({
+  package: '@synapticon/motion-master-client'
+});

package/src/lib/monitoring-config.ts

@@ -0,0 +1,6 @@
+export interface MonitoringConfig {
+  readonly bufferSize?: number;
+  readonly distinct?: boolean;
+  readonly messageId: string;
+  readonly topic: string;
+}

package/src/lib/{monitoring-entry.d.ts → monitoring-entry.ts}

@@ -1,9 +1,10 @@
 import { Observable } from "rxjs";
 import { MonitoringConfig } from "./monitoring-config";
 import { MotionMasterMessage, ParameterValueType } from "./types";
+
 export interface MonitoringEntry {
-    config: MonitoringConfig;
-    interval: number;
-    values$: Observable<ParameterValueType[]>;
-    parameters: MotionMasterMessage.Request.GetDeviceParameterValues.IParameter[];
+  config: MonitoringConfig;
+  interval: number;
+  values$: Observable<ParameterValueType[]>;
+  parameters: MotionMasterMessage.Request.GetDeviceParameterValues.IParameter[];
 }

package/src/lib/motion-master-client.ts

@@ -0,0 +1,126 @@
+import { combineLatest, defer, first, firstValueFrom, map, mergeMap, Observable, timeout } from "rxjs";
+import { v4 } from "uuid";
+import { MonitoringConfig } from "./monitoring-config";
+import { MotionMasterPubSubClient } from "./motion-master-pub-sub-client";
+import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
+import { MotionMasterPubSubWebSocket } from "./motion-master-pub-sub-web-socket";
+import { MotionMasterReqResClient } from "./motion-master-req-res-client";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { MotionMasterReqResWebSocket } from "./motion-master-req-res-web-socket";
+import { mapMonitoringParameterValuesStatusMessageToParameterValues, selectMotionMasterMessageByTopic } from "./operators";
+import { DeviceRef, MotionMasterMessage, ParameterValueType } from "./types";
+
+export function createMotionMasterClient(hostname: string) {
+  const reqResSocket = new MotionMasterReqResWebSocket();
+  const pubSubSocket = new MotionMasterPubSubWebSocket();
+
+  const client = new MotionMasterClient(reqResSocket, pubSubSocket);
+
+  const clientId = v4();
+  reqResSocket.open(`ws://${hostname}:63524?clientId=${clientId}`);
+  pubSubSocket.open(`ws://${hostname}:63525?clientId=${clientId}`);
+
+  return client;
+}
+
+export class MotionMasterClient {
+
+  readonly request: MotionMasterReqResClient;
+  readonly monitor: MotionMasterPubSubClient;
+
+  constructor(
+    readonly reqResSocket: MotionMasterReqResSocket,
+    readonly pubSubSocket: MotionMasterPubSubSocket,
+  ) {
+    this.request = new MotionMasterReqResClient(this.reqResSocket);
+    this.monitor = new MotionMasterPubSubClient(this.pubSubSocket);
+  }
+
+  /**
+   * This observable will emit true when both req/res and pub/sub sockets are opened.
+   * If any socket gets closed, this observable will emit false.
+   * This is a hot observable that will on subscription emit the last value of sockets opened.
+   */
+  socketsOpened$ = combineLatest([this.reqResSocket.opened$, this.pubSubSocket.opened$]).pipe(
+    map(([reqResSocketOpened, pubSubSocketOpened]) => reqResSocketOpened && pubSubSocketOpened),
+  );
+
+  /**
+   * Client is ready when both req/res and pub/sub sockets are opened.
+   * If both sockets are already opened, this function will immediately resolve to true.
+   * Otherwise, it will wait up to requestTimeout for both sockets to open, or throw an error.
+   */
+  async whenReady(requestTimeout = 5000) {
+    return firstValueFrom(
+      this.socketsOpened$.pipe(
+        first(Boolean),
+        timeout(requestTimeout),
+      ),
+    );
+  }
+
+  startMonitoring(
+    ids: string[] | [DeviceRef, number, number][],
+    interval: number,
+    config?: MonitoringConfig,
+    requestTimeout = 5000,
+  ) {
+    return defer(() => {
+      const topic = config?.topic ?? v4();
+      const messageId = config?.messageId ?? v4();
+
+      if (!config) {
+        config = { messageId, topic, bufferSize: 1, distinct: false };
+      }
+
+      this.request.resolveGetParameterValuesIds(ids).pipe(
+        mergeMap((refs) => {
+          if ((new Set(refs.map(([deviceAddress]) => deviceAddress))).size !== 1) {
+            throw new Error('Start monitoring only supports a single device');
+          }
+
+          const deviceAddress = refs[0][0];
+
+          const props: MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues = {
+            getDeviceParameterValues: {
+              deviceAddress,
+              parameters: refs.map(([, index, subindex]) => ({ index, subindex, loadFromCache: false })),
+              sendProgress: false,
+            },
+            interval,
+            topic,
+          };
+
+          return this.request.startMonitoringDeviceParameterValues(props, requestTimeout, messageId);
+        }),
+      ).subscribe();
+
+      this.monitor.subscribe(config);
+
+      const values$ = this.monitor.socket.data$.pipe(
+        selectMotionMasterMessageByTopic(config.topic),
+        mapMonitoringParameterValuesStatusMessageToParameterValues(),
+        map((values) => values.slice(1)), // remove fixed timestamp prepended by Motion Master
+      );
+
+      return new Observable<ParameterValueType[]>((subscriber) => {
+        const subscription = values$.subscribe(subscriber);
+        return () => {
+          subscription.unsubscribe();
+          this.stopMonitoring(messageId);
+        };
+      });
+    });
+  }
+
+  stopMonitoring(messageId: string): void {
+    this.request.stopMonitoringDeviceParameterValues({ startMonitoringRequestId: messageId });
+    this.monitor.unsubscribe(messageId);
+  }
+
+  closeSockets() {
+    this.reqResSocket.close();
+    this.pubSubSocket.close();
+  }
+
+}

package/src/lib/motion-master-pub-sub-client.ts

@@ -0,0 +1,94 @@
+import { bufferCount, distinctUntilChanged, filter, map, Observable, Subject, Subscription } from "rxjs";
+import { v4 } from "uuid";
+import { MonitoringConfig } from "./monitoring-config";
+import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
+import { selectMotionMasterMessageByTopic, selectMotionMasterMessageStatusByKey } from "./operators";
+import { MotionMasterMessage } from "./types";
+import * as equal from "fast-deep-equal";
+import { MotionMasterPubSubWorkerSocket } from "./motion-master-pub-sub-worker-socket";
+
+export class MotionMasterPubSubClient {
+
+  readonly data$ = new Subject<[string, MotionMasterMessage[]]>();
+
+  private subscriptions = new Map<string, Subscription>();
+
+  readonly notification$ = this.socket.data$.pipe(
+    selectMotionMasterMessageByTopic('notification'),
+  );
+
+  readonly systemEvent$ = this.notification$.pipe(
+    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.SystemEvent>('systemEvent'),
+  );
+
+  readonly deviceEvent$ = this.notification$.pipe(
+    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.DeviceEvent>('deviceEvent'),
+  );
+
+  constructor(
+    public readonly socket: MotionMasterPubSubSocket,
+  ) { }
+
+  subscribe(config: MonitoringConfig) {
+    if (!config.messageId) {
+      config = { ...config, messageId: v4() };
+    }
+
+    if (this.socket instanceof MotionMasterPubSubWorkerSocket) {
+      this.socket.worker.postMessage({ subscribe: config });
+    } else {
+      const { bufferSize = 1, distinct = false, messageId, topic } = config;
+
+      let observable: Observable<MotionMasterMessage> = this.socket.data$.pipe(
+        filter((data) => data[0] === topic),
+        map((data) => data[1]),
+      );
+
+      if (distinct) {
+        observable = observable.pipe(
+          distinctUntilChanged((prev, curr) => {
+            if (prev instanceof MotionMasterMessage && curr instanceof MotionMasterMessage) {
+              return equal(
+                prev?.status?.monitoringParameterValues?.deviceParameterValues?.parameterValues,
+                curr?.status?.monitoringParameterValues?.deviceParameterValues?.parameterValues,
+              )
+            }
+            return false;
+          }),
+        );
+      }
+
+      const subscription = observable.pipe(
+        bufferCount(bufferSize),
+      ).subscribe((data) => {
+        this.data$.next([topic, data]);
+      });
+
+      this.subscriptions.set(messageId, subscription);
+    }
+
+    return config.messageId;
+  }
+
+  unsubscribe(messageId: string) {
+    if (this.socket instanceof MotionMasterPubSubWorkerSocket) {
+      this.socket.worker.postMessage({ unsubcribe: { messageId } });
+    } else {
+      const subscription = this.subscriptions.get(messageId);
+      if (subscription) {
+        subscription.unsubscribe();
+        this.subscriptions.delete(messageId);
+      }
+    }
+  }
+
+  unsubscribeAll() {
+    if (this.socket instanceof MotionMasterPubSubWorkerSocket) {
+      this.socket.worker.postMessage({ unsubscribeAll: true });
+    } else {
+      this.subscriptions.forEach((subscription) => subscription.unsubscribe());
+      this.subscriptions.clear();
+    }
+  }
+
+}

package/src/lib/motion-master-pub-sub-socket.ts

@@ -0,0 +1,33 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { MotionMasterMessage } from "./types";
+
+export interface MotionMasterPubSubSocket {
+  /**
+   * Emits a boolean value when socket gets opened or closed.
+   */
+  readonly opened$: BehaviorSubject<boolean>;
+
+  /**
+   * Incoming data is a tuple of topic and decoded message.
+   */
+  readonly data$: Observable<[string, MotionMasterMessage]>;
+
+  /**
+   * URL set in call to open.
+   */
+  get url(): string | undefined;
+
+  /**
+   * Open socket.
+   *
+   * The connected$ and eventually alive$ observables will emit true values.
+   */
+  open(url: string): void;
+
+  /**
+   * Close socket.
+   *
+   * The opened$ and alive$ observables will emit false values.
+   */
+  close(): void;
+}

package/src/lib/motion-master-pub-sub-web-socket.ts

@@ -0,0 +1,71 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { webSocket, WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
+import { logger } from "./logger";
+import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
+import { MotionMasterMessage } from "./types";
+
+export class MotionMasterPubSubWebSocket implements MotionMasterPubSubSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly data$ = new Subject<[string, MotionMasterMessage]>();
+
+  private webSocket$?: WebSocketSubject<[string, MotionMasterMessage]>;
+
+  private _url?: string;
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  open(url: string): void {
+    if (this.opened$.getValue() === true) {
+      throw new Error('MotionMasterPubSubWebSocket is already opened!');
+    }
+
+    this._url = url;
+
+    this.webSocket$ = this.createWebSocket(url);
+
+    this.webSocket$.subscribe({
+      next: (value) => this.data$.next(value),
+      error: () => {
+        // ignore
+      },
+    });
+  }
+
+  close(): void {
+    this.webSocket$?.unsubscribe();
+  }
+
+  private createWebSocket(url: string) {
+    const decoder = new TextDecoder('utf-8');
+
+    const webSocketConfig: WebSocketSubjectConfig<[string, MotionMasterMessage]> = {
+      binaryType: 'arraybuffer',
+      closeObserver: {
+        next: () => {
+          this.opened$.next(false);
+          logger.info(`Connection closed ${url}`);
+        },
+      },
+      deserializer: (e: MessageEvent<ArrayBuffer>): [string, MotionMasterMessage] => {
+        const end = new Uint8Array(e.data, 0, 1)[0] + 1;
+        const topic = decoder.decode(e.data.slice(1, end)); // topic starts from the 2nd byte
+        const message = MotionMasterMessage.decode(new Uint8Array(e.data.slice(end)));
+        return [topic, message];
+      },
+      openObserver: {
+        next: () => {
+          this.opened$.next(true);
+          logger.info(`Connection opened ${url}`);
+        },
+      },
+      url,
+    };
+
+    return webSocket(webSocketConfig);
+  }
+
+}

package/src/lib/motion-master-pub-sub-worker-socket.ts

@@ -0,0 +1,46 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { logger } from "./logger";
+import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
+import { selectMotionMasterMessageByTopic, selectMotionMasterMessageStatusByKey } from "./operators";
+import { MotionMasterMessage } from "./types";
+
+export class MotionMasterPubSubWorkerSocket implements MotionMasterPubSubSocket {
+
+  opened$ = new BehaviorSubject(false);
+
+  data$ = new Subject<[string, MotionMasterMessage]>();
+
+  private _url?: string;
+
+  constructor(
+    public readonly worker: Worker,
+  ) { }
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  open(url: string): void {
+    this._url = url;
+
+    this.worker.onmessage = ({ data }) => {
+      if ('opened' in data) {
+        const { opened } = data;
+        this.opened$.next(opened);
+        logger.info(opened ? `Opened pub/sub 🔌 ${url}` : `Closed pub/sub 🔌 ${url}`);
+      } else if ('topic' in data) {
+        const { topic, messages }: { topic: string, messages: MotionMasterMessage[] } = data;
+        messages.forEach((message) => this.data$.next([topic, message]));
+      }
+    }
+
+    this.worker.postMessage({
+      open: { url }
+    });
+  }
+
+  close(): void {
+    this.worker.postMessage({ close: true })
+  }
+
+}