feat: add web support

README.md

@@ -30,6 +30,16 @@ Key:
 You might need to add your user to the `dialout` or, on Arch Linux, to the `uucp` group for the app to talk to the device. If your user is not in this group, you may get serial or permission errors.
 It is also highly recommended to either uninstall or disable ModemManager (`sudo systemctl disable --now modemmanager`) as many distros ship ModemManager and it may interfere with communication.
 
+#### Note for Web users:
+
+You need to pair your Chameleon first before it shows up on the connect page, click on the handshake icon and select the relevant serial devices.
+
+*Known issues*
+- Chameleon Lite's are displayed as Ultra's on the connect page (but are correct after connecting)
+> This is because the Web Serial API is quite limited with the [device information](https://developer.mozilla.org/en-US/docs/Web/API/SerialPort/getInfo) it returns as it only returns an usb vendor id & product id (which are the same for Ultra's & Lite's). So on the connect page any device will be displayed as an Ultra, after you connect to a specific device the correct device type will be detected by checking if the device supports reader mode (=Ultra) or not (=Lite)
+- key recovery is not supported (yet)
+- cannot download firmware due to CORS issue with nightly.link
+
 ## Contributing
 Contributions are welcome, most stuff that needs to be done can either be found in our [issues](https://github.com/GameTec-live/ChameleonUltraGUI/issues) or on the [Project board](https://github.com/users/GameTec-live/projects/2)
 

chameleonultragui/lib/bridge/chameleon.dart

@@ -343,12 +343,37 @@ class ChameleonCom {
   Future<int> getFirmwareVersion() async {
     var resp = await sendCmdSync(ChameleonCommand.getAppVersion, 0x00);
     if (resp!.data.length != 2) throw ("Invalid data length");
-    return (resp.data[1] << 8) | resp.data[0];
+    final result = (resp.data[1] << 8) | resp.data[0];
+    log.d("ChamelonCom.getFirmwareVersion: $result");
+    return result;
   }
 
   Future<String> getDeviceChipID() async {
     var resp = await sendCmdSync(ChameleonCommand.getDeviceChipID, 0x00);
-    return bytesToHex(resp!.data);
+    final result = bytesToHex(resp!.data);
+    log.d("ChamelonCom.getDeviceChipID: $result");
+    return result;
+  }
+
+  Future<bool> detectChameleonUltra() async {
+    // Check if device is a ChameleonUltra by trying to switch to reader mode,
+    // a ChameleonLite will return success on setting to reader but the
+    // actual device mode will always be emulator
+    var isReader = await isReaderDeviceMode();
+    if (isReader) {
+      return true;
+    }
+
+    await setReaderDeviceMode(true);
+
+    isReader = await isReaderDeviceMode();
+    if (isReader) {
+      // Reset device mode back to emulator
+      await setReaderDeviceMode(false);
+      return true;
+    }
+
+    return false;
   }
 
   Future<String> getDeviceBLEAddress() async {

chameleonultragui/lib/connector/serial_abstract.dart

@@ -20,6 +20,8 @@ class AbstractSerial {
     return false;
   }
 
+  Future pairDevices() async {} // For web only
+
   Future<List> availableDevices() async {
     return [];
   }

chameleonultragui/lib/connector/serial_android.dart

@@ -1,15 +1,15 @@
 import 'dart:async';
 import 'dart:typed_data';
 import 'package:chameleonultragui/connector/serial_abstract.dart';
-import 'package:chameleonultragui/connector/serial_ble.dart';
-import 'package:chameleonultragui/connector/serial_mobile.dart';
+import 'package:chameleonultragui/connector/serial_ble.dart' as ble;
+import 'package:chameleonultragui/connector/serial_mobile.dart' as mobile;
 import 'package:flutter/services.dart';
 import 'package:permission_handler/permission_handler.dart';
 
 // Class combines Android OTG and BLE serial
-class AndroidSerial extends AbstractSerial {
-  BLESerial bleSerial = BLESerial();
-  MobileSerial mobileSerial = MobileSerial();
+class SerialConnector extends AbstractSerial {
+  ble.SerialConnector bleSerial = ble.SerialConnector();
+  mobile.SerialConnector mobileSerial = mobile.SerialConnector();
 
   @override
   Future<bool> preformDisconnect() async {

chameleonultragui/lib/connector/serial_ble.dart

@@ -15,7 +15,7 @@ Uuid dfuUUID = Uuid.parse("FE59");
 Uuid dfuControl = Uuid.parse("8EC90001-F315-4F60-9FB8-838830DAEA50");
 Uuid dfuFirmware = Uuid.parse("8EC90002-F315-4F60-9FB8-838830DAEA50");
 
-class BLESerial extends AbstractSerial {
+class SerialConnector extends AbstractSerial {
   FlutterReactiveBle flutterReactiveBle = FlutterReactiveBle();
   QualifiedCharacteristic? txCharacteristic;
   QualifiedCharacteristic? rxCharacteristic;

chameleonultragui/lib/connector/serial_mobile.dart

@@ -6,7 +6,7 @@ import 'package:flutter/services.dart';
 import 'package:usb_serial/usb_serial.dart';
 
 // Class for Android Serial Communication
-class MobileSerial extends AbstractSerial {
+class SerialConnector extends AbstractSerial {
   Map<String, UsbDevice> deviceMap = {};
   List<Uint8List> messagePool = []; // TODO: Fix or rewrite on release
   UsbPort? port;

chameleonultragui/lib/connector/serial_native.dart

@@ -2,7 +2,7 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter_libserialport/flutter_libserialport.dart';
 import 'serial_abstract.dart';
 
-class NativeSerial extends AbstractSerial {
+class SerialConnector extends AbstractSerial {
   // Class for PC Serial Communication
   SerialPort? port;
   SerialPort? checkPort;

chameleonultragui/lib/connector/serial_stub.dart

@@ -0,0 +1,7 @@
+import 'serial_abstract.dart';
+
+class SerialConnector extends AbstractSerial {
+    SerialConnector() {
+        log.e("The serial stub class should not be used");
+  }
+}

chameleonultragui/lib/connector/serial_web.dart

@@ -0,0 +1,267 @@
+import 'dart:async';
+// ignore: avoid_web_libraries_in_flutter
+import 'dart:html';
+import 'dart:typed_data';
+import 'package:chameleonultragui/connector/serial_abstract.dart';
+import 'package:chameleonultragui/helpers/general.dart';
+import 'package:serial/serial.dart';
+
+class DeviceInfo {
+  final SerialPort port;
+  final SerialPortInfo info;
+  final ChameleonConnectType connection = ChameleonConnectType.usb;
+  ChameleonDevice _type = ChameleonDevice.ultra;
+
+  DeviceInfo(this.port, this.info);
+
+  get deviceName {
+    if (type == ChameleonDevice.ultra) {
+      return 'Ultra';
+    }
+    if (type == ChameleonDevice.lite) {
+      return 'Lite';
+    }
+
+    return 'Unknown';
+  }
+
+  ChameleonDevice get type {
+    return _type;
+  }
+
+  set type(ChameleonDevice dev) => {
+    _type = dev
+  };
+}
+
+// Class for WebUSB API Serial Communication
+class SerialConnector extends AbstractSerial {
+  Map<String, DeviceInfo> deviceMap = {};
+  List<Uint8List> messagePool = []; // TODO: Fix or rewrite on release
+  DeviceInfo? currentDevice;
+
+  ReadableStreamReader? reader;
+  bool keepReading = false;
+
+  @override
+  get device {
+    if (currentDevice != null) {
+      return currentDevice!.type;
+    }
+
+    return ChameleonDevice.none;
+  }
+
+  @override
+  get connectionType {
+    if (currentDevice != null) {
+      return currentDevice!.connection;
+    }
+
+    return ChameleonConnectType.none;
+  }
+
+  @override
+  Future<void> pairDevices() async {
+    try {
+      await window.navigator.serial.requestPort();
+    } catch (_) {
+      // ignore error
+    }
+  }
+
+  @override
+  Future<bool> preformDisconnect() async {
+    device = ChameleonDevice.none;
+    connectionType = ChameleonConnectType.none;
+    if (currentDevice != null) {
+      final readable = currentDevice!.port.readable;
+
+      if (readable.locked) {
+        if (reader != null) {
+          await reader!.cancel();
+          reader = null;
+        }
+
+        await readable.cancel();
+      }
+
+      await currentDevice!.port.close();
+
+      connected = false;
+      currentDevice = null;
+      return true;
+    }
+
+    connected = false; // For debug button
+    return false;
+  }
+
+  @override
+  Future<List> availableDevices() async {
+    device = ChameleonDevice.none;
+    connectionType = ChameleonConnectType.none;
+    deviceMap = {};
+
+    List output = [];
+
+    final pairedDevices = await window.navigator.serial.getPorts();
+    for (var deviceValue in pairedDevices) {
+      SerialPortInfo deviceInfo = deviceValue.getInfo();
+      // log.d('deviceInfo ${deviceInfo.hashCode} ${deviceInfo.usbVendorId} ${deviceInfo.usbProductId}');
+      if (deviceInfo.usbVendorId == 0x6868 || deviceInfo.usbVendorId == 0x1915) {
+        var portId = '${deviceInfo.usbVendorId}x${deviceInfo.usbProductId}';
+
+        deviceMap[portId] = DeviceInfo(deviceValue, deviceInfo);
+        output.add(portId);
+      }
+    }
+
+    return output;
+  }
+
+  @override
+  Future<List> availableChameleons(bool onlyDFU) async {
+    List output = [];
+
+    for (var devicePort in await availableDevices()) {
+      var device = deviceMap[devicePort];
+
+      if (device!.info.usbProductId == 1) { //}"Proxgrind") {
+        log.d("Found Chameleon ${device.deviceName}!");
+
+        if (device.info.usbVendorId == 0x1915) {
+          connectionType = ChameleonConnectType.dfu;
+          log.w("Chameleon is in DFU mode!");
+        }
+      }
+
+      if (onlyDFU) {
+        if (connectionType == ChameleonConnectType.dfu) {
+          output.add(
+              {'port': devicePort, 'device': device.type, 'type': connectionType});
+        }
+      } else {
+        output.add(
+            {'port': devicePort, 'device': device.type, 'type': connectionType});
+      }
+    }
+
+    return output;
+  }
+
+  @override
+  Future<bool> connectSpecific(devicePort) async {
+    await availableDevices();
+    connected = false;
+
+    if (deviceMap.containsKey(devicePort)) {
+      var deviceValue = deviceMap[devicePort] as DeviceInfo;
+      var serialPort = deviceValue.port;
+
+      try {
+        await serialPort.open(
+          baudRate: 115200,
+          dataBits: DataBits.eight,
+          stopBits: StopBits.one,
+          parity: Parity.none,
+        );
+
+        await serialPort.setSignals(
+          dataTerminalReady: true, // DTS
+          requestToSend: true, // RTS
+          // break: false, // Doesnt work
+        );
+      } catch (e) {
+        // ignore already connected/disconnected errors
+        var ignoreError = e.toString().contains('already');
+        if (!ignoreError) {
+          log.d('open port error: $e');
+          return false;
+        }
+      }
+
+      connected = true;
+      device = deviceValue.type;
+      currentDevice = deviceValue;
+
+      listen();
+
+      if (deviceValue.info.usbVendorId == 0x1915) {
+        connectionType = ChameleonConnectType.dfu;
+        log.w("Chameleon is in DFU mode!");
+      } else {
+        connectionType = ChameleonConnectType.usb;
+      }
+
+      return connected;
+    }
+    return false;
+  }
+
+  @override
+  Future<bool> write(Uint8List command, {bool firmware = false}) async {
+    try {
+      final writer = currentDevice!.port.writable.writer;
+
+      await writer.ready;
+      await writer.write(command);
+      await writer.close();
+
+      return true;
+    } catch (e) {
+      log.e('write error: $e');
+    }
+
+    return false;
+  }
+
+  Future listen () async {
+    final readable = currentDevice!.port.readable;
+    if (!readable.locked && reader == null) {
+      reader = currentDevice!.port.readable.reader;
+    }
+
+    keepReading = true;
+
+    while (connected && keepReading) {
+      try {
+        var result = await reader!.read();
+        if (result.done) {
+          keepReading = false;
+          // reader.cancel() has been called.
+          break;
+        }
+        // value is a Uint8Array.
+        messagePool.add(result.value);
+      } catch (e) {
+        log.e('read error: $e');
+        keepReading = false;
+      }
+    }
+
+    // Allow the serial port to be closed later.
+    reader!.releaseLock();
+  }
+
+  @override
+  Future<Uint8List> read(int length) async {
+    final completer = Completer<Uint8List>();
+    while (true) {
+      if (messagePool.isNotEmpty) {
+        var message = messagePool[0];
+        messagePool.removeWhere((item) => item == message);
+        completer.complete(message);
+        break;
+      }
+      await asyncSleep(100);
+    }
+
+    return completer.future;
+  }
+
+  @override
+  Future<void> finishRead() async {
+    messagePool = [];
+  }
+}