brilliantsole 0.0.26 → 0.0.28

package/src/WifiManager.ts

@@ -0,0 +1,323 @@
+import Device, { SendMessageCallback } from "./Device.ts";
+import { createConsole } from "./utils/Console.ts";
+import { isInNode } from "./utils/environment.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { textDecoder, textEncoder } from "./utils/Text.ts";
+import autoBind from "auto-bind";
+
+const _console = createConsole("WifiManager", { log: false });
+
+export const MinWifiSSIDLength = 1;
+export const MaxWifiSSIDLength = 32;
+
+export const MinWifiPasswordLength = 8;
+export const MaxWifiPasswordLength = 64;
+
+export const WifiMessageTypes = [
+  "isWifiAvailable",
+  "getWifiSSID",
+  "setWifiSSID",
+  "getWifiPassword",
+  "setWifiPassword",
+  "getWifiConnectionEnabled",
+  "setWifiConnectionEnabled",
+  "isWifiConnected",
+  "ipAddress",
+  "isWifiSecure",
+] as const;
+export type WifiMessageType = (typeof WifiMessageTypes)[number];
+
+export const RequiredWifiMessageTypes: WifiMessageType[] = [
+  "getWifiSSID",
+  "getWifiPassword",
+  "getWifiConnectionEnabled",
+  "isWifiConnected",
+  "ipAddress",
+  "isWifiSecure",
+] as const;
+
+export const WifiEventTypes = WifiMessageTypes;
+export type WifiEventType = (typeof WifiEventTypes)[number];
+
+export interface WifiEventMessages {
+  isWifiAvailable: { isWifiAvailable: boolean };
+  getWifiSSID: { wifiSSID: string };
+  getWifiPassword: { wifiPassword: string };
+  getEnableWifiConnection: { wifiConnectionEnabled: boolean };
+  isWifiConnected: { isWifiConnected: boolean };
+  ipAddress: { ipAddress?: string };
+}
+
+export type WifiEventDispatcher = EventDispatcher<
+  Device,
+  WifiEventType,
+  WifiEventMessages
+>;
+export type SendWifiMessageCallback = SendMessageCallback<WifiMessageType>;
+
+class WifiManager {
+  constructor() {
+    autoBind(this);
+  }
+
+  sendMessage!: SendWifiMessageCallback;
+
+  eventDispatcher!: WifiEventDispatcher;
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  requestRequiredInformation() {
+    _console.log("requesting required wifi information");
+    const messages = RequiredWifiMessageTypes.map((messageType) => ({
+      type: messageType,
+    }));
+    this.sendMessage(messages, false);
+  }
+
+  // PROPERTIES
+
+  #isWifiAvailable = false;
+  get isWifiAvailable() {
+    return this.#isWifiAvailable;
+  }
+  #updateIsWifiAvailable(updatedIsWifiAvailable: boolean) {
+    _console.assertTypeWithError(updatedIsWifiAvailable, "boolean");
+    this.#isWifiAvailable = updatedIsWifiAvailable;
+    _console.log({ isWifiAvailable: this.#isWifiAvailable });
+    this.#dispatchEvent("isWifiAvailable", {
+      isWifiAvailable: this.#isWifiAvailable,
+    });
+  }
+
+  #assertWifiIsAvailable() {
+    _console.assertWithError(this.#isWifiAvailable, "wifi is not available");
+  }
+
+  // WIFI SSID
+  #wifiSSID = "";
+  get wifiSSID() {
+    return this.#wifiSSID;
+  }
+
+  #updateWifiSSID(updatedWifiSSID: string) {
+    _console.assertTypeWithError(updatedWifiSSID, "string");
+    this.#wifiSSID = updatedWifiSSID;
+    _console.log({ wifiSSID: this.#wifiSSID });
+    this.#dispatchEvent("getWifiSSID", { wifiSSID: this.#wifiSSID });
+  }
+  async setWifiSSID(newWifiSSID: string) {
+    this.#assertWifiIsAvailable();
+    if (this.#wifiConnectionEnabled) {
+      _console.error("cannot change ssid while wifi connection is enabled");
+      return;
+    }
+    _console.assertTypeWithError(newWifiSSID, "string");
+    _console.assertRangeWithError(
+      "wifiSSID",
+      newWifiSSID.length,
+      MinWifiSSIDLength,
+      MaxWifiSSIDLength
+    );
+
+    const setWifiSSIDData = textEncoder.encode(newWifiSSID);
+    _console.log({ setWifiSSIDData });
+
+    const promise = this.waitForEvent("getWifiSSID");
+    this.sendMessage([{ type: "setWifiSSID", data: setWifiSSIDData.buffer }]);
+    await promise;
+  }
+
+  // WIFI PASSWORD
+  #wifiPassword = "";
+  get wifiPassword() {
+    return this.#wifiPassword;
+  }
+
+  #updateWifiPassword(updatedWifiPassword: string) {
+    _console.assertTypeWithError(updatedWifiPassword, "string");
+    this.#wifiPassword = updatedWifiPassword;
+    _console.log({ wifiPassword: this.#wifiPassword });
+    this.#dispatchEvent("getWifiPassword", {
+      wifiPassword: this.#wifiPassword,
+    });
+  }
+  async setWifiPassword(newWifiPassword: string) {
+    this.#assertWifiIsAvailable();
+    if (this.#wifiConnectionEnabled) {
+      _console.error("cannot change password while wifi connection is enabled");
+      return;
+    }
+    _console.assertTypeWithError(newWifiPassword, "string");
+    if (newWifiPassword.length > 0) {
+      _console.assertRangeWithError(
+        "wifiPassword",
+        newWifiPassword.length,
+        MinWifiPasswordLength,
+        MaxWifiPasswordLength
+      );
+    }
+
+    const setWifiPasswordData = textEncoder.encode(newWifiPassword);
+    _console.log({ setWifiPasswordData });
+
+    const promise = this.waitForEvent("getWifiPassword");
+    this.sendMessage([
+      { type: "setWifiPassword", data: setWifiPasswordData.buffer },
+    ]);
+    await promise;
+  }
+
+  // ENABLE WIFI CONNECTION
+  #wifiConnectionEnabled!: boolean;
+  get wifiConnectionEnabled() {
+    return this.#wifiConnectionEnabled;
+  }
+  #updateWifiConnectionEnabled(wifiConnectionEnabled: boolean) {
+    _console.log({ wifiConnectionEnabled });
+    this.#wifiConnectionEnabled = wifiConnectionEnabled;
+    this.#dispatchEvent("getWifiConnectionEnabled", {
+      wifiConnectionEnabled: wifiConnectionEnabled,
+    });
+  }
+  async setWifiConnectionEnabled(
+    newWifiConnectionEnabled: boolean,
+    sendImmediately: boolean = true
+  ) {
+    this.#assertWifiIsAvailable();
+    _console.assertTypeWithError(newWifiConnectionEnabled, "boolean");
+    if (this.#wifiConnectionEnabled == newWifiConnectionEnabled) {
+      _console.log(
+        `redundant wifiConnectionEnabled assignment ${newWifiConnectionEnabled}`
+      );
+      return;
+    }
+
+    const promise = this.waitForEvent("getWifiConnectionEnabled");
+    this.sendMessage(
+      [
+        {
+          type: "setWifiConnectionEnabled",
+          data: Uint8Array.from([Number(newWifiConnectionEnabled)]).buffer,
+        },
+      ],
+      sendImmediately
+    );
+    await promise;
+  }
+  async toggleWifiConnection() {
+    return this.setWifiConnectionEnabled(!this.wifiConnectionEnabled);
+  }
+  async enableWifiConnection() {
+    return this.setWifiConnectionEnabled(true);
+  }
+  async disableWifiConnection() {
+    return this.setWifiConnectionEnabled(false);
+  }
+
+  // IS WIFI CONNECTED
+  #isWifiConnected = false;
+  get isWifiConnected() {
+    return this.#isWifiConnected;
+  }
+  #updateIsWifiConnected(updatedIsWifiConnected: boolean) {
+    _console.assertTypeWithError(updatedIsWifiConnected, "boolean");
+    this.#isWifiConnected = updatedIsWifiConnected;
+    _console.log({ isWifiConnected: this.#isWifiConnected });
+    this.#dispatchEvent("isWifiConnected", {
+      isWifiConnected: this.#isWifiConnected,
+    });
+  }
+
+  // IP ADDRESS
+  #ipAddress?: string;
+  get ipAddress() {
+    return this.#ipAddress;
+  }
+
+  #updateIpAddress(updatedIpAddress?: string) {
+    this.#ipAddress = updatedIpAddress;
+    _console.log({ ipAddress: this.#ipAddress });
+    this.#dispatchEvent("ipAddress", {
+      ipAddress: this.#ipAddress,
+    });
+  }
+
+  // IS WIFI SECURE
+  #isWifiSecure = false;
+  get isWifiSecure() {
+    return this.#isWifiSecure;
+  }
+  #updateIsWifiSecure(updatedIsWifiSecure: boolean) {
+    _console.assertTypeWithError(updatedIsWifiSecure, "boolean");
+    this.#isWifiSecure = updatedIsWifiSecure;
+    _console.log({ isWifiSecure: this.#isWifiSecure });
+    this.#dispatchEvent("isWifiSecure", {
+      isWifiSecure: this.#isWifiSecure,
+    });
+  }
+
+  // MESSAGE
+  parseMessage(messageType: WifiMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "isWifiAvailable":
+        const isWifiAvailable = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiAvailable });
+        this.#updateIsWifiAvailable(isWifiAvailable);
+        break;
+      case "getWifiSSID":
+      case "setWifiSSID":
+        const ssid = textDecoder.decode(dataView.buffer);
+        _console.log({ ssid });
+        this.#updateWifiSSID(ssid);
+        break;
+      case "getWifiPassword":
+      case "setWifiPassword":
+        const password = textDecoder.decode(dataView.buffer);
+        _console.log({ password });
+        this.#updateWifiPassword(password);
+        break;
+      case "getWifiConnectionEnabled":
+      case "setWifiConnectionEnabled":
+        const enableWifiConnection = Boolean(dataView.getUint8(0));
+        _console.log({ enableWifiConnection });
+        this.#updateWifiConnectionEnabled(enableWifiConnection);
+        break;
+      case "isWifiConnected":
+        const isWifiConnected = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiConnected });
+        this.#updateIsWifiConnected(isWifiConnected);
+        break;
+      case "ipAddress":
+        let ipAddress: string | undefined = undefined;
+        if (dataView.byteLength == 4) {
+          ipAddress = new Uint8Array(dataView.buffer.slice(0, 4)).join(".");
+        }
+        _console.log({ ipAddress });
+        this.#updateIpAddress(ipAddress);
+        break;
+      case "isWifiSecure":
+        const isWifiSecure = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiSecure });
+        this.#updateIsWifiSecure(isWifiSecure);
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+
+  clear() {
+    this.#wifiSSID = "";
+    this.#wifiPassword = "";
+    this.#ipAddress = "";
+    this.#isWifiConnected = false;
+    this.#isWifiAvailable = false;
+  }
+}
+
+export default WifiManager;

