brilliantsole 0.0.27 → 0.0.29

package/src/DeviceInformationManager.ts

@@ -22,19 +22,23 @@ export interface DeviceInformation {
   serialNumber: string;
 }
 
-export const DeviceInformationMessageTypes = [
+export const DeviceInformationTypes = [
   "manufacturerName",
   "modelNumber",
-  "softwareRevision",
   "hardwareRevision",
   "firmwareRevision",
+  "softwareRevision",
   "pnpId",
   "serialNumber",
 ] as const;
-export type DeviceInformationMessageType = (typeof DeviceInformationMessageTypes)[number];
+export type DeviceInformationType = (typeof DeviceInformationTypes)[number];
 
-export const DeviceInformationEventTypes = [...DeviceInformationMessageTypes, "deviceInformation"] as const;
-export type DeviceInformationEventType = (typeof DeviceInformationEventTypes)[number];
+export const DeviceInformationEventTypes = [
+  ...DeviceInformationTypes,
+  "deviceInformation",
+] as const;
+export type DeviceInformationEventType =
+  (typeof DeviceInformationEventTypes)[number];
 
 export interface DeviceInformationEventMessages {
   manufacturerName: { manufacturerName: string };
@@ -67,18 +71,21 @@ class DeviceInformationManager {
     this.#information = {};
   }
   get #isComplete() {
-    return DeviceInformationMessageTypes.filter((key) => key != "serialNumber").every(
+    return DeviceInformationTypes.filter((key) => key != "serialNumber").every(
       (key) => key in this.#information
     );
   }
 
   #update(partialDeviceInformation: Partial<DeviceInformation>) {
     _console.log({ partialDeviceInformation });
-    const deviceInformationNames = Object.keys(partialDeviceInformation) as (keyof DeviceInformation)[];
+    const deviceInformationNames = Object.keys(
+      partialDeviceInformation
+    ) as (keyof DeviceInformation)[];
     deviceInformationNames.forEach((deviceInformationName) => {
       // @ts-expect-error
       this.#dispatchEvent(deviceInformationName, {
-        [deviceInformationName]: partialDeviceInformation[deviceInformationName],
+        [deviceInformationName]:
+          partialDeviceInformation[deviceInformationName],
       });
     });
 
@@ -86,11 +93,13 @@ class DeviceInformationManager {
     _console.log({ deviceInformation: this.#information });
     if (this.#isComplete) {
       _console.log("completed deviceInformation");
-      this.#dispatchEvent("deviceInformation", { deviceInformation: this.information });
+      this.#dispatchEvent("deviceInformation", {
+        deviceInformation: this.information,
+      });
     }
   }
 
