brilliantsole 0.0.27 → 0.0.29

package/src/TfliteManager.ts

@@ -8,6 +8,7 @@ import { parseTimestamp } from "./utils/MathUtils.ts";
 import { SensorType } from "./sensor/SensorDataManager.ts";
 import Device, { SendMessageCallback } from "./Device.ts";
 import autoBind from "auto-bind";
+import { FileConfiguration as BaseFileConfiguration } from "./FileTransferManager.ts";
 
 const _console = createConsole("TfliteManager", { log: false });
 
@@ -34,6 +35,17 @@ export type TfliteMessageType = (typeof TfliteMessageTypes)[number];
 export const TfliteEventTypes = TfliteMessageTypes;
 export type TfliteEventType = (typeof TfliteEventTypes)[number];
 
+export const RequiredTfliteMessageTypes: TfliteMessageType[] = [
+  "getTfliteName",
+  "getTfliteTask",
+  "getTfliteSampleRate",
+  "getTfliteSensorTypes",
+  "tfliteIsReady",
+  "getTfliteCaptureDelay",
+  "getTfliteThreshold",
+  "getTfliteInferencingEnabled",
+];
+
 export const TfliteTasks = ["classification", "regression"] as const;
 export type TfliteTask = (typeof TfliteTasks)[number];
 
@@ -54,14 +66,36 @@ export interface TfliteInference {
   values: number[];
   maxValue?: number;
   maxIndex?: number;
+  maxClass?: string;
+  classValues?: { [key: string]: number };
 }
 
-export type TfliteEventDispatcher = EventDispatcher<Device, TfliteEventType, TfliteEventMessages>;
+export type TfliteEventDispatcher = EventDispatcher<
+  Device,
+  TfliteEventType,
+  TfliteEventMessages
+>;
 export type SendTfliteMessageCallback = SendMessageCallback<TfliteMessageType>;
 
-export const TfliteSensorTypes: SensorType[] = ["pressure", "linearAcceleration", "gyroscope", "magnetometer"] as const;
+export const TfliteSensorTypes = [
+  "pressure",
+  "linearAcceleration",
+  "gyroscope",
+  "magnetometer",
+] as const satisfies readonly SensorType[];
 export type TfliteSensorType = (typeof TfliteSensorTypes)[number];
 
