brilliantsole 0.0.1

package/src/devicePair/DevicePair.ts

@@ -0,0 +1,253 @@
+import { createConsole } from "../utils/Console.ts";
+import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "../utils/EventDispatcher.ts";
+import { addEventListeners, removeEventListeners } from "../utils/EventUtils.ts";
+import Device, {
+  DeviceEvent,
+  DeviceEventType,
+  DeviceEventMessages,
+  DeviceEventTypes,
+  BoundDeviceEventListeners,
+  DeviceEventMap,
+} from "../Device.ts";
+import DevicePairSensorDataManager, { DevicePairSensorDataEventDispatcher } from "./DevicePairSensorDataManager.ts";
+import { capitalizeFirstCharacter } from "../utils/stringUtils.ts";
+import { InsoleSide, InsoleSides } 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 DeviceManager from "../DeviceManager.ts";
+
+const _console = createConsole("DevicePair", { log: true });
+
+interface BaseDevicePairDeviceEventMessage {
+  device: Device;
+  side: InsoleSide;
+}
+type DevicePairDeviceEventMessages = ExtendInterfaceValues<
+  AddPrefixToInterfaceKeys<DeviceEventMessages, "device">,
+  BaseDevicePairDeviceEventMessage
+>;
+type DevicePairDeviceEventType = KeyOf<DevicePairDeviceEventMessages>;
+function getDevicePairDeviceEventType(deviceEventType: DeviceEventType) {
+  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 interface DevicePairConnectionEventMessages {
+  isConnected: { isConnected: boolean };
+}
+
+export const DevicePairEventTypes = [
+  ...DevicePairConnectionEventTypes,
+  ...DevicePairSensorDataEventTypes,
+  ...DevicePairDeviceEventTypes,
+] as const;
+export type DevicePairEventType = (typeof DevicePairEventTypes)[number];
+
+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>;
+
+class DevicePair {
+  constructor() {
+    this.#sensorDataManager.eventDispatcher = this.#eventDispatcher as DevicePairSensorDataEventDispatcher;
+  }
+
+  get sides() {
+    return InsoleSides;
+  }
+
+  #eventDispatcher: DevicePairEventDispatcher = new EventDispatcher(this as DevicePair, DevicePairEventTypes);
+  get addEventListener() {
+    return this.#eventDispatcher.addEventListener;
+  }
+  get #dispatchEvent() {
+    return this.#eventDispatcher.dispatchEvent;
+  }
+  get removeEventListener() {
+    return this.#eventDispatcher.removeEventListener;
+  }
+  get waitForEvent() {
+    return this.#eventDispatcher.waitForEvent;
+  }
+
+  // SIDES
+  #left?: Device;
+  get left() {
+    return this.#left;
+  }
+
+  #right?: Device;
+  get right() {
+    return this.#right;
+  }
+
+  get isConnected() {
+    return InsoleSides.every((side) => this[side]?.isConnected);
+  }
+  get isPartiallyConnected() {
+    return InsoleSides.some((side) => this[side]?.isConnected);
+  }
+  get isHalfConnected() {
+    return this.isPartiallyConnected && !this.isConnected;
+  }
+  #assertIsConnected() {
+    _console.assertWithError(this.isConnected, "devicePair must be connected");
+  }
+
+  assignInsole(device: Device) {
+    if (!device.isInsole) {
+      _console.warn("device is not an insole");
+      return;
+    }
+    const side = device.insoleSide;
+
+    const currentDevice = this[side];
+
+    if (device == currentDevice) {
+      _console.log("device already assigned");
+      return;
+    }
+
+    if (currentDevice) {
+      this.#removeDeviceEventListeners(currentDevice);
+    }
+    this.#addDeviceEventListeners(device);
+
+    switch (side) {
+      case "left":
+        this.#left = device;
+        break;
+      case "right":
+        this.#right = device;
+        break;
+    }
+
+    _console.log(`assigned ${side} insole`, device);
+
+    this.resetPressureRange();
+
+    this.#dispatchEvent("isConnected", { isConnected: this.isConnected });
+    this.#dispatchEvent("deviceIsConnected", { device, isConnected: device.isConnected, side });
+
+    return currentDevice;
+  }
+
+  #addDeviceEventListeners(device: Device) {
+    addEventListeners(device, this.#boundDeviceEventListeners);
+    DeviceEventTypes.forEach((deviceEventType) => {
+      // @ts-expect-error
+      device.addEventListener(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));
+    });
+  }
+
+  #removeInsole(device: Device) {
+    const foundDevice = InsoleSides.some((side) => {
+      if (this[side] != device) {
+        return false;
+      }
+
+      _console.log(`removing ${side} insole`, device);
+      removeEventListeners(device, this.#boundDeviceEventListeners);
+      delete this[side];
+
+      return true;
+    });
+    if (foundDevice) {
+      this.#dispatchEvent("isConnected", { isConnected: this.isConnected });
+    }
+    return foundDevice;
+  }
+
+  #boundDeviceEventListeners: BoundDeviceEventListeners = {
+    isConnected: this.#onDeviceIsConnected.bind(this),
+    sensorData: this.#onDeviceSensorData.bind(this),
+    getType: this.#onDeviceType.bind(this),
+  };
+
+  #redispatchDeviceEvent(deviceEvent: DeviceEvent) {
+    const { type, target: device, message } = deviceEvent;
+    this.#dispatchEvent(getDevicePairDeviceEventType(type), {
+      ...message,
+      device,
+      side: device.insoleSide,
+    });
+  }
+
+  #onDeviceIsConnected(deviceEvent: DeviceEventMap["isConnected"]) {
+    this.#dispatchEvent("isConnected", { isConnected: this.isConnected });
+  }
+
+  #onDeviceType(deviceEvent: DeviceEventMap["getType"]) {
+    const { target: device } = deviceEvent;
+    if (this[device.insoleSide] == device) {
+      return;
+    }
+    const foundDevice = this.#removeInsole(device);
+    if (!foundDevice) {
+      return;
+    }
+    this.assignInsole(device);
+  }
+
+  // SENSOR CONFIGURATION
+  setSensorConfiguration(sensorConfiguration: SensorConfiguration) {
+    InsoleSides.forEach((side) => {
+      this[side]?.setSensorConfiguration(sensorConfiguration);
+    });
+  }
+
+  // SENSOR DATA
+  #sensorDataManager = new DevicePairSensorDataManager();
+  #onDeviceSensorData(deviceEvent: DeviceEventMap["sensorData"]) {
+    if (this.isConnected) {
+      this.#sensorDataManager.onDeviceSensorData(deviceEvent);
+    }
+  }
+  resetPressureRange() {
+    this.#sensorDataManager.resetPressureRange();
+  }
+
+  // VIBRATION
+  async triggerVibration(vibrationConfigurations: VibrationConfiguration[], sendImmediately?: boolean) {
+    const promises = InsoleSides.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;
+  }
+  static {
+    DeviceManager.AddEventListener("deviceConnected", (event) => {
+      const { device } = event.message;
+      if (device.isInsole) {
+        this.#shared.assignInsole(device);
+      }
+    });
+  }
+}
+
+export default DevicePair;