-  parseMessage(messageType: DeviceInformationMessageType, dataView: DataView) {
+  parseMessage(messageType: DeviceInformationType, dataView: DataView) {
     _console.log({ messageType });
 
     switch (messageType) {

package/src/DeviceManager.ts

@@ -4,7 +4,12 @@ import Device, { BoundDeviceEventListeners, DeviceEventMap } from "./Device.ts";
 import { DeviceType } from "./InformationManager.ts";
 import { createConsole } from "./utils/Console.ts";
 import { isInBluefy, isInBrowser } from "./utils/environment.ts";
-import EventDispatcher, { BoundEventListeners, Event, EventListenerMap, EventMap } from "./utils/EventDispatcher.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+  EventListenerMap,
+  EventMap,
+} from "./utils/EventDispatcher.ts";
 import { addEventListeners } from "./utils/EventUtils.ts";
 
 const _console = createConsole("DeviceManager", { log: false });
@@ -12,6 +17,8 @@ const _console = createConsole("DeviceManager", { log: false });
 export interface LocalStorageDeviceInformation {
   type: DeviceType;
   bluetoothId: string;
+  ipAddress?: string;
+  isWifiSecure?: boolean;
 }
 
 export interface LocalStorageConfiguration {
@@ -43,13 +50,21 @@ export type DeviceManagerEventDispatcher = EventDispatcher<
   DeviceManagerEventType,
   DeviceManagerEventMessages
 >;
-export type DeviceManagerEventMap = EventMap<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type DeviceManagerEventMap = EventMap<
+  typeof Device,
+  DeviceManagerEventType,
+  DeviceManagerEventMessages
+>;
 export type DeviceManagerEventListenerMap = EventListenerMap<
   typeof Device,
   DeviceManagerEventType,
   DeviceManagerEventMessages
 >;
-export type DeviceManagerEvent = Event<typeof Device, DeviceManagerEventType, DeviceManagerEventMessages>;
+export type DeviceManagerEvent = Event<
+  typeof Device,
+  DeviceManagerEventType,
+  DeviceManagerEventMessages
+>;
 export type BoundDeviceManagerEventListeners = BoundEventListeners<
   typeof Device,
   DeviceManagerEventType,
@@ -87,8 +102,15 @@ class DeviceManager {
 
   // CONNECTION STATUS
   /** @private */
-  OnDeviceConnectionStatusUpdated(device: Device, connectionStatus: ConnectionStatus) {
-    if (connectionStatus == "notConnected" && !device.canReconnect && this.#AvailableDevices.includes(device)) {
+  OnDeviceConnectionStatusUpdated(
+    device: Device,
+    connectionStatus: ConnectionStatus
+  ) {
+    if (
+      connectionStatus == "notConnected" &&
+      !device.canReconnect &&
+      this.#AvailableDevices.includes(device)
+    ) {
       const deviceIndex = this.#AvailableDevices.indexOf(device);
       this.AvailableDevices.splice(deviceIndex, 1);
       this.#DispatchAvailableDevices();
@@ -125,20 +147,29 @@ class DeviceManager {
   }
 
   #AssertLocalStorage() {
-    _console.assertWithError(isInBrowser, "localStorage is only available in the browser");
+    _console.assertWithError(
+      isInBrowser,
+      "localStorage is only available in the browser"
+    );
     _console.assertWithError(window.localStorage, "localStorage not found");
   }
   #LocalStorageKey = "BS.Device";
   #SaveToLocalStorage() {
     this.#AssertLocalStorage();
-    localStorage.setItem(this.#LocalStorageKey, JSON.stringify(this.#LocalStorageConfiguration));
+    localStorage.setItem(
+      this.#LocalStorageKey,
+      JSON.stringify(this.#LocalStorageConfiguration)
+    );
   }
   async #LoadFromLocalStorage() {
     this.#AssertLocalStorage();
     let localStorageString = localStorage.getItem(this.#LocalStorageKey);
     if (typeof localStorageString != "string") {
       _console.log("no info found in localStorage");
-      this.#LocalStorageConfiguration = Object.assign({}, this.#DefaultLocalStorageConfiguration);
+      this.#LocalStorageConfiguration = Object.assign(
+        {},
+        this.#DefaultLocalStorageConfiguration
+      );
       this.#SaveToLocalStorage();
       return;
     }
@@ -160,13 +191,17 @@ class DeviceManager {
       return;
     }
     this.#AssertLocalStorage();
-    const deviceInformationIndex = this.#LocalStorageConfiguration!.devices.findIndex((deviceInformation) => {
-      return deviceInformation.bluetoothId == device.bluetoothId;
-    });
+    const deviceInformationIndex =
+      this.#LocalStorageConfiguration!.devices.findIndex(
+        (deviceInformation) => {
+          return deviceInformation.bluetoothId == device.bluetoothId;
+        }
+      );
     if (deviceInformationIndex == -1) {
       return;
     }
-    this.#LocalStorageConfiguration!.devices[deviceInformationIndex].type = device.type;
+    this.#LocalStorageConfiguration!.devices[deviceInformationIndex].type =
+      device.type;
     this.#SaveToLocalStorage();
   }
 
@@ -229,7 +264,8 @@ class DeviceManager {
         return;
       }
       let deviceInformation = configuration.devices.find(
-        (deviceInformation) => bluetoothDevice.id == deviceInformation.bluetoothId
+        (deviceInformation) =>
+          bluetoothDevice.id == deviceInformation.bluetoothId
       );
       if (!deviceInformation) {
         return;
@@ -245,10 +281,13 @@ class DeviceManager {
       if (existingAvailableDevice) {
         if (
           existingConnectedDevice &&
-          existingConnectedDevice?.bluetoothId == existingAvailableDevice.bluetoothId &&
+          existingConnectedDevice?.bluetoothId ==
+            existingAvailableDevice.bluetoothId &&
           existingConnectedDevice != existingAvailableDevice
         ) {
-          this.AvailableDevices[this.#AvailableDevices.indexOf(existingAvailableDevice)] = existingConnectedDevice;
+          this.AvailableDevices[
+            this.#AvailableDevices.indexOf(existingAvailableDevice)
+          ] = existingConnectedDevice;
         }
         return;
       }
@@ -274,7 +313,10 @@ class DeviceManager {
 
   // STATIC EVENTLISTENERS
 
-  #EventDispatcher: DeviceManagerEventDispatcher = new EventDispatcher(this as DeviceManager, DeviceManagerEventTypes);
+  #EventDispatcher: DeviceManagerEventDispatcher = new EventDispatcher(
+    this as DeviceManager,
+    DeviceManagerEventTypes
+  );
 
   get AddEventListener() {
     return this.#EventDispatcher.addEventListener;
@@ -302,14 +344,19 @@ class DeviceManager {
           const deviceInformation: LocalStorageDeviceInformation = {
             type: device.type,
             bluetoothId: device.bluetoothId!,
+            ipAddress: device.ipAddress,
+            isWifiSecure: device.isWifiSecure,
           };
-          const deviceInformationIndex = this.#LocalStorageConfiguration!.devices.findIndex(
-            (_deviceInformation) => _deviceInformation.bluetoothId == deviceInformation.bluetoothId
-          );
+          const deviceInformationIndex =
+            this.#LocalStorageConfiguration!.devices.findIndex(
+              (_deviceInformation) =>
+                _deviceInformation.bluetoothId == deviceInformation.bluetoothId
+            );
           if (deviceInformationIndex == -1) {
             this.#LocalStorageConfiguration!.devices.push(deviceInformation);
           } else {
-            this.#LocalStorageConfiguration!.devices[deviceInformationIndex] = deviceInformation;
+            this.#LocalStorageConfiguration!.devices[deviceInformationIndex] =
+              deviceInformation;
           }
           this.#SaveToLocalStorage();
         }
@@ -322,7 +369,10 @@ class DeviceManager {
     } else {
       if (this.#ConnectedDevices.includes(device)) {
         _console.log("removing device", device);
-        this.#ConnectedDevices.splice(this.#ConnectedDevices.indexOf(device), 1);
+        this.#ConnectedDevices.splice(
+          this.#ConnectedDevices.indexOf(device),
+          1
+        );
         this.#DispatchEvent("deviceDisconnected", { device });
         this.#DispatchEvent("deviceIsConnected", { device });
         this.#DispatchConnectedDevices();
@@ -339,7 +389,9 @@ class DeviceManager {
       );
       _console.log({ existingAvailableDevice });
       if (existingAvailableDevice) {
-        this.AvailableDevices[this.AvailableDevices.indexOf(existingAvailableDevice)] = device;
+        this.AvailableDevices[
+          this.AvailableDevices.indexOf(existingAvailableDevice)
+        ] = device;
       } else {
         this.AvailableDevices.push(device);
       }
@@ -349,7 +401,11 @@ class DeviceManager {
   }
 
   _CheckDeviceAvailability(device: Device) {
-    if (!device.isConnected && !device.isAvailable && this.#AvailableDevices.includes(device)) {
+    if (
+      !device.isConnected &&
+      !device.isAvailable &&
+      this.#AvailableDevices.includes(device)
+    ) {
       _console.log("removing device from availableDevices...");
       this.#AvailableDevices.splice(this.#AvailableDevices.indexOf(device), 1);
       this.#DispatchAvailableDevices();
@@ -358,11 +414,15 @@ class DeviceManager {
 
   #DispatchAvailableDevices() {
     _console.log({ AvailableDevices: this.AvailableDevices });
-    this.#DispatchEvent("availableDevices", { availableDevices: this.AvailableDevices });
+    this.#DispatchEvent("availableDevices", {
+      availableDevices: this.AvailableDevices,
+    });
   }
   #DispatchConnectedDevices() {
     _console.log({ ConnectedDevices: this.ConnectedDevices });
-    this.#DispatchEvent("connectedDevices", { connectedDevices: this.ConnectedDevices });
+    this.#DispatchEvent("connectedDevices", {
+      connectedDevices: this.ConnectedDevices,
+    });
   }
 }
 

package/src/FileTransferManager.ts

@@ -9,6 +9,7 @@ import autoBind from "auto-bind";
 const _console = createConsole("FileTransferManager", { log: false });
 
 export const FileTransferMessageTypes = [
+  "getFileTypes",
   "maxFileLength",
   "getFileType",
   "setFileType",
@@ -24,13 +25,17 @@ export const FileTransferMessageTypes = [
 ] as const;
 export type FileTransferMessageType = (typeof FileTransferMessageTypes)[number];
 
-export const FileTypes = ["tflite"] as const;
+export const FileTypes = ["tflite", "wifiServerCert", "wifiServerKey"] as const;
 export type FileType = (typeof FileTypes)[number];
 
 export const FileTransferStatuses = ["idle", "sending", "receiving"] as const;
 export type FileTransferStatus = (typeof FileTransferStatuses)[number];
 
-export const FileTransferCommands = ["startSend", "startReceive", "cancel"] as const;
+export const FileTransferCommands = [
+  "startSend",
+  "startReceive",
+  "cancel",
+] as const;
 export type FileTransferCommand = (typeof FileTransferCommands)[number];
 
 export const FileTransferDirections = ["sending", "receiving"] as const;
@@ -44,7 +49,21 @@ export const FileTransferEventTypes = [
 ] as const;
 export type FileTransferEventType = (typeof FileTransferEventTypes)[number];
 
+export const RequiredFileTransferMessageTypes: FileTransferMessageType[] = [
+  "maxFileLength",
+  "getFileLength",
+  "getFileChecksum",
+  "getFileType",
+  "fileTransferStatus",
+];
+
+export interface FileConfiguration {
+  file: FileLike;
+  type: FileType;
+}
+
 export interface FileTransferEventMessages {
+  getFileTypes: { fileTypes: FileType[] };
   maxFileLength: { maxFileLength: number };
   getFileType: { fileType: FileType };
   getFileLength: { fileLength: number };
@@ -56,8 +75,13 @@ export interface FileTransferEventMessages {
   fileReceived: { file: File | Blob };
 }
 
-export type FileTransferEventDispatcher = EventDispatcher<Device, FileTransferEventType, FileTransferEventMessages>;
-export type SendFileTransferMessageCallback = SendMessageCallback<FileTransferMessageType>;
+export type FileTransferEventDispatcher = EventDispatcher<
+  Device,
+  FileTransferEventType,
+  FileTransferEventMessages
+>;
+export type SendFileTransferMessageCallback =
+  SendMessageCallback<FileTransferMessageType>;
 
 class FileTransferManager {
   constructor() {
@@ -82,17 +106,41 @@ class FileTransferManager {
   #assertValidType(type: FileType) {
     _console.assertEnumWithError(type, FileTypes);
   }
+  #isValidType(type: FileType) {
+    return FileTypes.includes(type);
+  }
   #assertValidTypeEnum(typeEnum: number) {
-    _console.assertWithError(typeEnum in FileTypes, `invalid typeEnum ${typeEnum}`);
+    _console.assertWithError(
+      typeEnum in FileTypes,
+      `invalid typeEnum ${typeEnum}`
+    );
   }
 
   #assertValidStatusEnum(statusEnum: number) {
-    _console.assertWithError(statusEnum in FileTransferStatuses, `invalid statusEnum ${statusEnum}`);
+    _console.assertWithError(
+      statusEnum in FileTransferStatuses,
+      `invalid statusEnum ${statusEnum}`
+    );
   }
   #assertValidCommand(command: FileTransferCommand) {
     _console.assertEnumWithError(command, FileTransferCommands);
   }
 
+  #fileTypes: FileType[] = [];
+  get fileTypes() {
+    return this.#fileTypes;
+  }
+  #parseFileTypes(dataView: DataView) {
+    const fileTypes = Array.from(new Uint8Array(dataView.buffer))
+      .map((index) => FileTypes[index])
+      .filter(Boolean);
+    this.#fileTypes = fileTypes;
+    _console.log("fileTypes", fileTypes);
+    this.#dispatchEvent("getFileTypes", {
+      fileTypes: this.#fileTypes,
+    });
+  }
+
   static #MaxLength = 0; // kB
   static get MaxLength() {
     return this.#MaxLength;
@@ -146,7 +194,10 @@ class FileTransferManager {
     const promise = this.waitForEvent("getFileType");
 
     const typeEnum = FileTypes.indexOf(newType);
-    this.sendMessage([{ type: "setFileType", data: Uint8Array.from([typeEnum]).buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setFileType", data: Uint8Array.from([typeEnum]).buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -178,7 +229,10 @@ class FileTransferManager {
 
     const dataView = new DataView(new ArrayBuffer(4));
     dataView.setUint32(0, newLength, true);
-    this.sendMessage([{ type: "setFileLength", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setFileLength", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -208,7 +262,10 @@ class FileTransferManager {
 
     const dataView = new DataView(new ArrayBuffer(4));
     dataView.setUint32(0, newChecksum, true);
-    this.sendMessage([{ type: "setFileChecksum", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setFileChecksum", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -220,7 +277,12 @@ class FileTransferManager {
     _console.log(`setting command ${command}`);
     const commandEnum = FileTransferCommands.indexOf(command);
     this.sendMessage(
-      [{ type: "setFileTransferCommand", data: Uint8Array.from([commandEnum]).buffer }],
+      [
+        {
+          type: "setFileTransferCommand",
+          data: Uint8Array.from([commandEnum]).buffer,
+        },
+      ],
       sendImmediately
     );
 
@@ -243,6 +305,7 @@ class FileTransferManager {
     this.#status = status;
     this.#dispatchEvent("fileTransferStatus", { fileTransferStatus: status });
     this.#receivedBlocks.length = 0;
+    this.#isCancelling = false;
   }
   #assertIsIdle() {
     _console.assertWithError(this.#status == "idle", "status is not idle");
@@ -259,10 +322,15 @@ class FileTransferManager {
     _console.log("parseFileBlock", dataView);
     this.#receivedBlocks.push(dataView.buffer);
 
-    const bytesReceived = this.#receivedBlocks.reduce((sum, arrayBuffer) => (sum += arrayBuffer.byteLength), 0);
+    const bytesReceived = this.#receivedBlocks.reduce(
+      (sum, arrayBuffer) => (sum += arrayBuffer.byteLength),
+      0
+    );
     const progress = bytesReceived / this.#length;
 
-    _console.log(`received ${bytesReceived} of ${this.#length} bytes (${progress * 100}%)`);
+    _console.log(
+      `received ${bytesReceived} of ${this.#length} bytes (${progress * 100}%)`
+    );
 
     this.#dispatchEvent("fileTransferProgress", { progress });
 
@@ -273,7 +341,9 @@ class FileTransferManager {
       if (this.isServerSide) {
         return;
       }
-      await this.sendMessage([{ type: "fileBytesTransferred", data: dataView.buffer }]);
+      await this.sendMessage([
+        { type: "fileBytesTransferred", data: dataView.buffer },
+      ]);
       return;
     }
 
@@ -284,6 +354,12 @@ class FileTransferManager {
       case "tflite":
         fileName += ".tflite";
         break;
+      case "wifiServerCert":
+        fileName += "_server.crt";
+        break;
+      case "wifiServerKey":
+        fileName += "_server.key";
+        break;
     }
 
     let file: File | Blob;
@@ -298,7 +374,9 @@ class FileTransferManager {
     _console.log({ checksum });
 
     if (checksum != this.#checksum) {
-      _console.error(`wrong checksum - expected ${this.#checksum}, got ${checksum}`);
+      _console.error(
+        `wrong checksum - expected ${this.#checksum}, got ${checksum}`
+      );
       return;
     }
 
@@ -313,6 +391,9 @@ class FileTransferManager {
     _console.log({ messageType });
 
     switch (messageType) {
+      case "getFileTypes":
+        this.#parseFileTypes(dataView);
+        break;
       case "maxFileLength":
         this.#parseMaxLength(dataView);
         break;
@@ -343,17 +424,39 @@ class FileTransferManager {
   }
 
   async send(type: FileType, file: FileLike) {
-    this.#assertIsIdle();
+    if (true) {
+      this.#assertIsIdle();
+      this.#assertValidType(type);
+    } else {
+      if (this.status != "idle") {
+        _console.warn(`cannot send file - status is ${this.status}`);
+        return false;
+      }
+      if (!this.#isValidType(type)) {
+        _console.warn(`invalid fileType ${type}`);
+        return false;
+      }
+    }
 
-    this.#assertValidType(type);
     const fileBuffer = await getFileBuffer(file);
+    const fileLength = fileBuffer.byteLength;
+    const checksum = crc32(fileBuffer);
+
+    if (type != this.type) {
+      _console.log("different fileTypes - sending");
+    } else if (fileLength != this.length) {
+      _console.log("different fileLengths - sending");
+    } else if (checksum != this.checksum) {
+      _console.log("different fileChecksums - sending");
+    } else {
+      _console.log("already sent file");
+      return false;
+    }
 
     const promises: Promise<any>[] = [];
 
     promises.push(this.#setType(type, false));
-    const fileLength = fileBuffer.byteLength;
     promises.push(this.#setLength(fileLength, false));
-    const checksum = crc32(fileBuffer);
     promises.push(this.#setChecksum(checksum, false));
     promises.push(this.#setCommand("startSend", false));
 
@@ -362,6 +465,8 @@ class FileTransferManager {
     await Promise.all(promises);
 
     await this.#send(fileBuffer);
+
+    return true;
   }
 
   #buffer?: ArrayBuffer;
@@ -377,6 +482,10 @@ class FileTransferManager {
     if (this.status != "sending") {
       return;
     }
+    if (this.#isCancelling) {
+      _console.error("not sending block - busy cancelling");
+      return;
+    }
     if (!this.#buffer) {
       if (!this.isServerSide) {
         _console.error("no buffer defined");
@@ -393,7 +502,9 @@ class FileTransferManager {
 
     const progress = 1 - bytesLeft / buffer.byteLength;
     _console.log(
-      `sending bytes ${offset}-${offset + slicedBuffer.byteLength} of ${buffer.byteLength} bytes (${progress * 100}%)`
+      `sending bytes ${offset}-${offset + slicedBuffer.byteLength} of ${
+        buffer.byteLength
+      } bytes (${progress * 100}%)`
     );
     this.#dispatchEvent("fileTransferProgress", { progress });
     if (slicedBuffer.byteLength == 0) {
@@ -415,7 +526,11 @@ class FileTransferManager {
       return;
     }
     if (!this.isServerSide && this.#bytesTransferred != bytesTransferred) {
-      _console.error(`bytesTransferred are not equal - got ${bytesTransferred}, expected ${this.#bytesTransferred}`);
+      _console.error(
+        `bytesTransferred are not equal - got ${bytesTransferred}, expected ${
+          this.#bytesTransferred
+        }`
+      );
       this.cancel();
       return;
     }
@@ -431,9 +546,11 @@ class FileTransferManager {
     await this.#setCommand("startReceive");
   }
 
+  #isCancelling = false;
   async cancel() {
     this.#assertIsNotIdle();
     _console.log("cancelling file transfer...");
+    this.#isCancelling = true;
     await this.#setCommand("cancel");
   }
 
@@ -450,6 +567,14 @@ class FileTransferManager {
     _console.log({ newIsServerSide });
     this.#isServerSide = newIsServerSide;
   }
+
+  requestRequiredInformation() {
+    _console.log("requesting required fileTransfer information");
+    const messages = RequiredFileTransferMessageTypes.map((messageType) => ({
+      type: messageType,
+    }));
+    this.sendMessage(messages, false);
+  }
 }
 
 export default FileTransferManager;