+export interface TfliteFileConfiguration extends BaseFileConfiguration {
+  type: "tflite";
+  name: string;
+  sensorTypes: TfliteSensorType[];
+  task: TfliteTask;
+  sampleRate: number;
+  captureDelay?: number;
+  threshold?: number;
+  classes?: string[];
+}
+
 class TfliteManager {
   constructor() {
     autoBind(this);
@@ -73,7 +107,10 @@ class TfliteManager {
     _console.assertEnumWithError(task, TfliteTasks);
   }
   #assertValidTaskEnum(taskEnum: number) {
-    _console.assertWithError(taskEnum in TfliteTasks, `invalid taskEnum ${taskEnum}`);
+    _console.assertWithError(
+      taskEnum in TfliteTasks,
+      `invalid taskEnum ${taskEnum}`
+    );
   }
 
   eventDispatcher!: TfliteEventDispatcher;
@@ -116,7 +153,10 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteName");
 
     const setNameData = textEncoder.encode(newName);
-    this.sendMessage([{ type: "setTfliteName", data: setNameData.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteName", data: setNameData.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -147,7 +187,10 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteTask");
 
     const taskEnum = TfliteTasks.indexOf(newTask);
-    this.sendMessage([{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteTask", data: Uint8Array.from([taskEnum]).buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -164,7 +207,9 @@ class TfliteManager {
   #updateSampleRate(sampleRate: number) {
     _console.log({ sampleRate });
     this.#sampleRate = sampleRate;
-    this.#dispatchEvent("getTfliteSampleRate", { tfliteSampleRate: sampleRate });
+    this.#dispatchEvent("getTfliteSampleRate", {
+      tfliteSampleRate: sampleRate,
+    });
   }
   async setSampleRate(newSampleRate: number, sendImmediately?: boolean) {
     _console.assertTypeWithError(newSampleRate, "number");
@@ -182,40 +227,56 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(2));
     dataView.setUint16(0, newSampleRate, true);
-    this.sendMessage([{ type: "setTfliteSampleRate", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteSampleRate", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
 
   static AssertValidSensorType(sensorType: SensorType) {
     SensorDataManager.AssertValidSensorType(sensorType);
-    _console.assertWithError(TfliteSensorTypes.includes(sensorType), `invalid tflite sensorType "${sensorType}"`);
+    const tfliteSensorType = sensorType as TfliteSensorType;
+    _console.assertWithError(
+      TfliteSensorTypes.includes(tfliteSensorType),
+      `invalid tflite sensorType "${sensorType}"`
+    );
   }
 
-  #sensorTypes: SensorType[] = [];
+  #sensorTypes: TfliteSensorType[] = [];
   get sensorTypes() {
     return this.#sensorTypes.slice();
   }
   #parseSensorTypes(dataView: DataView) {
     _console.log("parseSensorTypes", dataView);
-    const sensorTypes: SensorType[] = [];
+    const sensorTypes: TfliteSensorType[] = [];
     for (let index = 0; index < dataView.byteLength; index++) {
       const sensorTypeEnum = dataView.getUint8(index);
-      const sensorType = SensorTypes[sensorTypeEnum];
+      const sensorType = SensorTypes[sensorTypeEnum] as TfliteSensorType;
       if (sensorType) {
-        sensorTypes.push(sensorType);
+        if (TfliteSensorTypes.includes(sensorType)) {
+          sensorTypes.push(sensorType);
+        } else {
+          _console.error(`invalid tfliteSensorType ${sensorType}`);
+        }
       } else {
         _console.error(`invalid sensorTypeEnum ${sensorTypeEnum}`);
       }
     }
     this.#updateSensorTypes(sensorTypes);
   }
-  #updateSensorTypes(sensorTypes: SensorType[]) {
+  #updateSensorTypes(sensorTypes: TfliteSensorType[]) {
     _console.log({ sensorTypes });
     this.#sensorTypes = sensorTypes;
-    this.#dispatchEvent("getTfliteSensorTypes", { tfliteSensorTypes: sensorTypes });
+    this.#dispatchEvent("getTfliteSensorTypes", {
+      tfliteSensorTypes: sensorTypes,
+    });
   }
-  async setSensorTypes(newSensorTypes: SensorType[], sendImmediately?: boolean) {
+  async setSensorTypes(
+    newSensorTypes: SensorType[],
+    sendImmediately?: boolean
+  ) {
     newSensorTypes.forEach((sensorType) => {
       TfliteManager.AssertValidSensorType(sensorType);
     });
@@ -223,10 +284,17 @@ class TfliteManager {
     const promise = this.waitForEvent("getTfliteSensorTypes");
 
     newSensorTypes = arrayWithoutDuplicates(newSensorTypes);
-    const newSensorTypeEnums = newSensorTypes.map((sensorType) => SensorTypes.indexOf(sensorType)).sort();
+    const newSensorTypeEnums = newSensorTypes
+      .map((sensorType) => SensorTypes.indexOf(sensorType))
+      .sort();
     _console.log(newSensorTypes, newSensorTypeEnums);
     this.sendMessage(
-      [{ type: "setTfliteSensorTypes", data: Uint8Array.from(newSensorTypeEnums).buffer }],
+      [
+        {
+          type: "setTfliteSensorTypes",
+          data: Uint8Array.from(newSensorTypeEnums).buffer,
+        },
+      ],
       sendImmediately
     );
 
@@ -263,7 +331,9 @@ class TfliteManager {
   #updateCaptueDelay(captureDelay: number) {
     _console.log({ captureDelay });
     this.#captureDelay = captureDelay;
-    this.#dispatchEvent("getTfliteCaptureDelay", { tfliteCaptureDelay: captureDelay });
+    this.#dispatchEvent("getTfliteCaptureDelay", {
+      tfliteCaptureDelay: captureDelay,
+    });
   }
   async setCaptureDelay(newCaptureDelay: number, sendImmediately: boolean) {
     _console.assertTypeWithError(newCaptureDelay, "number");
@@ -276,7 +346,10 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(2));
     dataView.setUint16(0, newCaptureDelay, true);
-    this.sendMessage([{ type: "setTfliteCaptureDelay", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteCaptureDelay", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -297,7 +370,10 @@ class TfliteManager {
   }
   async setThreshold(newThreshold: number, sendImmediately: boolean) {
     _console.assertTypeWithError(newThreshold, "number");
-    _console.assertWithError(newThreshold >= 0, `threshold must be positive (got ${newThreshold})`);
+    _console.assertWithError(
+      newThreshold >= 0,
+      `threshold must be positive (got ${newThreshold})`
+    );
     if (this.#threshold == newThreshold) {
       _console.log(`redundant threshold assignment ${newThreshold}`);
       return;
@@ -307,7 +383,10 @@ class TfliteManager {
 
     const dataView = new DataView(new ArrayBuffer(4));
     dataView.setFloat32(0, newThreshold, true);
-    this.sendMessage([{ type: "setTfliteThreshold", data: dataView.buffer }], sendImmediately);
+    this.sendMessage(
+      [{ type: "setTfliteThreshold", data: dataView.buffer }],
+      sendImmediately
+    );
 
     await promise;
   }
@@ -324,16 +403,23 @@ class TfliteManager {
   #updateInferencingEnabled(inferencingEnabled: boolean) {
     _console.log({ inferencingEnabled });
     this.#inferencingEnabled = inferencingEnabled;
-    this.#dispatchEvent("getTfliteInferencingEnabled", { tfliteInferencingEnabled: inferencingEnabled });
+    this.#dispatchEvent("getTfliteInferencingEnabled", {
+      tfliteInferencingEnabled: inferencingEnabled,
+    });
   }
-  async setInferencingEnabled(newInferencingEnabled: boolean, sendImmediately: boolean = true) {
+  async setInferencingEnabled(
+    newInferencingEnabled: boolean,
+    sendImmediately: boolean = true
+  ) {
     _console.assertTypeWithError(newInferencingEnabled, "boolean");
     if (!newInferencingEnabled && !this.isReady) {
       return;
     }
     this.#assertIsReady();
     if (this.#inferencingEnabled == newInferencingEnabled) {
-      _console.log(`redundant inferencingEnabled assignment ${newInferencingEnabled}`);
+      _console.log(
+        `redundant inferencingEnabled assignment ${newInferencingEnabled}`
+      );
       return;
     }
 
@@ -375,7 +461,11 @@ class TfliteManager {
     _console.log({ timestamp });
 
     const values: number[] = [];
-    for (let index = 0, byteOffset = 2; byteOffset < dataView.byteLength; index++, byteOffset += 4) {
+    for (
+      let index = 0, byteOffset = 2;
+      byteOffset < dataView.byteLength;
+      index++, byteOffset += 4
+    ) {
       const value = dataView.getFloat32(byteOffset, true);
       values.push(value);
     }
@@ -398,6 +488,15 @@ class TfliteManager {
       _console.log({ maxIndex, maxValue });
       inference.maxIndex = maxIndex;
       inference.maxValue = maxValue;
+      if (this.#configuration?.classes) {
+        const { classes } = this.#configuration;
+        inference.maxClass = classes[maxIndex];
+        inference.classValues = {};
+        values.forEach((value, index) => {
+          const key = classes[index];
+          inference.classValues![key] = value;
+        });
+      }
     }
 
     this.#dispatchEvent("tfliteInference", { tfliteInference: inference });
@@ -445,6 +544,53 @@ class TfliteManager {
         throw Error(`uncaught messageType ${messageType}`);
     }
   }
+
+  #configuration?: TfliteFileConfiguration;
+  get configuration() {
+    return this.#configuration;
+  }
+  sendConfiguration(
+    configuration: TfliteFileConfiguration,
+    sendImmediately?: boolean
+  ) {
+    if (configuration == this.#configuration) {
+      _console.log("redundant tflite configuration assignment");
+      return;
+    }
+    this.#configuration = configuration;
+    _console.log("assigned new tflite configuration", this.configuration);
+    if (!this.configuration) {
+      return;
+    }
+    const { name, task, captureDelay, sampleRate, threshold, sensorTypes } =
+      this.configuration;
+    this.setName(name, false);
+    this.setTask(task, false);
+    if (captureDelay != undefined) {
+      this.setCaptureDelay(captureDelay, false);
+    }
+    this.setSampleRate(sampleRate, false);
+    if (threshold != undefined) {
+      this.setThreshold(threshold, false);
+    }
+    this.setSensorTypes(sensorTypes, sendImmediately);
+  }
+
+  clear() {
+    this.#configuration = undefined;
+    this.#inferencingEnabled = false;
+    this.#sensorTypes = [];
+    this.#sampleRate = 0;
+    this.#isReady = false;
+  }
+
+  requestRequiredInformation() {
+    _console.log("requesting required tflite information");
+    const messages = RequiredTfliteMessageTypes.map((messageType) => ({
+      type: messageType,
+    }));
+    this.sendMessage(messages, false);
+  }
 }
 
 export default TfliteManager;

package/src/WifiManager.ts

@@ -0,0 +1,323 @@
+import Device, { SendMessageCallback } from "./Device.ts";
+import { createConsole } from "./utils/Console.ts";
+import { isInNode } from "./utils/environment.ts";
+import EventDispatcher from "./utils/EventDispatcher.ts";
+import { textDecoder, textEncoder } from "./utils/Text.ts";
+import autoBind from "auto-bind";
+
+const _console = createConsole("WifiManager", { log: false });
+
+export const MinWifiSSIDLength = 1;
+export const MaxWifiSSIDLength = 32;
+
+export const MinWifiPasswordLength = 8;
+export const MaxWifiPasswordLength = 64;
+
+export const WifiMessageTypes = [
+  "isWifiAvailable",
+  "getWifiSSID",
+  "setWifiSSID",
+  "getWifiPassword",
+  "setWifiPassword",
+  "getWifiConnectionEnabled",
+  "setWifiConnectionEnabled",
+  "isWifiConnected",
+  "ipAddress",
+  "isWifiSecure",
+] as const;
+export type WifiMessageType = (typeof WifiMessageTypes)[number];
+
+export const RequiredWifiMessageTypes: WifiMessageType[] = [
+  "getWifiSSID",
+  "getWifiPassword",
+  "getWifiConnectionEnabled",
+  "isWifiConnected",
+  "ipAddress",
+  "isWifiSecure",
+] as const;
+
+export const WifiEventTypes = WifiMessageTypes;
+export type WifiEventType = (typeof WifiEventTypes)[number];
+
+export interface WifiEventMessages {
+  isWifiAvailable: { isWifiAvailable: boolean };
+  getWifiSSID: { wifiSSID: string };
+  getWifiPassword: { wifiPassword: string };
+  getEnableWifiConnection: { wifiConnectionEnabled: boolean };
+  isWifiConnected: { isWifiConnected: boolean };
+  ipAddress: { ipAddress?: string };
+}
+
+export type WifiEventDispatcher = EventDispatcher<
+  Device,
+  WifiEventType,
+  WifiEventMessages
+>;
+export type SendWifiMessageCallback = SendMessageCallback<WifiMessageType>;
+
+class WifiManager {
+  constructor() {
+    autoBind(this);
+  }
+
+  sendMessage!: SendWifiMessageCallback;
+
+  eventDispatcher!: WifiEventDispatcher;
+  get #dispatchEvent() {
+    return this.eventDispatcher.dispatchEvent;
+  }
+  get waitForEvent() {
+    return this.eventDispatcher.waitForEvent;
+  }
+
+  requestRequiredInformation() {
+    _console.log("requesting required wifi information");
+    const messages = RequiredWifiMessageTypes.map((messageType) => ({
+      type: messageType,
+    }));
+    this.sendMessage(messages, false);
+  }
+
+  // PROPERTIES
+
+  #isWifiAvailable = false;
+  get isWifiAvailable() {
+    return this.#isWifiAvailable;
+  }
+  #updateIsWifiAvailable(updatedIsWifiAvailable: boolean) {
+    _console.assertTypeWithError(updatedIsWifiAvailable, "boolean");
+    this.#isWifiAvailable = updatedIsWifiAvailable;
+    _console.log({ isWifiAvailable: this.#isWifiAvailable });
+    this.#dispatchEvent("isWifiAvailable", {
+      isWifiAvailable: this.#isWifiAvailable,
+    });
+  }
+
+  #assertWifiIsAvailable() {
+    _console.assertWithError(this.#isWifiAvailable, "wifi is not available");
+  }
+
+  // WIFI SSID
+  #wifiSSID = "";
+  get wifiSSID() {
+    return this.#wifiSSID;
+  }
+
+  #updateWifiSSID(updatedWifiSSID: string) {
+    _console.assertTypeWithError(updatedWifiSSID, "string");
+    this.#wifiSSID = updatedWifiSSID;
+    _console.log({ wifiSSID: this.#wifiSSID });
+    this.#dispatchEvent("getWifiSSID", { wifiSSID: this.#wifiSSID });
+  }
+  async setWifiSSID(newWifiSSID: string) {
+    this.#assertWifiIsAvailable();
+    if (this.#wifiConnectionEnabled) {
+      _console.error("cannot change ssid while wifi connection is enabled");
+      return;
+    }
+    _console.assertTypeWithError(newWifiSSID, "string");
+    _console.assertRangeWithError(
+      "wifiSSID",
+      newWifiSSID.length,
+      MinWifiSSIDLength,
+      MaxWifiSSIDLength
+    );
+
+    const setWifiSSIDData = textEncoder.encode(newWifiSSID);
+    _console.log({ setWifiSSIDData });
+
+    const promise = this.waitForEvent("getWifiSSID");
+    this.sendMessage([{ type: "setWifiSSID", data: setWifiSSIDData.buffer }]);
+    await promise;
+  }
+
+  // WIFI PASSWORD
+  #wifiPassword = "";
+  get wifiPassword() {
+    return this.#wifiPassword;
+  }
+
+  #updateWifiPassword(updatedWifiPassword: string) {
+    _console.assertTypeWithError(updatedWifiPassword, "string");
+    this.#wifiPassword = updatedWifiPassword;
+    _console.log({ wifiPassword: this.#wifiPassword });
+    this.#dispatchEvent("getWifiPassword", {
+      wifiPassword: this.#wifiPassword,
+    });
+  }
+  async setWifiPassword(newWifiPassword: string) {
+    this.#assertWifiIsAvailable();
+    if (this.#wifiConnectionEnabled) {
+      _console.error("cannot change password while wifi connection is enabled");
+      return;
+    }
+    _console.assertTypeWithError(newWifiPassword, "string");
+    if (newWifiPassword.length > 0) {
+      _console.assertRangeWithError(
+        "wifiPassword",
+        newWifiPassword.length,
+        MinWifiPasswordLength,
+        MaxWifiPasswordLength
+      );
+    }
+
+    const setWifiPasswordData = textEncoder.encode(newWifiPassword);
+    _console.log({ setWifiPasswordData });
+
+    const promise = this.waitForEvent("getWifiPassword");
+    this.sendMessage([
+      { type: "setWifiPassword", data: setWifiPasswordData.buffer },
+    ]);
+    await promise;
+  }
+
+  // ENABLE WIFI CONNECTION
+  #wifiConnectionEnabled!: boolean;
+  get wifiConnectionEnabled() {
+    return this.#wifiConnectionEnabled;
+  }
+  #updateWifiConnectionEnabled(wifiConnectionEnabled: boolean) {
+    _console.log({ wifiConnectionEnabled });
+    this.#wifiConnectionEnabled = wifiConnectionEnabled;
+    this.#dispatchEvent("getWifiConnectionEnabled", {
+      wifiConnectionEnabled: wifiConnectionEnabled,
+    });
+  }
+  async setWifiConnectionEnabled(
+    newWifiConnectionEnabled: boolean,
+    sendImmediately: boolean = true
+  ) {
+    this.#assertWifiIsAvailable();
+    _console.assertTypeWithError(newWifiConnectionEnabled, "boolean");
+    if (this.#wifiConnectionEnabled == newWifiConnectionEnabled) {
+      _console.log(
+        `redundant wifiConnectionEnabled assignment ${newWifiConnectionEnabled}`
+      );
+      return;
+    }
+
+    const promise = this.waitForEvent("getWifiConnectionEnabled");
+    this.sendMessage(
+      [
+        {
+          type: "setWifiConnectionEnabled",
+          data: Uint8Array.from([Number(newWifiConnectionEnabled)]).buffer,
+        },
+      ],
+      sendImmediately
+    );
+    await promise;
+  }
+  async toggleWifiConnection() {
+    return this.setWifiConnectionEnabled(!this.wifiConnectionEnabled);
+  }
+  async enableWifiConnection() {
+    return this.setWifiConnectionEnabled(true);
+  }
+  async disableWifiConnection() {
+    return this.setWifiConnectionEnabled(false);
+  }
+
+  // IS WIFI CONNECTED
+  #isWifiConnected = false;
+  get isWifiConnected() {
+    return this.#isWifiConnected;
+  }
+  #updateIsWifiConnected(updatedIsWifiConnected: boolean) {
+    _console.assertTypeWithError(updatedIsWifiConnected, "boolean");
+    this.#isWifiConnected = updatedIsWifiConnected;
+    _console.log({ isWifiConnected: this.#isWifiConnected });
+    this.#dispatchEvent("isWifiConnected", {
+      isWifiConnected: this.#isWifiConnected,
+    });
+  }
+
+  // IP ADDRESS
+  #ipAddress?: string;
+  get ipAddress() {
+    return this.#ipAddress;
+  }
+
+  #updateIpAddress(updatedIpAddress?: string) {
+    this.#ipAddress = updatedIpAddress;
+    _console.log({ ipAddress: this.#ipAddress });
+    this.#dispatchEvent("ipAddress", {
+      ipAddress: this.#ipAddress,
+    });
+  }
+
+  // IS WIFI SECURE
+  #isWifiSecure = false;
+  get isWifiSecure() {
+    return this.#isWifiSecure;
+  }
+  #updateIsWifiSecure(updatedIsWifiSecure: boolean) {
+    _console.assertTypeWithError(updatedIsWifiSecure, "boolean");
+    this.#isWifiSecure = updatedIsWifiSecure;
+    _console.log({ isWifiSecure: this.#isWifiSecure });
+    this.#dispatchEvent("isWifiSecure", {
+      isWifiSecure: this.#isWifiSecure,
+    });
+  }
+
+  // MESSAGE
+  parseMessage(messageType: WifiMessageType, dataView: DataView) {
+    _console.log({ messageType });
+
+    switch (messageType) {
+      case "isWifiAvailable":
+        const isWifiAvailable = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiAvailable });
+        this.#updateIsWifiAvailable(isWifiAvailable);
+        break;
+      case "getWifiSSID":
+      case "setWifiSSID":
+        const ssid = textDecoder.decode(dataView.buffer);
+        _console.log({ ssid });
+        this.#updateWifiSSID(ssid);
+        break;
+      case "getWifiPassword":
+      case "setWifiPassword":
+        const password = textDecoder.decode(dataView.buffer);
+        _console.log({ password });
+        this.#updateWifiPassword(password);
+        break;
+      case "getWifiConnectionEnabled":
+      case "setWifiConnectionEnabled":
+        const enableWifiConnection = Boolean(dataView.getUint8(0));
+        _console.log({ enableWifiConnection });
+        this.#updateWifiConnectionEnabled(enableWifiConnection);
+        break;
+      case "isWifiConnected":
+        const isWifiConnected = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiConnected });
+        this.#updateIsWifiConnected(isWifiConnected);
+        break;
+      case "ipAddress":
+        let ipAddress: string | undefined = undefined;
+        if (dataView.byteLength == 4) {
+          ipAddress = new Uint8Array(dataView.buffer.slice(0, 4)).join(".");
+        }
+        _console.log({ ipAddress });
+        this.#updateIpAddress(ipAddress);
+        break;
+      case "isWifiSecure":
+        const isWifiSecure = Boolean(dataView.getUint8(0));
+        _console.log({ isWifiSecure });
+        this.#updateIsWifiSecure(isWifiSecure);
+        break;
+      default:
+        throw Error(`uncaught messageType ${messageType}`);
+    }
+  }
+
+  clear() {
+    this.#wifiSSID = "";
+    this.#wifiPassword = "";
+    this.#ipAddress = "";
+    this.#isWifiConnected = false;
+    this.#isWifiAvailable = false;
+  }
+}
+
+export default WifiManager;