Review fixes: - Keep stored message history beyond the 200-message window; stop messages leaking between radios; reset link/session state on disconnect - Accept firmware's 176-byte RX frames over USB/TCP - Hold APP_START during contact sync; contact-sync watchdog; replay DMs from not-yet-known senders; tombstone late command replies; finish channel sync on ERR_NOT_FOUND; fail region-scoped sends cleanly - DM retry watchdog when RESP_CODE_SENT never arrives; late repeater CLI replies; ACK hash collisions; UTF-8-safe name truncation - Image pipeline: delete-during-decode, lifecycle cancels, decoder memory release, entry cap, dead worker recovery, atomic model writes - Storage: deterministic reaction hash across web/native, Smaz double-decode, per-entry parsing, per-radio path history and regions, review-mode data isolation - UI: safe channel slot selection, byte-length name limits, double-send guard, mounted checks, localized hardcoded strings - Skip persisted-store reload on repeat SELF_INFO Features: - Radio default flood scope (firmware ver 11+) and explicit unscoped sends (ver 12+) - Scan for nearby nodes (#570) - Optional distinct first-hop repeater counting for channel resend (#589) - Optional region next to hop count (#580) Issues: - Message text follows system font size (#569) - Repeater/room password field accepts 20 chars (#576) - TCP auto-reconnect and keepalive (#571) - Order feeds by local receive time; flag future timestamps (#584) - Coding rate help text (#568), French "Favoris" (#575) - iOS/macOS app badge now clears Translations for all new strings in every locale.
116 lines
3.2 KiB
Dart
116 lines
3.2 KiB
Dart
import 'dart:typed_data';
|
|
|
|
const int usbSerialTxFrameStart = 0x3c;
|
|
const int usbSerialRxFrameStart = 0x3e;
|
|
const int usbSerialHeaderLength = 3;
|
|
// Outgoing (app → radio) payload cap; matches the app's TX frame budget.
|
|
const int usbSerialMaxPayloadLength = 172;
|
|
// Incoming (radio → app) payload cap; firmware MAX_FRAME_SIZE is 176 (it
|
|
// grew by 4 bytes for region transport codes).
|
|
const int usbSerialMaxRxPayloadLength = 176;
|
|
|
|
Uint8List wrapUsbSerialTxFrame(Uint8List payload) {
|
|
if (payload.length > usbSerialMaxPayloadLength) {
|
|
throw ArgumentError.value(
|
|
payload.length,
|
|
'payload.length',
|
|
'USB serial payload exceeds $usbSerialMaxPayloadLength bytes',
|
|
);
|
|
}
|
|
final packet = Uint8List(usbSerialHeaderLength + payload.length);
|
|
packet[0] = usbSerialTxFrameStart;
|
|
packet[1] = payload.length & 0xff;
|
|
packet[2] = (payload.length >> 8) & 0xff;
|
|
packet.setRange(usbSerialHeaderLength, packet.length, payload);
|
|
return packet;
|
|
}
|
|
|
|
class UsbSerialDecodedPacket {
|
|
const UsbSerialDecodedPacket({
|
|
required this.frameStart,
|
|
required this.payload,
|
|
});
|
|
|
|
final int frameStart;
|
|
final Uint8List payload;
|
|
|
|
bool get isRxFrame => frameStart == usbSerialRxFrameStart;
|
|
}
|
|
|
|
class UsbSerialFrameDecoder {
|
|
final List<int> _rxBuffer = <int>[];
|
|
int _startIndex = 0;
|
|
|
|
void reset() {
|
|
_rxBuffer.clear();
|
|
_startIndex = 0;
|
|
}
|
|
|
|
List<UsbSerialDecodedPacket> ingest(Uint8List bytes) {
|
|
if (bytes.isEmpty) {
|
|
return const <UsbSerialDecodedPacket>[];
|
|
}
|
|
|
|
_rxBuffer.addAll(bytes);
|
|
final packets = <UsbSerialDecodedPacket>[];
|
|
|
|
while (true) {
|
|
if (_startIndex >= _rxBuffer.length) {
|
|
_rxBuffer.clear();
|
|
_startIndex = 0;
|
|
return packets;
|
|
}
|
|
|
|
if (_rxBuffer[_startIndex] != usbSerialRxFrameStart &&
|
|
_rxBuffer[_startIndex] != usbSerialTxFrameStart) {
|
|
_startIndex++;
|
|
_compactBufferIfNeeded();
|
|
continue;
|
|
}
|
|
|
|
final availableLength = _rxBuffer.length - _startIndex;
|
|
if (availableLength < usbSerialHeaderLength) {
|
|
_compactBufferIfNeeded(force: true);
|
|
return packets;
|
|
}
|
|
|
|
final payloadLength =
|
|
_rxBuffer[_startIndex + 1] | (_rxBuffer[_startIndex + 2] << 8);
|
|
if (payloadLength > usbSerialMaxRxPayloadLength) {
|
|
_startIndex++;
|
|
_compactBufferIfNeeded();
|
|
continue;
|
|
}
|
|
final packetLength = usbSerialHeaderLength + payloadLength;
|
|
if (availableLength < packetLength) {
|
|
_compactBufferIfNeeded(force: true);
|
|
return packets;
|
|
}
|
|
|
|
final frameStart = _rxBuffer[_startIndex];
|
|
final payload = Uint8List.fromList(
|
|
_rxBuffer.sublist(
|
|
_startIndex + usbSerialHeaderLength,
|
|
_startIndex + packetLength,
|
|
),
|
|
);
|
|
_startIndex += packetLength;
|
|
_compactBufferIfNeeded();
|
|
packets.add(
|
|
UsbSerialDecodedPacket(frameStart: frameStart, payload: payload),
|
|
);
|
|
}
|
|
}
|
|
|
|
void _compactBufferIfNeeded({bool force = false}) {
|
|
if (_startIndex == 0) {
|
|
return;
|
|
}
|
|
if (!force && _startIndex < 1024 && _startIndex < (_rxBuffer.length ~/ 2)) {
|
|
return;
|
|
}
|
|
_rxBuffer.removeRange(0, _startIndex);
|
|
_startIndex = 0;
|
|
}
|
|
}
|