package/src/devicePair/DevicePairPressureSensorDataManager.ts

@@ -0,0 +1,82 @@
+import { createConsole } from "../utils/Console.ts";
+import CenterOfPressureHelper from "../utils/CenterOfPressureHelper.ts";
+import { PressureData } from "../sensor/PressureSensorDataManager.ts";
+import { CenterOfPressure } from "../utils/CenterOfPressureHelper.ts";
+import { InsoleSide, InsoleSides } from "../InformationManager.ts";
+import { DeviceEventMap } from "../Device.ts";
+
+const _console = createConsole("DevicePairPressureSensorDataManager", { log: true });
+
+export type DevicePairRawPressureData = { [insoleSide in InsoleSide]: PressureData };
+
+export interface DevicePairPressureData {
+  rawSum: number;
+  normalizedSum: number;
+  center?: CenterOfPressure;
+  normalizedCenter?: CenterOfPressure;
+}
+
+export interface DevicePairPressureDataEventMessage {
+  pressure: DevicePairPressureData;
+}
+
+export interface DevicePairPressureDataEventMessages {
+  pressure: DevicePairPressureDataEventMessage;
+}
+
+class DevicePairPressureSensorDataManager {
+  #rawPressure: Partial<DevicePairRawPressureData> = {};
+
+  #centerOfPressureHelper = new CenterOfPressureHelper();
+
+  resetPressureRange() {
+    this.#centerOfPressureHelper.reset();
+  }
+
+  onDevicePressureData(event: DeviceEventMap["pressure"]) {
+    const { pressure } = event.message;
+    const insoleSide = event.target.insoleSide;
+    _console.log({ pressure, insoleSide });
+    this.#rawPressure[insoleSide] = pressure;
+    if (this.#hasAllPressureData) {
+      return this.#updatePressureData();
+    } else {
+      _console.log("doesn't have all pressure data yet...");
+    }
+  }
+
+  get #hasAllPressureData() {
+    return InsoleSides.every((side) => side in this.#rawPressure);
+  }
+
+  #updatePressureData() {
+    const pressure: DevicePairPressureData = { rawSum: 0, normalizedSum: 0 };
+
+    InsoleSides.forEach((side) => {
+      pressure.rawSum += this.#rawPressure[side]!.scaledSum;
+      pressure.normalizedSum += this.#rawPressure[side]!.normalizedSum;
+    });
+
+    if (pressure.normalizedSum > 0) {
+      pressure.center = { x: 0, y: 0 };
+      InsoleSides.forEach((side) => {
+        const sidePressure = this.#rawPressure[side]!;
+        const normalizedPressureSumWeight = sidePressure.normalizedSum / pressure.normalizedSum;
+        if (normalizedPressureSumWeight > 0) {
+          pressure.center!.y += sidePressure.normalizedCenter!.y * normalizedPressureSumWeight;
+          if (side == "right") {
+            pressure.center!.x = normalizedPressureSumWeight;
+          }
+        }
+      });
+
+      pressure.normalizedCenter = this.#centerOfPressureHelper.updateAndGetNormalization(pressure.center);
+    }
+
+    _console.log({ devicePairPressure: pressure });
+
+    return pressure;
+  }
+}
+
+export default DevicePairPressureSensorDataManager;

