Fix tracing path and display issues

2026-08-11 16:30:28 +00:00 · 2026-03-12 14:08:00 +01:00
parent b38a8c55d6
commit 2d1e6c0ca4
11 changed files with 1021 additions and 89 deletions
--- a/lib/widgets/messages/message_trace_sheet.dart
+++ b/lib/widgets/messages/message_trace_sheet.dart
@@ -14,6 +14,7 @@ import '../../providers/messages_provider.dart';
 import '../../services/mesh_map_nodes_service.dart';
 import '../../services/route_hash_preferences.dart';
 import '../../utils/log_rx_route_decoder.dart';
+import '../../utils/trace_node_resolver.dart';

 class MessageTraceSheet extends StatefulWidget {
  final Message message;
@@ -38,10 +39,10 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
    final contactsProvider = context.read<ContactsProvider>();
    final messagesProvider = context.read<MessagesProvider>();
    final preferredHashSize = await RouteHashPreferences.getHashSize();
-    final storedPath =
-        messagesProvider.getMessageReceptionDetails(widget.message.id)?.pathBytes;
-    final packetPath =
-        (storedPath != null && storedPath.isNotEmpty)
+    final storedPath = messagesProvider
+        .getMessageReceptionDetails(widget.message.id)
+        ?.pathBytes;
+    final packetPath = (storedPath != null && storedPath.isNotEmpty)
        ? storedPath
        : _extractPathFromPacketLogs(
            logs: connectionProvider.bleService.packetLogs,
@@ -54,8 +55,10 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
        : _toPrefixHex(connectionProvider.deviceInfo.publicKey);

    final localNodes = _localNodesFromContacts(contactsProvider);
+    final localPublicKeys = localNodes.map((node) => node.publicKey).toSet();
    var trace = _buildTraceResult(
      nodes: localNodes,
+      localPublicKeys: localPublicKeys,
      packetPath: packetPath,
      preferredHashSize: preferredHashSize,
      senderPrefix: senderPrefix,
@@ -79,6 +82,7 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
    );
    trace = _buildTraceResult(
      nodes: _mergeNodes(localNodes, remoteNodes),
+      localPublicKeys: localPublicKeys,
      packetPath: packetPath,
      preferredHashSize: preferredHashSize,
      senderPrefix: senderPrefix,
@@ -114,8 +118,8 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
          final trace = snapshot.data!;
          final routeEntries = _displayRouteEntries(trace);
          final concretePathNodes = routeEntries
-              .where((entry) => entry.node != null)
-              .map((entry) => entry.node!)
+              .where((entry) => entry.resolved.node != null)
+              .map((entry) => entry.resolved.node!)
              .toList();
          final mapPoints = concretePathNodes
              .map((n) => LatLng(n.latitude, n.longitude))
@@ -289,7 +293,7 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
                          ),
                          title: Text(entry.value.label),
                          subtitle: Text(
-                            '${_routeRoleLabel(entry.key, routeEntries.length)}${entry.value.keyLabel == null ? '' : ' • ${entry.value.keyLabel}'}',
+                            '${_routeRoleLabel(entry.key, routeEntries.length)}${entry.value.keyLabel == null ? '' : ' • ${entry.value.keyLabel}'}${entry.value.matchSummary == null ? '' : ' • ${entry.value.matchSummary}'}',
                          ),
                        ),
                      ),