package/src/connection/BaseConnectionManager.ts

@@ -5,21 +5,69 @@ import { FileTransferMessageTypes } from "../FileTransferManager.ts";
 import { TfliteMessageTypes } from "../TfliteManager.ts";
 import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
 import { parseMessage } from "../utils/ParseUtils.ts";
-import { DeviceInformationMessageTypes } from "../DeviceInformationManager.ts";
+import { DeviceInformationTypes } from "../DeviceInformationManager.ts";
 import { InformationMessageTypes } from "../InformationManager.ts";
 import { VibrationMessageTypes } from "../vibration/VibrationManager.ts";
 import { SensorConfigurationMessageTypes } from "../sensor/SensorConfigurationManager.ts";
 import { SensorDataMessageTypes } from "../sensor/SensorDataManager.ts";
+import { WifiMessageTypes } from "../WifiManager.ts";
+import { CameraMessageTypes } from "../CameraManager.ts";
 
-const _console = createConsole("BaseConnectionManager", { log: true });
+const _console = createConsole("BaseConnectionManager", { log: false });
 
-export const ConnectionTypes = ["webBluetooth", "noble", "client"] as const;
+export const ConnectionTypes = [
+  "webBluetooth",
+  "noble",
+  "client",
+  "webSocket",
+  "udp",
+] as const;
 export type ConnectionType = (typeof ConnectionTypes)[number];
 
