brilliantsole 0.0.26 → 0.0.28

package/src/connection/bluetooth/WebBluetoothConnectionManager.ts

@@ -1,6 +1,14 @@
 import { createConsole } from "../../utils/Console.ts";
-import { isInNode, isInBrowser, isInBluefy, isInWebBLE } from "../../utils/environment.ts";
-import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import {
+  isInNode,
+  isInBrowser,
+  isInBluefy,
+  isInWebBLE,
+} from "../../utils/environment.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
 import {
   serviceUUIDs,
   optionalServiceUUIDs,
@@ -9,10 +17,13 @@ import {
   getCharacteristicProperties,
 } from "./bluetoothUUIDs.ts";
 import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
-import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import {
+  BluetoothCharacteristicName,
+  BluetoothServiceName,
+} from "./bluetoothUUIDs.ts";
 import { ConnectionType } from "../BaseConnectionManager.ts";
 
-const _console = createConsole("WebBluetoothConnectionManager", { log: true });
+const _console = createConsole("WebBluetoothConnectionManager", { log: false });
 
 type WebBluetoothInterface = webbluetooth.Bluetooth | Bluetooth;
 
@@ -42,12 +53,19 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     return this.device!.id;
   }
 
-  #boundBluetoothCharacteristicEventListeners: { [eventType: string]: EventListener } = {
+  get canUpdateFirmware() {
+    return this.#characteristics.has("smp");
+  }
+
+  #boundBluetoothCharacteristicEventListeners: {
+    [eventType: string]: EventListener;
+  } = {
     characteristicvaluechanged: this.#onCharacteristicvaluechanged.bind(this),
   };
-  #boundBluetoothDeviceEventListeners: { [eventType: string]: EventListener } = {
-    gattserverdisconnected: this.#onGattserverdisconnected.bind(this),
-  };
+  #boundBluetoothDeviceEventListeners: { [eventType: string]: EventListener } =
+    {
+      gattserverdisconnected: this.#onGattserverdisconnected.bind(this),
+    };
 
   static get isSupported() {
     return Boolean(bluetooth);
@@ -56,7 +74,7 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     return "webBluetooth";
   }
 
-  #device!: BluetoothDevice | undefined;
+  #device?: BluetoothDevice;
   get device() {
     return this.#device;
   }
