brilliantsole 0.0.26 → 0.0.28

package/src/Device.ts

@@ -1,5 +1,10 @@
 import { createConsole } from "./utils/Console.ts";
-import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "./utils/EventDispatcher.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+  EventListenerMap,
+  EventMap,
+} from "./utils/EventDispatcher.ts";
 import BaseConnectionManager, {
   TxMessage,
   TxRxMessageType,
@@ -9,6 +14,9 @@ import BaseConnectionManager, {
   BatteryLevelMessageTypes,
   ConnectionEventTypes,
   ConnectionStatusEventMessages,
+  ConnectionTypes,
+  ConnectionType,
+  ConnectOptions,
 } from "./connection/BaseConnectionManager.ts";
 import { isInBrowser, isInNode } from "./utils/environment.ts";
 import WebBluetoothConnectionManager from "./connection/bluetooth/WebBluetoothConnectionManager.ts";
@@ -29,10 +37,15 @@ import SensorDataManager, {
   SensorType,
   ContinuousSensorTypes,
   SensorDataEventDispatcher,
+  RequiredPressureMessageTypes,
 } from "./sensor/SensorDataManager.ts";
 import VibrationManager, {
   SendVibrationMessageCallback,
   VibrationConfiguration,
+  VibrationEventDispatcher,
+  VibrationEventTypes,
+  VibrationMessageType,
+  VibrationMessageTypes,
 } from "./vibration/VibrationManager.ts";
 import FileTransferManager, {
   FileTransferEventTypes,
@@ -42,6 +55,8 @@ import FileTransferManager, {
   FileTransferMessageTypes,
   FileTransferMessageType,
   FileType,
+  FileTypes,
+  RequiredFileTransferMessageTypes,
 } from "./FileTransferManager.ts";
 import TfliteManager, {
   TfliteEventTypes,
@@ -51,6 +66,9 @@ import TfliteManager, {
   TfliteMessageTypes,
   TfliteMessageType,
   TfliteSensorTypes,
+  TfliteFileConfiguration,
+  TfliteSensorType,
+  RequiredTfliteMessageTypes,
 } from "./TfliteManager.ts";
 import FirmwareManager, {
   FirmwareEventDispatcher,
@@ -62,8 +80,8 @@ import FirmwareManager, {
 import DeviceInformationManager, {
   DeviceInformationEventDispatcher,
   DeviceInformationEventTypes,
-  DeviceInformationMessageType,
-  DeviceInformationMessageTypes,
+  DeviceInformationType,
+  DeviceInformationTypes,
   DeviceInformationEventMessages,
 } from "./DeviceInformationManager.ts";
 import InformationManager, {
@@ -77,8 +95,32 @@ import InformationManager, {
 } from "./InformationManager.ts";
 import { FileLike } from "./utils/ArrayBufferUtils.ts";
 import DeviceManager from "./DeviceManager.ts";
-
-const _console = createConsole("Device", { log: true });
+import CameraManager, {
+  CameraEventDispatcher,
+  CameraEventMessages,
+  CameraEventTypes,
+  CameraMessageType,
+  CameraMessageTypes,
+  RequiredCameraMessageTypes,
+  SendCameraMessageCallback,
+} from "./CameraManager.ts";
+import WifiManager, {
+  RequiredWifiMessageTypes,
+  SendWifiMessageCallback,
+  WifiEventDispatcher,
+  WifiEventMessages,
+  WifiEventTypes,
+  WifiMessageType,
+  WifiMessageTypes,
+} from "./WifiManager.ts";
+import WebSocketConnectionManager from "./connection/websocket/WebSocketConnectionManager.ts";
+import ClientConnectionManager from "./connection/ClientConnectionManager.ts";
+
+/** NODE_START */
+import UDPConnectionManager from "./connection/udp/UDPConnectionManager.ts";
+/** NODE_END */
+
+const _console = createConsole("Device", { log: false });
 
 export const DeviceEventTypes = [
   "connectionMessage",
@@ -89,8 +131,11 @@ export const DeviceEventTypes = [
   ...DeviceInformationEventTypes,
   ...SensorConfigurationEventTypes,
   ...SensorDataEventTypes,
+  ...VibrationEventTypes,
   ...FileTransferEventTypes,
   ...TfliteEventTypes,
+  ...WifiEventTypes,
+  ...CameraEventTypes,
   ...FirmwareEventTypes,
 ] as const;
 export type DeviceEventType = (typeof DeviceEventTypes)[number];
@@ -103,6 +148,8 @@ export interface DeviceEventMessages
     SensorConfigurationEventMessages,
     TfliteEventMessages,
     FileTransferEventMessages,
+    WifiEventMessages,
+    CameraEventMessages,
     FirmwareEventMessages {
   batteryLevel: { batteryLevel: number };
   connectionMessage: { messageType: ConnectionMessageType; dataView: DataView };
@@ -115,11 +162,27 @@ export type SendMessageCallback<MessageType extends string> = (
 
 export type SendSmpMessageCallback = (data: ArrayBuffer) => Promise<void>;
 
-export type DeviceEventDispatcher = EventDispatcher<Device, DeviceEventType, DeviceEventMessages>;
+export type DeviceEventDispatcher = EventDispatcher<
+  Device,
+  DeviceEventType,
+  DeviceEventMessages
+>;
 export type DeviceEvent = Event<Device, DeviceEventType, DeviceEventMessages>;
-export type DeviceEventMap = EventMap<Device, DeviceEventType, DeviceEventMessages>;
-export type DeviceEventListenerMap = EventListenerMap<Device, DeviceEventType, DeviceEventMessages>;
-export type BoundDeviceEventListeners = BoundEventListeners<Device, DeviceEventType, DeviceEventMessages>;
+export type DeviceEventMap = EventMap<
+  Device,
+  DeviceEventType,
+  DeviceEventMessages
+>;
+export type DeviceEventListenerMap = EventListenerMap<
+  Device,
+  DeviceEventType,
+  DeviceEventMessages
+>;
+export type BoundDeviceEventListeners = BoundEventListeners<
+  Device,
+  DeviceEventType,
+  DeviceEventMessages
+>;
 
 export const RequiredInformationConnectionMessages: TxRxMessageType[] = [
   "isCharging",
@@ -132,22 +195,12 @@ export const RequiredInformationConnectionMessages: TxRxMessageType[] = [
   "getCurrentTime",
   "getSensorConfiguration",
   "getSensorScalars",
-  "getPressurePositions",
-
-  "maxFileLength",
-  "getFileLength",
-  "getFileChecksum",
-  "getFileType",
-  "fileTransferStatus",
-
-  "getTfliteName",
-  "getTfliteTask",
-  "getTfliteSampleRate",
-  "getTfliteSensorTypes",
-  "tfliteIsReady",
-  "getTfliteCaptureDelay",
-  "getTfliteThreshold",
-  "getTfliteInferencingEnabled",
+
+  "getVibrationLocations",
+
+  "getFileTypes",
+
+  "isWifiAvailable",
 ];
 
 class Device {
@@ -155,33 +208,110 @@ class Device {
     return this.#connectionManager?.bluetoothId;
   }
 
-  constructor() {
-    this.#deviceInformationManager.eventDispatcher = this.#eventDispatcher as DeviceInformationEventDispatcher;
-
-    this._informationManager.sendMessage = this.sendTxMessages as SendInformationMessageCallback;
-    this._informationManager.eventDispatcher = this.#eventDispatcher as InformationEventDispatcher;
-
-    this.#sensorConfigurationManager.sendMessage = this.sendTxMessages as SendSensorConfigurationMessageCallback;
-    this.#sensorConfigurationManager.eventDispatcher = this.#eventDispatcher as SensorConfigurationEventDispatcher;
-
-    this.#sensorDataManager.eventDispatcher = this.#eventDispatcher as SensorDataEventDispatcher;
-
-    this.#vibrationManager.sendMessage = this.sendTxMessages as SendVibrationMessageCallback;
-
-    this.#tfliteManager.sendMessage = this.sendTxMessages as SendTfliteMessageCallback;
-    this.#tfliteManager.eventDispatcher = this.#eventDispatcher as TfliteEventDispatcher;
-
-    this.#fileTransferManager.sendMessage = this.sendTxMessages as SendFileTransferMessageCallback;
-    this.#fileTransferManager.eventDispatcher = this.#eventDispatcher as FileTransferEventDispatcher;
+  get isAvailable() {
+    return this.#connectionManager?.isAvailable;
+  }
 
-    this.#firmwareManager.sendMessage = this.sendSmpMessage as SendSmpMessageCallback;
-    this.#firmwareManager.eventDispatcher = this.#eventDispatcher as FirmwareEventDispatcher;
+  constructor() {
+    this.#deviceInformationManager.eventDispatcher = this
+      .#eventDispatcher as DeviceInformationEventDispatcher;
+
+    this._informationManager.sendMessage = this
+      .sendTxMessages as SendInformationMessageCallback;
+    this._informationManager.eventDispatcher = this
+      .#eventDispatcher as InformationEventDispatcher;
+
+    this.#sensorConfigurationManager.sendMessage = this
+      .sendTxMessages as SendSensorConfigurationMessageCallback;
+    this.#sensorConfigurationManager.eventDispatcher = this
+      .#eventDispatcher as SensorConfigurationEventDispatcher;
+
+    this.#sensorDataManager.eventDispatcher = this
+      .#eventDispatcher as SensorDataEventDispatcher;
+
+    this.#vibrationManager.sendMessage = this
+      .sendTxMessages as SendVibrationMessageCallback;
+    this.#vibrationManager.eventDispatcher = this
+      .#eventDispatcher as VibrationEventDispatcher;
+
+    this.#tfliteManager.sendMessage = this
+      .sendTxMessages as SendTfliteMessageCallback;
+    this.#tfliteManager.eventDispatcher = this
+      .#eventDispatcher as TfliteEventDispatcher;
+
+    this.#fileTransferManager.sendMessage = this
+      .sendTxMessages as SendFileTransferMessageCallback;
+    this.#fileTransferManager.eventDispatcher = this
+      .#eventDispatcher as FileTransferEventDispatcher;
+
+    this.#wifiManager.sendMessage = this
+      .sendTxMessages as SendWifiMessageCallback;
+    this.#wifiManager.eventDispatcher = this
+      .#eventDispatcher as WifiEventDispatcher;
+
+    this.#cameraManager.sendMessage = this
+      .sendTxMessages as SendCameraMessageCallback;
+    this.#cameraManager.eventDispatcher = this
+      .#eventDispatcher as CameraEventDispatcher;
+
+    this.#firmwareManager.sendMessage = this
+      .sendSmpMessage as SendSmpMessageCallback;
+    this.#firmwareManager.eventDispatcher = this
+      .#eventDispatcher as FirmwareEventDispatcher;
 
     this.addEventListener("getMtu", () => {
       this.#firmwareManager.mtu = this.mtu;
       this.#fileTransferManager.mtu = this.mtu;
       this.connectionManager!.mtu = this.mtu;
     });
+    this.addEventListener("getSensorConfiguration", () => {
+      if (this.connectionStatus != "connecting") {
+        return;
+      }
+      if (this.sensorTypes.includes("pressure")) {
+        _console.log("requesting required pressure information");
+        const messages = RequiredPressureMessageTypes.map((messageType) => ({
+          type: messageType,
+        }));
+        this.sendTxMessages(messages, false);
+      } else {
+        _console.log("don't need to request pressure infomration");
+      }
+
+      if (this.sensorTypes.includes("camera")) {
+        _console.log("requesting required camera information");
+        const messages = RequiredCameraMessageTypes.map((messageType) => ({
+          type: messageType,
+        }));
+        this.sendTxMessages(messages, false);
+      } else {
+        _console.log("don't need to request camera infomration");
+      }
+    });
+    this.addEventListener("getFileTypes", () => {
+      if (this.connectionStatus != "connecting") {
+        return;
+      }
+      if (this.fileTypes.length > 0) {
+        this.#fileTransferManager.requestRequiredInformation();
+      }
+      if (this.fileTypes.includes("tflite")) {
+        this.#tfliteManager.requestRequiredInformation();
+      }
+    });
+    this.addEventListener("isWifiAvailable", () => {
+      if (this.connectionStatus != "connecting") {
+        return;
+      }
+      if (this.connectionType == "client" && !isInNode) {
+        return;
+      }
+      if (this.isWifiAvailable) {
+        if (this.connectionType != "client") {
+          this.#wifiManager.requestRequiredInformation();
+        }
+      }
+    });
     DeviceManager.onDevice(this);
     if (isInBrowser) {
       window.addEventListener("beforeunload", () => {
@@ -204,7 +334,10 @@ class Device {
     return new WebBluetoothConnectionManager();
   }
 
-  #eventDispatcher: DeviceEventDispatcher = new EventDispatcher(this as Device, DeviceEventTypes);
+  #eventDispatcher: DeviceEventDispatcher = new EventDispatcher(
+    this as Device,
+    DeviceEventTypes
+  );
   get addEventListener() {
     return this.#eventDispatcher.addEventListener;
   }
@@ -237,29 +370,100 @@ class Device {
     }
 
     if (this.connectionManager) {
-      this.connectionManager.onStatusUpdated = undefined;
-      this.connectionManager.onMessageReceived = undefined;
-      this.connectionManager.onMessagesReceived = undefined;
+      this.connectionManager.remove();
     }
     if (newConnectionManager) {
-      newConnectionManager.onStatusUpdated = this.#onConnectionStatusUpdated.bind(this);
-      newConnectionManager.onMessageReceived = this.#onConnectionMessageReceived.bind(this);
-      newConnectionManager.onMessagesReceived = this.#onConnectionMessagesReceived.bind(this);
+      newConnectionManager.onStatusUpdated =
+        this.#onConnectionStatusUpdated.bind(this);
+      newConnectionManager.onMessageReceived =
+        this.#onConnectionMessageReceived.bind(this);
+      newConnectionManager.onMessagesReceived =
+        this.#onConnectionMessagesReceived.bind(this);
     }
 
     this.#connectionManager = newConnectionManager;
     _console.log("assigned new connectionManager", this.#connectionManager);
+
+    this._informationManager.connectionType = this.connectionType;
   }
   async #sendTxMessages(messages?: TxMessage[], sendImmediately?: boolean) {
     await this.#connectionManager?.sendTxMessages(messages, sendImmediately);
   }
   private sendTxMessages = this.#sendTxMessages.bind(this);
 
-  async connect() {
+  async connect(options?: ConnectOptions) {
+    _console.log("connect options", options);
+    if (options) {
+      switch (options.type) {
+        case "webBluetooth":
+          if (this.connectionType != "webBluetooth") {
+            this.connectionManager = new WebBluetoothConnectionManager();
+          }
+          break;
+        case "webSocket":
+          {
+            let createConnectionManager = false;
+            if (this.connectionType == "webSocket") {
+              const connectionManager = this
+                .connectionManager as WebSocketConnectionManager;
+              if (
+                connectionManager.ipAddress != options.ipAddress ||
+                connectionManager.isSecure != options.isWifiSecure
+              ) {
+                createConnectionManager = true;
+              }
+            } else {
+              createConnectionManager = true;
+            }
+            if (createConnectionManager) {
+              this.connectionManager = new WebSocketConnectionManager(
+                options.ipAddress,
+                options.isWifiSecure,
+                this.bluetoothId
+              );
+            }
+          }
+
+          break;
+        case "udp":
+          {
+            let createConnectionManager = false;
+            if (this.connectionType == "udp") {
+              const connectionManager = this
+                .connectionManager as UDPConnectionManager;
+              if (connectionManager.ipAddress != options.ipAddress) {
+                createConnectionManager = true;
+              }
+              this.reconnectOnDisconnection = true;
+            } else {
+              createConnectionManager = true;
+            }
+            if (createConnectionManager) {
+              this.connectionManager = new UDPConnectionManager(
+                options.ipAddress,
+                this.bluetoothId
+              );
+            }
+          }
+          break;
+      }
+    }
     if (!this.connectionManager) {
       this.connectionManager = Device.#DefaultConnectionManager();
     }
     this.#clear();
+
+    if (options?.type == "client") {
+      _console.assertWithError(
+        this.connectionType == "client",
+        "expected clientConnectionManager"
+      );
+      const clientConnectionManager = this
+        .connectionManager as ClientConnectionManager;
+      clientConnectionManager.subType = options.subType;
+      return clientConnectionManager.connect();
+    }
+    _console.log("connectionManager type", this.connectionManager.type);
     return this.connectionManager.connect();
   }
   #isConnected = false;
@@ -271,15 +475,54 @@ class Device {
     _console.assertWithError(this.isConnected, "notConnected");
   }
 
-  get #hasRequiredInformation() {
-    return RequiredInformationConnectionMessages.every((messageType) => {
-      return this.latestConnectionMessage.has(messageType);
+  #didReceiveMessageTypes(messageTypes: ConnectionMessageType[]) {
+    return messageTypes.every((messageType) => {
+      const hasConnectionMessage =
+        this.latestConnectionMessages.has(messageType);
+      if (!hasConnectionMessage) {
+        _console.log(`didn't receive "${messageType}" message`);
+      }
+      return hasConnectionMessage;
     });
   }
+  get #hasRequiredInformation() {
+    let hasRequiredInformation = this.#didReceiveMessageTypes(
+      RequiredInformationConnectionMessages
+    );
+    if (hasRequiredInformation && this.sensorTypes.includes("pressure")) {
+      hasRequiredInformation = this.#didReceiveMessageTypes(
+        RequiredPressureMessageTypes
+      );
+    }
+    if (hasRequiredInformation && this.isWifiAvailable) {
+      hasRequiredInformation = this.#didReceiveMessageTypes(
+        RequiredWifiMessageTypes
+      );
+    }
+    if (hasRequiredInformation && this.fileTypes.length > 0) {
+      hasRequiredInformation = this.#didReceiveMessageTypes(
+        RequiredFileTransferMessageTypes
+      );
+    }
+    if (hasRequiredInformation && this.fileTypes.includes("tflite")) {
+      hasRequiredInformation = this.#didReceiveMessageTypes(
+        RequiredTfliteMessageTypes
+      );
+    }
+    if (hasRequiredInformation && this.hasCamera) {
+      hasRequiredInformation = this.#didReceiveMessageTypes(
+        RequiredCameraMessageTypes
+      );
+    }
+    return hasRequiredInformation;
+  }
   #requestRequiredInformation() {
-    const messages: TxMessage[] = RequiredInformationConnectionMessages.map((messageType) => ({
-      type: messageType,
-    }));
+    _console.log("requesting required information");
+    const messages: TxMessage[] = RequiredInformationConnectionMessages.map(
+      (messageType) => ({
+        type: messageType,
+      })
+    );
     this.#sendTxMessages(messages);
   }
 
@@ -343,7 +586,12 @@ class Device {
     if (this.isConnected) {
       this.disconnect();
     } else if (this.canReconnect) {
-      this.reconnect();
+      try {
+        this.reconnect();
+      } catch (error) {
+        _console.error("error trying to reconnect", error);
+        this.connect();
+      }
     } else {
       this.connect();
     }
@@ -362,14 +610,17 @@ class Device {
     }
   }
   get isConnectionBusy() {
-    return this.connectionStatus == "connecting" || this.connectionStatus == "disconnecting";
+    return (
+      this.connectionStatus == "connecting" ||
+      this.connectionStatus == "disconnecting"
+    );
   }
 
   #onConnectionStatusUpdated(connectionStatus: ConnectionStatus) {
     _console.log({ connectionStatus });
 
     if (connectionStatus == "notConnected") {
-      //this.#clear();
+      this.#clearConnection();
 
       if (this.canReconnect && this.reconnectOnDisconnection) {
         _console.log("starting reconnect interval...");
@@ -389,14 +640,18 @@ class Device {
     this.#checkConnection();
 
     if (connectionStatus == "connected" && !this.#isConnected) {
-      this.#requestRequiredInformation();
+      if (this.connectionType != "client") {
+        this.#requestRequiredInformation();
+      }
     }
 
     DeviceManager.OnDeviceConnectionStatusUpdated(this, connectionStatus);
   }
 
   #dispatchConnectionEvents(includeIsConnected: boolean = false) {
-    this.#dispatchEvent("connectionStatus", { connectionStatus: this.connectionStatus });
+    this.#dispatchEvent("connectionStatus", {
+      connectionStatus: this.connectionStatus,
+    });
     this.#dispatchEvent(this.connectionStatus, {});
     if (includeIsConnected) {
       this.#dispatchEvent("isConnected", { isConnected: this.isConnected });
@@ -424,13 +679,22 @@ class Device {
   }
 
   #clear() {
-    this.connectionManager?.clear();
-    this.latestConnectionMessage.clear();
+    this.#clearConnection();
     this._informationManager.clear();
     this.#deviceInformationManager.clear();
+    this.#tfliteManager.clear();
+    this.#wifiManager.clear();
+    this.#cameraManager.clear();
+  }
+  #clearConnection() {
+    this.connectionManager?.clear();
+    this.latestConnectionMessages.clear();
   }
 
-  #onConnectionMessageReceived(messageType: ConnectionMessageType, dataView: DataView) {
+  #onConnectionMessageReceived(
+    messageType: ConnectionMessageType,
+    dataView: DataView
+  ) {
     _console.log({ messageType, dataView });
     switch (messageType) {
       case "batteryLevel":
@@ -440,26 +704,93 @@ class Device {
         break;
 
       default:
-        if (FileTransferMessageTypes.includes(messageType as FileTransferMessageType)) {
-          this.#fileTransferManager.parseMessage(messageType as FileTransferMessageType, dataView);
-        } else if (TfliteMessageTypes.includes(messageType as TfliteMessageType)) {
-          this.#tfliteManager.parseMessage(messageType as TfliteMessageType, dataView);
-        } else if (SensorDataMessageTypes.includes(messageType as SensorDataMessageType)) {
-          this.#sensorDataManager.parseMessage(messageType as SensorDataMessageType, dataView);
-        } else if (FirmwareMessageTypes.includes(messageType as FirmwareMessageType)) {
-          this.#firmwareManager.parseMessage(messageType as FirmwareMessageType, dataView);
-        } else if (DeviceInformationMessageTypes.includes(messageType as DeviceInformationMessageType)) {
-          this.#deviceInformationManager.parseMessage(messageType as DeviceInformationMessageType, dataView);
-        } else if (InformationMessageTypes.includes(messageType as InformationMessageType)) {
-          this._informationManager.parseMessage(messageType as InformationMessageType, dataView);
-        } else if (SensorConfigurationMessageTypes.includes(messageType as SensorConfigurationMessageType)) {
-          this.#sensorConfigurationManager.parseMessage(messageType as SensorConfigurationMessageType, dataView);
+        if (
+          FileTransferMessageTypes.includes(
+            messageType as FileTransferMessageType
+          )
+        ) {
+          this.#fileTransferManager.parseMessage(
+            messageType as FileTransferMessageType,
+            dataView
+          );
+        } else if (
+          TfliteMessageTypes.includes(messageType as TfliteMessageType)
+        ) {
+          this.#tfliteManager.parseMessage(
+            messageType as TfliteMessageType,
+            dataView
+          );
+        } else if (
+          SensorDataMessageTypes.includes(messageType as SensorDataMessageType)
+        ) {
+          this.#sensorDataManager.parseMessage(
+            messageType as SensorDataMessageType,
+            dataView
+          );
+        } else if (
+          FirmwareMessageTypes.includes(messageType as FirmwareMessageType)
+        ) {
+          this.#firmwareManager.parseMessage(
+            messageType as FirmwareMessageType,
+            dataView
+          );
+        } else if (
+          DeviceInformationTypes.includes(messageType as DeviceInformationType)
+        ) {
+          this.#deviceInformationManager.parseMessage(
+            messageType as DeviceInformationType,
+            dataView
+          );
+        } else if (
+          InformationMessageTypes.includes(
+            messageType as InformationMessageType
+          )
+        ) {
+          this._informationManager.parseMessage(
+            messageType as InformationMessageType,
+            dataView
+          );
+        } else if (
+          SensorConfigurationMessageTypes.includes(
+            messageType as SensorConfigurationMessageType
+          )
+        ) {
+          this.#sensorConfigurationManager.parseMessage(
+            messageType as SensorConfigurationMessageType,
+            dataView
+          );
+        } else if (
+          VibrationMessageTypes.includes(messageType as VibrationMessageType)
+        ) {
+          this.#vibrationManager.parseMessage(
+            messageType as VibrationMessageType,
+            dataView
+          );
+        } else if (WifiMessageTypes.includes(messageType as WifiMessageType)) {
+          this.#wifiManager.parseMessage(
+            messageType as WifiMessageType,
+            dataView
+          );
+        } else if (
+          CameraMessageTypes.includes(messageType as CameraMessageType)
+        ) {
+          this.#cameraManager.parseMessage(
+            messageType as CameraMessageType,
+            dataView
+          );
         } else {
           throw Error(`uncaught messageType ${messageType}`);
         }
     }
 
