brilliantsole 0.0.26 → 0.0.28

package/src/connection/ClientConnectionManager.ts

@@ -1,17 +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: true });
+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() {
@@ -21,6 +36,16 @@ 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() {
     return this.#bluetoothId!;
@@ -53,9 +78,13 @@ class ClientConnectionManager extends BaseConnectionManager {
     }
   }
 
+  get isAvailable() {
+    return this.client.isConnected;
+  }
+
   async connect() {
     await super.connect();
-    this.sendClientConnectMessage();
+    this.sendClientConnectMessage(this.subType);
   }
   async disconnect() {
     await super.disconnect();
@@ -67,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);
@@ -89,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

@@ -1,14 +1,22 @@
 import { createConsole } from "../../utils/Console.ts";
 import BaseConnectionManager from "../BaseConnectionManager.ts";
 
-const _console = createConsole("BluetoothConnectionManager", { log: true });
+const _console = createConsole("BluetoothConnectionManager", { log: false });
 
 import { BluetoothCharacteristicName } from "./bluetoothUUIDs.ts";
 
 abstract class BluetoothConnectionManager extends BaseConnectionManager {
+  get isAvailable() {
+    // no way to tell if the user has turned bluetooth on or off
+    return true;
+  }
+
   isInRange = true;
 
-  protected onCharacteristicValueChanged(characteristicName: BluetoothCharacteristicName, dataView: DataView) {
+  protected onCharacteristicValueChanged(
+    characteristicName: BluetoothCharacteristicName,
+    dataView: DataView
+  ) {
     if (characteristicName == "rx") {
       this.parseRxMessage(dataView);
     } else {
@@ -16,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);
   }
 

package/src/connection/bluetooth/NobleConnectionManager.ts

@@ -1,7 +1,11 @@
 import { dataToArrayBuffer } from "../../utils/ArrayBufferUtils.ts";
 import { createConsole } from "../../utils/Console.ts";
 import { isInNode } from "../../utils/environment.ts";
-import { addEventListeners, removeEventListeners, BoundGenericEventListeners } from "../../utils/EventUtils.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+  BoundGenericEventListeners,
+} from "../../utils/EventUtils.ts";
 import {
   allServiceUUIDs,
   getServiceNameFromUUID,
@@ -11,26 +15,33 @@ import {
 } from "./bluetoothUUIDs.ts";
 import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
 
-const _console = createConsole("NobleConnectionManager", { log: true });
+const _console = createConsole("NobleConnectionManager", { log: false });
 
 /** NODE_START */
 import type * as noble from "@abandonware/noble";
 /** NODE_END */
 
-import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import {
+  BluetoothCharacteristicName,
+  BluetoothServiceName,
+} from "./bluetoothUUIDs.ts";
 import { ConnectionType } from "../BaseConnectionManager.ts";
 import NobleScanner from "../../scanner/NobleScanner.ts";
 
 interface HasConnectionManager {
   connectionManager: NobleConnectionManager | undefined;
 }
-export interface NoblePeripheral extends noble.Peripheral, HasConnectionManager {
+export interface NoblePeripheral
+  extends noble.Peripheral,
+    HasConnectionManager {
   scanner: NobleScanner;
 }
 interface NobleService extends noble.Service, HasConnectionManager {
   name: BluetoothServiceName;
 }
-interface NobleCharacteristic extends noble.Characteristic, HasConnectionManager {
+interface NobleCharacteristic
+  extends noble.Characteristic,
+    HasConnectionManager {
   name: BluetoothCharacteristicName;
 }
 
@@ -39,6 +50,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     return this.#noblePeripheral!.id;
   }
 
+  get canUpdateFirmware() {
+    return this.#characteristics.has("smp");
+  }
+
   static get isSupported() {
     return isInNode;
   }
@@ -59,16 +74,27 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     await this.#noblePeripheral!.disconnectAsync();
   }
 
-  async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+  async writeCharacteristic(
+    characteristicName: BluetoothCharacteristicName,
+    data: ArrayBuffer
+  ) {
     const characteristic = this.#characteristics.get(characteristicName)!;
-    _console.assertWithError(characteristic, `no characteristic found with name "${characteristicName}"`);
+    _console.assertWithError(
+      characteristic,
+      `no characteristic found with name "${characteristicName}"`
+    );
     // if (data instanceof DataView) {
     //     data = data.buffer;
     // }
     const properties = getCharacteristicProperties(characteristicName);
     const buffer = Buffer.from(data);
     const writeWithoutResponse = properties.writeWithoutResponse;
-    _console.log(`writing to ${characteristicName} ${writeWithoutResponse ? "without" : "with"} response`, buffer);
+    _console.log(
+      `writing to ${characteristicName} ${
+        writeWithoutResponse ? "without" : "with"
+      } response`,
+      buffer
+    );
     await characteristic.writeAsync(buffer, writeWithoutResponse);
     if (characteristic.properties.includes("read")) {
       await characteristic.readAsync();
@@ -80,32 +106,39 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
   async reconnect() {
     await super.reconnect();
-    _console.log("attempting to reconnect...");
-    this.connect();
+    await this.#noblePeripheral!.connectAsync();
   }
 
   // NOBLE
-  #noblePeripheral!: NoblePeripheral | undefined;
-  get noblePeripheral(): NoblePeripheral | undefined {
+  #noblePeripheral?: NoblePeripheral;
+  get noblePeripheral() {
     return this.#noblePeripheral;
   }
-  set noblePeripheral(newNoblePeripheral: NoblePeripheral) {
-    _console.assertTypeWithError(newNoblePeripheral, "object");
+  set noblePeripheral(newNoblePeripheral) {
+    if (newNoblePeripheral) {
+      _console.assertTypeWithError(newNoblePeripheral, "object");
+    }
     if (this.noblePeripheral == newNoblePeripheral) {
       _console.log("attempted to assign duplicate noblePeripheral");
       return;
     }
 
-    _console.log("newNoblePeripheral", newNoblePeripheral.id);
+    _console.log("newNoblePeripheral", newNoblePeripheral?.id);
 
     if (this.#noblePeripheral) {
-      removeEventListeners(this.#noblePeripheral, this.#unboundNoblePeripheralListeners);
+      removeEventListeners(
+        this.#noblePeripheral,
+        this.#unboundNoblePeripheralListeners
+      );
       delete this.#noblePeripheral!.connectionManager;
     }
 
     if (newNoblePeripheral) {
       newNoblePeripheral.connectionManager = this;
-      addEventListeners(newNoblePeripheral, this.#unboundNoblePeripheralListeners);
+      addEventListeners(
+        newNoblePeripheral,
+        this.#unboundNoblePeripheralListeners
+      );
     }
 
     this.#noblePeripheral = newNoblePeripheral;
@@ -123,9 +156,15 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     await this.connectionManager!.onNoblePeripheralConnect(this);
   }
   async onNoblePeripheralConnect(noblePeripheral: NoblePeripheral) {
-    _console.log("onNoblePeripheralConnect", noblePeripheral.id, noblePeripheral.state);
+    _console.log(
+      "onNoblePeripheralConnect",
+      noblePeripheral.id,
+      noblePeripheral.state
+    );
     if (noblePeripheral.state == "connected") {
-      await this.#noblePeripheral!.discoverServicesAsync(allServiceUUIDs as string[]);
+      await this.#noblePeripheral!.discoverServicesAsync(
+        allServiceUUIDs as string[]
+      );
     }
     // this gets called when it connects and disconnects, so we use the noblePeripheral's "state" property instead
     await this.#onNoblePeripheralState();
@@ -140,7 +179,11 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
 
   async #onNoblePeripheralState() {
-    _console.log(`noblePeripheral ${this.bluetoothId} state ${this.#noblePeripheral!.state}`);
+    _console.log(
+      `noblePeripheral ${this.bluetoothId} state ${
+        this.#noblePeripheral!.state
+      }`
+    );
 
     switch (this.#noblePeripheral!.state) {
       case "connected":
@@ -160,7 +203,9 @@ class NobleConnectionManager extends BluetoothConnectionManager {
         _console.error("noblePeripheral error");
         break;
       default:
-        _console.log(`uncaught noblePeripheral state ${this.#noblePeripheral!.state}`);
+        _console.log(
+          `uncaught noblePeripheral state ${this.#noblePeripheral!.state}`
+        );
         break;
     }
   }
@@ -176,7 +221,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       _console.log(
         `removing listeners from characteristic "${characteristic.name}" has ${characteristic.listeners.length} listeners`
       );
-      removeEventListeners(characteristic, this.#unboundNobleCharacteristicListeners);
+      removeEventListeners(
+        characteristic,
+        this.#unboundNobleCharacteristicListeners
+      );
     });
     this.#characteristics.clear();
   }
@@ -184,15 +232,27 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   async #onNoblePeripheralRssiUpdate(this: NoblePeripheral, rssi: number) {
     await this.connectionManager!.onNoblePeripheralRssiUpdate(this, rssi);
   }
-  async onNoblePeripheralRssiUpdate(noblePeripheral: NoblePeripheral, rssi: number) {
+  async onNoblePeripheralRssiUpdate(
+    noblePeripheral: NoblePeripheral,
+    rssi: number
+  ) {
     _console.log("onNoblePeripheralRssiUpdate", noblePeripheral.id, rssi);
-    // FILL
+    // TODO: - can this be useful?
   }
 
-  async #onNoblePeripheralServicesDiscover(this: NoblePeripheral, services: NobleService[]) {
-    await this.connectionManager!.onNoblePeripheralServicesDiscover(this, services);
+  async #onNoblePeripheralServicesDiscover(
+    this: NoblePeripheral,
+    services: NobleService[]
+  ) {
+    await this.connectionManager!.onNoblePeripheralServicesDiscover(
+      this,
+      services
+    );
   }
-  async onNoblePeripheralServicesDiscover(noblePeripheral: NoblePeripheral, services: NobleService[]) {
+  async onNoblePeripheralServicesDiscover(
+    noblePeripheral: NoblePeripheral,
+    services: NobleService[]
+  ) {
     _console.log(
       "onNoblePeripheralServicesDiscover",
       noblePeripheral.id,
@@ -202,7 +262,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       const service = services[index];
       _console.log("service", service.uuid);
       const serviceName = getServiceNameFromUUID(service.uuid)!;
-      _console.assertWithError(serviceName, `no name found for service uuid "${service.uuid}"`);
+      _console.assertWithError(
+        serviceName,
+        `no name found for service uuid "${service.uuid}"`
+      );
       _console.log({ serviceName });
       this.#services.set(serviceName, service);
       service.name = serviceName;
@@ -219,10 +282,19 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     characteristicsDiscover: this.#onNobleServiceCharacteristicsDiscover,
   };
 
-  async #onNobleServiceCharacteristicsDiscover(this: NobleService, characteristics: NobleCharacteristic[]) {
-    await this.connectionManager!.onNobleServiceCharacteristicsDiscover(this, characteristics);
+  async #onNobleServiceCharacteristicsDiscover(
+    this: NobleService,
+    characteristics: NobleCharacteristic[]
+  ) {
+    await this.connectionManager!.onNobleServiceCharacteristicsDiscover(
+      this,
+      characteristics
+    );
   }
-  async onNobleServiceCharacteristicsDiscover(service: NobleService, characteristics: NobleCharacteristic[]) {
+  async onNobleServiceCharacteristicsDiscover(
+    service: NobleService,
+    characteristics: NobleCharacteristic[]
+  ) {
     _console.log(
       "onNobleServiceCharacteristicsDiscover",
       service.uuid,
@@ -232,7 +304,9 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     for (const index in characteristics) {
       const characteristic = characteristics[index];
       _console.log("characteristic", characteristic.uuid);
-      const characteristicName = getCharacteristicNameFromUUID(characteristic.uuid)!;
+      const characteristicName = getCharacteristicNameFromUUID(
+        characteristic.uuid
+      )!;
       _console.assertWithError(
         Boolean(characteristicName),
         `no name found for characteristic uuid "${characteristic.uuid}"`
@@ -244,7 +318,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       _console.log(
         `adding listeners to characteristic "${characteristic.name}" (currently has ${characteristic.listeners.length} listeners)`
       );
-      addEventListeners(characteristic, this.#unboundNobleCharacteristicListeners);
+      addEventListeners(
+        characteristic,
+        this.#unboundNobleCharacteristicListeners
+      );
       if (characteristic.properties.includes("read")) {
         await characteristic.readAsync();
       }
@@ -265,19 +342,40 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     notify: this.#onNobleCharacteristicNotify,
   };
 
-  #characteristics: Map<BluetoothCharacteristicName, NobleCharacteristic> = new Map();
+  #characteristics: Map<BluetoothCharacteristicName, NobleCharacteristic> =
+    new Map();
 
   get #hasAllCharacteristics() {
     return allCharacteristicNames.every((characteristicName) => {
+      if (characteristicName == "smp") {
+        return true;
+      }
       return this.#characteristics.has(characteristicName);
     });
   }
 
-  #onNobleCharacteristicData(this: NobleCharacteristic, data: Buffer, isNotification: boolean) {
-    this.connectionManager!.onNobleCharacteristicData(this, data, isNotification);
+  #onNobleCharacteristicData(
+    this: NobleCharacteristic,
+    data: Buffer,
+    isNotification: boolean
+  ) {
+    this.connectionManager!.onNobleCharacteristicData(
+      this,
+      data,
+      isNotification
+    );
   }
-  onNobleCharacteristicData(characteristic: NobleCharacteristic, data: Buffer, isNotification: boolean) {
-    _console.log("onNobleCharacteristicData", characteristic.uuid, data, isNotification);
+  onNobleCharacteristicData(
+    characteristic: NobleCharacteristic,
+    data: Buffer,
+    isNotification: boolean
+  ) {
+    _console.log(
+      "onNobleCharacteristicData",
+      characteristic.uuid,
+      data,
+      isNotification
+    );
     const dataView = new DataView(dataToArrayBuffer(data));
 
     const characteristicName: BluetoothCharacteristicName = characteristic.name;
@@ -294,14 +392,29 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
   onNobleCharacteristicWrite(characteristic: NobleCharacteristic) {
     _console.log("onNobleCharacteristicWrite", characteristic.uuid);
-    // FILL
+    // TODO: - can this be useful?
   }
 
-  #onNobleCharacteristicNotify(this: NobleCharacteristic, isSubscribed: boolean) {
+  #onNobleCharacteristicNotify(
+    this: NobleCharacteristic,
+    isSubscribed: boolean
+  ) {
     this.connectionManager!.onNobleCharacteristicNotify(this, isSubscribed);
   }
-  onNobleCharacteristicNotify(characteristic: NobleCharacteristic, isSubscribed: boolean) {
-    _console.log("onNobleCharacteristicNotify", characteristic.uuid, isSubscribed);
+  onNobleCharacteristicNotify(
+    characteristic: NobleCharacteristic,
+    isSubscribed: boolean
+  ) {
+    _console.log(
+      "onNobleCharacteristicNotify",
+      characteristic.uuid,
+      isSubscribed
+    );
+  }
+
+  remove() {
+    super.remove();
+    this.noblePeripheral = undefined;
   }
 }