@@ -66,7 +84,10 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       return;
     }
     if (this.#device) {
-      removeEventListeners(this.#device, this.#boundBluetoothDeviceEventListeners);
+      removeEventListeners(
+        this.#device,
+        this.#boundBluetoothDeviceEventListeners
+      );
     }
     if (newDevice) {
       addEventListeners(newDevice, this.#boundBluetoothDeviceEventListeners);
@@ -82,7 +103,8 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
 
   #services: Map<BluetoothServiceName, BluetoothService> = new Map();
-  #characteristics: Map<BluetoothCharacteristicName, BluetoothCharacteristic> = new Map();
+  #characteristics: Map<BluetoothCharacteristicName, BluetoothCharacteristic> =
+    new Map();
 
   async connect() {
     await super.connect();
@@ -125,7 +147,10 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       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.assertWithError(
+        serviceName,
+        `no name found for service uuid "${service.uuid}"`
+      );
       _console.log(`got "${serviceName}" service`);
       service.name = serviceName;
       this.#services.set(serviceName, service);
@@ -133,20 +158,33 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       const characteristics = await service.getCharacteristics();
       _console.log(`got characteristics for "${serviceName}" service`);
       for (const characteristicIndex in characteristics) {
-        const characteristic = characteristics[characteristicIndex] as BluetoothCharacteristic;
+        const characteristic = characteristics[
+          characteristicIndex
+        ] as BluetoothCharacteristic;
         _console.log({ characteristic });
-        const characteristicName = getCharacteristicNameFromUUID(characteristic.uuid)!;
+        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`);
+        _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);
+        addEventListeners(
+          characteristic,
+          this.#boundBluetoothCharacteristicEventListeners
+        );
+        const characteristicProperties =
+          characteristic.properties ||
+          getCharacteristicProperties(characteristicName);
         if (characteristicProperties.notify) {
-          _console.log(`starting notifications for "${characteristicName}" characteristic`);
+          _console.log(
+            `starting notifications for "${characteristicName}" characteristic`
+          );
           await characteristic.startNotifications();
         }
         if (characteristicProperties.read) {
@@ -161,18 +199,30 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
   async #removeEventListeners() {
     if (this.device) {
-      removeEventListeners(this.device, this.#boundBluetoothDeviceEventListeners);
+      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();
+    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);
   }
@@ -199,10 +249,18 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       `no name found for characteristic with uuid "${characteristic.uuid}"`
     );
 
-    _console.log(`oncharacteristicvaluechanged for "${characteristicName}" characteristic`);
+    _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)));
+    _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);
@@ -211,13 +269,21 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     }
   }
 
-  async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+  async writeCharacteristic(
+    characteristicName: BluetoothCharacteristicName,
+    data: ArrayBuffer
+  ) {
     super.writeCharacteristic(characteristicName, data);
 
     const characteristic = this.#characteristics.get(characteristicName)!;
-    _console.assertWithError(characteristic, `${characteristicName} characteristic not found`);
+    _console.assertWithError(
+      characteristic,
+      `${characteristicName} characteristic not found`
+    );
     _console.log("writing characteristic", characteristic, data);
-    const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+    const characteristicProperties =
+      characteristic.properties ||
+      getCharacteristicProperties(characteristicName);
     if (characteristicProperties.writeWithoutResponse) {
       _console.log("writing without response");
       await characteristic.writeValueWithoutResponse(data);
@@ -246,8 +312,6 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
   async reconnect() {
     await super.reconnect();
-    _console.log("attempting to reconnect...");
-    this.status = "connecting";
     try {
       await this.server!.connect();
     } catch (error) {
@@ -264,6 +328,11 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       this.status = "notConnected";
     }
   }
+
+  remove() {
+    super.remove();
+    this.device = undefined;
+  }
 }
 
 export default WebBluetoothConnectionManager;

package/src/connection/bluetooth/bluetoothUUIDs.ts

@@ -15,11 +15,16 @@ if (isInBrowser) {
 
 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`;
+  _console.assertWithError(
+    value.length == 4,
+    "value must be 4 characters long"
+  );
+  return `ea6d${value}-a725-4f9b-893d-c3913e33b39f`;
 }
 
-function stringToCharacteristicUUID(identifier: string): BluetoothCharacteristicUUID {
+function stringToCharacteristicUUID(
+  identifier: string
+): BluetoothCharacteristicUUID {
   return BluetoothUUID?.getCharacteristic?.(identifier);
 }
 
@@ -27,19 +32,32 @@ 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";
+export type BluetoothServiceName =
+  | "deviceInformation"
+  | "battery"
+  | "main"
+  | "smp";
+import { DeviceInformationType } from "../../DeviceInformationManager.ts";
+export type BluetoothCharacteristicName =
+  | DeviceInformationType
+  | "batteryLevel"
+  | "rx"
+  | "tx"
+  | "smp";
 
 interface BluetoothCharacteristicInformation {
   uuid: BluetoothCharacteristicUUID;
 }
 interface BluetoothServiceInformation {
   uuid: BluetoothServiceUUID;
-  characteristics: { [characteristicName in BluetoothCharacteristicName]?: BluetoothCharacteristicInformation };
+  characteristics: {
+    [characteristicName in BluetoothCharacteristicName]?: BluetoothCharacteristicInformation;
+  };
 }
 interface BluetoothServicesInformation {
-  services: { [serviceName in BluetoothServiceName]: BluetoothServiceInformation };
+  services: {
+    [serviceName in BluetoothServiceName]: BluetoothServiceInformation;
+  };
 }
 const bluetoothUUIDs: BluetoothServicesInformation = Object.freeze({
   services: {
@@ -101,9 +119,13 @@ export const optionalServiceUUIDs = [
 ];
 export const allServiceUUIDs = [...serviceUUIDs, ...optionalServiceUUIDs];
 
-export function getServiceNameFromUUID(serviceUUID: BluetoothServiceUUID): BluetoothServiceName | undefined {
+export function getServiceNameFromUUID(
+  serviceUUID: BluetoothServiceUUID
+): BluetoothServiceName | undefined {
   serviceUUID = serviceUUID.toString().toLowerCase();
-  const serviceNames = Object.keys(bluetoothUUIDs.services) as BluetoothServiceName[];
+  const serviceNames = Object.keys(
+    bluetoothUUIDs.services
+  ) as BluetoothServiceName[];
   return serviceNames.find((serviceName) => {
     const serviceInfo = bluetoothUUIDs.services[serviceName];
     let serviceInfoUUID = serviceInfo.uuid.toString();
@@ -127,7 +149,9 @@ Object.values(bluetoothUUIDs.services).forEach((serviceInfo) => {
   if (!serviceInfo.characteristics) {
     return;
   }
-  const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+  const characteristicNames = Object.keys(
+    serviceInfo.characteristics
+  ) as BluetoothCharacteristicName[];
   characteristicNames.forEach((characteristicName) => {
     const characteristicInfo = serviceInfo.characteristics[characteristicName]!;
     if (serviceUUIDs.includes(serviceInfo.uuid)) {
@@ -148,9 +172,12 @@ export function getCharacteristicNameFromUUID(
   characteristicUUID = characteristicUUID.toString().toLowerCase();
   var characteristicName: BluetoothCharacteristicName | undefined;
   Object.values(bluetoothUUIDs.services).some((serviceInfo) => {
-    const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+    const characteristicNames = Object.keys(
+      serviceInfo.characteristics
+    ) as BluetoothCharacteristicName[];
     characteristicName = characteristicNames.find((_characteristicName) => {
-      const characteristicInfo = serviceInfo.characteristics[_characteristicName]!;
+      const characteristicInfo =
+        serviceInfo.characteristics[_characteristicName]!;
       let characteristicInfoUUID = characteristicInfo.uuid.toString();
       if (characteristicUUID.length == 4) {
         characteristicInfoUUID = characteristicInfoUUID.slice(4, 8);

package/src/connection/udp/UDPConnectionManager.ts

@@ -0,0 +1,356 @@
+import { DeviceInformationTypes } from "../../DeviceInformationManager.ts";
+import {
+  createMessage,
+  Message,
+  MessageLike,
+} from "../../server/ServerUtils.ts";
+import { createConsole } from "../../utils/Console.ts";
+import { isInNode } from "../../utils/environment.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
+import { parseMessage } from "../../utils/ParseUtils.ts";
+import Timer from "../../utils/Timer.ts";
+import BaseConnectionManager, {
+  ConnectionType,
+} from "../BaseConnectionManager.ts";
+
+import * as dgram from "dgram";
+
+const _console = createConsole("UDPConnectionManager", { log: false });
+
+export const UDPSendPort = 3000;
+
+export const UDPPingInterval = 2_000;
+
+const SocketMessageTypes = [
+  "ping",
+  "pong",
+  "setRemoteReceivePort",
+  "batteryLevel",
+  "deviceInformation",
+  "message",
+] as const;
+type SocketMessageType = (typeof SocketMessageTypes)[number];
+
+type SocketMessage = SocketMessageType | Message<SocketMessageType>;
+function createSocketMessage(...messages: SocketMessage[]) {
+  _console.log("createSocketMessage", ...messages);
+  return createMessage(SocketMessageTypes, ...messages);
+}
+
+const SocketDeviceInformationMessageTypes: SocketMessageType[] = [
+  "deviceInformation",
+  "batteryLevel",
+];
+
+class UDPConnectionManager extends BaseConnectionManager {
+  #bluetoothId?: string;
+  get bluetoothId() {
+    return this.#bluetoothId ?? "";
+  }
+
+  defaultMtu = 2 ** 10;
+
+  constructor(ipAddress: string, bluetoothId?: string, receivePort?: number) {
+    super();
+    this.ipAddress = ipAddress;
+    this.mtu = this.defaultMtu;
+    this.#bluetoothId = bluetoothId;
+    if (receivePort) {
+      this.receivePort = receivePort;
+    }
+  }
+
+  get isAvailable() {
+    return true;
+  }
+  static get isSupported() {
+    return isInNode;
+  }
+  static get type(): ConnectionType {
+    return "udp";
+  }
+
+  // IP ADDRESS
+  #ipAddress!: string;
+  get ipAddress() {
+    return this.#ipAddress;
+  }
+  set ipAddress(newIpAddress) {
+    this.assertIsNotConnected();
+    if (this.#ipAddress == newIpAddress) {
+      _console.log(`redundnant ipAddress assignment "${newIpAddress}"`);
+      return;
+    }
+    this.#ipAddress = newIpAddress;
+    _console.log(`updated ipAddress to "${this.ipAddress}"`);
+  }
+
+  // RECEIVE PORT
+  #receivePort?: number;
+  get receivePort() {
+    return this.#receivePort;
+  }
+  set receivePort(newReceivePort) {
+    this.assertIsNotConnected();
+    if (this.#receivePort == newReceivePort) {
+      _console.log(`redundnant receivePort assignment ${newReceivePort}`);
+      return;
+    }
+    this.#receivePort = newReceivePort;
+    _console.log(`updated receivePort to ${this.#receivePort}`);
+    if (this.#receivePort) {
+      this.#setRemoteReceivePortDataView.setUint16(0, this.#receivePort, true);
+    }
+  }
+
+  // SET REMOTE RECEIVE PORT
+  #didSetRemoteReceivePort = false;
+  #setRemoteReceivePortDataView = new DataView(new ArrayBuffer(2));
+  #parseReceivePort(dataView: DataView) {
+    const parsedReceivePort = dataView.getUint16(0, true);
+    if (parsedReceivePort != this.receivePort) {
+      _console.error(
+        `incorrect receivePort (expected ${this.receivePort}, got ${parsedReceivePort})`
+      );
+      return;
+    }
+    this.#didSetRemoteReceivePort = true;
+  }
+
+  // SOCKET
+  #socket?: dgram.Socket;
+  get socket() {
+    return this.#socket;
+  }
+  set socket(newSocket) {
+    if (this.#socket == newSocket) {
+      _console.log("redundant socket assignment");
+      return;
+    }
+
+    _console.log("assigning socket", newSocket);
+
+    if (this.#socket) {
+      _console.log("removing existing socket...");
+      removeEventListeners(this.#socket, this.#boundSocketEventListeners);
+      try {
+        this.#socket.close();
+      } catch (error) {
+        _console.error(error);
+      }
+    }
+
+    if (newSocket) {
+      addEventListeners(newSocket, this.#boundSocketEventListeners);
+    }
+    this.#socket = newSocket;
+
+    _console.log("assigned socket");
+  }
+
+  // SOCKET MESSAGING
+  #sendMessage(message: MessageLike) {
+    // this.assertIsConnected();
+    _console.log("sending socket message", message);
+    const dataView = Buffer.from(message);
+    this.#socket!.send(dataView);
+    this.#pingTimer.restart();
+  }
+
+  #sendSocketMessage(...messages: SocketMessage[]) {
+    this.#sendMessage(createSocketMessage(...messages));
+  }
+
+  // BASE CONNECTION MANAGER
+  async sendSmpMessage(data: ArrayBuffer) {
+    super.sendSmpMessage(data);
+    _console.error("smp not supported on udp");
+  }
+
+  async sendTxData(data: ArrayBuffer) {
+    super.sendTxData(data);
+    if (data.byteLength == 0) {
+      return;
+    }
+    this.#sendSocketMessage({ type: "message", data });
+  }
+
+  // SOCKET EVENTS
+  #boundSocketEventListeners: { [eventType: string]: Function } = {
+    close: this.#onSocketClose.bind(this),
+    connect: this.#onSocketConnect.bind(this),
+    error: this.#onSocketError.bind(this),
+    listening: this.#onSocketListening.bind(this),
+    message: this.#onSocketMessage.bind(this),
+  };
+
+  #onSocketClose() {
+    _console.log("socket.close");
+    this.status = "notConnected";
+    this.clear();
+  }
+  #onSocketConnect() {
+    _console.log("socket.connect");
+    this.#pingTimer.start(true);
+  }
+  #onSocketError(error: Error) {
+    _console.error("socket.error", error);
+  }
+  #onSocketListening() {
+    const address = this.socket!.address();
+    _console.log(`socket.listening on ${address.address}:${address.port}`);
+    this.receivePort = address.port;
+    this.socket!.connect(UDPSendPort, this.ipAddress);
+  }
+  #onSocketMessage(message: Buffer, remoteInfo: dgram.RemoteInfo) {
+    this.#pongTimeoutTimer.stop();
+    _console.log("socket.message", message.byteLength, remoteInfo);
+    const arrayBuffer = message.buffer.slice(
+      message.byteOffset,
+      message.byteOffset + message.byteLength
+    );
+    const dataView = new DataView(arrayBuffer);
+    this.#parseSocketMessage(dataView);
+
+    if (this.status == "connecting" && this.#didSetRemoteReceivePort) {
+      this.status = "connected";
+      this.#requestDeviceInformation();
+    }
+  }
+
+  #setupSocket() {
+    this.#didSetRemoteReceivePort = false;
+    this.socket = dgram.createSocket({
+      type: "udp4",
+    });
+    try {
+      if (this.receivePort) {
+        this.socket.bind(this.receivePort);
+      } else {
+        this.socket.bind();
+      }
+    } catch (error) {
+      _console.error(error);
+      this.disconnect();
+    }
+  }
+
+  // CONNECTION
+  async connect() {
+    await super.connect();
+    this.#setupSocket();
+  }
+  async disconnect() {
+    await super.disconnect();
+    _console.log("closing socket");
+    try {
+      this.#socket?.close();
+    } catch (error) {
+      _console.error(error);
+    }
+    this.#pingTimer.stop();
+  }
+
+  get canReconnect() {
+    return Boolean(this.socket);
+  }
+  async reconnect() {
+    await super.reconnect();
+    this.#setupSocket();
+  }
+
+  // PARSING
+  #parseSocketMessage(dataView: DataView) {
+    parseMessage(
+      dataView,
+      SocketMessageTypes,
+      this.#onMessage.bind(this),
+      null,
+      true
+    );
+  }
+
+  #onMessage(messageType: SocketMessageType, dataView: DataView) {
+    _console.log(
+      `received "${messageType}" message (${dataView.byteLength} bytes)`
+    );
+    switch (messageType) {
+      case "ping":
+        this.#pong();
+        break;
+      case "pong":
+        break;
+      case "setRemoteReceivePort":
+        this.#parseReceivePort(dataView);
+        break;
+      case "batteryLevel":
+        this.onMessageReceived?.("batteryLevel", dataView);
+        break;
+      case "deviceInformation":
+        parseMessage(
+          dataView,
+          DeviceInformationTypes,
+          (deviceInformationType, dataView) => {
+            this.onMessageReceived!(deviceInformationType, dataView);
+          }
+        );
+        break;
+      case "message":
+        this.parseRxMessage(dataView);
+        break;
+      default:
+        _console.error(`uncaught messageType "${messageType}"`);
+        break;
+    }
+  }
+
+  // PING
+  #pingTimer = new Timer(this.#ping.bind(this), UDPPingInterval);
+  #ping() {
+    _console.log("pinging");
+    if (this.#didSetRemoteReceivePort || !this.#receivePort) {
+      this.#sendSocketMessage("ping");
+    } else {
+      this.#sendSocketMessage({
+        type: "setRemoteReceivePort",
+        data: this.#setRemoteReceivePortDataView,
+      });
+    }
+    if (this.isConnected) {
+      this.#pongTimeoutTimer.start();
+    }
+  }
+  #pong() {
+    _console.log("ponging");
+    this.#sendSocketMessage("pong");
+  }
+
+  #pongTimeout() {
+    this.#pongTimeoutTimer.stop();
+    _console.log("pong timeout");
+    this.disconnect();
+  }
+  #pongTimeoutTimer = new Timer(() => this.#pongTimeout(), 1_000);
+
+  // DEVICE INFORMATION
+  #requestDeviceInformation() {
+    this.#sendSocketMessage(...SocketDeviceInformationMessageTypes);
+  }
+
+  clear() {
+    super.clear();
+    this.#didSetRemoteReceivePort = false;
+    this.#pingTimer.stop();
+    this.#pongTimeoutTimer.stop();
+  }
+
+  remove() {
+    super.remove();
+    this.socket = undefined;
+  }
+}
+
+export default UDPConnectionManager;