brilliantsole 0.0.1

package/src/connection/bluetooth/WebBluetoothConnectionManager.ts

@@ -0,0 +1,269 @@
+import { createConsole } from "../../utils/Console.ts";
+import { isInNode, isInBrowser, isInBluefy, isInWebBLE } from "../../utils/environment.ts";
+import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import {
+  serviceUUIDs,
+  optionalServiceUUIDs,
+  getServiceNameFromUUID,
+  getCharacteristicNameFromUUID,
+  getCharacteristicProperties,
+} from "./bluetoothUUIDs.ts";
+import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
+import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import { ConnectionType } from "../BaseConnectionManager.ts";
+
+const _console = createConsole("WebBluetoothConnectionManager", { log: true });
+
+type WebBluetoothInterface = webbluetooth.Bluetooth | Bluetooth;
+
+interface BluetoothService extends BluetoothRemoteGATTService {
+  name?: BluetoothServiceName;
+}
+interface BluetoothCharacteristic extends BluetoothRemoteGATTCharacteristic {
+  name?: BluetoothCharacteristicName;
+}
+
+var bluetooth: WebBluetoothInterface | undefined;
+/** NODE_START */
+import * as webbluetooth from "webbluetooth";
+if (isInNode) {
+  bluetooth = webbluetooth.bluetooth;
+}
+/** NODE_END */
+
+/** BROWSER_START */
+if (isInBrowser) {
+  bluetooth = window.navigator.bluetooth;
+}
+/** BROWSER_END */
+
+class WebBluetoothConnectionManager extends BluetoothConnectionManager {
+  get bluetoothId() {
+    return this.device!.id;
+  }
+
+  #boundBluetoothCharacteristicEventListeners: { [eventType: string]: EventListener } = {
+    characteristicvaluechanged: this.#onCharacteristicvaluechanged.bind(this),
+  };
+  #boundBluetoothDeviceEventListeners: { [eventType: string]: EventListener } = {
+    gattserverdisconnected: this.#onGattserverdisconnected.bind(this),
+  };
+
+  static get isSupported() {
+    return Boolean(bluetooth);
+  }
+  static get type(): ConnectionType {
+    return "webBluetooth";
+  }
+
+  #device!: BluetoothDevice | undefined;
+  get device() {
+    return this.#device;
+  }
+  set device(newDevice) {
+    if (this.#device == newDevice) {
+      _console.log("tried to assign the same BluetoothDevice");
+      return;
+    }
+    if (this.#device) {
+      removeEventListeners(this.#device, this.#boundBluetoothDeviceEventListeners);
+    }
+    if (newDevice) {
+      addEventListeners(newDevice, this.#boundBluetoothDeviceEventListeners);
+    }
+    this.#device = newDevice;
+  }
+
+  get server(): BluetoothRemoteGATTServer | undefined {
+    return this.#device?.gatt;
+  }
+  get isConnected() {
+    return this.server?.connected || false;
+  }
+
+  #services: Map<BluetoothServiceName, BluetoothService> = new Map();
+  #characteristics: Map<BluetoothCharacteristicName, BluetoothCharacteristic> = new Map();
+
+  async connect() {
+    await super.connect();
+
+    try {
+      const device = await bluetooth!.requestDevice({
+        filters: [{ services: serviceUUIDs }],
+        optionalServices: isInBrowser ? optionalServiceUUIDs : [],
+      });
+
+      _console.log("got BluetoothDevice");
+      this.device = device;
+
+      _console.log("connecting to device...");
+      const server = await this.server!.connect();
+      _console.log(`connected to device? ${server.connected}`);
+
+      await this.#getServicesAndCharacteristics();
+
+      _console.log("fully connected");
+
+      this.status = "connected";
+    } catch (error) {
+      _console.error(error);
+      this.status = "notConnected";
+      this.server?.disconnect();
+      this.#removeEventListeners();
+    }
+  }
+  async #getServicesAndCharacteristics() {
+    this.#removeEventListeners();
+
+    _console.log("getting services...");
+    const services = await this.server!.getPrimaryServices();
+    _console.log("got services", services.length);
+    const service = await this.server!.getPrimaryService("8d53dc1d-1db7-4cd3-868b-8a527460aa84");
+
+    _console.log("getting characteristics...");
+    for (const serviceIndex in services) {
+      const service = services[serviceIndex] as BluetoothService;
+      _console.log({ service });
+      const serviceName = getServiceNameFromUUID(service.uuid)!;
+      _console.assertWithError(serviceName, `no name found for service uuid "${service.uuid}"`);
+      _console.log(`got "${serviceName}" service`);
+      service.name = serviceName;
+      this.#services.set(serviceName, service);
+      _console.log(`getting characteristics for "${serviceName}" service`);
+      const characteristics = await service.getCharacteristics();
+      _console.log(`got characteristics for "${serviceName}" service`);
+      for (const characteristicIndex in characteristics) {
+        const characteristic = characteristics[characteristicIndex] as BluetoothCharacteristic;
+        _console.log({ characteristic });
+        const characteristicName = getCharacteristicNameFromUUID(characteristic.uuid)!;
+        _console.assertWithError(
+          Boolean(characteristicName),
+          `no name found for characteristic uuid "${characteristic.uuid}" in "${serviceName}" service`
+        );
+        _console.log(`got "${characteristicName}" characteristic in "${serviceName}" service`);
+        characteristic.name = characteristicName;
+        this.#characteristics.set(characteristicName, characteristic);
+        addEventListeners(characteristic, this.#boundBluetoothCharacteristicEventListeners);
+        const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+        if (characteristicProperties.notify) {
+          _console.log(`starting notifications for "${characteristicName}" characteristic`);
+          await characteristic.startNotifications();
+        }
+        if (characteristicProperties.read) {
+          _console.log(`reading "${characteristicName}" characteristic...`);
+          await characteristic.readValue();
+          if (isInBluefy || isInWebBLE) {
+            this.#onCharacteristicValueChanged(characteristic);
+          }
+        }
+      }
+    }
+  }
+  async #removeEventListeners() {
+    if (this.device) {
+      removeEventListeners(this.device, this.#boundBluetoothDeviceEventListeners);
+    }
+
+    const promises = Array.from(this.#characteristics.keys()).map((characteristicName) => {
+      const characteristic = this.#characteristics.get(characteristicName)!;
+      removeEventListeners(characteristic, this.#boundBluetoothCharacteristicEventListeners);
+      const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+      if (characteristicProperties.notify) {
+        _console.log(`stopping notifications for "${characteristicName}" characteristic`);
+        return characteristic.stopNotifications();
+      }
+    });
+
+    return Promise.allSettled(promises);
+  }
+  async disconnect() {
+    await this.#removeEventListeners();
+    await super.disconnect();
+    this.server?.disconnect();
+    this.status = "notConnected";
+  }
+
+  #onCharacteristicvaluechanged(event: Event) {
+    _console.log("oncharacteristicvaluechanged");
+
+    const characteristic = event.target as BluetoothCharacteristic;
+    this.#onCharacteristicValueChanged(characteristic);
+  }
+
+  #onCharacteristicValueChanged(characteristic: BluetoothCharacteristic) {
+    _console.log("onCharacteristicValue");
+
+    const characteristicName = characteristic.name!;
+    _console.assertWithError(
+      Boolean(characteristicName),
+      `no name found for characteristic with uuid "${characteristic.uuid}"`
+    );
+
+    _console.log(`oncharacteristicvaluechanged for "${characteristicName}" characteristic`);
+    const dataView = characteristic.value!;
+    _console.assertWithError(dataView, `no data found for "${characteristicName}" characteristic`);
+    _console.log(`data for "${characteristicName}" characteristic`, Array.from(new Uint8Array(dataView.buffer)));
+
+    try {
+      this.onCharacteristicValueChanged(characteristicName, dataView);
+    } catch (error) {
+      _console.error(error);
+    }
+  }
+
+  async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+    super.writeCharacteristic(characteristicName, data);
+
+    const characteristic = this.#characteristics.get(characteristicName)!;
+    _console.assertWithError(characteristic, `${characteristicName} characteristic not found`);
+    _console.log("writing characteristic", characteristic, data);
+    const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+    if (characteristicProperties.writeWithoutResponse) {
+      _console.log("writing without response");
+      await characteristic.writeValueWithoutResponse(data);
+    } else {
+      _console.log("writing with response");
+      await characteristic.writeValueWithResponse(data);
+    }
+    _console.log("wrote characteristic");
+
+    if (characteristicProperties.read && !characteristicProperties.notify) {
+      _console.log("reading value after write...");
+      await characteristic.readValue();
+      if (isInBluefy || isInWebBLE) {
+        this.#onCharacteristicValueChanged(characteristic);
+      }
+    }
+  }
+
+  #onGattserverdisconnected() {
+    _console.log("gattserverdisconnected");
+    this.status = "notConnected";
+  }
+
+  get canReconnect() {
+    return Boolean(this.server && !this.server.connected && this.isInRange);
+  }
+  async reconnect() {
+    await super.reconnect();
+    _console.log("attempting to reconnect...");
+    this.status = "connecting";
+    try {
+      await this.server!.connect();
+    } catch (error) {
+      _console.error(error);
+      this.isInRange = false;
+    }
+
+    if (this.isConnected) {
+      _console.log("successfully reconnected!");
+      await this.#getServicesAndCharacteristics();
+      this.status = "connected";
+    } else {
+      _console.log("unable to reconnect");
+      this.status = "notConnected";
+    }
+  }
+}
+
+export default WebBluetoothConnectionManager;