package/src/devicePair/DevicePairSensorDataManager.ts

@@ -0,0 +1,90 @@
+import DevicePairPressureSensorDataManager, {
+  DevicePairPressureDataEventMessages,
+} from "./DevicePairPressureSensorDataManager.ts";
+import { createConsole } from "../utils/Console.ts";
+import { InsoleSide } from "../InformationManager.ts";
+import { SensorType } from "../sensor/SensorDataManager.ts";
+import { DeviceEventMap, SpecificDeviceEvent } from "../Device.ts";
+import EventDispatcher from "../utils/EventDispatcher.ts";
+import DevicePair from "./DevicePair.ts";
+import { AddKeysAsPropertyToInterface, ExtendInterfaceValues, ValueOf } from "../utils/TypeScriptUtils.ts";
+
+const _console = createConsole("DevicePairSensorDataManager", { log: true });
+
+export const DevicePairSensorTypes = ["pressure", "sensorData"] as const;
+export type DevicePairSensorType = (typeof DevicePairSensorTypes)[number];
+
+export const DevicePairSensorDataEventTypes = DevicePairSensorTypes;
+export type DevicePairSensorDataEventType = (typeof DevicePairSensorDataEventTypes)[number];
+
+export type DevicePairSensorDataTimestamps = { [insoleSide in InsoleSide]: number };
+
+interface BaseDevicePairSensorDataEventMessage {
+  timestamps: DevicePairSensorDataTimestamps;
+}
+
+type BaseDevicePairSensorDataEventMessages = DevicePairPressureDataEventMessages;
+type _DevicePairSensorDataEventMessages = ExtendInterfaceValues<
+  AddKeysAsPropertyToInterface<BaseDevicePairSensorDataEventMessages, "sensorType">,
+  BaseDevicePairSensorDataEventMessage
+>;
+
+export type DevicePairSensorDataEventMessage = ValueOf<_DevicePairSensorDataEventMessages>;
+interface AnyDevicePairSensorDataEventMessages {
+  sensorData: DevicePairSensorDataEventMessage;
+}
+export type DevicePairSensorDataEventMessages = _DevicePairSensorDataEventMessages &
+  AnyDevicePairSensorDataEventMessages;
+
+export type DevicePairSensorDataEventDispatcher = EventDispatcher<
+  DevicePair,
+  DevicePairSensorDataEventType,
+  DevicePairSensorDataEventMessages
+>;
+
+class DevicePairSensorDataManager {
+  eventDispatcher!: DevicePairSensorDataEventDispatcher;
+  get dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+
+  #timestamps: { [sensorType in SensorType]?: Partial<DevicePairSensorDataTimestamps> } = {};
+
+  pressureSensorDataManager = new DevicePairPressureSensorDataManager();
+  resetPressureRange() {
+    this.pressureSensorDataManager.resetPressureRange();
+  }
+
+  onDeviceSensorData(event: DeviceEventMap["sensorData"]) {
+    const { timestamp, sensorType } = event.message;
+
+    _console.log({ sensorType, timestamp, event });
+
+    if (!this.#timestamps[sensorType]) {
+      this.#timestamps[sensorType] = {};
+    }
+    this.#timestamps[sensorType]![event.target.insoleSide] = timestamp;
+
+    let value;
+    switch (sensorType) {
+      case "pressure":
+        value = this.pressureSensorDataManager.onDevicePressureData(event as unknown as DeviceEventMap["pressure"]);
+        break;
+      default:
+        _console.log(`uncaught sensorType "${sensorType}"`);
+        break;
+    }
+
+    if (value) {
+      const timestamps = Object.assign({}, this.#timestamps[sensorType]) as DevicePairSensorDataTimestamps;
+      // @ts-expect-error
+      this.dispatchEvent(sensorType as DevicePairSensorDataEventType, { sensorType, timestamps, [sensorType]: value });
+      // @ts-expect-error
+      this.dispatchEvent("sensorData", { sensorType, timestamps, [sensorType]: value });
+    } else {
+      _console.log("no value received");
+    }
+  }
+}
+
+export default DevicePairSensorDataManager;

package/src/scanner/BaseScanner.ts

@@ -0,0 +1,189 @@
+import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import { addEventListeners } from "../utils/EventUtils.ts";
+import { createConsole } from "../utils/Console.ts";
+import Timer from "../utils/Timer.ts";
+import { DeviceType } from "../InformationManager.ts";
+
+const _console = createConsole("BaseScanner");
+
+export const ScannerEventTypes = [
+  "isScanningAvailable",
+  "isScanning",
+  "discoveredDevice",
+  "expiredDiscoveredDevice",
+] as const;
+export type ScannerEventType = (typeof ScannerEventTypes)[number];
+
+export interface DiscoveredDevice {
+  bluetoothId: string;
+  name: string;
+  deviceType: DeviceType;
+  rssi: number;
+}
+
+interface ScannerDiscoveredDeviceEventMessage {
+  discoveredDevice: DiscoveredDevice;
+}
+
+export interface ScannerEventMessages {
+  discoveredDevice: ScannerDiscoveredDeviceEventMessage;
+  expiredDiscoveredDevice: ScannerDiscoveredDeviceEventMessage;
+  isScanningAvailable: { isScanningAvailable: boolean };
+  isScanning: { isScanning: boolean };
+}
+
+export type ScannerEventDispatcher = EventDispatcher<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type ScannerEventMap = EventMap<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type ScannerEvent = Event<BaseScanner, ScannerEventType, ScannerEventMessages>;
+export type BoundScannerEventListeners = BoundEventListeners<BaseScanner, ScannerEventType, ScannerEventMessages>;
+
+export type DiscoveredDevicesMap = { [deviceId: string]: DiscoveredDevice };
+
+abstract class BaseScanner {
+  // IS SUPPORTED
+  protected get baseConstructor() {
+    return this.constructor as typeof BaseScanner;
+  }
+  static get isSupported() {
+    return false;
+  }
+  get isSupported() {
+    return this.baseConstructor.isSupported;
+  }
+
+  #assertIsSupported() {
+    _console.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
+  }
+
+  // CONSTRUCTOR
+  #assertIsSubclass() {
+    _console.assertWithError(this.constructor != BaseScanner, `${this.constructor.name} must be subclassed`);
+  }
+  constructor() {
+    this.#assertIsSubclass();
+    this.#assertIsSupported();
+    addEventListeners(this, this.#boundEventListeners);
+  }
+
+  #boundEventListeners: BoundScannerEventListeners = {
+    discoveredDevice: this.#onDiscoveredDevice.bind(this),
+    isScanning: this.#onIsScanning.bind(this),
+  };
+
+  // EVENT DISPATCHER
+  #eventDispatcher: ScannerEventDispatcher = new EventDispatcher(this as BaseScanner, ScannerEventTypes);
+  get addEventListener() {
+    return this.#eventDispatcher.addEventListener;
+  }
+  protected get dispatchEvent() {
+    return this.#eventDispatcher.dispatchEvent;
+  }
+  get removeEventListener() {
+    return this.#eventDispatcher.removeEventListener;
+  }
+  get waitForEvent() {
+    return this.#eventDispatcher.waitForEvent;
+  }
+
+  // AVAILABILITY
+  get isScanningAvailable() {
+    return false;
+  }
+  #assertIsAvailable() {
+    _console.assertWithError(this.isScanningAvailable, "not available");
+  }
+
+  // SCANNING
+  get isScanning() {
+    return false;
+  }
+  #assertIsScanning() {
+    _console.assertWithError(this.isScanning, "not scanning");
+  }
+  #assertIsNotScanning() {
+    _console.assertWithError(!this.isScanning, "already scanning");
+  }
+
+  startScan() {
+    this.#assertIsAvailable();
+    this.#assertIsNotScanning();
+  }
+  stopScan() {
+    this.#assertIsScanning();
+  }
+  #onIsScanning(event: ScannerEventMap["isScanning"]) {
+    if (this.isScanning) {
+      this.#discoveredDevices = {};
+      this.#discoveredDeviceTimestamps = {};
+    } else {
+      this.#checkDiscoveredDevicesExpirationTimer.stop();
+    }
+  }
+
+  // DISCOVERED DEVICES
+  #discoveredDevices: DiscoveredDevicesMap = {};
+  get discoveredDevices(): Readonly<DiscoveredDevicesMap> {
+    return this.#discoveredDevices;
+  }
+  get discoveredDevicesArray() {
+    return Object.values(this.#discoveredDevices).sort((a, b) => {
+      return this.#discoveredDeviceTimestamps[a.bluetoothId] - this.#discoveredDeviceTimestamps[b.bluetoothId];
+    });
+  }
+  #assertValidDiscoveredDeviceId(discoveredDeviceId: string) {
+    _console.assertWithError(
+      this.#discoveredDevices[discoveredDeviceId],
+      `no discovered device with id "${discoveredDeviceId}"`
+    );
+  }
+
+  #onDiscoveredDevice(event: ScannerEventMap["discoveredDevice"]) {
+    const { discoveredDevice } = event.message;
+    this.#discoveredDevices[discoveredDevice.bluetoothId] = discoveredDevice;
+    this.#discoveredDeviceTimestamps[discoveredDevice.bluetoothId] = Date.now();
+    this.#checkDiscoveredDevicesExpirationTimer.start();
+  }
+
+  #discoveredDeviceTimestamps: { [id: string]: number } = {};
+
+  static #DiscoveredDeviceExpirationTimeout = 5000;
+  static get DiscoveredDeviceExpirationTimeout() {
+    return this.#DiscoveredDeviceExpirationTimeout;
+  }
+  get #discoveredDeviceExpirationTimeout() {
+    return BaseScanner.DiscoveredDeviceExpirationTimeout;
+  }
+  #checkDiscoveredDevicesExpirationTimer = new Timer(this.#checkDiscoveredDevicesExpiration.bind(this), 1000);
+  #checkDiscoveredDevicesExpiration() {
+    const entries = Object.entries(this.#discoveredDevices);
+    if (entries.length == 0) {
+      this.#checkDiscoveredDevicesExpirationTimer.stop();
+      return;
+    }
+    const now = Date.now();
+    entries.forEach(([id, discoveredDevice]) => {
+      const timestamp = this.#discoveredDeviceTimestamps[id];
+      if (now - timestamp > this.#discoveredDeviceExpirationTimeout) {
+        _console.log("discovered device timeout");
+        delete this.#discoveredDevices[id];
+        delete this.#discoveredDeviceTimestamps[id];
+        this.dispatchEvent("expiredDiscoveredDevice", { discoveredDevice });
+      }
+    });
+  }
+
+  // DEVICE CONNECTION
+  async connectToDevice(deviceId: string) {
+    this.#assertIsAvailable();
+  }
+
+  // RESET
+  get canReset() {
+    return false;
+  }
+  reset() {
+    _console.log("resetting...");
+  }
+}
+
+export default BaseScanner;