-export const ConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"] as const;
+export const ClientConnectionTypes = ["noble", "webSocket", "udp"] as const;
+export type ClientConnectionType = (typeof ClientConnectionTypes)[number];
+
+interface BaseConnectOptions {
+  type: "client" | "webBluetooth" | "webSocket" | "udp";
+}
+export interface WebBluetoothConnectOptions extends BaseConnectOptions {
+  type: "webBluetooth";
+}
+interface BaseWifiConnectOptions extends BaseConnectOptions {
+  ipAddress: string;
+}
+export interface ClientConnectOptions extends BaseConnectOptions {
+  type: "client";
+  subType?: "noble" | "webSocket" | "udp";
+}
+export interface WebSocketConnectOptions extends BaseWifiConnectOptions {
+  type: "webSocket";
+  isWifiSecure?: boolean;
+}
+export interface UDPConnectOptions extends BaseWifiConnectOptions {
+  type: "udp";
+  //sendPort: number;
+  receivePort?: number;
+}
+export type ConnectOptions =
+  | WebBluetoothConnectOptions
+  | WebSocketConnectOptions
+  | UDPConnectOptions
+  | ClientConnectOptions;
+
+export const ConnectionStatuses = [
+  "notConnected",
+  "connecting",
+  "connected",
+  "disconnecting",
+] as const;
 export type ConnectionStatus = (typeof ConnectionStatuses)[number];
 
