brilliantsole 0.0.29 → 0.0.30

package/src/FileTransferManager.ts

@@ -1,6 +1,6 @@
 import { createConsole } from "./utils/Console.ts";
 import { crc32 } from "./utils/checksum.ts";
-import { getFileBuffer } from "./utils/ArrayBufferUtils.ts";
+import { getFileBuffer, UInt8ByteBuffer } from "./utils/ArrayBufferUtils.ts";
 import { FileLike } from "./utils/ArrayBufferUtils.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
 import EventDispatcher from "./utils/EventDispatcher.ts";
@@ -25,7 +25,12 @@ export const FileTransferMessageTypes = [
 ] as const;
 export type FileTransferMessageType = (typeof FileTransferMessageTypes)[number];
 
-export const FileTypes = ["tflite", "wifiServerCert", "wifiServerKey"] as const;
+export const FileTypes = [
+  "tflite",
+  "wifiServerCert",
+  "wifiServerKey",
+  "spriteSheet",
+] as const;
 export type FileType = (typeof FileTypes)[number];
 
 export const FileTransferStatuses = ["idle", "sending", "receiving"] as const;
@@ -68,11 +73,17 @@ export interface FileTransferEventMessages {
   getFileType: { fileType: FileType };
   getFileLength: { fileLength: number };
   getFileChecksum: { fileChecksum: number };
-  fileTransferStatus: { fileTransferStatus: FileTransferStatus };
+  fileTransferStatus: {
+    fileType: FileType;
+    fileTransferStatus: FileTransferStatus;
+  };
   getFileBlock: { fileTransferBlock: DataView };
-  fileTransferProgress: { progress: number };
-  fileTransferComplete: { direction: FileTransferDirection };
-  fileReceived: { file: File | Blob };
+  fileTransferProgress: { fileType: FileType; progress: number };
+  fileTransferComplete: {
+    fileType: FileType;
+    direction: FileTransferDirection;
+  };
+  fileReceived: { fileType: FileType; file: File | Blob };
 }
 
 export type FileTransferEventDispatcher = EventDispatcher<
@@ -83,6 +94,12 @@ export type FileTransferEventDispatcher = EventDispatcher<
 export type SendFileTransferMessageCallback =
   SendMessageCallback<FileTransferMessageType>;
 
