brilliantsole 0.0.26 → 0.0.28

package/src/connection/websocket/WebSocketConnectionManager.ts

@@ -0,0 +1,282 @@
+import { DeviceInformationTypes } from "../../DeviceInformationManager.ts";
+import {
+  createMessage,
+  Message,
+  MessageLike,
+} from "../../server/ServerUtils.ts";
+import { webSocketPingTimeout } from "../../server/websocket/WebSocketUtils.ts";
+import { createConsole } from "../../utils/Console.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
+import { parseMessage } from "../../utils/ParseUtils.ts";
+import Timer from "../../utils/Timer.ts";
+import BaseConnectionManager, {
+  ConnectionType,
+} from "../BaseConnectionManager.ts";
+import type * as ws from "ws";
+
+const _console = createConsole("WebSocketConnectionManager", { log: false });
+
+const WebSocketMessageTypes = [
+  "ping",
+  "pong",
+  "batteryLevel",
+  "deviceInformation",
+  "message",
+] as const;
+type WebSocketMessageType = (typeof WebSocketMessageTypes)[number];
+
+type WebSocketMessage = WebSocketMessageType | Message<WebSocketMessageType>;
+function createWebSocketMessage(...messages: WebSocketMessage[]) {
+  _console.log("createWebSocketMessage", ...messages);
+  return createMessage(WebSocketMessageTypes, ...messages);
+}
+
+const WebSocketDeviceInformationMessageTypes: WebSocketMessageType[] = [
+  "deviceInformation",
+  "batteryLevel",
+];
+
+class WebSocketConnectionManager extends BaseConnectionManager {
+  #bluetoothId?: string;
+  get bluetoothId() {
+    return this.#bluetoothId ?? "";
+  }
+
+  defaultMtu = 2 ** 10;
+
+  constructor(
+    ipAddress: string,
+    isSecure: boolean = false,
+    bluetoothId?: string
+  ) {
+    super();
+    this.ipAddress = ipAddress;
+    this.isSecure = isSecure;
+    this.mtu = this.defaultMtu;
+    this.#bluetoothId = bluetoothId;
+  }
+
+  get isAvailable() {
+    return true;
+  }
+
+  static get isSupported() {
+    return true;
+  }
+  static get type(): ConnectionType {
+    return "webSocket";
+  }
+
+  // WEBSOCKET
+  #webSocket?: WebSocket;
+  get webSocket() {
+    return this.#webSocket;
+  }
+  set webSocket(newWebSocket) {
+    if (this.#webSocket == newWebSocket) {
+      _console.log("redundant webSocket assignment");
+      return;
+    }
+
+    _console.log("assigning webSocket", newWebSocket);
+
+    if (this.#webSocket) {
+      removeEventListeners(this.#webSocket, this.#boundWebSocketEventListeners);
+      if (this.#webSocket.readyState == this.#webSocket.OPEN) {
+        this.#webSocket.close();
+      }
+    }
+
+    if (newWebSocket) {
+      addEventListeners(newWebSocket, this.#boundWebSocketEventListeners);
+    }
+    this.#webSocket = newWebSocket;
+
+    _console.log("assigned webSocket");
+  }
+
+  // IP ADDRESS
+  #ipAddress!: string;
+  get ipAddress() {
+    return this.#ipAddress;
+  }
+  set ipAddress(newIpAddress) {
+    this.assertIsNotConnected();
+    if (this.#ipAddress == newIpAddress) {
+      _console.log(`redundnant ipAddress assignment "${newIpAddress}"`);
+      return;
+    }
+    this.#ipAddress = newIpAddress;
+    _console.log(`updated ipAddress to "${this.ipAddress}"`);
+  }
+
+  // IS SECURE
+  #isSecure = false;
+  get isSecure() {
+    return this.#isSecure;
+  }
+  set isSecure(newIsSecure) {
+    this.assertIsNotConnected();
+    if (this.#isSecure == newIsSecure) {
+      _console.log(`redundant isSecure assignment ${newIsSecure}`);
+      return;
+    }
+    this.#isSecure = newIsSecure;
+    _console.log(`updated isSecure to "${this.isSecure}"`);
+  }
+
+  // URL
+  get url() {
+    return `${this.isSecure ? "wss" : "ws"}://${this.ipAddress}/ws`;
+  }
+
+  // CONNECTION
+  async connect() {
+    await super.connect();
+    try {
+      this.webSocket = new WebSocket(this.url);
+    } catch (error) {
+      _console.error("error connecting to webSocket", error);
+      this.status = "notConnected";
+    }
+  }
+  async disconnect() {
+    await super.disconnect();
+    _console.log("closing websocket");
+    this.#pingTimer.stop();
+    this.#webSocket?.close();
+  }
+
+  get canReconnect() {
+    return Boolean(this.webSocket);
+  }
+  async reconnect() {
+    await super.reconnect();
+    this.webSocket = new WebSocket(this.url);
+  }
+
+  // BASE CONNECTION MANAGER
+  async sendSmpMessage(data: ArrayBuffer) {
+    super.sendSmpMessage(data);
+    _console.error("smp not supported on webSockets");
+  }
+
+  async sendTxData(data: ArrayBuffer) {
+    await super.sendTxData(data);
+    if (data.byteLength == 0) {
+      return;
+    }
+    this.#sendWebSocketMessage({ type: "message", data });
+  }
+
+  // WEBSOCKET MESSAGING
+  #sendMessage(message: MessageLike) {
+    this.assertIsConnected();
+    _console.log("sending webSocket message", message);
+    this.#webSocket!.send(message);
+    this.#pingTimer.restart();
+  }
+
+  #sendWebSocketMessage(...messages: WebSocketMessage[]) {
+    this.#sendMessage(createWebSocketMessage(...messages));
+  }
+
+  // WEBSOCKET EVENTS
+  #boundWebSocketEventListeners: { [eventType: string]: Function } = {
+    open: this.#onWebSocketOpen.bind(this),
+    message: this.#onWebSocketMessage.bind(this),
+    close: this.#onWebSocketClose.bind(this),
+    error: this.#onWebSocketError.bind(this),
+  };
+
+  #onWebSocketOpen(event: ws.Event) {
+    _console.log("webSocket.open", event);
+    this.#pingTimer.start();
+    this.status = "connected";
+    this.#requestDeviceInformation();
+  }
+  async #onWebSocketMessage(event: ws.MessageEvent) {
+    // this.#pingTimer.restart();
+    //@ts-expect-error
+    const arrayBuffer = await event.data.arrayBuffer();
+    const dataView = new DataView(arrayBuffer);
+    _console.log(`webSocket.message (${dataView.byteLength} bytes)`);
+    this.#parseWebSocketMessage(dataView);
+  }
+  #onWebSocketClose(event: ws.CloseEvent) {
+    _console.log("webSocket.close", event);
+    this.status = "notConnected";
+    this.#pingTimer.stop();
+  }
+  #onWebSocketError(event: ws.ErrorEvent) {
+    _console.error("webSocket.error", event);
+  }
+
+  // PARSING
+  #parseWebSocketMessage(dataView: DataView) {
+    parseMessage(
+      dataView,
+      WebSocketMessageTypes,
+      this.#onMessage.bind(this),
+      null,
+      true
+    );
+  }
+
+  #onMessage(messageType: WebSocketMessageType, dataView: DataView) {
+    _console.log(
+      `received "${messageType}" message (${dataView.byteLength} bytes)`
+    );
+    switch (messageType) {
+      case "ping":
+        this.#pong();
+        break;
+      case "pong":
+        break;
+      case "batteryLevel":
+        this.onMessageReceived?.("batteryLevel", dataView);
+        break;
+      case "deviceInformation":
+        parseMessage(
+          dataView,
+          DeviceInformationTypes,
+          (deviceInformationType, dataView) => {
+            this.onMessageReceived!(deviceInformationType, dataView);
+          }
+        );
+        break;
+      case "message":
+        this.parseRxMessage(dataView);
+        break;
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  // PING
+  #pingTimer = new Timer(this.#ping.bind(this), webSocketPingTimeout - 1_000);
+  #ping() {
+    _console.log("pinging");
+    this.#sendWebSocketMessage("ping");
+  }
+  #pong() {
+    _console.log("ponging");
+    this.#sendWebSocketMessage("pong");
+  }
+
+  // DEVICE INFORMATION
+  #requestDeviceInformation() {
+    this.#sendWebSocketMessage(...WebSocketDeviceInformationMessageTypes);
+  }
+
+  remove() {
+    super.remove();
+    this.webSocket = undefined;
+  }
+}
+
+export default WebSocketConnectionManager;