-export const ConnectionEventTypes = [...ConnectionStatuses, "connectionStatus", "isConnected"] as const;
+export const ConnectionEventTypes = [
+  ...ConnectionStatuses,
+  "connectionStatus",
+  "isConnected",
+] as const;
 export type ConnectionEventType = (typeof ConnectionEventTypes)[number];
 
 export interface ConnectionStatusEventMessages {
@@ -41,8 +89,10 @@ export const TxRxMessageTypes = [
   ...SensorConfigurationMessageTypes,
   ...SensorDataMessageTypes,
   ...VibrationMessageTypes,
-  ...TfliteMessageTypes,
   ...FileTransferMessageTypes,
+  ...TfliteMessageTypes,
+  ...WifiMessageTypes,
+  ...CameraMessageTypes,
 ] as const;
 export type TxRxMessageType = (typeof TxRxMessageTypes)[number];
 
@@ -53,11 +103,12 @@ export const BatteryLevelMessageTypes = ["batteryLevel"] as const;
 export type BatteryLevelMessageType = (typeof BatteryLevelMessageTypes)[number];
 
 export const MetaConnectionMessageTypes = ["rx", "tx"] as const;
-export type MetaConnectionMessageType = (typeof MetaConnectionMessageTypes)[number];
+export type MetaConnectionMessageType =
+  (typeof MetaConnectionMessageTypes)[number];
 
 export const ConnectionMessageTypes = [
   ...BatteryLevelMessageTypes,
-  ...DeviceInformationMessageTypes,
+  ...DeviceInformationTypes,
   ...MetaConnectionMessageTypes,
   ...TxRxMessageTypes,
   ...SMPMessageTypes,
@@ -65,7 +116,10 @@ export const ConnectionMessageTypes = [
 export type ConnectionMessageType = (typeof ConnectionMessageTypes)[number];
 
 export type ConnectionStatusCallback = (status: ConnectionStatus) => void;
-export type MessageReceivedCallback = (messageType: ConnectionMessageType, dataView: DataView) => void;
+export type MessageReceivedCallback = (
+  messageType: ConnectionMessageType,
+  dataView: DataView
+) => void;
 export type MessagesReceivedCallback = () => void;
 
 abstract class BaseConnectionManager {
@@ -90,6 +144,10 @@ abstract class BaseConnectionManager {
     return this.baseConstructor.isSupported;
   }
 
+  get canUpdateFirmware() {
+    return false;
+  }
+
   static type: ConnectionType;
   get type(): ConnectionType {
     return this.baseConstructor.type;
@@ -97,7 +155,10 @@ abstract class BaseConnectionManager {
 
   /** @throws {Error} if not supported */
   #assertIsSupported() {
-    _console.assertWithError(this.isSupported, `${this.constructor.name} is not supported`);
+    _console.assertWithError(
+      this.isSupported,
+      `${this.constructor.name} is not supported`
+    );
   }
 
   constructor() {
@@ -111,7 +172,9 @@ abstract class BaseConnectionManager {
   protected set status(newConnectionStatus) {
     _console.assertEnumWithError(newConnectionStatus, ConnectionStatuses);
     if (this.#status == newConnectionStatus) {
-      _console.log(`tried to assign same connection status "${newConnectionStatus}"`);
+      _console.log(
+        `tried to assign same connection status "${newConnectionStatus}"`
+      );
       return;
     }
     _console.log(`new connection status "${newConnectionStatus}"`);
@@ -125,7 +188,7 @@ abstract class BaseConnectionManager {
     }
 
     if (this.#status == "notConnected") {
-      this.mtu = undefined;
+      this.mtu = this.defaultMtu;
     }
   }
 
@@ -133,30 +196,40 @@ abstract class BaseConnectionManager {
     return this.status == "connected";
   }
 
+  get isAvailable() {
+    return false;
+  }
+
   /** @throws {Error} if connected */
-  #assertIsNotConnected() {
+  protected assertIsNotConnected() {
     _console.assertWithError(!this.isConnected, "device is already connected");
   }
   /** @throws {Error} if connecting */
   #assertIsNotConnecting() {
-    _console.assertWithError(this.status != "connecting", "device is already connecting");
+    _console.assertWithError(
+      this.status != "connecting",
+      "device is already connecting"
+    );
   }
   /** @throws {Error} if not connected */
-  #assertIsConnected() {
+  protected assertIsConnected() {
     _console.assertWithError(this.isConnected, "device is not connected");
   }
   /** @throws {Error} if disconnecting */
   #assertIsNotDisconnecting() {
-    _console.assertWithError(this.status != "disconnecting", "device is already disconnecting");
+    _console.assertWithError(
+      this.status != "disconnecting",
+      "device is already disconnecting"
+    );
   }
   /** @throws {Error} if not connected or is disconnecting */
-  #assertIsConnectedAndNotDisconnecting() {
-    this.#assertIsConnected();
+  assertIsConnectedAndNotDisconnecting() {
+    this.assertIsConnected();
     this.#assertIsNotDisconnecting();
   }
 
   async connect() {
-    this.#assertIsNotConnected();
+    this.assertIsNotConnected();
     this.#assertIsNotConnecting();
     this.status = "connecting";
   }
@@ -164,26 +237,31 @@ abstract class BaseConnectionManager {
     return false;
   }
   async reconnect() {
-    this.#assertIsNotConnected();
+    this.assertIsNotConnected();
     this.#assertIsNotConnecting();
-    _console.assert(this.canReconnect, "unable to reconnect");
+    _console.assertWithError(this.canReconnect, "unable to reconnect");
+    this.status = "connecting";
+    _console.log("attempting to reconnect...");
   }
   async disconnect() {
-    this.#assertIsConnected();
+    this.assertIsConnected();
     this.#assertIsNotDisconnecting();
     this.status = "disconnecting";
     _console.log("disconnecting from device...");
   }
 
   async sendSmpMessage(data: ArrayBuffer) {
-    this.#assertIsConnectedAndNotDisconnecting();
+    this.assertIsConnectedAndNotDisconnecting();
     _console.log("sending smp message", data);
   }
 
   #pendingMessages: TxMessage[] = [];
   #isSendingMessages = false;
-  async sendTxMessages(messages: TxMessage[] | undefined, sendImmediately: boolean = true) {
-    this.#assertIsConnectedAndNotDisconnecting();
+  async sendTxMessages(
+    messages: TxMessage[] | undefined,
+    sendImmediately: boolean = true
+  ) {
+    this.assertIsConnectedAndNotDisconnecting();
 
     if (messages) {
       this.#pendingMessages.push(...messages);
@@ -196,7 +274,11 @@ abstract class BaseConnectionManager {
     }
 
     if (this.#isSendingMessages) {
-      console.log("already sending messages - waiting until later");
+      _console.log("already sending messages - waiting until later");
+      return;
+    }
+    if (this.#pendingMessages.length == 0) {
+      _console.log("no pendingMessages");
       return;
     }
     this.#isSendingMessages = true;
@@ -214,12 +296,27 @@ abstract class BaseConnectionManager {
 
     if (this.mtu) {
       while (arrayBuffers.length > 0) {
+        if (
+          arrayBuffers.every(
+            (arrayBuffer) => arrayBuffer.byteLength > this.mtu! - 3
+          )
+        ) {
+          _console.log("every arrayBuffer is too big to send");
+          break;
+        }
+        _console.log("remaining arrayBuffers.length", arrayBuffers.length);
         let arrayBufferByteLength = 0;
         let arrayBufferCount = 0;
         arrayBuffers.some((arrayBuffer) => {
           if (arrayBufferByteLength + arrayBuffer.byteLength > this.mtu! - 3) {
+            _console.log(
+              `stopping appending arrayBuffers ( length ${arrayBuffer.byteLength} too much)`
+            );
             return true;
           }
+          _console.log(
+            `allowing arrayBuffer with length ${arrayBuffer.byteLength}`
+          );
           arrayBufferCount++;
           arrayBufferByteLength += arrayBuffer.byteLength;
         });
@@ -227,26 +324,36 @@ abstract class BaseConnectionManager {
         _console.log({ arrayBufferCount, arrayBuffersToSend });
 
         const arrayBuffer = concatenateArrayBuffers(...arrayBuffersToSend);
-        _console.log("sending arrayBuffer", arrayBuffer);
+        _console.log("sending arrayBuffer (partitioned)", arrayBuffer);
         await this.sendTxData(arrayBuffer);
       }
     } else {
       const arrayBuffer = concatenateArrayBuffers(...arrayBuffers);
-      _console.log("sending arrayBuffer", arrayBuffer);
+      _console.log("sending arrayBuffer (all)", arrayBuffer);
       await this.sendTxData(arrayBuffer);
     }
 
     this.#isSendingMessages = false;
+
+    this.sendTxMessages(undefined, true);
   }
 
-  mtu?: number;
+  protected defaultMtu = 23;
+  //mtu?: number;
+  mtu?: number = this.defaultMtu;
 
   async sendTxData(data: ArrayBuffer) {
     _console.log("sendTxData", data);
   }
 
   parseRxMessage(dataView: DataView) {
-    parseMessage(dataView, TxRxMessageTypes, this.#onRxMessage.bind(this), null, true);
+    parseMessage(
+      dataView,
+      TxRxMessageTypes,
+      this.#onRxMessage.bind(this),
+      null,
+      true
+    );
     this.onMessagesReceived!();
   }
 
@@ -268,6 +375,14 @@ abstract class BaseConnectionManager {
     this.#isSendingMessages = false;
     this.#pendingMessages.length = 0;
   }
+
+  remove() {
+    this.clear();
+
+    this.onStatusUpdated = undefined;
+    this.onMessageReceived = undefined;
+    this.onMessagesReceived = undefined;
+  }
 }
 
 export default BaseConnectionManager;