+export type SendFileCallback = (
+  type: FileType,
+  file: FileLike,
+  override?: boolean
+) => Promise<boolean>;
+
 class FileTransferManager {
   constructor() {
     autoBind(this);
@@ -194,8 +211,9 @@ class FileTransferManager {
     const promise = this.waitForEvent("getFileType");
 
     const typeEnum = FileTypes.indexOf(newType);
+
     this.sendMessage(
-      [{ type: "setFileType", data: Uint8Array.from([typeEnum]).buffer }],
+      [{ type: "setFileType", data: UInt8ByteBuffer(typeEnum) }],
       sendImmediately
     );
 
@@ -276,11 +294,12 @@ class FileTransferManager {
     const promise = this.waitForEvent("fileTransferStatus");
     _console.log(`setting command ${command}`);
     const commandEnum = FileTransferCommands.indexOf(command);
+
     this.sendMessage(
       [
         {
           type: "setFileTransferCommand",
-          data: Uint8Array.from([commandEnum]).buffer,
+          data: UInt8ByteBuffer(commandEnum),
         },
       ],
       sendImmediately
@@ -303,9 +322,14 @@ class FileTransferManager {
   #updateStatus(status: FileTransferStatus) {
     _console.log({ status });
     this.#status = status;
-    this.#dispatchEvent("fileTransferStatus", { fileTransferStatus: status });
     this.#receivedBlocks.length = 0;
     this.#isCancelling = false;
+    this.#buffer = undefined;
+    this.#bytesTransferred = 0;
+    this.#dispatchEvent("fileTransferStatus", {
+      fileTransferStatus: status,
+      fileType: this.type!,
+    });
   }
   #assertIsIdle() {
     _console.assertWithError(this.#status == "idle", "status is not idle");
@@ -332,7 +356,10 @@ class FileTransferManager {
       `received ${bytesReceived} of ${this.#length} bytes (${progress * 100}%)`
     );
 
-    this.#dispatchEvent("fileTransferProgress", { progress });
+    this.#dispatchEvent("fileTransferProgress", {
+      progress,
+      fileType: this.type!,
+    });
 
     if (bytesReceived != this.#length) {
       const dataView = new DataView(new ArrayBuffer(4));
@@ -383,8 +410,11 @@ class FileTransferManager {
     _console.log("received file", file);
 
     this.#dispatchEvent("getFileBlock", { fileTransferBlock: dataView });
-    this.#dispatchEvent("fileTransferComplete", { direction: "receiving" });
-    this.#dispatchEvent("fileReceived", { file });
+    this.#dispatchEvent("fileTransferComplete", {
+      direction: "receiving",
+      fileType: this.type!,
+    });
+    this.#dispatchEvent("fileReceived", { file, fileType: this.type! });
   }
 
   parseMessage(messageType: FileTransferMessageType, dataView: DataView) {
@@ -423,7 +453,7 @@ class FileTransferManager {
     }
   }
 
-  async send(type: FileType, file: FileLike) {
+  async send(type: FileType, file: FileLike, override?: boolean) {
     if (true) {
       this.#assertIsIdle();
       this.#assertValidType(type);
@@ -441,16 +471,19 @@ class FileTransferManager {
     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;
+    this.#assertValidLength(fileLength);
+
+    if (!override) {
+      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>[] = [];
@@ -464,6 +497,16 @@ class FileTransferManager {
 
     await Promise.all(promises);
 
+    if (this.#buffer) {
+      return false;
+    }
+    if (this.#length != fileLength) {
+      return false;
+    }
+    if (this.#checksum != checksum) {
+      return false;
+    }
+
     await this.#send(fileBuffer);
 
     return true;
@@ -473,7 +516,6 @@ class FileTransferManager {
   #bytesTransferred = 0;
   async #send(buffer: ArrayBuffer) {
     this.#buffer = buffer;
-    this.#bytesTransferred = 0;
     return this.#sendBlock();
   }
 
@@ -506,10 +548,16 @@ class FileTransferManager {
         buffer.byteLength
       } bytes (${progress * 100}%)`
     );
-    this.#dispatchEvent("fileTransferProgress", { progress });
+    this.#dispatchEvent("fileTransferProgress", {
+      progress,
+      fileType: this.type!,
+    });
     if (slicedBuffer.byteLength == 0) {
       _console.log("finished sending buffer");
-      this.#dispatchEvent("fileTransferComplete", { direction: "sending" });
+      this.#dispatchEvent("fileTransferComplete", {
+        direction: "sending",
+        fileType: this.type!,
+      });
     } else {
       await this.sendMessage([{ type: "setFileBlock", data: slicedBuffer }]);
       this.#bytesTransferred = offset + slicedBuffer.byteLength;
@@ -575,6 +623,11 @@ class FileTransferManager {
     }));
     this.sendMessage(messages, false);
   }
+
+  clear() {
+    this.#status = "idle";
+    this.#isServerSide = false;
+  }
 }
 
 export default FileTransferManager;

package/src/InformationManager.ts

@@ -1,7 +1,7 @@
 import { ConnectionType } from "./connection/BaseConnectionManager.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
+import { UInt8ByteBuffer } from "./utils/ArrayBufferUtils.ts";
 import { createConsole } from "./utils/Console.ts";
-import { isInBrowser } from "./utils/environment.ts";
 import EventDispatcher from "./utils/EventDispatcher.ts";
 import { Uint16Max } from "./utils/MathUtils.ts";
 import { textDecoder, textEncoder } from "./utils/Text.ts";
@@ -165,10 +165,10 @@ class InformationManager {
   }
   updateType(updatedType: DeviceType) {
     this.#assertValidDeviceType(updatedType);
-    if (updatedType == this.type) {
-      _console.log("redundant type assignment");
-      return;
-    }
+    // if (updatedType == this.type) {
+    //   _console.log("redundant type assignment");
+    //   return;
+    // }
     this.#type = updatedType;
     _console.log({ updatedType: this.#type });
 
@@ -176,10 +176,11 @@ class InformationManager {
   }
   async #setTypeEnum(newTypeEnum: number) {
     this.#assertValidDeviceTypeEnum(newTypeEnum);
-    const setTypeData = Uint8Array.from([newTypeEnum]);
+
+    const setTypeData = UInt8ByteBuffer(newTypeEnum);
     _console.log({ setTypeData });
     const promise = this.waitForEvent("getType");
-    this.sendMessage([{ type: "setType", data: setTypeData.buffer }]);
+    this.sendMessage([{ type: "setType", data: setTypeData }]);
     await promise;
   }
   async setType(newType: DeviceType) {

package/src/MicrophoneManager.ts

@@ -2,7 +2,10 @@ import Device, { SendMessageCallback } from "./Device.ts";
 import { createConsole } from "./utils/Console.ts";
 import EventDispatcher from "./utils/EventDispatcher.ts";
 import autoBind from "auto-bind";
-import { concatenateArrayBuffers } from "./utils/ArrayBufferUtils.ts";
+import {
+  concatenateArrayBuffers,
+  UInt8ByteBuffer,
+} from "./utils/ArrayBufferUtils.ts";
 import { float32ArrayToWav } from "./utils/AudioUtils.ts";
 
 const _console = createConsole("MicrophoneManager", { log: false });
@@ -149,11 +152,12 @@ class MicrophoneManager {
     const promise = this.waitForEvent("microphoneStatus");
     _console.log(`setting command "${command}"`);
     const commandEnum = MicrophoneCommands.indexOf(command);
+
     this.sendMessage(
       [
         {
           type: "microphoneCommand",
-          data: Uint8Array.from([commandEnum]).buffer,
+          data: UInt8ByteBuffer(commandEnum),
         },
       ],
       sendImmediately
@@ -184,7 +188,10 @@ class MicrophoneManager {
     await this.#sendMicrophoneCommand("start");
   }
   async stop() {
-    this.#assertIsNotIdle();
+    if (this.microphoneStatus == "idle") {
+      _console.log("microphone is already idle");
+      return;
+    }
     await this.#sendMicrophoneCommand("stop");
   }
   async vad() {

package/src/TfliteManager.ts

@@ -9,6 +9,7 @@ import { SensorType } from "./sensor/SensorDataManager.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
 import autoBind from "auto-bind";
 import { FileConfiguration as BaseFileConfiguration } from "./FileTransferManager.ts";
+import { UInt8ByteBuffer } from "./utils/ArrayBufferUtils.ts";
 
 const _console = createConsole("TfliteManager", { log: false });
 
@@ -188,7 +189,7 @@ class TfliteManager {
 
     const taskEnum = TfliteTasks.indexOf(newTask);
     this.sendMessage(
-      [{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }],
+      [{ type: "setTfliteTask", data: UInt8ByteBuffer(taskEnum) }],
       sendImmediately
     );
 
@@ -429,7 +430,8 @@ class TfliteManager {
       [
         {
           type: "setTfliteInferencingEnabled",
-          data: Uint8Array.from([Number(newInferencingEnabled)]).buffer,
+
+          data: UInt8ByteBuffer(Number(newInferencingEnabled)),
         },
       ],
       sendImmediately

package/src/WifiManager.ts

@@ -1,4 +1,5 @@
 import Device, { SendMessageCallback } from "./Device.ts";
+import { UInt8ByteBuffer } from "./utils/ArrayBufferUtils.ts";
 import { createConsole } from "./utils/Console.ts";
 import { isInNode } from "./utils/environment.ts";
 import EventDispatcher from "./utils/EventDispatcher.ts";
@@ -197,11 +198,13 @@ class WifiManager {
     }
 
     const promise = this.waitForEvent("getWifiConnectionEnabled");
+
     this.sendMessage(
       [
         {
           type: "setWifiConnectionEnabled",
-          data: Uint8Array.from([Number(newWifiConnectionEnabled)]).buffer,
+
+          data: UInt8ByteBuffer(Number(newWifiConnectionEnabled)),
         },
       ],
       sendImmediately

package/src/connection/BaseConnectionManager.ts

@@ -13,6 +13,7 @@ import { SensorDataMessageTypes } from "../sensor/SensorDataManager.ts";
 import { WifiMessageTypes } from "../WifiManager.ts";
 import { CameraMessageTypes } from "../CameraManager.ts";
 import { MicrophoneMessageTypes } from "../MicrophoneManager.ts";
+import { DisplayMessageTypes } from "../DisplayManager.ts";
 
 const _console = createConsole("BaseConnectionManager", { log: false });
 
@@ -95,6 +96,7 @@ export const TxRxMessageTypes = [
   ...WifiMessageTypes,
   ...CameraMessageTypes,
   ...MicrophoneMessageTypes,
+  ...DisplayMessageTypes,
 ] as const;
 export type TxRxMessageType = (typeof TxRxMessageTypes)[number];
 

package/src/connection/bluetooth/bluetoothUUIDs.ts

@@ -1,4 +1,8 @@
-import { isInBrowser, isInNode } from "../../utils/environment.ts";
+import {
+  isInBrowser,
+  isInLensStudio,
+  isInNode,
+} from "../../utils/environment.ts";
 import { createConsole } from "../../utils/Console.ts";
 
 const _console = createConsole("bluetoothUUIDs", { log: false });
@@ -7,12 +11,43 @@ const _console = createConsole("bluetoothUUIDs", { log: false });
 import * as webbluetooth from "webbluetooth";
 var BluetoothUUID = webbluetooth.BluetoothUUID;
 /** NODE_END */
+
 /** BROWSER_START */
 if (isInBrowser) {
   var BluetoothUUID = window.BluetoothUUID;
 }
 /** BROWSER_END */
 
+/** LS_START */
+
+var BluetoothUUID = {
+  getService: (uuid: number | string): string => toUUID(uuid),
+
+  getCharacteristic: (uuid: number | string): string => toUUID(uuid),
+
+  getDescriptor: (uuid: number | string): string => toUUID(uuid),
+
+  getCharacteristicName: (uuid: number | string): string | null => null,
+
+  getServiceName: (uuid: number | string): string | null => null,
+
+  getDescriptorName: (uuid: number | string): string | null => null,
+};
+
+function toUUID(uuid: number | string): string {
+  if (typeof uuid === "number") {
+    uuid = uuid.toString(16).padStart(4, "0");
+  }
+
+  if (/^[0-9a-fA-F]{4,8}$/.test(uuid)) {
+    return `0000${uuid.padStart(8, "0")}-0000-1000-8000-00805f9b34fb`;
+  }
+
+  return uuid.toLowerCase();
+}
+
+/** LS_END */
+
 function generateBluetoothUUID(value: string): BluetoothServiceUUID {
   _console.assertTypeWithError(value, "string");
   _console.assertWithError(

package/src/devicePair/DevicePairPressureSensorDataManager.ts

@@ -101,7 +101,7 @@ class DevicePairPressureSensorDataManager {
           }
         } else {
           sidePressure.sensors.forEach((sensor) => {
-            const _sensor: PressureSensorValue = { ...sensor };
+            const _sensor: PressureSensorValue = structuredClone(sensor);
             _sensor.weightedValue = sensor.scaledValue / pressure.scaledSum;
             let { x, y } = sensor.position;
             x /= 2;

package/src/scanner/NobleScanner.ts

@@ -122,7 +122,7 @@ class NobleScanner extends BaseScanner {
         ipAddress = new Uint8Array(
           manufacturerData.buffer.slice(3, 3 + 4)
         ).join(".");
-        //_console.log({ ipAddress });
+        _console.log({ ipAddress });
       }
       if (manufacturerData.byteLength >= 3 + 4 + 1) {
         isWifiSecure = manufacturerData.readUint8(3 + 4) != 0;

package/src/sensor/SensorConfigurationManager.ts

@@ -84,6 +84,10 @@ class SensorConfigurationManager {
     });
   }
 
+  clear() {
+    this.#updateConfiguration({});
+  }
+
   #isRedundant(sensorConfiguration: SensorConfiguration) {
     let sensorTypes = Object.keys(sensorConfiguration) as SensorType[];
     return sensorTypes.every((sensorType) => {
@@ -93,11 +97,12 @@ class SensorConfigurationManager {
 
   async setConfiguration(
     newSensorConfiguration: SensorConfiguration,
-    clearRest?: boolean
+    clearRest?: boolean,
+    sendImmediately?: boolean
   ) {
     if (clearRest) {
       newSensorConfiguration = Object.assign(
-        { ...this.zeroSensorConfiguration },
+        structuredClone(this.zeroSensorConfiguration),
         newSensorConfiguration
       );
     }
@@ -110,12 +115,15 @@ class SensorConfigurationManager {
     _console.log({ setSensorConfigurationData });
 
     const promise = this.waitForEvent("getSensorConfiguration");
-    this.sendMessage([
-      {
-        type: "setSensorConfiguration",
-        data: setSensorConfigurationData.buffer,
-      },
-    ]);
+    this.sendMessage(
+      [
+        {
+          type: "setSensorConfiguration",
+          data: setSensorConfigurationData.buffer,
+        },
+      ],
+      sendImmediately
+    );
     await promise;
   }
 

package/src/server/udp/UDPServer.ts

@@ -56,10 +56,10 @@ class UDPServer extends BaseServer {
       client = {
         ...remoteInfo,
         isAlive: true,
-        removeSelfTimer: new Timer(
-          () => this.#removeClient(client!),
-          removeUDPClientTimeout
-        ),
+        removeSelfTimer: new Timer(() => {
+          _console.log("removing client due to timeout...");
+          this.#removeClient(client!);
+        }, removeUDPClientTimeout),
         lastTimeSentData: 0,
       };
       _console.log("created new client", client);

package/src/server/udp/UDPUtils.ts

@@ -4,7 +4,7 @@ import { createMessage, Message } from "../ServerUtils.ts";
 const _console = createConsole("UDPUtils", { log: false });
 
 export const pongUDPClientTimeout = 2_000;
-export const removeUDPClientTimeout = 3_000;
+export const removeUDPClientTimeout = 4_000;
 
 export const UDPServerMessageTypes = [
   "ping",

package/src/server/websocket/WebSocketClient.ts

@@ -21,6 +21,7 @@ import {
   WebSocketMessage,
 } from "./WebSocketUtils.ts";
 import { parseMessage } from "../../utils/ParseUtils.ts";
+import { isInLensStudio, isInBrowser } from "../../utils/environment.ts";
 
 const _console = createConsole("WebSocketClient", { log: false });
 
@@ -62,7 +63,55 @@ class WebSocketClient extends BaseClient {
       this.assertDisconnection();
     }
     this._connectionStatus = "connecting";
-    this.webSocket = new WebSocket(url);
+
+    if (isInLensStudio) {
+      if (globalThis.internetModule) {
+        // FILL
+        /*
+        let socket = globalThis.internetModule.createWebSocket(url);
+        socket.binaryType = "blob";
+
+        socket.onopen = (event) => {
+          socket.send("Message 1");
+
+          // Try sending a binary message
+          // (the bytes below spell 'Message 2')
+          const message = [77, 101, 115, 115, 97, 103, 101, 32, 50];
+          const bytes = new Uint8Array(message);
+          socket.send(bytes);
+        };
+
+        // Listen for messages
+        socket.onmessage = async (event) => {
+          if (event.data instanceof Blob) {
+            // Binary frame, can be retrieved as either Uint8Array or string
+            let bytes = await event.data.bytes();
+            let text = await event.data.text();
+
+            print("Received binary message, printing as text: " + text);
+          } else {
+            // Text frame
+            let text = event.data;
+            print("Received text message: " + text);
+          }
+        };
+
+        socket.onclose = (event) => {
+          if (event.wasClean) {
+            print("Socket closed cleanly");
+          } else {
+            print("Socket closed with error, code: " + event.code);
+          }
+        };
+
+        socket.onerror = (event) => {
+          print("Socket error");
+        };
+        */
+      }
+    } else {
+      this.webSocket = new WebSocket(url);
+    }
   }
 
   disconnect() {

package/src/utils/ArrayBufferUtils.ts

@@ -4,7 +4,9 @@ import { textEncoder } from "./Text.ts";
 const _console = createConsole("ArrayBufferUtils", { log: false });
 
 export function concatenateArrayBuffers(...arrayBuffers: any[]): ArrayBuffer {
-  arrayBuffers = arrayBuffers.filter((arrayBuffer) => arrayBuffer != undefined || arrayBuffer != null);
+  arrayBuffers = arrayBuffers.filter(
+    (arrayBuffer) => arrayBuffer != undefined || arrayBuffer != null
+  );
   arrayBuffers = arrayBuffers.map((arrayBuffer) => {
     if (typeof arrayBuffer == "number") {
       const number = arrayBuffer;
@@ -20,7 +22,10 @@ export function concatenateArrayBuffers(...arrayBuffers: any[]): ArrayBuffer {
       return concatenateArrayBuffers(...array);
     } else if (arrayBuffer instanceof ArrayBuffer) {
       return arrayBuffer;
-    } else if ("buffer" in arrayBuffer && arrayBuffer.buffer instanceof ArrayBuffer) {
+    } else if (
+      "buffer" in arrayBuffer &&
+      arrayBuffer.buffer instanceof ArrayBuffer
+    ) {
       const bufferContainer = arrayBuffer;
       return bufferContainer.buffer;
     } else if (arrayBuffer instanceof DataView) {
@@ -33,8 +38,13 @@ export function concatenateArrayBuffers(...arrayBuffers: any[]): ArrayBuffer {
       return arrayBuffer;
     }
   });
-  arrayBuffers = arrayBuffers.filter((arrayBuffer) => arrayBuffer && "byteLength" in arrayBuffer);
-  const length = arrayBuffers.reduce((length, arrayBuffer) => length + arrayBuffer.byteLength, 0);
+  arrayBuffers = arrayBuffers.filter(
+    (arrayBuffer) => arrayBuffer && "byteLength" in arrayBuffer
+  );
+  const length = arrayBuffers.reduce(
+    (length, arrayBuffer) => length + arrayBuffer.byteLength,
+    0
+  );
   const uint8Array = new Uint8Array(length);
   let byteOffset = 0;
   arrayBuffers.forEach((arrayBuffer) => {
@@ -57,7 +67,11 @@ export function objectToArrayBuffer(object: object) {
   return stringToArrayBuffer(JSON.stringify(object));
 }
 
-export function sliceDataView(dataView: DataView, begin: number, length?: number) {
+export function sliceDataView(
+  dataView: DataView,
+  begin: number,
+  length?: number
+) {
   let end;
   if (length != undefined) {
     end = dataView.byteOffset + begin + length;
@@ -86,3 +100,7 @@ export async function getFileBuffer(file: FileLike) {
   }
   return fileBuffer;
 }
+
+export function UInt8ByteBuffer(value: number) {
+  return Uint8Array.from([value]).buffer;
+}

package/src/utils/AudioUtils.ts

@@ -1,6 +1,6 @@
 import { createConsole } from "./Console.ts";
 
-const _console = createConsole("AudioUtils", { log: true });
+const _console = createConsole("AudioUtils", { log: false });
 
 export function float32ArrayToWav(
   audioData: Float32Array,