motion-master-client 0.0.1 → 0.0.3

package/src/lib/motion-master-req-res-socket.ts

@@ -0,0 +1,45 @@
+import { BehaviorSubject, Observable } from "rxjs";
+import { MotionMasterMessage } from "./types";
+
+export interface MotionMasterReqResSocket {
+  /**
+   * Emits a boolean value when socket gets opened or closed.
+   */
+  readonly opened$: BehaviorSubject<boolean>;
+
+  /**
+   * Motion Master is considered alive when it sends messages in regular time interval.
+   */
+  readonly alive$: BehaviorSubject<boolean>;
+
+  /**
+   * Decoded message instances coming from Motion Master.
+   */
+  readonly message$: Observable<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, pingSystemInterval?: number, systemAliveTimeout?: number): void;
+
+  /**
+   * Close socket.
+   * 
+   * The opened$ and alive$ observables will emit false values.
+   */
+  close(): void;
+
+  /**
+   * Send an instance of a message.
+   * 
+   * Subscribe to the message$ observable in order to receive the response messages.
+   */
+  send(message: MotionMasterMessage): void;
+}

package/src/lib/motion-master-req-res-web-socket.ts

@@ -0,0 +1,119 @@
+import { BehaviorSubject, filter, interval, map, Subject, Subscription, tap } from "rxjs";
+import { webSocket, WebSocketSubject, WebSocketSubjectConfig } from "rxjs/webSocket";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { MotionMasterMessage } from "./types";
+
+export class MotionMasterReqResWebSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<MotionMasterMessage>();
+
+  private aliveTimeoutId = 0;
+
+  private pingSystem = MotionMasterMessage.create({
+    request: { pingSystem: MotionMasterMessage.Request.PingSystem.create() }
+  });
+
+  private pingSystemObserver = { next: () => this.send(this.pingSystem) };
+
+  private pingSystemSubscription = new Subscription();
+
+  private webSocket$?: WebSocketSubject<Uint8Array>;
+
+  private _url?: string;
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    if (this.opened$.getValue() === true) {
+      throw new Error('MotionMasterReqResWebSocket is already opened!');
+    }
+
+    this._url = url;
+
+    this.webSocket$ = this.createWebSocket(url, pingSystemInterval);
+
+    this.webSocket$?.pipe(
+      map((data: Uint8Array) => MotionMasterMessage.decode(data)),
+      tap(() => this.keepalive(systemAliveTimeout)),
+      filter((message) => !(message.status?.systemPong)),
+      tap((message) => {
+        if (message.status) {
+          const keys = Object.keys(message.status).join();
+          const motionMasterMessage = message.toJSON ? message.toJSON() : message;
+          logger.info({
+            namespace: 'reqResMessage',
+            motionMasterMessage,
+            type: message.type,
+          }, `Received ${keys}`);
+        }
+      }),
+    ).subscribe({
+      next: (message) => this.message$.next(message),
+      error: () => {
+        // ignore
+      },
+    });
+  }
+
+  close(): void {
+    clearTimeout(this.aliveTimeoutId);
+    this.pingSystemSubscription.unsubscribe();
+    this.webSocket$?.unsubscribe();
+  }
+
+  send(message: MotionMasterMessage): void {
+    if (!(message.request?.pingSystem)) {
+      if (message.request) {
+        const keys = Object.keys(message.request).join();
+        const motionMasterMessage = message.toJSON ? message.toJSON() : message;
+        logger.info({
+          namespace: 'reqResMessage',
+          motionMasterMessage,
+          type: message.type,
+        }, `Send ${keys}`);
+      }
+    }
+    this.webSocket$?.next(MotionMasterMessage.encode(message).finish());
+  }
+
+  private createWebSocket(url: string, pingSystemInterval = 250) {
+    const webSocketConfig: WebSocketSubjectConfig<Uint8Array> = {
+      binaryType: 'arraybuffer',
+      closeObserver: {
+        next: () => {
+          this.opened$.next(false);
+          logger.info(`Connection closed ${url}`);
+        },
+      },
+      deserializer: (e: MessageEvent) => new Uint8Array(e.data as unknown as Iterable<number>),
+      openObserver: {
+        next: () => {
+          this.pingSystemSubscription = interval(pingSystemInterval)
+            .subscribe(this.pingSystemObserver);
+          this.opened$.next(true);
+          logger.info(`Connection opened ${url}`);
+        },
+      },
+      serializer: (value: Uint8Array) => value,
+      url,
+    };
+
+    return webSocket(webSocketConfig);
+  }
+
+  private keepalive(systemAliveTimeout = 1000) {
+    if (this.alive$.getValue() === false) {
+      this.alive$.next(true);
+    }
+    self.clearTimeout(this.aliveTimeoutId);
+    this.aliveTimeoutId = self.setTimeout(() => this.alive$.next(false), systemAliveTimeout);
+  }
+
+}

package/src/lib/motion-master-req-res-worker-socket.ts

@@ -0,0 +1,63 @@
+import { BehaviorSubject, Subject } from "rxjs";
+import { logger } from "./logger";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { MotionMasterMessage } from "./types";
+import { createPlainObjectFromMotionMasterMessage } from "./util";
+
+export class MotionMasterReqResWorkerSocket implements MotionMasterReqResSocket {
+
+  readonly opened$ = new BehaviorSubject<boolean>(false);
+
+  readonly alive$ = new BehaviorSubject<boolean>(false);
+
+  readonly message$ = new Subject<MotionMasterMessage>();
+
+  private _url?: string;
+
+  constructor(
+    public readonly worker: Worker,
+  ) { }
+
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  open(url: string, pingSystemInterval = 250, systemAliveTimeout = 1000): void {
+    if (this.opened$.getValue() === true) {
+      throw new Error('MotionMasterReqResWorkerSocket is already opened!');
+    }
+
+    this._url = url;
+
+    this.worker.onmessage = ({ data }) => {
+      if ('opened' in data) {
+        const { opened } = data;
+        this.opened$.next(opened);
+        logger.info(opened ? `Opened req/res 🔌 ${url}` : `Closed req/res 🔌 ${url}`);
+      } else if ('alive' in data) {
+        const { alive } = data;
+        this.alive$.next(alive);
+        logger.info(alive ? `System is alive 💓` : 'System is as dead as 🦤');
+      } else if ('message' in data) {
+        const { message: motionMasterMessage } = data;
+        this.message$.next(motionMasterMessage);
+        logger.info({ namespace: 'reqResMessage', motionMasterMessage, type: motionMasterMessage.type }, `Received ${motionMasterMessage.status.type}`);
+      }
+    }
+
+    this.worker.postMessage({
+      open: { url, pingSystemInterval, systemAliveTimeout },
+    });
+  }
+
+  close(): void {
+    this.worker.postMessage({ close: true });
+  }
+
+  send(message: MotionMasterMessage): void {
+    const motionMasterMessage = createPlainObjectFromMotionMasterMessage(message);
+    logger.info({ namespace: 'reqResMessage', motionMasterMessage, type: motionMasterMessage.type }, `Send ${motionMasterMessage.request.type}`);
+    this.worker.postMessage({ message });
+  }
+
+}