Files
meshcore-open/lib/connector/pending_command_replies.dart
T
Zach d74587c167 Refactor LoRa airtime tests and add new functionality
- Updated LoRa airtime calculations in `lora_airtime_test.dart` to reflect new reference values.
- Introduced new tests for LDRO behavior and preamble symbol calculations.
- Added `contact_path_width_test.dart` to validate path hash width handling in contacts.
- Enhanced `model_changes_test.dart` to ensure legacy data migration works correctly.
- Created `remote_node_stats_test.dart` to decode and validate remote node statistics.
- Implemented `map_marker_parse_test.dart` for parsing marker text with coordinate validation.
- Developed `map_tile_cache_key_test.dart` to ensure API keys are excluded from cache keys.
- Added `message_retry_failure_test.dart` to test message retry service behavior on failures.
- Extended `path_history_service_test.dart` to preserve learned state across path attempts.
- Enhanced `received_image_store_test.dart` to handle concurrent writes and review fixes.
- Implemented `repeater_command_service_test.dart` to validate command response handling.
- Created `store_tolerant_parsing_test.dart` to ensure stores skip malformed records gracefully.
- Cleared untranslated JSON file for localization updates.
2026-09-25 10:01:18 -07:00

184 lines
5.8 KiB
Dart

import 'dart:async';
import 'package:flutter/foundation.dart';
import '../services/image_chunk_transport.dart' show cmdSendChannelData;
import 'meshcore_protocol.dart';
/// A command waiting for its reply from the companion firmware.
class PendingCommandReply {
final int commandCode;
/// Response code the firmware sends on success (RESP_CODE_OK or a specific
/// RESP_CODE_*). Any command may instead be answered with RESP_CODE_ERR.
final int replyCode;
/// For GET_CONTACT_BY_KEY: only a CONTACT frame for this key is the reply.
final Uint8List? matchKey;
final String? channelSendQueueId;
final Completer<void>? completer;
final DateTime createdAt = DateTime.now();
PendingCommandReply({
required this.commandCode,
required this.replyCode,
this.matchKey,
this.channelSendQueueId,
this.completer,
});
}
/// Success reply for each command whose single reply is OK/ERR or a specific
/// RESP_CODE (companion MyMesh.cpp handleCmdFrame). Commands with no reply
/// (REBOOT) or a multi-code reply (SYNC_NEXT_MESSAGE) are not tracked.
int? replyCodeForCommand(Uint8List data) {
switch (data[0]) {
case cmdSendChannelTxtMsg:
case cmdSetDeviceTime:
case cmdSendSelfAdvert:
case cmdSetAdvertName:
case cmdAddUpdateContact:
case cmdSetRadioParams:
case cmdSetRadioTxPower:
case cmdResetPath:
case cmdSetAdvertLatLon:
case cmdRemoveContact:
case cmdShareContact:
case cmdImportContact:
case cmdSetChannel:
case cmdSetOtherParams:
case cmdSetCustomVar:
case cmdSetFloodScope:
case cmdSendControlData:
case cmdSetAutoAddConfig:
case cmdSetPathHashMode:
case cmdSendChannelData:
return respCodeOk;
case cmdSendTxtMsg:
case cmdSendLogin:
case cmdSendStatusReq:
case cmdSendTracePath:
case cmdSendBinaryReq:
case cmdSendAnonReq:
return respCodeSent;
case cmdSendTelemetryReq:
// The 4-byte 'self' form answers with PUSH_CODE_TELEMETRY_RESPONSE.
return data.length > 4 ? respCodeSent : null;
case cmdAppStart:
return respCodeSelfInfo;
case cmdDeviceQuery:
return respCodeDeviceInfo;
case cmdGetContacts:
return respCodeContactsStart;
case cmdGetContactByKey:
return respCodeContact;
case cmdGetDeviceTime:
return respCodeCurrTime;
case cmdExportContact:
return respCodeExportContact;
case cmdGetBattAndStorage:
return respCodeBattAndStorage;
case cmdGetChannel:
return respCodeChannelInfo;
case cmdGetCustomVar:
return respCodeCustomVars;
case cmdGetStats:
return respCodeStats;
case cmdGetAutoAddConfig:
return respCodeAutoAddConfig;
case cmdGetAllowedRepeatFreq:
return respCodeAllowedRepeatFreq;
}
return null;
}
/// FIFO of commands awaiting a reply. The firmware handles commands in order
/// and answers each with OK, ERR or a specific RESP_CODE, so an ERR belongs
/// to the oldest pending command and an OK to the oldest one expecting OK.
class PendingCommandReplies {
PendingCommandReplies({required this.staleAfter});
/// Entries older than this are dropped so a lost reply cannot swallow a
/// later, unrelated OK/ERR. Awaited entries time out in sendFrame first.
final Duration staleAfter;
final List<PendingCommandReply> _queue = [];
int get length => _queue.length;
PendingCommandReply? track(
Uint8List data, {
String? channelSendQueueId,
bool expectsOk = false,
bool waitForReply = false,
}) {
if (data.isEmpty) return null;
final replyCode =
replyCodeForCommand(data) ?? (expectsOk ? respCodeOk : null);
if (replyCode == null) return null;
final pending = PendingCommandReply(
commandCode: data[0],
replyCode: replyCode,
matchKey: data[0] == cmdGetContactByKey && data.length >= 1 + pubKeySize
? Uint8List.fromList(data.sublist(1, 1 + pubKeySize))
: null,
channelSendQueueId: channelSendQueueId,
completer: waitForReply ? Completer<void>() : null,
);
if (pending.completer != null) {
// The sender awaits this future after transport I/O; attach an error
// handler now in case the ERR arrives first.
unawaited(pending.completer!.future.catchError((_) {}));
}
_queue.add(pending);
return pending;
}
void remove(PendingCommandReply pending) => _queue.remove(pending);
void clear() => _queue.clear();
/// Completes the oldest command whose success reply is [frame]'s code.
bool completeReply(Uint8List frame) {
if (frame.isEmpty) return false;
final code = frame[0];
if (code == respCodeOk || code == respCodeErr) return false;
final key = code == respCodeContact && frame.length >= 1 + pubKeySize
? frame.sublist(1, 1 + pubKeySize)
: null;
final index = _queue.indexWhere(
(p) =>
p.replyCode == code &&
(p.matchKey == null || listEquals(p.matchKey, key)),
);
if (index < 0) return false;
_queue.removeAt(index).completer?.complete();
return true;
}
/// Attributes RESP_CODE_OK; commands expecting a specific reply are skipped.
PendingCommandReply? takeOk() {
_pruneStale();
final index = _queue.indexWhere((p) => p.replyCode == respCodeOk);
if (index < 0) return null;
final pending = _queue.removeAt(index);
pending.completer?.complete();
return pending;
}
/// Attributes RESP_CODE_ERR to the oldest pending command.
PendingCommandReply? takeErr(int errCode) {
_pruneStale();
if (_queue.isEmpty) return null;
final pending = _queue.removeAt(0);
pending.completer?.completeError(
Exception('Command failed with error code $errCode'),
);
return pending;
}
void _pruneStale() {
final cutoff = DateTime.now().subtract(staleAfter);
_queue.removeWhere((p) => p.createdAt.isBefore(cutoff));
}
}