motion-master-client 0.0.21 → 0.0.22

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

@@ -0,0 +1,221 @@
+import { combineLatest, defer, filter, 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 { mapMonitoringParameterValuesStatusMessageToDeviceParameters, mapMonitoringParameterValuesStatusMessageToParameterValues, selectMotionMasterMessageByTopic } from "./operators";
+import { DeviceParameterIds, DeviceRef, MotionMasterMessage, ParameterValueType } from "./types";
+import { Parameter } from "./parameter";
+
+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.
+   * This observable will emit whenever the sockets opened property changes to true.
+   */
+  ready$ = this.socketsOpened$.pipe(
+    filter(Boolean),
+  );
+
+  /**
+   * This observable will emit only once when both req/res and pub/sub sockets are opened.
+   * NOTE: This observable might never emit and it doesn't timeout.
+   */
+  onceReady$ = this.ready$.pipe(
+    first(),
+  );
+
+  /**
+   * 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.ready$.pipe(
+        timeout(requestTimeout),
+      ),
+    );
+  }
+
+  startMonitoring(
+    ids: DeviceParameterIds,
+    interval: number,
+    config?: MonitoringConfig,
+    requestTimeout = 5000,
+  ): Observable<ParameterValueType[]> {
+    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);
+        };
+      });
+    });
+  }
+
+  /**
+   * TODO: return device parameters instead of just parameters
+   * get parameters from ESI uprfront, and then when parameters are received
+   * from motion master just concatenate (spread operator) props from ESI and props from parameter
+   * assign device parameter id like 0x1018:00.12345
+   * when assembling device parameter, get parameter from device in ESI based on product code, see ESI service
+   * this should probably done for other get parameters functions, get ESI file from device or prepared, get data from it
+   */
+  startMonitoringDeviceParameters(
+    ids: DeviceParameterIds,
+    interval: number,
+    config?: MonitoringConfig,
+    requestTimeout = 5000,
+  ): Observable<Parameter[]> {
+    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),
+        mapMonitoringParameterValuesStatusMessageToDeviceParameters(),
+        map((values) => values.slice(1)), // remove fixed timestamp prepended by Motion Master
+      );
+
+      return new Observable<Parameter[]>((subscriber) => {
+        const subscription = values$.subscribe(subscriber);
+        return () => {
+          subscription.unsubscribe();
+          this.stopMonitoring(messageId);
+        };
+      });
+    });
+  }
+
+  startMonitoringValue<T extends ParameterValueType = number>(
+    id: string | [DeviceRef, number, number],
+    interval: number,
+    config?: MonitoringConfig,
+    requestTimeout = 5000,
+  ): Observable<T> {
+    const ids = typeof id === 'string' ? [id] : [id];
+    return this.startMonitoring(ids, interval, config, requestTimeout).pipe(
+      map((parameters) => (parameters[0] ?? 0) as T),
+    );
+  }
+
+  stopMonitoring(messageId: string): void {
+    this.request.stopMonitoringDeviceParameterValues({ startMonitoringRequestId: messageId });
+    this.monitor.unsubscribe(messageId);
+  }
+
+  closeSockets() {
+    this.reqResSocket.close();
+    this.pubSubSocket.close();
+  }
+
+  reopenSockets() {
+    this.reqResSocket.reopen();
+    this.pubSubSocket.reopen();
+  }
+
+}

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

@@ -0,0 +1,95 @@
+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 { IMotionMasterMessage, 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, IMotionMasterMessage[]]>();
+
+  private subscriptions = new Map<string, Subscription>();
+
+  readonly notification$ = this.socket.data$.pipe(
+    selectMotionMasterMessageByTopic('notification'),
+  );
+
+  readonly systemEvent$ = this.notification$.pipe(
+    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.ISystemEvent>('systemEvent'),
+  );
+
+  readonly deviceEvent$ = this.notification$.pipe(
+    selectMotionMasterMessageStatusByKey<MotionMasterMessage.Status.IDeviceEvent>('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<IMotionMasterMessage> = this.socket.data$.pipe(
+        filter((data) => data[0] === topic),
+        map((data) => data[1]),
+      );
+
+      if (distinct) {
+        observable = observable.pipe(
+          distinctUntilChanged((prev, curr) => {
+            if (prev?.status?.monitoringParameterValues?.deviceParameterValues?.parameterValues
+              && curr?.status?.monitoringParameterValues?.deviceParameterValues?.parameterValues) {
+              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,40 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { IMotionMasterMessage } 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, IMotionMasterMessage]>;
+
+  /**
+   * 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;
+
+  /**
+   * Reopen socket.
+   *
+   * Reopen if closed using the same url previously set in open.
+   */
+  reopen(): 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,78 @@
+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 { IMotionMasterMessage, MotionMasterMessage } from "./types";
+import { createPlainObjectFromMotionMasterMessage } from "./util";
+
+export class MotionMasterPubSubWebSocket implements MotionMasterPubSubSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly data$ = new Subject<[string, IMotionMasterMessage]>();
+
+  private webSocket$?: WebSocketSubject<[string, IMotionMasterMessage]>;
+
+  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();
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url);
+    }
+  }
+
+  private createWebSocket(url: string) {
+    const decoder = new TextDecoder('utf-8');
+
+    const webSocketConfig: WebSocketSubjectConfig<[string, IMotionMasterMessage]> = {
+      binaryType: 'arraybuffer',
+      closeObserver: {
+        next: () => {
+          this.opened$.next(false);
+          logger.info(`Connection closed ${url}`);
+        },
+      },
+      deserializer: (e: MessageEvent<ArrayBuffer>): [string, IMotionMasterMessage] => {
+        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, createPlainObjectFromMotionMasterMessage(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,51 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { MotionMasterPubSubSocket } from "./motion-master-pub-sub-socket";
+import { IMotionMasterMessage } from "./types";
+import { logger } from "./logger";
+
+export class MotionMasterPubSubWorkerSocket implements MotionMasterPubSubSocket {
+
+  opened$ = new BehaviorSubject(false);
+
+  data$ = new Subject<[string, IMotionMasterMessage]>();
+
+  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: IMotionMasterMessage[] } = data;
+        messages.forEach((message) => this.data$.next([topic, message]));
+      }
+    }
+
+    this.worker.postMessage({
+      open: { url }
+    });
+  }
+
+  close(): void {
+    this.worker.postMessage({ close: true })
+  }
+
+  reopen() {
+    if (this.url && this.opened$.value === false) {
+      this.open(this.url);
+    }
+  }
+
+}