-    this.latestConnectionMessage.set(messageType, dataView);
+    this.latestConnectionMessages.set(messageType, dataView);
+    if (messageType.startsWith("set")) {
+      this.latestConnectionMessages.set(
+        // @ts-expect-error
+        messageType.replace("set", "get"),
+        dataView
+      );
+    }
     this.#dispatchEvent("connectionMessage", { messageType, dataView });
   }
   #onConnectionMessagesReceived() {
@@ -472,7 +803,7 @@ class Device {
     this.#sendTxMessages();
   }
 
-  latestConnectionMessage: Map<ConnectionMessageType, DataView> = new Map();
+  latestConnectionMessages: Map<ConnectionMessageType, DataView> = new Map();
 
   // DEVICE INFORMATION
   #deviceInformationManager = new DeviceInformationManager();
@@ -531,8 +862,11 @@ class Device {
   get isInsole() {
     return this._informationManager.isInsole;
   }
-  get insoleSide() {
-    return this._informationManager.insoleSide;
+  get isGlove() {
+    return this._informationManager.isGlove;
+  }
+  get side() {
+    return this._informationManager.side;
   }
 
   get mtu() {
@@ -544,7 +878,9 @@ class Device {
     return Object.keys(this.sensorConfiguration) as SensorType[];
   }
   get continuousSensorTypes() {
-    return ContinuousSensorTypes.filter((sensorType) => this.sensorTypes.includes(sensorType));
+    return ContinuousSensorTypes.filter((sensorType) =>
+      this.sensorTypes.includes(sensorType)
+    );
   }
 
   // SENSOR CONFIGURATION
@@ -555,8 +891,14 @@ class Device {
     return this.#sensorConfigurationManager.configuration;
   }
 
-  async setSensorConfiguration(newSensorConfiguration: SensorConfiguration, clearRest?: boolean) {
-    await this.#sensorConfigurationManager.setConfiguration(newSensorConfiguration, clearRest);
+  async setSensorConfiguration(
+    newSensorConfiguration: SensorConfiguration,
+    clearRest?: boolean
+  ) {
+    await this.#sensorConfigurationManager.setConfiguration(
+      newSensorConfiguration,
+      clearRest
+    );
   }
 
   async clearSensorConfiguration() {
@@ -567,7 +909,9 @@ class Device {
   static get ClearSensorConfigurationOnLeave() {
     return this.#ClearSensorConfigurationOnLeave;
   }
-  static set ClearSensorConfigurationOnLeave(newClearSensorConfigurationOnLeave) {
+  static set ClearSensorConfigurationOnLeave(
+    newClearSensorConfigurationOnLeave
+  ) {
     _console.assertTypeWithError(newClearSensorConfigurationOnLeave, "boolean");
     this.#ClearSensorConfigurationOnLeave = newClearSensorConfigurationOnLeave;
   }
@@ -593,19 +937,44 @@ class Device {
   }
 
   // VIBRATION
+  get vibrationLocations() {
+    return this.#vibrationManager.vibrationLocations;
+  }
+
   #vibrationManager = new VibrationManager();
-  async triggerVibration(vibrationConfigurations: VibrationConfiguration[], sendImmediately?: boolean) {
-    this.#vibrationManager.triggerVibration(vibrationConfigurations, sendImmediately);
+  async triggerVibration(
+    vibrationConfigurations: VibrationConfiguration[],
+    sendImmediately?: boolean
+  ) {
+    this.#vibrationManager.triggerVibration(
+      vibrationConfigurations,
+      sendImmediately
+    );
   }
 
   // FILE TRANSFER
   #fileTransferManager = new FileTransferManager();
 
+  get fileTypes() {
+    return this.#fileTransferManager.fileTypes;
+  }
   get maxFileLength() {
     return this.#fileTransferManager.maxLength;
   }
+  get validFileTypes() {
+    return FileTypes.filter((fileType) => {
+      if (fileType.includes("wifi") && !this.isWifiAvailable) {
+        return false;
+      }
+      return true;
+    });
+  }
 
   async sendFile(fileType: FileType, file: FileLike) {
+    _console.assertWithError(
+      this.validFileTypes.includes(fileType),
+      `invalid fileType ${fileType}`
+    );
     const promise = this.waitForEvent("fileTransferComplete");
     this.#fileTransferManager.send(fileType, file);
     await promise;
@@ -634,6 +1003,18 @@ class Device {
     return this.#tfliteManager.setName;
   }
 
+  async sendTfliteConfiguration(configuration: TfliteFileConfiguration) {
+    configuration.type = "tflite";
+    this.#tfliteManager.sendConfiguration(configuration, false);
+    const didSendFile = await this.#fileTransferManager.send(
+      configuration.type,
+      configuration.file
+    );
+    if (!didSendFile) {
+      this.#sendTxMessages();
+    }
+  }
+
   // TFLITE MODEL CONFIG
   get tfliteTask() {
     return this.#tfliteManager.task;
@@ -651,7 +1032,9 @@ class Device {
     return this.#tfliteManager.sensorTypes;
   }
   get allowedTfliteSensorTypes() {
-    return this.sensorTypes.filter((sensorType) => TfliteSensorTypes.includes(sensorType));
+    return this.sensorTypes.filter((sensorType) =>
+      TfliteSensorTypes.includes(sensorType as TfliteSensorType)
+    );
   }
   get setTfliteSensorTypes() {
     return this.#tfliteManager.setSensorTypes;
@@ -697,15 +1080,31 @@ class Device {
 
   #firmwareManager = new FirmwareManager();
 
+  get canUpdateFirmware() {
+    return this.#connectionManager?.canUpdateFirmware;
+  }
+  #assertCanUpdateFirmware() {
+    _console.assertWithError(this.canUpdateFirmware, "can't update firmware");
+  }
+
   #sendSmpMessage(data: ArrayBuffer) {
+    this.#assertCanUpdateFirmware();
     return this.#connectionManager!.sendSmpMessage(data);
   }
   private sendSmpMessage = this.#sendSmpMessage.bind(this);
 
   get uploadFirmware() {
+    this.#assertCanUpdateFirmware();
     return this.#firmwareManager.uploadFirmware;
   }
+  get canReset() {
+    return this.canUpdateFirmware;
+  }
   async reset() {
+    _console.assertWithError(
+      this.canReset,
+      "reset is not enabled for this device"
+    );
     await this.#firmwareManager.reset();
     return this.#connectionManager!.disconnect();
   }
@@ -713,18 +1112,22 @@ class Device {
     return this.#firmwareManager.status;
   }
   get getFirmwareImages() {
+    this.#assertCanUpdateFirmware();
     return this.#firmwareManager.getImages;
   }
   get firmwareImages() {
     return this.#firmwareManager.images;
   }
   get eraseFirmwareImage() {
+    this.#assertCanUpdateFirmware();
     return this.#firmwareManager.eraseImage;
   }
   get confirmFirmwareImage() {
+    this.#assertCanUpdateFirmware();
     return this.#firmwareManager.confirmImage;
   }
   get testFirmwareImage() {
+    this.#assertCanUpdateFirmware();
     return this.#firmwareManager.testImage;
   }
 
@@ -743,6 +1146,131 @@ class Device {
 
     this.#fileTransferManager.isServerSide = this.isServerSide;
   }
+
+  // UKATON
+  get isUkaton() {
+    return this.deviceInformation.modelNumber.includes("Ukaton");
+  }
+
+  // WIFI MANAGER
+  #wifiManager = new WifiManager();
+  get isWifiAvailable() {
+    return this.#wifiManager.isWifiAvailable;
+  }
+  get wifiSSID() {
+    return this.#wifiManager.wifiSSID;
+  }
+  async setWifiSSID(newWifiSSID: string) {
+    return this.#wifiManager.setWifiSSID(newWifiSSID);
+  }
+  get wifiPassword() {
+    return this.#wifiManager.wifiPassword;
+  }
+  async setWifiPassword(newWifiPassword: string) {
+    return this.#wifiManager.setWifiPassword(newWifiPassword);
+  }
+  get isWifiConnected() {
+    return this.#wifiManager.isWifiConnected;
+  }
+  get ipAddress() {
+    return this.#wifiManager.ipAddress;
+  }
+  get wifiConnectionEnabled() {
+    return this.#wifiManager.wifiConnectionEnabled;
+  }
+  get enableWifiConnection() {
+    return this.#wifiManager.enableWifiConnection;
+  }
+  get setWifiConnectionEnabled() {
+    return this.#wifiManager.setWifiConnectionEnabled;
+  }
+  get disableWifiConnection() {
+    return this.#wifiManager.disableWifiConnection;
+  }
+  get toggleWifiConnection() {
+    return this.#wifiManager.toggleWifiConnection;
+  }
+  get isWifiSecure() {
+    return this.#wifiManager.isWifiSecure;
+  }
+
+  async reconnectViaWebSockets() {
+    _console.assertWithError(this.isWifiConnected, "wifi is not connected");
+    _console.assertWithError(
+      this.connectionType != "webSocket",
+      "already connected via webSockets"
+    );
+    _console.assertTypeWithError(this.ipAddress, "string");
+    _console.log("reconnecting via websockets...");
+    await this.disconnect();
+    await this.connect({
+      type: "webSocket",
+      ipAddress: this.ipAddress!,
+      isWifiSecure: this.isWifiSecure,
+    });
+  }
+
+  async reconnectViaUDP() {
+    _console.assertWithError(isInNode, "udp is only available in node");
+    _console.assertWithError(this.isWifiConnected, "wifi is not connected");
+    _console.assertWithError(
+      this.connectionType != "udp",
+      "already connected via udp"
+    );
+    _console.assertTypeWithError(this.ipAddress, "string");
+    _console.log("reconnecting via udp...");
+    await this.disconnect();
+    await this.connect({
+      type: "udp",
+      ipAddress: this.ipAddress!,
+    });
+  }
+
+  // CAMERA MANAGER
+  #cameraManager = new CameraManager();
+  get hasCamera() {
+    return this.sensorTypes.includes("camera");
+  }
+  get cameraStatus() {
+    return this.#cameraManager.cameraStatus;
+  }
+  #assertHasCamera() {
+    _console.assertWithError(this.hasCamera, "camera not available");
+  }
+  async takePicture() {
+    this.#assertHasCamera();
+    await this.#cameraManager.takePicture();
+  }
+  async focusCamera() {
+    this.#assertHasCamera();
+    await this.#cameraManager.focus();
+  }
+  async stopCamera() {
+    this.#assertHasCamera();
+    await this.#cameraManager.stop();
+  }
+  async wakeCamera() {
+    this.#assertHasCamera();
+    await this.#cameraManager.wake();
+  }
+  async sleepCamera() {
+    this.#assertHasCamera();
+    await this.#cameraManager.sleep();
+  }
+
+  get cameraConfiguration() {
+    return this.#cameraManager.cameraConfiguration;
+  }
+  get availableCameraConfigurationTypes() {
+    return this.#cameraManager.availableCameraConfigurationTypes;
+  }
+  get cameraConfigurationRanges() {
+    return this.#cameraManager.cameraConfigurationRanges;
+  }
+
+  get setCameraConfiguration() {
+    return this.#cameraManager.setCameraConfiguration;
+  }
 }
 
 export default Device;