✨ Add Bluetooth auto mode support with command serialization

- Add readAutoMode() and setAutoMode() BLE functions
- Update fetchDeviceInfoBle() to poll auto mode state
- Enable onAutoModeToggle() for Bluetooth mode
- Fix race condition in sendCommand() by serializing BLE commands
- Add unit tests for new auto mode functions

Author: AndreMiras

src/hooks/useDeviceControl.ts

@@ -8,10 +8,12 @@ import { ErrorContext } from "@/context/error";
 import { useNetwork } from "@/context/network";
 import { TokenContext } from "@/context/token";
 import {
+  readAutoMode,
   readFan1Speed,
   readPowerLevel,
   readPowerState,
   readTemperature,
+  setAutoMode as setBtAutoMode,
   setFan1Speed as setBtFan1Speed,
   setPower as setBtPower,
   setPowerLevel as setBtPowerLevel,
@@ -151,17 +153,19 @@ export function useDeviceControl(
     if (!bleDeviceId || !isConnected) return;
 
     try {
-      const [power, temp, level, fan] = await Promise.all([
+      const [power, temp, level, fan, auto] = await Promise.all([
         readPowerState(bleDeviceId),
         readTemperature(bleDeviceId),
         readPowerLevel(bleDeviceId),
         readFan1Speed(bleDeviceId),
+        readAutoMode(bleDeviceId),
       ]);
 
       setPowerState(power);
       setTemperature(temp);
       setPowerLevelState(level);
       setFan1SpeedState(fan);
+      setIsAutoState(auto);
       setLastUpdated(new Date());
       setLoading(false);
     } catch (error) {
@@ -304,7 +308,11 @@ export function useDeviceControl(
     const previousAuto = isAuto;
     setIsAutoState(enabled);
     try {
-      await withRetry(token!, (t) => setAuto(t, mac!, enabled));
+      if (connectionMode === "ble" && bleDeviceId && isConnected) {
+        await setBtAutoMode(bleDeviceId, enabled);
+      } else {
+        await withRetry(token!, (t) => setAuto(t, mac!, enabled));
+      }
     } catch (error) {
       console.error(error);
       addError({

src/test/__mocks__/capacitor-bluetooth-le.ts

@@ -1,5 +1,8 @@
 import { vi } from "vitest";
 
+// Store the notification callback so tests can trigger responses
+let notificationCallback: ((value: DataView) => void) | null = null;
+
 export const BleClient = {
   initialize: vi.fn().mockResolvedValue(undefined),
   requestDevice: vi.fn().mockResolvedValue({
@@ -14,5 +17,37 @@ export const BleClient = {
   disconnect: vi.fn().mockResolvedValue(undefined),
   getServices: vi.fn().mockResolvedValue([]),
   read: vi.fn().mockResolvedValue(new DataView(new ArrayBuffer(0))),
-  write: vi.fn().mockResolvedValue(undefined),
+  write: vi.fn().mockImplementation(async () => {
+    // Simulate device response after write
+    if (notificationCallback) {
+      // Return a success response (non-error, with data)
+      const response = new Uint8Array([0x01, 0x03, 0x02, 0x00, 0x01]);
+      notificationCallback(new DataView(response.buffer));
+    }
+  }),
+  startNotifications: vi
+    .fn()
+    .mockImplementation(
+      async (
+        _deviceId: string,
+        _serviceUUID: string,
+        _charUUID: string,
+        callback: (value: DataView) => void,
+      ) => {
+        notificationCallback = callback;
+      },
+    ),
+  stopNotifications: vi.fn().mockResolvedValue(undefined),
+};
+
+// Helper to trigger a custom response in tests
+export const triggerNotification = (data: Uint8Array) => {
+  if (notificationCallback) {
+    notificationCallback(new DataView(data.buffer));
+  }
+};
+
+// Helper to reset the notification callback
+export const resetNotificationCallback = () => {
+  notificationCallback = null;
 };

src/test/__mocks__/edilkamin-bluetooth.ts

@@ -13,3 +13,93 @@ export interface DiscoveredDevice {
   name: string;
   rssi?: number;
 }
+
+// BLE protocol layer exports
+export const SERVICE_UUID = "0000abf0-0000-1000-8000-00805f9b34fb";
+export const NOTIFY_CHARACTERISTIC_UUID =
+  "0000abf2-0000-1000-8000-00805f9b34fb";
+export const WRITE_CHARACTERISTIC_UUID = "0000abf1-0000-1000-8000-00805f9b34fb";
+
+export const readCommands = {
+  power: new Uint8Array([0x01, 0x03, 0x00, 0x00, 0x00, 0x01]),
+  temperature: new Uint8Array([0x01, 0x03, 0x00, 0x01, 0x00, 0x01]),
+  powerLevel: new Uint8Array([0x01, 0x03, 0x00, 0x02, 0x00, 0x01]),
+  fan1Speed: new Uint8Array([0x01, 0x03, 0x00, 0x03, 0x00, 0x01]),
+  autoMode: new Uint8Array([0x01, 0x03, 0x00, 0x10, 0x00, 0x01]),
+};
+
+export const writeCommands = {
+  setPower: (on: boolean) =>
+    new Uint8Array([0x01, 0x06, 0x00, 0x00, 0x00, on ? 0x01 : 0x00]),
+  setTemperature: (temp: number) =>
+    new Uint8Array([0x01, 0x06, 0x00, 0x01, 0x00, temp * 2]),
+  setPowerLevel: (level: number) =>
+    new Uint8Array([0x01, 0x06, 0x00, 0x02, 0x00, level]),
+  setFan1Speed: (speed: number) =>
+    new Uint8Array([0x01, 0x06, 0x00, 0x03, 0x00, speed]),
+  setAutoMode: (enabled: boolean) =>
+    new Uint8Array([0x01, 0x06, 0x00, 0x10, 0x00, enabled ? 0x01 : 0x00]),
+};
+
+export interface ModbusResponse {
+  isError: boolean;
+  data: Uint8Array;
+}
+
+export const parsers = {
+  // Boolean values are typically in the last byte of a 2-byte register value
+  boolean: (response: ModbusResponse) => {
+    // If 2 bytes (register value), check last byte; otherwise check first
+    if (response.data.length >= 2) {
+      return response.data[1] === 1;
+    }
+    return response.data[0] === 1;
+  },
+  number: (response: ModbusResponse) => {
+    // If 2 bytes, combine as 16-bit value; otherwise return single byte
+    if (response.data.length >= 2) {
+      return (response.data[0] << 8) | response.data[1];
+    }
+    return response.data[0];
+  },
+  temperature: (response: ModbusResponse) => {
+    // Temperature is stored as degrees * 2
+    if (response.data.length >= 2) {
+      return ((response.data[0] << 8) | response.data[1]) / 2;
+    }
+    return response.data[0] / 2;
+  },
+};
+
+export const createPacket = vi.fn(async (cmd: Uint8Array) => cmd);
+export const parseResponse = vi.fn((data: Uint8Array): ModbusResponse => {
+  // Check if function code has error bit set (0x80)
+  // Modbus error responses have function code with high bit set
+  const functionCode = data[1];
+  const isError = (functionCode & 0x80) !== 0;
+
+  if (isError) {
+    // Error response: data[2] is the error code
+    return {
+      isError: true,
+      data: new Uint8Array([data[2]]),
+    };
+  }
+
+  // Normal response: for read responses, data starts at byte 3
+  // For function code 0x03 (read holding registers): [addr, func, byteCount, data...]
+  if (functionCode === 0x03) {
+    const byteCount = data[2];
+    // Extract data bytes (typically 2 bytes for single register)
+    return {
+      isError: false,
+      data: data.slice(3, 3 + byteCount),
+    };
+  }
+
+  // For function code 0x06 (write single register): echo response
+  return {
+    isError: false,
+    data: new Uint8Array([]),
+  };
+});

src/test/setup.ts

@@ -34,10 +34,12 @@ vi.mock("../utils/bluetooth", () => ({
   readTemperature: vi.fn(),
   readPowerLevel: vi.fn(),
   readFan1Speed: vi.fn(),
+  readAutoMode: vi.fn(),
   setPower: vi.fn(),
   setTemperature: vi.fn(),
   setPowerLevel: vi.fn(),
   setFan1Speed: vi.fn(),
+  setAutoMode: vi.fn(),
   isBluetoothEnabled: vi.fn().mockResolvedValue(true),
   requestEnableBluetooth: vi.fn(),
   // scanForDevices returns empty array by default; tests can spy and override

src/utils/bluetooth.test.ts

@@ -1,5 +1,11 @@
 import { Capacitor } from "@capacitor/core";
-import { BleClient } from "@capacitor-community/bluetooth-le";
+import {
+  BleClient,
+  // @ts-expect-error - Mock-only exports not in type definitions
+  resetNotificationCallback,
+  // @ts-expect-error - Mock-only exports not in type definitions
+  triggerNotification,
+} from "@capacitor-community/bluetooth-le";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 // Unmock the bluetooth module (overrides the global mock in setup.ts)
@@ -8,10 +14,13 @@ vi.unmock("@/utils/bluetooth");
 vi.unmock("../utils/bluetooth");
 
 import {
+  connectToDevice,
   isBluetoothEnabled,
   isBluetoothSupported,
+  readAutoMode,
   requestEnableBluetooth,
   scanForDevices,
+  setAutoMode,
 } from "./bluetooth";
 
 // Mock Capacitor
@@ -121,4 +130,87 @@ describe("bluetooth utility", () => {
       expect(BleClient.requestEnable).toHaveBeenCalled();
     });
   });
+
+  describe("readAutoMode", () => {
+    beforeEach(async () => {
+      vi.mocked(Capacitor.isNativePlatform).mockReturnValue(true);
+      resetNotificationCallback();
+      // Connect first to set up notification handler
+      await connectToDevice("test-device-id");
+    });
+
+    it("returns true when device is in auto mode", async () => {
+      // Mock BleClient.write to return auto mode enabled response
+      vi.mocked(BleClient.write).mockImplementationOnce(async () => {
+        // Response format: [slaveAddr, funcCode, byteCount, dataHigh, dataLow]
+        // For boolean true: data[0] = 1
+        const response = new Uint8Array([0x01, 0x03, 0x02, 0x00, 0x01]);
+        triggerNotification(response);
+      });
+
+      const result = await readAutoMode("test-device-id");
+
+      expect(BleClient.write).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it("returns false when device is in manual mode", async () => {
+      // Mock BleClient.write to return auto mode disabled response
+      vi.mocked(BleClient.write).mockImplementationOnce(async () => {
+        // For boolean false: data[0] = 0
+        const response = new Uint8Array([0x01, 0x03, 0x02, 0x00, 0x00]);
+        triggerNotification(response);
+      });
+
+      const result = await readAutoMode("test-device-id");
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("setAutoMode", () => {
+    beforeEach(async () => {
+      vi.mocked(Capacitor.isNativePlatform).mockReturnValue(true);
+      resetNotificationCallback();
+      // Connect first to set up notification handler
+      await connectToDevice("test-device-id");
+    });
+
+    it("sends correct command to enable auto mode", async () => {
+      // Mock successful write response
+      vi.mocked(BleClient.write).mockImplementationOnce(async () => {
+        const response = new Uint8Array([0x01, 0x06, 0x00, 0x10, 0x00, 0x01]);
+        triggerNotification(response);
+      });
+
+      await setAutoMode("test-device-id", true);
+
+      expect(BleClient.write).toHaveBeenCalled();
+    });
+
+    it("sends correct command to disable auto mode", async () => {
+      // Mock successful write response
+      vi.mocked(BleClient.write).mockImplementationOnce(async () => {
+        const response = new Uint8Array([0x01, 0x06, 0x00, 0x10, 0x00, 0x00]);
+        triggerNotification(response);
+      });
+
+      await setAutoMode("test-device-id", false);
+
+      expect(BleClient.write).toHaveBeenCalled();
+    });
+
+    it("throws error when command fails", async () => {
+      // Mock error response (isError = true when function code has high bit set)
+      vi.mocked(BleClient.write).mockImplementationOnce(async () => {
+        // Error response: function code 0x86 (0x06 | 0x80), error code 1
+        const response = new Uint8Array([0x01, 0x86, 0x01]);
+        triggerNotification(response);
+      });
+
+      await expect(setAutoMode("test-device-id", true)).rejects.toThrow(
+        "Failed to set auto mode: error code 1",
+      );
+    });
+  });
 });