package/src/devicePair/DevicePair.ts

@@ -1,6 +1,14 @@
 import { createConsole } from "../utils/Console.ts";
-import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "../utils/EventDispatcher.ts";
-import { addEventListeners, removeEventListeners } from "../utils/EventUtils.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+  EventListenerMap,
+  EventMap,
+} from "../utils/EventDispatcher.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../utils/EventUtils.ts";
 import Device, {
   DeviceEvent,
   DeviceEventType,
@@ -9,20 +17,29 @@ import Device, {
   BoundDeviceEventListeners,
   DeviceEventMap,
 } from "../Device.ts";
-import DevicePairSensorDataManager, { DevicePairSensorDataEventDispatcher } from "./DevicePairSensorDataManager.ts";
+import DevicePairSensorDataManager, {
+  DevicePairSensorDataEventDispatcher,
+} from "./DevicePairSensorDataManager.ts";
 import { capitalizeFirstCharacter } from "../utils/stringUtils.ts";
-import { InsoleSide, InsoleSides } from "../InformationManager.ts";
+import { Side, Sides } from "../InformationManager.ts";
 import { VibrationConfiguration } from "../vibration/VibrationManager.ts";
 import { SensorConfiguration } from "../sensor/SensorConfigurationManager.ts";
-import { DevicePairSensorDataEventMessages, DevicePairSensorDataEventTypes } from "./DevicePairSensorDataManager.ts";
-import { AddPrefixToInterfaceKeys, ExtendInterfaceValues, KeyOf } from "../utils/TypeScriptUtils.ts";
+import {
+  DevicePairSensorDataEventMessages,
+  DevicePairSensorDataEventTypes,
+} from "./DevicePairSensorDataManager.ts";
+import {
+  AddPrefixToInterfaceKeys,
+  ExtendInterfaceValues,
+  KeyOf,
+} from "../utils/TypeScriptUtils.ts";
 import DeviceManager from "../DeviceManager.ts";
 
-const _console = createConsole("DevicePair", { log: true });
+const _console = createConsole("DevicePair", { log: false });
 
 interface BaseDevicePairDeviceEventMessage {
   device: Device;
-  side: InsoleSide;
+  side: Side;
 }
 type DevicePairDeviceEventMessages = ExtendInterfaceValues<
   AddPrefixToInterfaceKeys<DeviceEventMessages, "device">,
@@ -30,14 +47,17 @@ type DevicePairDeviceEventMessages = ExtendInterfaceValues<
 >;
 type DevicePairDeviceEventType = KeyOf<DevicePairDeviceEventMessages>;
 function getDevicePairDeviceEventType(deviceEventType: DeviceEventType) {
-  return `device${capitalizeFirstCharacter(deviceEventType)}` as DevicePairDeviceEventType;
+  return `device${capitalizeFirstCharacter(
+    deviceEventType
+  )}` as DevicePairDeviceEventType;
 }
 const DevicePairDeviceEventTypes = DeviceEventTypes.map((eventType) =>
   getDevicePairDeviceEventType(eventType)
 ) as DevicePairDeviceEventType[];
 
 export const DevicePairConnectionEventTypes = ["isConnected"] as const;
-export type DevicePairConnectionEventType = (typeof DevicePairConnectionEventTypes)[number];
+export type DevicePairConnectionEventType =
+  (typeof DevicePairConnectionEventTypes)[number];
 
 export interface DevicePairConnectionEventMessages {
   isConnected: { isConnected: boolean };
@@ -54,22 +74,55 @@ export type DevicePairEventMessages = DevicePairConnectionEventMessages &
   DevicePairSensorDataEventMessages &
   DevicePairDeviceEventMessages;
 
-export type DevicePairEventDispatcher = EventDispatcher<DevicePair, DevicePairEventType, DevicePairEventMessages>;
-export type DevicePairEventMap = EventMap<DevicePair, DeviceEventType, DevicePairEventMessages>;
-export type DevicePairEventListenerMap = EventListenerMap<DevicePair, DeviceEventType, DevicePairEventMessages>;
-export type DevicePairEvent = Event<DevicePair, DeviceEventType, DevicePairEventMessages>;
-export type BoundDevicePairEventListeners = BoundEventListeners<DevicePair, DeviceEventType, DevicePairEventMessages>;
+export type DevicePairEventDispatcher = EventDispatcher<
+  DevicePair,
+  DevicePairEventType,
+  DevicePairEventMessages
+>;
+export type DevicePairEventMap = EventMap<
+  DevicePair,
+  DeviceEventType,
+  DevicePairEventMessages
+>;
+export type DevicePairEventListenerMap = EventListenerMap<
+  DevicePair,
+  DeviceEventType,
+  DevicePairEventMessages
+>;
+export type DevicePairEvent = Event<
+  DevicePair,
+  DeviceEventType,
+  DevicePairEventMessages
+>;
+export type BoundDevicePairEventListeners = BoundEventListeners<
+  DevicePair,
+  DeviceEventType,
+  DevicePairEventMessages
+>;
+
+export const DevicePairTypes = ["insoles", "gloves"] as const;
+export type DevicePairType = (typeof DevicePairTypes)[number];
 
 class DevicePair {
-  constructor() {
-    this.#sensorDataManager.eventDispatcher = this.#eventDispatcher as DevicePairSensorDataEventDispatcher;
+  constructor(type: DevicePairType) {
+    this.#type = type;
+    this.#sensorDataManager.eventDispatcher = this
+      .#eventDispatcher as DevicePairSensorDataEventDispatcher;
   }
 
   get sides() {
-    return InsoleSides;
+    return Sides;
   }
 
-  #eventDispatcher: DevicePairEventDispatcher = new EventDispatcher(this as DevicePair, DevicePairEventTypes);
+  #type: DevicePairType;
+  get type() {
+    return this.#type;
+  }
+
+  #eventDispatcher: DevicePairEventDispatcher = new EventDispatcher(
+    this as DevicePair,
+    DevicePairEventTypes
+  );
   get addEventListener() {
     return this.#eventDispatcher.addEventListener;
   }
@@ -101,10 +154,10 @@ class DevicePair {
   }
 
   get isConnected() {
-    return InsoleSides.every((side) => this[side]?.isConnected);
+    return Sides.every((side) => this[side]?.isConnected);
   }
   get isPartiallyConnected() {
-    return InsoleSides.some((side) => this[side]?.isConnected);
+    return Sides.some((side) => this[side]?.isConnected);
   }
   get isHalfConnected() {
     return this.isPartiallyConnected && !this.isConnected;
@@ -113,12 +166,23 @@ class DevicePair {
     _console.assertWithError(this.isConnected, "devicePair must be connected");
   }
 
-  assignInsole(device: Device) {
-    if (!device.isInsole) {
-      _console.warn("device is not an insole");
+  #isDeviceCorrectType(device: Device) {
+    switch (this.type) {
+      case "insoles":
+        return device.isInsole;
+      case "gloves":
+        return device.isGlove;
+    }
+  }
+
+  assignDevice(device: Device) {
+    if (!this.#isDeviceCorrectType(device)) {
+      _console.log(
+        `device is incorrect type ${device.type} for ${this.type} devicePair`
+      );
       return;
     }
-    const side = device.insoleSide;
+    const side = device.side;
 
     const currentDevice = this[side];
 
@@ -141,12 +205,16 @@ class DevicePair {
         break;
     }
 
-    _console.log(`assigned ${side} insole`, device);
+    _console.log(`assigned ${side} ${this.type} device`, device);
 
     this.resetPressureRange();
 
     this.#dispatchEvent("isConnected", { isConnected: this.isConnected });
-    this.#dispatchEvent("deviceIsConnected", { device, isConnected: device.isConnected, side });
+    this.#dispatchEvent("deviceIsConnected", {
+      device,
+      isConnected: device.isConnected,
+      side,
+    });
 
     return currentDevice;
   }
@@ -154,27 +222,41 @@ class DevicePair {
   #addDeviceEventListeners(device: Device) {
     addEventListeners(device, this.#boundDeviceEventListeners);
     DeviceEventTypes.forEach((deviceEventType) => {
-      // @ts-expect-error
-      device.addEventListener(deviceEventType, this.#redispatchDeviceEvent.bind(this));
+      device.addEventListener(
+        // @ts-expect-error
+        deviceEventType,
+        this.#redispatchDeviceEvent.bind(this)
+      );
     });
   }
   #removeDeviceEventListeners(device: Device) {
     removeEventListeners(device, this.#boundDeviceEventListeners);
     DeviceEventTypes.forEach((deviceEventType) => {
-      // @ts-expect-error
-      device.removeEventListener(deviceEventType, this.#redispatchDeviceEvent.bind(this));
+      device.removeEventListener(
+        // @ts-expect-error
+        deviceEventType,
+        this.#redispatchDeviceEvent.bind(this)
+      );
     });
   }
 
-  #removeInsole(device: Device) {
-    const foundDevice = InsoleSides.some((side) => {
+  #removeDevice(device: Device) {
+    const foundDevice = Sides.some((side) => {
       if (this[side] != device) {
         return false;
       }
 
-      _console.log(`removing ${side} insole`, device);
+      _console.log(`removing ${side} ${this.type} device`, device);
       removeEventListeners(device, this.#boundDeviceEventListeners);
-      delete this[side];
+
+      switch (side) {
+        case "left":
+          this.#left = undefined;
+          break;
+        case "right":
+          this.#right = undefined;
+          break;
+      }
 
       return true;
     });
@@ -195,7 +277,7 @@ class DevicePair {
     this.#dispatchEvent(getDevicePairDeviceEventType(type), {
       ...message,
       device,
-      side: device.insoleSide,
+      side: device.side,
     });
   }
 
@@ -205,20 +287,20 @@ class DevicePair {
 
   #onDeviceType(deviceEvent: DeviceEventMap["getType"]) {
     const { target: device } = deviceEvent;
-    if (this[device.insoleSide] == device) {
+    if (this[device.side] == device) {
       return;
     }
-    const foundDevice = this.#removeInsole(device);
+    const foundDevice = this.#removeDevice(device);
     if (!foundDevice) {
       return;
     }
-    this.assignInsole(device);
+    this.assignDevice(device);
   }
 
   // SENSOR CONFIGURATION
   async setSensorConfiguration(sensorConfiguration: SensorConfiguration) {
-    for (let i = 0; i < InsoleSides.length; i++) {
-      const side = InsoleSides[i];
+    for (let i = 0; i < Sides.length; i++) {
+      const side = Sides[i];
       if (this[side]?.isConnected) {
         await this[side].setSensorConfiguration(sensorConfiguration);
       }
@@ -233,27 +315,41 @@ class DevicePair {
     }
   }
   resetPressureRange() {
+    Sides.forEach((side) => this[side]?.resetPressureRange());
     this.#sensorDataManager.resetPressureRange();
   }
 
   // VIBRATION
-  async triggerVibration(vibrationConfigurations: VibrationConfiguration[], sendImmediately?: boolean) {
-    const promises = InsoleSides.map((side) => {
-      return this[side]?.triggerVibration(vibrationConfigurations, sendImmediately);
+  async triggerVibration(
+    vibrationConfigurations: VibrationConfiguration[],
+    sendImmediately?: boolean
+  ) {
+    const promises = Sides.map((side) => {
+      return this[side]?.triggerVibration(
+        vibrationConfigurations,
+        sendImmediately
+      );
     }).filter(Boolean);
     return Promise.allSettled(promises);
   }
 
-  // SHARED INSTANCE
-  static #shared = new DevicePair();
-  static get shared() {
-    return this.#shared;
+  // SHARED INSTANCES
+  static #insoles = new DevicePair("insoles");
+  static get insoles() {
+    return this.#insoles;
+  }
+  static #gloves = new DevicePair("gloves");
+  static get gloves() {
+    return this.#gloves;
   }
   static {
     DeviceManager.AddEventListener("deviceConnected", (event) => {
       const { device } = event.message;
       if (device.isInsole) {
-        this.#shared.assignInsole(device);
+        this.#insoles.assignDevice(device);
+      }
+      if (device.isGlove) {
+        this.#gloves.assignDevice(device);
       }
     });
   }