@@ -333,7 +337,10 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
  }

  List<MeshMapNode> _relayNodes(_TraceResult trace) {
-    final concrete = trace.matchedPathNodes.whereType<MeshMapNode>().toList();
+    final concrete = trace.matchedPathNodes
+        .map((entry) => entry.node)
+        .whereType<MeshMapNode>()
+        .toList();
    if (concrete.isEmpty) return const [];

    if (trace.mode == TraceMode.packetPath) {
@@ -346,13 +353,17 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
  }

  List<_RouteDisplayEntry> _displayRouteEntries(_TraceResult trace) {
-    final pathNodes = trace.matchedPathNodes.whereType<MeshMapNode>().toList();
+    final pathNodes = trace.matchedPathNodes
+        .map((entry) => entry.node)
+        .whereType<MeshMapNode>()
+        .toList();
    if (pathNodes.isEmpty) {
      return [
-        if (trace.sender != null) _RouteDisplayEntry.fromNode(trace.sender!),
-        if (trace.recipient != null &&
-            trace.recipient!.publicKey != trace.sender?.publicKey)
-          _RouteDisplayEntry.fromNode(trace.recipient!),
+        if (trace.sender.node != null)
+          _RouteDisplayEntry.fromResolved(trace.sender),
+        if (trace.recipient.node != null &&
+            trace.recipient.node!.publicKey != trace.sender.node?.publicKey)
+          _RouteDisplayEntry.fromResolved(trace.recipient),
      ];
    }

@@ -360,29 +371,34 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
      final entries = trace.matchedPathNodes.asMap().entries.map((entry) {
        final hashHex = trace.pathHashes[entry.key].toUpperCase();
        return _RouteDisplayEntry(
-          node: entry.value,
-          label: entry.value?.name ?? 'Unknown',
-          keyLabel: entry.value != null
-              ? _prefixKeyLabel(entry.value!.publicKey)
+          resolved: entry.value,
+          label: entry.value.node?.name ?? 'Unknown',
+          keyLabel: entry.value.node != null
+              ? _prefixKeyLabel(entry.value.node!.publicKey)
              : hashHex,
+          matchSummary: entry.value.matchSummary,
        );
      }).toList();
      final lastKey = pathNodes.last.publicKey;
      return [
        ...entries,
-        if (trace.recipient != null && trace.recipient!.publicKey != lastKey)
-          _RouteDisplayEntry.fromNode(trace.recipient!),
+        if (trace.recipient.node != null &&
+            trace.recipient.node!.publicKey != lastKey)
+          _RouteDisplayEntry.fromResolved(trace.recipient),
      ];
    }

    final firstKey = pathNodes.first.publicKey;
    final lastKey = pathNodes.last.publicKey;
    return [
-      if (trace.sender != null && trace.sender!.publicKey != firstKey)
-        _RouteDisplayEntry.fromNode(trace.sender!),
-      ...pathNodes.map(_RouteDisplayEntry.fromNode),
-      if (trace.recipient != null && trace.recipient!.publicKey != lastKey)
-        _RouteDisplayEntry.fromNode(trace.recipient!),
+      if (trace.sender.node != null && trace.sender.node!.publicKey != firstKey)
+        _RouteDisplayEntry.fromResolved(trace.sender),
+      ...trace.matchedPathNodes
+          .where((entry) => entry.node != null)
+          .map(_RouteDisplayEntry.fromResolved),
+      if (trace.recipient.node != null &&
+          trace.recipient.node!.publicKey != lastKey)
+        _RouteDisplayEntry.fromResolved(trace.recipient),
    ];
  }

@@ -405,14 +421,6 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
        .toLowerCase();
  }

