Files
meshcore-open/lib/models/path_selection.dart
T
zjs81 5ea44d6ce9 Tester feedback: routing, bulk select, notifications, map crash
Routing
- Auto routing picks routes by Thompson sampling over faded delivery
  stats (24 h half-life, capped evidence), weighted by what the radio
  currently hears; retries prefer a different route; last attempt floods.
- Route failures are held until a message's fate is known, so an offline
  contact no longer wrecks its route history; failing routes are only
  deleted after a week without a delivery.
- Direct (zero-hop) path is a rotation candidate (#643) and a new Direct
  mode in the routing sheet; history routes are used for repeater logins.
- Remove the route-weight sliders the new chooser no longer uses.

Chats
- Bulk selection in channel chats (spam / not spam / delete / copy) and
  in the Filtered messages list.
- Tapping a search result jumps to the message.
- Swipe-to-reply ignores vertical scrolls.
- Active conversation follows route lifecycle, so covered chats count
  unread again.

Notifications
- Tapping a notification opens its conversation.
- Per-conversation coalescing and one alert per queued-message sync.
- Monochrome status-bar icon; background service stops when the app is
  swiped away; stale notifications cleared on radio or slot change.

Other
- Online map: opaque links and painted dots for dense areas to avoid an
  Impeller GPU crash; expandable hop list on path maps.
- Contact share: clipboard import of shared contacts, "Add again".
- Android: enableEdgeToEdge and scrolling-screenshot support.
- Translations for all new strings; fix mistranslated routing labels.
2026-11-08 23:19:15 -07:00

99 lines
2.8 KiB
Dart

import 'dart:typed_data';
import 'contact.dart';
const int recentAttemptDiversityWindow = 2;
/// What the radio can hear right now, so auto routing can prefer routes that
/// fit where the user currently is (e.g. home vs. work repeaters).
///
/// "Not heard" is weak evidence — repeaters advert rarely and the radio only
/// reports what it hears — so routes that don't fit are deprioritised, never
/// excluded.
class RouteContext {
/// Whether anything was heard recently. Without that, nothing is known
/// about the surroundings and every route is treated alike.
final bool hasNeighbourInfo;
/// Whether the contact itself was heard with no repeater in between.
final bool contactHeardDirectly;
/// Whether the first hop of a route ([pathBytes], [hashWidth] bytes per
/// hop) was heard directly recently.
final bool Function(List<int> pathBytes, int hashWidth) firstHopHeard;
/// The path the radio currently holds for the contact, if any.
final List<int>? radioPath;
const RouteContext({
required this.hasNeighbourInfo,
required this.contactHeardDirectly,
required this.firstHopHeard,
this.radioPath,
});
static bool _never(List<int> pathBytes, int hashWidth) => false;
/// Nothing known: every route is treated alike.
static const RouteContext unknown = RouteContext(
hasNeighbourInfo: false,
contactHeardDirectly: false,
firstHopHeard: _never,
);
}
class PathSelection {
final List<int> pathBytes;
final int hopCount;
final bool useFlood;
const PathSelection({
required this.pathBytes,
required this.hopCount,
required this.useFlood,
});
}
PathSelection resolvePathSelection(
Contact contact, {
PathSelection? selection,
bool forceFlood = false,
}) {
if (contact.pathOverride != null) {
if (contact.pathOverride! < 0) {
return const PathSelection(pathBytes: [], hopCount: -1, useFlood: true);
}
return PathSelection(
pathBytes: contact.pathOverrideBytes ?? Uint8List(0),
hopCount: contact.pathOverride!,
useFlood: false,
);
}
if (forceFlood || selection?.useFlood == true) {
return const PathSelection(pathBytes: [], hopCount: -1, useFlood: true);
}
// A route picked from history wins even when the radio holds no path for
// the contact: it is proven, and flooding would throw that away. A direct
// (zero-hop) selection has no hop bytes but is still a real path.
if (selection != null &&
(selection.pathBytes.isNotEmpty || selection.hopCount == 0)) {
return PathSelection(
pathBytes: selection.pathBytes,
hopCount: selection.hopCount,
useFlood: false,
);
}
if (contact.pathLength < 0) {
return const PathSelection(pathBytes: [], hopCount: -1, useFlood: true);
}
return PathSelection(
pathBytes: contact.path,
hopCount: contact.pathLength,
useFlood: false,
);
}