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*
+- Downloading firmware assets requires the use of a CORS proxy. This project provides one but you can also set one yourself
+- On the connect page there is no indication if the connected device is a Chameleon Ultra or Lite. After connecting to a device the correct type is displayed
+> 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 just Chameleon, after you connect to a specific device the correct device type will be detected
+- blackside key recovery is not supported (yet)
+
 ## 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

@@ -45,10 +45,10 @@ enum ChameleonCommand {
   factoryReset(1020), // WARNING: ERASES ALL
 
   // button config
-  getButtonPressConfig(1026),
-  setButtonPressConfig(1027),
-  getLongButtonPressConfig(1028),
-  setLongButtonPressConfig(1029),
+  getButtonConfigConfig(1026),
+  setButtonConfigConfig(1027),
+  getLongButtonConfigConfig(1028),
+  setLongButtonConfigConfig(1029),
 
   // hf reader commands
   scan14ATag(2000),
@@ -93,18 +93,16 @@ enum ChameleonCommand {
   final int value;
 }
 
-enum TagType {
-  unknown(0),
-  em410X(1),
-  mifareMini(2),
-  mifare1K(3),
-  mifare2K(4),
-  mifare4K(5),
-  ntag213(6),
-  ntag215(7),
-  ntag216(8);
-
-  const TagType(this.value);
+enum ChameleonCommandStatus {
+  paramError(96),
+  deviceModeError(102),
+  invalidCommand(103),
+  deviceSuccess(104),
+  notImplemented(105),
+  flashWriteFail(112),
+  flashReadFail(113);
+
+  const ChameleonCommandStatus(this.value);
   final int value;
 }
 
@@ -117,6 +115,24 @@ enum TagFrequency {
   final int value;
 }
 
+enum TagType {
+  unknown(0, 'Unknown', TagFrequency.unknown, false),
+  em410X(1, 'EM410X', TagFrequency.lf, true),
+  mifareMini(2, 'Mifare Mini', TagFrequency.hf, true),
+  mifare1K(3, 'Mifare Classic 1K', TagFrequency.hf, true),
+  mifare2K(4, 'Mifare Classic 2K', TagFrequency.hf, true),
+  mifare4K(5, 'Mifare Classic 4K', TagFrequency.hf, true),
+  ntag213(6, 'NTAG213', TagFrequency.hf, false),
+  ntag215(7, 'NTAG215', TagFrequency.hf, false),
+  ntag216(8, 'NTAG216', TagFrequency.hf, false);
+
+  const TagType(this.value, this.name, this.frequency, this.writable);
+  final int value;
+  final String name;
+  final TagFrequency frequency;
+  final bool writable;
+}
+
 enum AnimationSetting {
   full(0),
   minimal(1),
@@ -332,6 +348,7 @@ class ChameleonCommunicator {
               data: Uint8List.fromList(dataResponse));
           log.d(
               "Received message: command = ${message.command}, status = ${message.status}, data = ${bytesToHex(message.data)}");
+
           dataPosition = 0;
           dataBuffer = [];
           messageQueue.add(message);
@@ -358,17 +375,23 @@ class ChameleonCommunicator {
       _serialInstance!.isOpen = true;
     }
 
-    log.d("Sending: ${bytesToHex(dataFrame)}");
+    log.d("Sending $cmd (${cmd.value}), data: ${bytesToHex(dataFrame)}");
+
+    var success = false;
+    try {
+      success = await _serialInstance!.write(Uint8List.fromList(dataFrame));
+    } catch (_) {
+      rethrow;
+    }
+
+    if (!success) {
+      throw ("Write failed for $cmd (${cmd.value})");
+    }
 
     if (skipReceive) {
-      try {
-        await _serialInstance!.write(Uint8List.fromList(dataFrame));
-      } catch (_) {}
       return null;
     }
 
-    await _serialInstance!.write(Uint8List.fromList(dataFrame));
-
     while (true) {
       for (var message in messageQueue) {
         if (message.command == cmd.value) {
@@ -377,9 +400,9 @@ class ChameleonCommunicator {
         }
       }
 
-      if (startTime.millisecondsSinceEpoch + timeout.inMilliseconds <
-          DateTime.now().millisecondsSinceEpoch) {
-        throw ("Timeout waiting for response for command ${cmd.value}");
+      var msSinceStart = DateTime.now().millisecondsSinceEpoch - startTime.millisecondsSinceEpoch;
+      if (msSinceStart >= timeout.inMilliseconds) {
+        throw ("Timeout after ${msSinceStart}ms waiting for response for command $cmd  (${cmd.value})");
       }
 
       await asyncSleep(1);
@@ -397,12 +420,29 @@ class ChameleonCommunicator {
   Future<int> getFirmwareVersion() async {
     var resp = await sendCmd(ChameleonCommand.getAppVersion);
     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];
+    return result;
   }
 
   Future<String> getDeviceChipID() async {
     var resp = await sendCmd(ChameleonCommand.getDeviceChipID);
-    return bytesToHex(resp!.data);
+    final result = bytesToHex(resp!.data);
+    return result;
+  }
+
+  Future<bool> detectChameleonUltra() async {
+    // Check if device is a ChameleonUltra by trying to write a LF tag but
+    // with empty parameters.
+    //
+    // A Chameleon Ultra will return either:
+    // - STATUS_PAR_ERR = 0x60
+    // - STATUS_DEVICE_MODE_ERROR = 0x66
+    //
+    // A Chameleon Lite will return
+    // - STATUS_INVALID_CMD = 0x67
+    //
+    var result = await sendCmd(ChameleonCommand.writeEM410XtoT5577);
+    return result!.status != ChameleonCommandStatus.invalidCommand.value;
   }
 
   Future<String> getDeviceBLEAddress() async {
@@ -740,16 +780,17 @@ class ChameleonCommunicator {
 
   Future<int> getActiveSlot() async {
     // get the selected slot on the device, 0-7 (8 slots)
-    return (await sendCmd(ChameleonCommand.getActiveSlot))!.data[0];
+    var resp = (await sendCmd(ChameleonCommand.getActiveSlot));
+    return resp!.data[0];
   }
 
   Future<List<(TagType, TagType)>> getUsedSlots() async {
     List<(TagType, TagType)> tags = [];
     var resp = await sendCmd(ChameleonCommand.getSlotInfo);
     for (var i = 0; i < 8; i++) {
       tags.add((
-        numberToChameleonTag(resp!.data[(i * 2)]),
-        numberToChameleonTag(resp.data[(i * 2) + 1])
+        numberToTagType(resp!.data[(i * 2)]),
+        numberToTagType(resp.data[(i * 2) + 1])
       ));
     }
     return tags;
@@ -845,9 +886,14 @@ class ChameleonCommunicator {
   }
 
   Future<ButtonConfig> getButtonConfig(ButtonType type) async {
-    var resp = await sendCmd(ChameleonCommand.getButtonPressConfig,
+    var resp = await sendCmd(ChameleonCommand.getButtonConfigConfig,
         data: Uint8List.fromList([type.value]));
-    if (resp!.data[0] == 1) {
+
+    if (resp!.data.isEmpty) {
+      return ButtonConfig.disable;
+    }
+
+    if (resp.data[0] == 1) {
       return ButtonConfig.cycleForward;
     } else if (resp.data[0] == 2) {
       return ButtonConfig.cycleBackward;
@@ -859,12 +905,12 @@ class ChameleonCommunicator {
   }
 
   Future<void> setButtonConfig(ButtonType type, ButtonConfig mode) async {
-    await sendCmd(ChameleonCommand.setButtonPressConfig,
+    await sendCmd(ChameleonCommand.setButtonConfigConfig,
         data: Uint8List.fromList([type.value, mode.value]));
   }
 
   Future<ButtonConfig> getLongButtonConfig(ButtonType type) async {
-    var resp = await sendCmd(ChameleonCommand.getLongButtonPressConfig,
+    var resp = await sendCmd(ChameleonCommand.getLongButtonConfigConfig,
         data: Uint8List.fromList([type.value]));
     if (resp!.data[0] == 1) {
       return ButtonConfig.cycleForward;
@@ -878,7 +924,7 @@ class ChameleonCommunicator {
   }
 
   Future<void> setLongButtonConfig(ButtonType type, ButtonConfig mode) async {
-    await sendCmd(ChameleonCommand.setLongButtonPressConfig,
+    await sendCmd(ChameleonCommand.setLongButtonConfigConfig,
         data: Uint8List.fromList([type.value, mode.value]));
   }
 }

chameleonultragui/lib/bridge/dfu.dart

@@ -3,6 +3,7 @@ import 'dart:typed_data';
 import 'dart:async';
 import 'package:chameleonultragui/helpers/general.dart';
 import 'package:chameleonultragui/connector/serial_abstract.dart';
+import 'package:flutter/foundation.dart' show kIsWeb;
 import 'package:logger/logger.dart';
 import 'dart:math';
 
@@ -166,12 +167,37 @@ class DFUCommunicator {
     }
 
     // we initialize completer each time in DFU, because it being recreated on each message
-    await _serialInstance!.registerCallback(responseCompleter?.complete);
+    List<int>? readBuffer = List<int>.empty(growable: true);
+    await _serialInstance!.registerCallback((List<int> bytes) {
+      if (kIsWeb) {
+        readBuffer?.addAll(bytes);
+      } else {
+        responseCompleter?.complete(bytes);
+      }
+    });
 
     log.d("Sending: ${bytesToHex(packet)}");
     await _serialInstance!.write(packet);
 
-    List<int>? readBuffer = await responseCompleter?.future;
+    if (kIsWeb) {
+      // Use a while loop to ensure the serial port stream has been
+      // fully drained. E.g. on web there is no good way to check if
+      // the stream is empty but the stream might consist of more then
+      // one chunk, even if the chunk is only a couple bytes
+      var bufferSize = readBuffer.length;
+      while(true) {
+        await asyncSleep(10);
+
+        // Stop checking for more data
+        if (bufferSize > 0 && bufferSize == readBuffer.length) {
+          break;
+        }
+
+        bufferSize = readBuffer.length;
+      }
+    } else {
+      readBuffer = await responseCompleter?.future;
+    }
 
     if (readBuffer == null || readBuffer.isEmpty) {
       return null;
@@ -339,12 +365,12 @@ class DFUCommunicator {
   Future<void> delayedSend(Uint8List packet) async {
     // Windows has some issues with transmitting data
     // We work around it by sending message by parts with delay
-    var offsetSize = 128;
-    if (isBLE) {
-      offsetSize = 20;
-    }
+    if (!kIsWeb && (Platform.isWindows || Platform.isMacOS || isBLE)) {
+      var offsetSize = 128;
+      if (isBLE) {
+        offsetSize = 20;
+      }
 
-    if (Platform.isWindows || Platform.isMacOS || isBLE) {
       for (var offset = 0; offset < packet.length; offset += offsetSize) {
         await _serialInstance!.write(
             packet.sublist(

chameleonultragui/lib/connector/serial_abstract.dart

@@ -1,7 +1,18 @@
-import 'dart:typed_data';
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
 import 'package:logger/logger.dart';
 
-enum ChameleonDevice { none, ultra, lite }
+// ChameleonDevice.unknown means we know the device is a Chameleon just not whether its an ultra or lite
+enum ChameleonDevice {
+  none('None'),
+  unknown('Chameleon'),
+  ultra('Chameleon Ultra'),
+  lite('Chameleon Lite');
+
+  const ChameleonDevice(this.name);
+  final String name;
+}
 
 enum ConnectionType { none, usb, ble }
 
@@ -18,6 +29,25 @@ class Chameleon {
       required this.dfu});
 }
 
+enum ChameleonVendor {
+  proxgrind(0x6868),
+  dfu(0x1915);
+
+  const ChameleonVendor(this.value);
+  final int value;
+}
+
+bool isChameleonVendor(int? vendorId, [ChameleonVendor? vendor, List<ChameleonVendor>? vendors ]) {
+  if (vendors == null && vendor != null) {
+    vendors = [vendor];
+  }
+
+  vendors ??= ChameleonVendor.values;
+  return vendors.any((id) {
+    return id.value == vendorId;
+  });
+}
+
 class AbstractSerial {
   Logger log = Logger();
   ChameleonDevice device = ChameleonDevice.none;
@@ -26,16 +56,25 @@ class AbstractSerial {
   bool isDFU = false;
   String portName = "None";
   ConnectionType connectionType = ConnectionType.none;
-  dynamic messageCallback;
+  void Function(List<int>)? messageCallback;
 
   Future<bool> performConnect() async {
     return false;
   }
 
+  @mustCallSuper
   Future<bool> performDisconnect() async {
+    // Reset state of connected device
+    isOpen = false;
+    // connected = false; // TODO: should this be unset here too or in child implementations?
+    device = ChameleonDevice.none;
+    connectionType = ConnectionType.none;
+    messageCallback = null;
     return false;
   }
 
+  Future pairDevices() async {} // For web only
+
   Future<List> availableDevices() async {
     return [];
   }
@@ -54,7 +93,7 @@ class AbstractSerial {
     return false;
   }
 
-  Future<void> registerCallback(dynamic callback) async {
+  Future<void> registerCallback(void Function(List<int>)? callback) async {
     messageCallback = callback;
   }
 }