package/src/connection/bluetooth/bluetoothUUIDs.ts

@@ -0,0 +1,218 @@
+import { isInBrowser, isInNode } from "../../utils/environment.ts";
+import { createConsole } from "../../utils/Console.ts";
+
+const _console = createConsole("bluetoothUUIDs", { log: false });
+
+/** NODE_START */
+import * as webbluetooth from "webbluetooth";
+var BluetoothUUID = webbluetooth.BluetoothUUID;
+/** NODE_END */
+/** BROWSER_START */
+if (isInBrowser) {
+  var BluetoothUUID = window.BluetoothUUID;
+}
+/** BROWSER_END */
+
+function generateBluetoothUUID(value: string): BluetoothServiceUUID {
+  _console.assertTypeWithError(value, "string");
+  _console.assertWithError(value.length == 4, "value must be 4 characters long");
+  return `ea6da725-${value}-4f9b-893d-c3913e33b39f`;
+}
+
+function stringToCharacteristicUUID(identifier: string): BluetoothCharacteristicUUID {
+  return BluetoothUUID?.getCharacteristic?.(identifier);
+}
+
+function stringToServiceUUID(identifier: string): BluetoothServiceUUID {
+  return BluetoothUUID?.getService?.(identifier);
+}
+
+export type BluetoothServiceName = "deviceInformation" | "battery" | "main" | "smp";
+import { DeviceInformationMessageType } from "../../DeviceInformationManager.ts";
+export type BluetoothCharacteristicName = DeviceInformationMessageType | "batteryLevel" | "rx" | "tx" | "smp";
+
+interface BluetoothCharacteristicInformation {
+  uuid: BluetoothCharacteristicUUID;
+}
+interface BluetoothServiceInformation {
+  uuid: BluetoothServiceUUID;
+  characteristics: { [characteristicName in BluetoothCharacteristicName]?: BluetoothCharacteristicInformation };
+}
+interface BluetoothServicesInformation {
+  services: { [serviceName in BluetoothServiceName]: BluetoothServiceInformation };
+}
+const bluetoothUUIDs: BluetoothServicesInformation = Object.freeze({
+  services: {
+    deviceInformation: {
+      uuid: stringToServiceUUID("device_information"),
+      characteristics: {
+        manufacturerName: {
+          uuid: stringToCharacteristicUUID("manufacturer_name_string"),
+        },
+        modelNumber: {
+          uuid: stringToCharacteristicUUID("model_number_string"),
+        },
+        hardwareRevision: {
+          uuid: stringToCharacteristicUUID("hardware_revision_string"),
+        },
+        firmwareRevision: {
+          uuid: stringToCharacteristicUUID("firmware_revision_string"),
+        },
+        softwareRevision: {
+          uuid: stringToCharacteristicUUID("software_revision_string"),
+        },
+        pnpId: {
+          uuid: stringToCharacteristicUUID("pnp_id"),
+        },
+        serialNumber: {
+          uuid: stringToCharacteristicUUID("serial_number_string"),
+        },
+      },
+    },
+    battery: {
+      uuid: stringToServiceUUID("battery_service"),
+      characteristics: {
+        batteryLevel: {
+          uuid: stringToCharacteristicUUID("battery_level"),
+        },
+      },
+    },
+    main: {
+      uuid: generateBluetoothUUID("0000"),
+      characteristics: {
+        rx: { uuid: generateBluetoothUUID("1000") },
+        tx: { uuid: generateBluetoothUUID("1001") },
+      },
+    },
+    smp: {
+      uuid: "8d53dc1d-1db7-4cd3-868b-8a527460aa84",
+      characteristics: {
+        smp: { uuid: "da2e7828-fbce-4e01-ae9e-261174997c48" },
+      },
+    },
+  },
+});
+
+export const serviceUUIDs = [bluetoothUUIDs.services.main.uuid];
+export const optionalServiceUUIDs = [
+  bluetoothUUIDs.services.deviceInformation.uuid,
+  bluetoothUUIDs.services.battery.uuid,
+  bluetoothUUIDs.services.smp.uuid,
+];
+export const allServiceUUIDs = [...serviceUUIDs, ...optionalServiceUUIDs];
+
+export function getServiceNameFromUUID(serviceUUID: BluetoothServiceUUID): BluetoothServiceName | undefined {
+  serviceUUID = serviceUUID.toString().toLowerCase();
+  const serviceNames = Object.keys(bluetoothUUIDs.services) as BluetoothServiceName[];
+  return serviceNames.find((serviceName) => {
+    const serviceInfo = bluetoothUUIDs.services[serviceName];
+    let serviceInfoUUID = serviceInfo.uuid.toString();
+    if (serviceUUID.length == 4) {
+      serviceInfoUUID = serviceInfoUUID.slice(4, 8);
+    }
+    if (!serviceUUID.includes("-")) {
+      serviceInfoUUID = serviceInfoUUID.replaceAll("-", "");
+    }
+    return serviceUUID == serviceInfoUUID;
+  });
+}
+
+export const characteristicUUIDs: BluetoothCharacteristicUUID[] = [];
+export const allCharacteristicUUIDs: BluetoothCharacteristicUUID[] = [];
+
+export const characteristicNames: BluetoothCharacteristicName[] = [];
+export const allCharacteristicNames: BluetoothCharacteristicName[] = [];
+
+Object.values(bluetoothUUIDs.services).forEach((serviceInfo) => {
+  if (!serviceInfo.characteristics) {
+    return;
+  }
+  const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+  characteristicNames.forEach((characteristicName) => {
+    const characteristicInfo = serviceInfo.characteristics[characteristicName]!;
+    if (serviceUUIDs.includes(serviceInfo.uuid)) {
+      characteristicUUIDs.push(characteristicInfo.uuid);
+      characteristicNames.push(characteristicName);
+    }
+    allCharacteristicUUIDs.push(characteristicInfo.uuid);
+    allCharacteristicNames.push(characteristicName);
+  });
+}, []);
+
+//_console.log({ characteristicUUIDs, allCharacteristicUUIDs });
+
+export function getCharacteristicNameFromUUID(
+  characteristicUUID: BluetoothCharacteristicUUID
+): BluetoothCharacteristicName | undefined {
+  //_console.log({ characteristicUUID });
+  characteristicUUID = characteristicUUID.toString().toLowerCase();
+  var characteristicName: BluetoothCharacteristicName | undefined;
+  Object.values(bluetoothUUIDs.services).some((serviceInfo) => {
+    const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+    characteristicName = characteristicNames.find((_characteristicName) => {
+      const characteristicInfo = serviceInfo.characteristics[_characteristicName]!;
+      let characteristicInfoUUID = characteristicInfo.uuid.toString();
+      if (characteristicUUID.length == 4) {
+        characteristicInfoUUID = characteristicInfoUUID.slice(4, 8);
+      }
+      if (!characteristicUUID.includes("-")) {
+        characteristicInfoUUID = characteristicInfoUUID.replaceAll("-", "");
+      }
+      return characteristicUUID == characteristicInfoUUID;
+    });
+    return characteristicName;
+  });
+  return characteristicName;
+}
+
+export function getCharacteristicProperties(
+  characteristicName: BluetoothCharacteristicName
+): BluetoothCharacteristicProperties {
+  const properties = {
+    broadcast: false,
+    read: true,
+    writeWithoutResponse: false,
+    write: false,
+    notify: false,
+    indicate: false,
+    authenticatedSignedWrites: false,
+    reliableWrite: false,
+    writableAuxiliaries: false,
+  };
+
+  // read
+  switch (characteristicName) {
+    case "rx":
+    case "tx":
+    case "smp":
+      properties.read = false;
+      break;
+  }
+
+  // notify
+  switch (characteristicName) {
+    case "batteryLevel":
+    case "rx":
+    case "smp":
+      properties.notify = true;
+      break;
+  }
+
+  // write without response
+  switch (characteristicName) {
+    case "smp":
+      properties.writeWithoutResponse = true;
+      break;
+  }
+
+  // write
+  switch (characteristicName) {
+    case "tx":
+      properties.write = true;
+      break;
+  }
+
+  return properties;
+}
+
+export const serviceDataUUID = "0000";