-  MeshMapNode? _bestNodeForPrefix(List<MeshMapNode> nodes, String? prefixHex) {
-    if (prefixHex == null || prefixHex.isEmpty) return null;
-    final matches =
-        nodes.where((n) => n.publicKey.startsWith(prefixHex)).toList()
-          ..sort((a, b) => b.updatedAtMs.compareTo(a.updatedAtMs));
-    return matches.isEmpty ? null : matches.first;
-  }
-
  List<MeshMapNode> _localNodesFromContacts(ContactsProvider contactsProvider) {
    return contactsProvider.contactsWithLocation
        .map((contact) {
@@ -447,13 +455,28 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {

  _TraceResult _buildTraceResult({
    required List<MeshMapNode> nodes,
+    required Set<String> localPublicKeys,
    required List<int>? packetPath,
    required int preferredHashSize,
    required String? senderPrefix,
    required String? recipientPrefix,
  }) {
-    final senderNode = _bestNodeForPrefix(nodes, senderPrefix);
-    final recipientNode = _bestNodeForPrefix(nodes, recipientPrefix);
+    final senderNode = TraceNodeResolver.resolveBest(
+      nodes: nodes,
+      localPublicKeys: localPublicKeys,
+      prefixHex: senderPrefix,
+    );
+    final recipientNode = TraceNodeResolver.resolveBest(
+      nodes: nodes,
+      localPublicKeys: localPublicKeys,
+      prefixHex: recipientPrefix,
+    );
+    final senderLatLng = senderNode.node == null
+        ? null
+        : LatLng(senderNode.node!.latitude, senderNode.node!.longitude);
+    final recipientLatLng = recipientNode.node == null
+        ? null
+        : LatLng(recipientNode.node!.latitude, recipientNode.node!.longitude);

    if (packetPath != null && packetPath.isNotEmpty) {
      final hashSize = LogRxRouteDecoder.inferHashSize(
@@ -466,9 +489,12 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
      ).reversed.toList();
      final matched = _matchNodesFromPathHashes(
        nodes: nodes,
+        localPublicKeys: localPublicKeys,
        pathHashes: hopHashes,
        senderPrefix: senderPrefix,
        recipientPrefix: recipientPrefix,
+        senderLatLng: senderLatLng,
+        recipientLatLng: recipientLatLng,
      );
      return _TraceResult(
        mode: TraceMode.packetPath,
@@ -481,14 +507,20 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {

    final inferred = _inferRelaysFromHopCount(
      nodes: nodes,
-      sender: senderNode,
-      recipient: recipientNode,
+      sender: senderNode.node,
+      recipient: recipientNode.node,
      relayCount: math.max(0, widget.message.pathLen),
    );
-    final matchedPathNodes = <MeshMapNode?>[
-      if (senderNode != null) senderNode,
-      ...inferred,
-      if (recipientNode != null) recipientNode,
+    final matchedPathNodes = <ResolvedTraceNode>[
+      if (senderNode.node != null) senderNode,
+      ...inferred.map(
+        (node) => ResolvedTraceNode(
+          node: node,
+          matchCount: 1,
+          usedOnlineFallback: false,
+        ),
+      ),
+      if (recipientNode.node != null) recipientNode,
    ];

    return _TraceResult(
@@ -501,16 +533,17 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
  }

  bool _isCompleteTrace(_TraceResult trace, {required int expectedRelayCount}) {
-    if (trace.sender == null || trace.recipient == null) {
+    if (trace.sender.node == null || trace.recipient.node == null) {
      return false;
    }

    if (trace.mode == TraceMode.packetPath) {
      return trace.matchedPathNodes.length == trace.pathHashes.length &&
-          trace.matchedPathNodes.every((node) => node != null);
+          trace.matchedPathNodes.every((node) => node.node != null);
    }

    final concreteCount = trace.matchedPathNodes
+        .map((entry) => entry.node)
        .whereType<MeshMapNode>()
        .length;
    return concreteCount >= expectedRelayCount + 2;
@@ -551,39 +584,30 @@ class _MessageTraceSheetState extends State<MessageTraceSheet> {
    return decoded.pathBytes;
  }

-  List<MeshMapNode?> _matchNodesFromPathHashes({
+  List<ResolvedTraceNode> _matchNodesFromPathHashes({
    required List<MeshMapNode> nodes,
+    required Set<String> localPublicKeys,
    required List<String> pathHashes,
    required String? senderPrefix,
    required String? recipientPrefix,
+    required LatLng? senderLatLng,
+    required LatLng? recipientLatLng,
  }) {
-    final result = <MeshMapNode?>[];
+    final result = <ResolvedTraceNode>[];
    for (var i = 0; i < pathHashes.length; i++) {
      final hashHex = pathHashes[i].toLowerCase();
-      final candidates = nodes
-          .where((n) => n.publicKey.startsWith(hashHex))
-          .toList();
-      if (candidates.isEmpty) {
-        result.add(null);
-        continue;
-      }
-
-      List<MeshMapNode> filtered = candidates;
-      if (i == 0 && senderPrefix != null) {
-        final senderMatches = filtered
-            .where((n) => n.publicKey.startsWith(senderPrefix))
-            .toList();
-        if (senderMatches.isNotEmpty) filtered = senderMatches;
-      }
-      if (i == pathHashes.length - 1 && recipientPrefix != null) {
-        final recipientMatches = filtered
-            .where((n) => n.publicKey.startsWith(recipientPrefix))
-            .toList();
-        if (recipientMatches.isNotEmpty) filtered = recipientMatches;
-      }
-
-      filtered.sort((a, b) => b.updatedAtMs.compareTo(a.updatedAtMs));
-      result.add(filtered.first);
+      result.add(
+        TraceNodeResolver.resolveBest(
+          nodes: nodes,
+          localPublicKeys: localPublicKeys,
+          prefixHex: hashHex,
+          preferredPrefix: i == 0
+              ? senderPrefix
+              : (i == pathHashes.length - 1 ? recipientPrefix : null),
+          referenceA: senderLatLng,
+          referenceB: recipientLatLng,
+        ),
+      );
    }
    return result;
  }
@@ -652,10 +676,10 @@ enum TraceMode { packetPath, hopCountInference }

 class _TraceResult {
  final TraceMode mode;
-  final MeshMapNode? sender;
-  final MeshMapNode? recipient;
+  final ResolvedTraceNode sender;
+  final ResolvedTraceNode recipient;
  final List<String> pathHashes;
-  final List<MeshMapNode?> matchedPathNodes;
+  final List<ResolvedTraceNode> matchedPathNodes;

  const _TraceResult({
    required this.mode,
@@ -667,24 +691,30 @@ class _TraceResult {
 }

 class _RouteDisplayEntry {
-  final MeshMapNode? node;
+  final ResolvedTraceNode resolved;
  final String label;
  final String? keyLabel;
+  final String? matchSummary;

  const _RouteDisplayEntry({
-    required this.node,
+    required this.resolved,
    required this.label,
    required this.keyLabel,
+    required this.matchSummary,
  });

-  factory _RouteDisplayEntry.fromNode(MeshMapNode node) {
+  MeshMapNode? get node => resolved.node;
+
+  factory _RouteDisplayEntry.fromResolved(ResolvedTraceNode resolved) {
+    final node = resolved.node!;
    return _RouteDisplayEntry(
-      node: node,
+      resolved: resolved,
      label: node.name,
      keyLabel: node.publicKey.substring(
        0,
        math.min(12, node.publicKey.length),
      ),
+      matchSummary: resolved.matchSummary,
    );
  }
 }