brilliantsole 0.0.27 → 0.0.29

package/src/connection/BaseConnectionManager.ts

@@ -5,21 +5,70 @@ 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";
+import { MicrophoneMessageTypes } from "../MicrophoneManager.ts";
 
 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 +90,11 @@ export const TxRxMessageTypes = [
   ...SensorConfigurationMessageTypes,
   ...SensorDataMessageTypes,
   ...VibrationMessageTypes,
-  ...TfliteMessageTypes,
   ...FileTransferMessageTypes,
+  ...TfliteMessageTypes,
+  ...WifiMessageTypes,
+  ...CameraMessageTypes,
+  ...MicrophoneMessageTypes,
 ] as const;
 export type TxRxMessageType = (typeof TxRxMessageTypes)[number];
 
@@ -53,11 +105,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 +118,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 {
@@ -101,7 +157,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() {
@@ -115,7 +174,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}"`);
@@ -129,7 +190,7 @@ abstract class BaseConnectionManager {
     }
 
     if (this.#status == "notConnected") {
-      this.mtu = this.#defaultMtu;
+      this.mtu = this.defaultMtu;
     }
   }
 
@@ -142,29 +203,35 @@ abstract class BaseConnectionManager {
   }
 
   /** @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";
   }
@@ -172,26 +239,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);
@@ -207,6 +279,10 @@ abstract class BaseConnectionManager {
       _console.log("already sending messages - waiting until later");
       return;
     }
+    if (this.#pendingMessages.length == 0) {
+      _console.log("no pendingMessages");
+      return;
+    }
     this.#isSendingMessages = true;
 
     _console.log("sendTxMessages", this.#pendingMessages.slice());
@@ -222,7 +298,11 @@ abstract class BaseConnectionManager {
 
     if (this.mtu) {
       while (arrayBuffers.length > 0) {
-        if (arrayBuffers.every((arrayBuffer) => arrayBuffer.byteLength > this.mtu! - 3)) {
+        if (
+          arrayBuffers.every(
+            (arrayBuffer) => arrayBuffer.byteLength > this.mtu! - 3
+          )
+        ) {
           _console.log("every arrayBuffer is too big to send");
           break;
         }
@@ -231,10 +311,14 @@ abstract class BaseConnectionManager {
         let arrayBufferCount = 0;
         arrayBuffers.some((arrayBuffer) => {
           if (arrayBufferByteLength + arrayBuffer.byteLength > this.mtu! - 3) {
-            _console.log(`stopping appending arrayBuffers ( length ${arrayBuffer.byteLength} too much)`);
+            _console.log(
+              `stopping appending arrayBuffers ( length ${arrayBuffer.byteLength} too much)`
+            );
             return true;
           }
-          _console.log(`allowing arrayBuffer with length ${arrayBuffer.byteLength}`);
+          _console.log(
+            `allowing arrayBuffer with length ${arrayBuffer.byteLength}`
+          );
           arrayBufferCount++;
           arrayBufferByteLength += arrayBuffer.byteLength;
         });
@@ -252,18 +336,26 @@ abstract class BaseConnectionManager {
     }
 
     this.#isSendingMessages = false;
+
+    this.sendTxMessages(undefined, true);
   }
 
-  #defaultMtu = 23;
+  protected defaultMtu = 23;
   //mtu?: number;
-  mtu?: number = this.#defaultMtu;
+  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!();
   }
 
@@ -285,6 +377,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;

package/src/connection/ClientConnectionManager.ts

@@ -1,18 +1,32 @@
 import { createConsole } from "../utils/Console.ts";
 import { isInBrowser } from "../utils/environment.ts";
-import BaseConnectionManager, { ConnectionType, ConnectionMessageType } from "./BaseConnectionManager.ts";
+import BaseConnectionManager, {
+  ConnectionType,
+  ConnectionMessageType,
+  ClientConnectionType,
+} from "./BaseConnectionManager.ts";
 import { DeviceEventTypes } from "../Device.ts";
 import { parseMessage } from "../utils/ParseUtils.ts";
-import { DeviceInformationMessageTypes } from "../DeviceInformationManager.ts";
+import { DeviceInformationTypes } from "../DeviceInformationManager.ts";
 import { DeviceEventType } from "../Device.ts";
 import { ClientDeviceMessage } from "../server/ServerUtils.ts";
 import BaseClient from "../server/BaseClient.ts";
+import { DiscoveredDevice } from "../BS.ts";
 
 const _console = createConsole("ClientConnectionManager", { log: false });
 
-export type SendClientMessageCallback = (...messages: ClientDeviceMessage[]) => void;
+export type SendClientMessageCallback = (
+  ...messages: ClientDeviceMessage[]
+) => void;
 
-const ClientDeviceInformationMessageTypes: ConnectionMessageType[] = [...DeviceInformationMessageTypes, "batteryLevel"];
+export type SendClientConnectMessageCallback = (
+  connectionType?: ClientConnectionType
+) => void;
+
+const ClientDeviceInformationMessageTypes: ConnectionMessageType[] = [
+  ...DeviceInformationTypes,
+  "batteryLevel",
+];
 
 class ClientConnectionManager extends BaseConnectionManager {
   static get isSupported() {
@@ -22,12 +36,15 @@ class ClientConnectionManager extends BaseConnectionManager {
     return "client";
   }
 
+  subType?: ClientConnectionType;
+
   get canUpdateFirmware() {
     // FIX - how to know if it has an smp characteristic?
     return false;
   }
 
   client!: BaseClient;
+  discoveredDevice!: DiscoveredDevice;
 
   #bluetoothId!: string;
   get bluetoothId() {
@@ -67,7 +84,7 @@ class ClientConnectionManager extends BaseConnectionManager {
 
   async connect() {
     await super.connect();
-    this.sendClientConnectMessage();
+    this.sendClientConnectMessage(this.subType);
   }
   async disconnect() {
     await super.disconnect();
@@ -79,13 +96,13 @@ class ClientConnectionManager extends BaseConnectionManager {
   }
   async reconnect() {
     await super.reconnect();
-    _console.log("attempting to reconnect...");
-    this.connect();
+    this.sendClientConnectMessage();
   }
 
   sendClientMessage!: SendClientMessageCallback;
-  sendClientConnectMessage!: Function;
+  sendClientConnectMessage!: SendClientConnectMessageCallback;
   sendClientDisconnectMessage!: Function;
+  sendRequiredDeviceInformationMessage!: Function;
 
   async sendSmpMessage(data: ArrayBuffer) {
     super.sendSmpMessage(data);
@@ -101,12 +118,19 @@ class ClientConnectionManager extends BaseConnectionManager {
   }
 
   #requestDeviceInformation() {
-    this.sendClientMessage(...ClientDeviceInformationMessageTypes);
+    //this.sendClientMessage(...ClientDeviceInformationMessageTypes);
+    this.sendRequiredDeviceInformationMessage();
   }
 
   onClientMessage(dataView: DataView) {
     _console.log({ dataView });
-    parseMessage(dataView, DeviceEventTypes, this.#onClientMessageCallback.bind(this), null, true);
+    parseMessage(
+      dataView,
+      DeviceEventTypes,
+      this.#onClientMessageCallback.bind(this),
+      null,
+      true
+    );
     this.onMessagesReceived!();
   }
 

package/src/connection/bluetooth/BluetoothConnectionManager.ts

@@ -13,7 +13,10 @@ abstract class BluetoothConnectionManager extends BaseConnectionManager {
 
   isInRange = true;
 
-  protected onCharacteristicValueChanged(characteristicName: BluetoothCharacteristicName, dataView: DataView) {
+  protected onCharacteristicValueChanged(
+    characteristicName: BluetoothCharacteristicName,
+    dataView: DataView
+  ) {
     if (characteristicName == "rx") {
       this.parseRxMessage(dataView);
     } else {
@@ -21,7 +24,10 @@ abstract class BluetoothConnectionManager extends BaseConnectionManager {
     }
   }
 
-  protected async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+  protected async writeCharacteristic(
+    characteristicName: BluetoothCharacteristicName,
+    data: ArrayBuffer
+  ) {
     _console.log("writeCharacteristic", ...arguments);
   }