Store histories and the tile index in SQLite
Message, channel and route histories move from whole-blob preferences to indexed SQLite rows on native platforms, so chats page from storage instead of loading a full conversation. Web keeps the preferences store. Existing histories are imported once on the first launch. Linux and Windows keep the map tile index in SQLite and import the old JSON index on first use. Unreadable legacy data no longer blocks saves, migrations or startup: it is left in place and skipped. If the database cannot be opened, the run keeps histories in preferences and the next launch merges them in. Also adds a performance profiling reference and a script that clears the Dart HTTP profile.
This commit is contained in:
1 parent
0106569e7d
commit
2d56d5e349
47 files changed
+4465
-614
No files matched your search
@@ -39,7 +39,7 @@ For Linux, use `nix develop`; see [Linux with Nix](README.md#linux-with-nix) for
|
||||
| Serial marker/length framing | `lib/services/usb_serial_frame_codec.dart` |
|
||||
| ACK tracking and retry scheduling | `lib/services/message_retry_service.dart` |
|
||||
| Route scoring/history | `lib/services/path_history_service.dart` |
|
||||
| Preferences and JSON stores | `lib/storage/` |
|
||||
| Preferences, native history database, and JSON stores | `lib/storage/` |
|
||||
| Region list and channel/default assignments | `lib/storage/region_store.dart`, `lib/storage/channel_region_store.dart` |
|
||||
| Message filter (rules, duplicate/spam checks, on-device classifier) | `lib/services/message_filter/`, `lib/models/message_filter.dart`, `lib/storage/message_filter_store.dart`, `lib/screens/message_filter_settings_screen.dart`, `lib/screens/filtered_messages_screen.dart` |
|
||||
| Translation models/inference | `lib/services/translation_service.dart` |
|
||||
@@ -51,6 +51,8 @@ For Linux, use `nix develop`; see [Linux with Nix](README.md#linux-with-nix) for
|
||||
|
||||
`Provider`/`ChangeNotifier` drives UI state. `main.dart` wires `MeshTheme.light()` and `MeshTheme.dark()` and uses the saved theme preference. Its `MultiProvider` exposes `MeshCoreConnector`, `MessageRetryService`, `PathHistoryService`, `AppSettingsService`, `BleDebugLogService`, `AppDebugLogService`, `ChatTextScaleService`, `TranslationService`, `UiViewStateService`, `StorageService` (plain `Provider`), `MapTileCacheService`, `TimeoutPredictionService`, `ImageCodecService`, `ReceivedImageStore`, and `MessageFilterService`; screens read them with `Consumer<T>`, `context.watch<T>()`, or `context.read<T>()`.
|
||||
|
||||
Message/channel histories use indexed SQLite rows on native platforms, and route histories use the same database. Web builds use preferences. Startup imports old history preferences once; backup and review-mode cleanup include database histories. See [local history storage](documentation/performance-profiling.md#local-history-storage).
|
||||
|
||||
Most JSON stores scope keys by the first 10 hex chars of the connected device's public key, so per-radio data stays isolated; some preferences, including the saved region-name list, are global. Model bundles, received images, and caches use files.
|
||||
|
||||
## Localization
|
||||
|
||||
@@ -33,6 +33,7 @@ MeshCore Open is an open-source Flutter client for MeshCore LoRa mesh networking
|
||||
20. [Message Filter](message-filter.md) - Hide spam and repeated channel messages with your own rules, automatic checks, and learning from Spam taps, all on the device
|
||||
21. [UI Design Reference](design.md) - Contributor reference: theme, typography, spacing, shared widgets, sheets vs dialogs vs pages, states, and localization rules for UI changes
|
||||
22. [Offline Mode](offline-mode.md) - Read-only view of the last radio's contacts, channels and messages while no radio is connected, and the Connect sheet
|
||||
23. [Performance Profiling](performance-profiling.md) - Contributor reference: frame and memory baselines, HTTP capture retention, and resetting diagnostic recordings
|
||||
|
||||
## App Overview
|
||||
|
||||
|
||||
@@ -184,6 +184,15 @@ A full-screen map with a draggable bottom sheet containing:
|
||||
|
||||
## Offline Map Cache
|
||||
|
||||
Linux and Windows keep the tile index in SQLite, so opening a large offline map
|
||||
does not load every tile's metadata into memory. Existing JSON indexes migrate
|
||||
automatically on first use; downloaded tile files and the cache limit are
|
||||
preserved. The old index is removed only after its replacement is committed.
|
||||
Unreadable records are skipped, and an index that contained any is kept beside
|
||||
the database with an `.unreadable` suffix instead of being deleted.
|
||||
The database and import marker are versioned, so a completed migration is not
|
||||
repeated and an older app does not downgrade a newer database.
|
||||
|
||||
### How to Access
|
||||
Settings → App Settings → Map Display → Offline Map Cache
|
||||
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
# Performance and memory profiling
|
||||
|
||||
Use `flutter run --profile` to measure frame times and memory after repeating
|
||||
the same actions. Debug builds also retain Dart source, JIT code and debugger
|
||||
objects, so their process memory is not a release-build baseline.
|
||||
|
||||
## HTTP recording retains response bodies
|
||||
|
||||
Dart's HTTP timeline logging defaults to off. The app does not enable it.
|
||||
Developer tools can enable it through the VM service, independently of the
|
||||
app's debug-log settings. When enabled, Dart retains HTTP request records and
|
||||
response bodies until those captures are cleared. Map browsing and downloads
|
||||
can therefore increase profiling memory even after the app stops displaying
|
||||
the downloaded images. Stopping recording does not clear earlier captures.
|
||||
|
||||
For a memory baseline, stop HTTP recording and clear its captures in DevTools'
|
||||
Network view. Close or disconnect tools that turn recording back on. If the
|
||||
Network controls are unavailable, run this command from the repository root
|
||||
with the Dart VM service URI printed by `flutter run`:
|
||||
|
||||
```sh
|
||||
dart run scripts/reset_http_profile.dart http://127.0.0.1:PORT/TOKEN=/
|
||||
```
|
||||
|
||||
This explicitly stops HTTP recording and clears the retained Dart HTTP profile
|
||||
in the running app's main isolate. Save any captures you need first. It does
|
||||
not delete downloaded map tiles, change app settings, stop network requests or
|
||||
change CPU/timeline profiling. You can enable HTTP recording again in DevTools
|
||||
when investigating network requests. Other HTTP profiling providers may keep
|
||||
their own records; the command reports any requests that remain.
|
||||
|
||||
After clearing, use DevTools' memory view to collect garbage and compare live
|
||||
heap snapshots at the same point in the workflow. Process RSS can remain high
|
||||
because the runtime and native libraries can keep reusable allocations; a
|
||||
larger RSS alone does not establish a leak. Keep frame measurements collected
|
||||
before heap inspection separate from collection pauses caused by diagnostics.
|
||||
|
||||
## Local history storage
|
||||
|
||||
Native apps store direct messages, channel messages, and route histories in
|
||||
`history_v1.db` in the application support directory. Small preferences remain
|
||||
in SharedPreferences. Web builds continue to use browser preferences.
|
||||
|
||||
The first launch after upgrading imports existing histories. The database has a
|
||||
schema version and a separate import version, so a completed import is skipped
|
||||
on later launches. Source preferences are removed only after their database
|
||||
writes commit; an interrupted import retries safely. Unreadable history values
|
||||
remain in preferences for recovery instead of being discarded; new messages for
|
||||
that conversation are saved to the database beside them. A failed import step
|
||||
does not stop the app: the database is used and the step repeats on the next
|
||||
launch. If the database cannot be opened at all, that run keeps histories in
|
||||
preferences, and the next launch that opens the database merges them in.
|
||||
|
||||
Chat history is indexed by entry, allowing older pages to be read without loading
|
||||
the whole conversation. Backups include native database histories and restore
|
||||
them into the selected radio's scope. Review-mode cleanup also covers the database.
|
||||
For a manual full application-data copy, keep the history database alongside the
|
||||
application's other support files; copying the preferences file alone no longer
|
||||
includes native message or route histories.
|
||||
@@ -255,6 +255,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
static const int _errCodeNotFound = 2;
|
||||
int _reactionSendQueueSequence = 0;
|
||||
final Set<String> _loadedConversationKeys = {};
|
||||
int _messageHistoryGeneration = 0;
|
||||
final Map<String, Future<List<Message>>> _conversationPageLoads = {};
|
||||
final Map<String, Future<List<ChannelMessage>>> _channelPageLoads = {};
|
||||
// Self public key of the radio whose messages are held in memory.
|
||||
String? _messageStateOwnerKey;
|
||||
// Self public key whose persisted stores were loaded this link session.
|
||||
@@ -985,63 +988,82 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
Future<void> _loadMessagesForContact(String contactKeyHex) async {
|
||||
if (_loadedConversationKeys.contains(contactKeyHex)) return;
|
||||
_loadedConversationKeys.add(contactKeyHex);
|
||||
|
||||
final allMessages = await _messageStore.loadMessages(contactKeyHex);
|
||||
if (allMessages.isNotEmpty) {
|
||||
// Keep only the most recent N messages in memory to bound memory usage
|
||||
final windowedMessages = allMessages.length > _messageWindowSize
|
||||
? allMessages.sublist(allMessages.length - _messageWindowSize)
|
||||
: allMessages;
|
||||
final archivedMessages = allMessages.sublist(
|
||||
0,
|
||||
allMessages.length - windowedMessages.length,
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _messageStore.publicKeyHex;
|
||||
bool current() =>
|
||||
!_disposed &&
|
||||
generation == _messageHistoryGeneration &&
|
||||
scope == _messageStore.publicKeyHex;
|
||||
final page = await _readSettledPage(
|
||||
current: current,
|
||||
window: () => _conversations[contactKeyHex] ?? const <Message>[],
|
||||
archived: () => _messageStore.archivedCount(contactKeyHex),
|
||||
read: (_, _) => _messageStore.loadMessagePage(
|
||||
contactKeyHex,
|
||||
limit: _messageWindowSize,
|
||||
),
|
||||
);
|
||||
if (page == null) return;
|
||||
final currentMessages = _conversations[contactKeyHex] ?? const <Message>[];
|
||||
final mergedMessages = <Message>[...page.messages];
|
||||
final persistedKeyCounts = <String, int>{};
|
||||
for (final message in page.messages) {
|
||||
final key = _messageMergeKey(message);
|
||||
persistedKeyCounts[key] = (persistedKeyCounts[key] ?? 0) + 1;
|
||||
}
|
||||
final currentKeyCounts = <String, int>{};
|
||||
for (final message in currentMessages) {
|
||||
final key = _messageMergeKey(message);
|
||||
final count = (currentKeyCounts[key] ?? 0) + 1;
|
||||
currentKeyCounts[key] = count;
|
||||
if (count > (persistedKeyCounts[key] ?? 0)) mergedMessages.add(message);
|
||||
}
|
||||
mergedMessages.sort((a, b) => a.receivedAt.compareTo(b.receivedAt));
|
||||
final trimCount = (mergedMessages.length - _messageWindowSize).clamp(
|
||||
0,
|
||||
mergedMessages.length,
|
||||
);
|
||||
_messageStore.setArchivedCount(contactKeyHex, page.start);
|
||||
if (trimCount > 0) {
|
||||
_messageStore.archive(
|
||||
contactKeyHex,
|
||||
mergedMessages.sublist(0, trimCount),
|
||||
);
|
||||
|
||||
final currentMessages =
|
||||
_conversations[contactKeyHex] ?? const <Message>[];
|
||||
final mergedMessages = <Message>[...windowedMessages];
|
||||
final persistedKeyCounts = <String, int>{};
|
||||
for (final message in windowedMessages) {
|
||||
final key = _messageMergeKey(message);
|
||||
persistedKeyCounts[key] = (persistedKeyCounts[key] ?? 0) + 1;
|
||||
}
|
||||
final currentKeyCounts = <String, int>{};
|
||||
|
||||
for (final message in currentMessages) {
|
||||
final key = _messageMergeKey(message);
|
||||
final currentCount = (currentKeyCounts[key] ?? 0) + 1;
|
||||
currentKeyCounts[key] = currentCount;
|
||||
final persistedCount = persistedKeyCounts[key] ?? 0;
|
||||
|
||||
// Preserve distinct duplicates without IDs (for example same text
|
||||
// received multiple times in the same second) by only skipping the
|
||||
// overlapping occurrences that already exist in persisted storage.
|
||||
if (currentCount > persistedCount) {
|
||||
mergedMessages.add(message);
|
||||
}
|
||||
}
|
||||
|
||||
// Re-sort after merging persisted and in-memory messages so the
|
||||
// conversation window remains stable after optimistic inserts.
|
||||
mergedMessages.sort((a, b) => a.receivedAt.compareTo(b.receivedAt));
|
||||
final trimCount = mergedMessages.length > _messageWindowSize
|
||||
? mergedMessages.length - _messageWindowSize
|
||||
: 0;
|
||||
final windowedMergedMessages = mergedMessages.sublist(trimCount);
|
||||
|
||||
// Everything stored ahead of the window stays in storage on the next
|
||||
// save instead of being overwritten by the window.
|
||||
_messageStore.setArchived(contactKeyHex, [
|
||||
...archivedMessages,
|
||||
...mergedMessages.sublist(0, trimCount),
|
||||
]);
|
||||
_conversations[contactKeyHex] = windowedMergedMessages;
|
||||
}
|
||||
if (mergedMessages.isNotEmpty) {
|
||||
_conversations[contactKeyHex] = mergedMessages.sublist(trimCount);
|
||||
notifyListeners();
|
||||
} else {
|
||||
_messageStore.setArchived(contactKeyHex, const []);
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads a stored page once queued writes have landed, and again whenever
|
||||
/// the in-memory [window] or the [archived] count moved during the read.
|
||||
/// Returns null when [current] turns false, or when [older] history is
|
||||
/// requested and none is archived.
|
||||
Future<P?> _readSettledPage<M, P>({
|
||||
required bool Function() current,
|
||||
required List<M> Function() window,
|
||||
required int? Function() archived,
|
||||
required Future<P> Function(int? archived, List<M> window) read,
|
||||
bool older = false,
|
||||
}) async {
|
||||
while (true) {
|
||||
await _coalescedWrites.flush();
|
||||
if (!current()) return null;
|
||||
final archivedBefore = archived();
|
||||
if (older && archivedBefore == 0) return null;
|
||||
final snapshot = List<M>.of(window());
|
||||
final page = await read(archivedBefore, snapshot);
|
||||
if (!current()) return null;
|
||||
if (listEquals(snapshot, window()) && archivedBefore == archived()) {
|
||||
return page;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int _startOfWindow(int stored, List<Object?> window) =>
|
||||
(stored - window.length).clamp(0, stored);
|
||||
|
||||
String _messageMergeKey(Message message) {
|
||||
final messageId = message.messageId;
|
||||
if (messageId.isNotEmpty) {
|
||||
@@ -1054,58 +1076,126 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
Future<List<Message>> loadOlderMessages(
|
||||
String contactKeyHex, {
|
||||
int count = 50,
|
||||
}) async {
|
||||
final allMessages = await _messageStore.loadMessages(contactKeyHex);
|
||||
final currentMessages = _conversations[contactKeyHex] ?? [];
|
||||
}) {
|
||||
if (count <= 0) return Future.value([]);
|
||||
final loadKey = '${_messageStore.publicKeyHex}:$contactKeyHex';
|
||||
final pending = _conversationPageLoads[loadKey];
|
||||
if (pending != null) return pending;
|
||||
final started = _loadOlderMessages(contactKeyHex, count);
|
||||
_conversationPageLoads[loadKey] = started;
|
||||
return started.whenComplete(() {
|
||||
if (identical(_conversationPageLoads[loadKey], started)) {
|
||||
_conversationPageLoads.remove(loadKey);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Storage holds the archived entries followed by the in-memory window.
|
||||
final currentOffset =
|
||||
(_messageStore.archivedCount(contactKeyHex) ??
|
||||
allMessages.length - currentMessages.length)
|
||||
.clamp(0, allMessages.length);
|
||||
if (currentOffset == 0) {
|
||||
return []; // No more messages to load
|
||||
}
|
||||
|
||||
final fetchCount = count.clamp(0, currentOffset);
|
||||
final startIndex = currentOffset - fetchCount;
|
||||
|
||||
final olderMessages = allMessages.sublist(startIndex, currentOffset);
|
||||
_messageStore.unarchiveNewest(contactKeyHex, olderMessages.length);
|
||||
|
||||
// Prepend to current conversation
|
||||
_conversations[contactKeyHex] = [...olderMessages, ...currentMessages];
|
||||
Future<List<Message>> _loadOlderMessages(
|
||||
String contactKeyHex,
|
||||
int count,
|
||||
) async {
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _messageStore.publicKeyHex;
|
||||
bool current() =>
|
||||
!_disposed &&
|
||||
generation == _messageHistoryGeneration &&
|
||||
scope == _messageStore.publicKeyHex;
|
||||
final page = await _readSettledPage(
|
||||
current: current,
|
||||
window: () => _conversations[contactKeyHex] ?? const <Message>[],
|
||||
archived: () => _messageStore.archivedCount(contactKeyHex),
|
||||
older: true,
|
||||
read: (archived, window) async => _messageStore.loadMessagePage(
|
||||
contactKeyHex,
|
||||
// Unreconciled storage is assumed to end with the loaded window.
|
||||
before:
|
||||
archived ??
|
||||
_startOfWindow(
|
||||
(await _messageStore.loadMessagePage(
|
||||
contactKeyHex,
|
||||
limit: 0,
|
||||
)).total,
|
||||
window,
|
||||
),
|
||||
limit: count,
|
||||
),
|
||||
);
|
||||
if (page == null) return [];
|
||||
_messageStore.setArchivedCount(contactKeyHex, page.start);
|
||||
if (page.messages.isEmpty) return [];
|
||||
final currentMessages = _conversations[contactKeyHex] ?? const <Message>[];
|
||||
_conversations[contactKeyHex] = [...page.messages, ...currentMessages];
|
||||
notifyListeners();
|
||||
|
||||
return olderMessages;
|
||||
return page.messages;
|
||||
}
|
||||
|
||||
/// Full stored history (archived prefix plus the in-memory window) for
|
||||
/// search. Read-only: nothing is unarchived and listeners are not notified.
|
||||
Future<List<Message>> allMessagesForSearch(String contactKeyHex) async {
|
||||
final stored = await _messageStore.loadMessages(contactKeyHex);
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _messageStore.publicKeyHex;
|
||||
await _coalescedWrites.flush();
|
||||
if (_disposed ||
|
||||
generation != _messageHistoryGeneration ||
|
||||
scope != _messageStore.publicKeyHex) {
|
||||
return [];
|
||||
}
|
||||
final archived = _messageStore.archivedCount(contactKeyHex);
|
||||
final stored = await _messageStore.loadMessages(
|
||||
contactKeyHex,
|
||||
limit: archived,
|
||||
);
|
||||
if (_disposed ||
|
||||
generation != _messageHistoryGeneration ||
|
||||
scope != _messageStore.publicKeyHex) {
|
||||
return [];
|
||||
}
|
||||
final window = _conversations[contactKeyHex] ?? const <Message>[];
|
||||
final archived =
|
||||
(_messageStore.archivedCount(contactKeyHex) ??
|
||||
stored.length - window.length)
|
||||
.clamp(0, stored.length);
|
||||
return [...stored.sublist(0, archived), ...window];
|
||||
final prefix = archived == null
|
||||
? stored.sublist(
|
||||
0,
|
||||
(stored.length - window.length).clamp(0, stored.length),
|
||||
)
|
||||
: stored;
|
||||
return [...prefix, ...window];
|
||||
}
|
||||
|
||||
/// Channel counterpart of [allMessagesForSearch]; read-only.
|
||||
Future<List<ChannelMessage>> allChannelMessagesForSearch(
|
||||
int channelIndex,
|
||||
) async {
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _channelMessageStore.publicKeyHex;
|
||||
final slot = _canonicalSlot(channelIndex);
|
||||
final window = _channelMessages[slot] ?? const <ChannelMessage>[];
|
||||
final channelId = _channelIdForSlot(slot);
|
||||
if (channelId == null) return List.of(window);
|
||||
final stored = await _channelMessageStore.loadChannelMessages(channelId);
|
||||
final archived =
|
||||
(_channelMessageStore.archivedCount(channelId) ??
|
||||
stored.length - window.length)
|
||||
.clamp(0, stored.length);
|
||||
return [..._bindToSlot(stored.sublist(0, archived), slot), ...window];
|
||||
if (channelId == null) return List.of(_channelMessages[slot] ?? []);
|
||||
await _coalescedWrites.flush();
|
||||
if (_disposed ||
|
||||
generation != _messageHistoryGeneration ||
|
||||
scope != _channelMessageStore.publicKeyHex ||
|
||||
_slotChannelIds[slot] != channelId) {
|
||||
return [];
|
||||
}
|
||||
final archived = _channelMessageStore.archivedCount(channelId);
|
||||
final stored = await _channelMessageStore.loadChannelMessages(
|
||||
channelId,
|
||||
limit: archived,
|
||||
);
|
||||
if (_disposed ||
|
||||
generation != _messageHistoryGeneration ||
|
||||
scope != _channelMessageStore.publicKeyHex ||
|
||||
_slotChannelIds[slot] != channelId) {
|
||||
return [];
|
||||
}
|
||||
final window = _channelMessages[slot] ?? const <ChannelMessage>[];
|
||||
final rebound = _bindToSlot(stored, slot);
|
||||
final prefix = archived == null
|
||||
? rebound.sublist(
|
||||
0,
|
||||
(rebound.length - window.length).clamp(0, rebound.length),
|
||||
)
|
||||
: rebound;
|
||||
return [...prefix, ...window];
|
||||
}
|
||||
|
||||
List<ChannelMessage> getChannelMessages(Channel channel) {
|
||||
@@ -1492,7 +1582,14 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
|
||||
/// Runs queued persistence now. Called before the app is backgrounded and
|
||||
/// whenever the stores are about to switch to another radio.
|
||||
Future<void> flushPendingWrites() => _coalescedWrites.flush();
|
||||
Future<void> flushPendingWrites() async {
|
||||
await Future.wait([
|
||||
_coalescedWrites.flush(),
|
||||
_unreadStore.flush(),
|
||||
if (_pathHistoryService != null)
|
||||
_pathHistoryService!.flushPendingWrites(),
|
||||
]);
|
||||
}
|
||||
|
||||
int getUnreadCountForContact(Contact contact) {
|
||||
if (contact.type == advTypeRepeater) return 0;
|
||||
@@ -2045,77 +2142,103 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
: message.copyWith(channelIndex: slot),
|
||||
];
|
||||
|
||||
/// Load persisted channel messages for a specific channel
|
||||
/// Load only the newest persisted window of a channel.
|
||||
Future<void> _loadChannelMessages(int channelIndex) async {
|
||||
// The load replaces the in-memory history, so queued writes of it must
|
||||
// reach storage (whose cache updates synchronously) first.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _channelMessageStore.publicKeyHex;
|
||||
final channelId = _slotChannelIds[channelIndex];
|
||||
final allMessages = channelId == null
|
||||
? <ChannelMessage>[]
|
||||
: _bindToSlot(
|
||||
await _channelMessageStore.loadChannelMessages(channelId),
|
||||
channelIndex,
|
||||
);
|
||||
// Keep only the most recent N messages in memory to bound memory usage
|
||||
final windowedMessages = allMessages.length > _messageWindowSize
|
||||
? allMessages.sublist(allMessages.length - _messageWindowSize)
|
||||
: allMessages;
|
||||
if (channelId != null) {
|
||||
_channelMessageStore.setArchived(
|
||||
channelId,
|
||||
allMessages.sublist(0, allMessages.length - windowedMessages.length),
|
||||
bool current() =>
|
||||
!_disposed &&
|
||||
generation == _messageHistoryGeneration &&
|
||||
scope == _channelMessageStore.publicKeyHex &&
|
||||
_slotChannelIds[channelIndex] == channelId;
|
||||
var windowedMessages = <ChannelMessage>[];
|
||||
if (channelId == null) {
|
||||
await _coalescedWrites.flush();
|
||||
if (!current()) return;
|
||||
} else {
|
||||
final page = await _readSettledPage(
|
||||
current: current,
|
||||
window: () =>
|
||||
_channelMessages[channelIndex] ?? const <ChannelMessage>[],
|
||||
archived: () => _channelMessageStore.archivedCount(channelId),
|
||||
read: (_, _) => _channelMessageStore.loadMessagePage(
|
||||
channelId,
|
||||
limit: _messageWindowSize,
|
||||
),
|
||||
);
|
||||
if (page == null) return;
|
||||
windowedMessages = _bindToSlot(page.messages, channelIndex);
|
||||
_channelMessageStore.setArchivedCount(channelId, page.start);
|
||||
}
|
||||
// Replace even when nothing is stored so another radio's messages never
|
||||
// linger under this index.
|
||||
final hadMessages = _channelMessages[channelIndex]?.isNotEmpty ?? false;
|
||||
// Rules may have changed since these were stored.
|
||||
if (_applyFilterRules(channelIndex, windowedMessages)) {
|
||||
_scheduleChannelSave(channelIndex);
|
||||
}
|
||||
final retagged = _applyFilterRules(channelIndex, windowedMessages);
|
||||
_channelMessages[channelIndex] = windowedMessages;
|
||||
if (retagged) _scheduleChannelSave(channelIndex);
|
||||
if (hadMessages || windowedMessages.isNotEmpty) notifyListeners();
|
||||
}
|
||||
|
||||
/// Load older channel messages (pagination)
|
||||
Future<List<ChannelMessage>> loadOlderChannelMessages(
|
||||
int channelIndex, {
|
||||
int count = 50,
|
||||
}) async {
|
||||
}) {
|
||||
if (count <= 0) return Future.value([]);
|
||||
final slot = _canonicalSlot(channelIndex);
|
||||
final channelId = _channelIdForSlot(slot);
|
||||
if (channelId == null) return [];
|
||||
final allMessages = await _channelMessageStore.loadChannelMessages(
|
||||
channelId,
|
||||
if (channelId == null) return Future.value([]);
|
||||
final loadKey = '${_channelMessageStore.publicKeyHex}:$channelId';
|
||||
final pending = _channelPageLoads[loadKey];
|
||||
if (pending != null) return pending;
|
||||
final started = _loadOlderChannelMessages(slot, channelId, count);
|
||||
_channelPageLoads[loadKey] = started;
|
||||
return started.whenComplete(() {
|
||||
if (identical(_channelPageLoads[loadKey], started)) {
|
||||
_channelPageLoads.remove(loadKey);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
Future<List<ChannelMessage>> _loadOlderChannelMessages(
|
||||
int slot,
|
||||
String channelId,
|
||||
int count,
|
||||
) async {
|
||||
final generation = _messageHistoryGeneration;
|
||||
final scope = _channelMessageStore.publicKeyHex;
|
||||
bool current() =>
|
||||
!_disposed &&
|
||||
generation == _messageHistoryGeneration &&
|
||||
scope == _channelMessageStore.publicKeyHex &&
|
||||
_slotChannelIds[slot] == channelId;
|
||||
final page = await _readSettledPage(
|
||||
current: current,
|
||||
window: () => _channelMessages[slot] ?? const <ChannelMessage>[],
|
||||
archived: () => _channelMessageStore.archivedCount(channelId),
|
||||
older: true,
|
||||
read: (archived, window) async => _channelMessageStore.loadMessagePage(
|
||||
channelId,
|
||||
// Unreconciled storage is assumed to end with the loaded window.
|
||||
before:
|
||||
archived ??
|
||||
_startOfWindow(
|
||||
(await _channelMessageStore.loadMessagePage(
|
||||
channelId,
|
||||
limit: 0,
|
||||
)).total,
|
||||
window,
|
||||
),
|
||||
limit: count,
|
||||
),
|
||||
);
|
||||
final currentMessages = _channelMessages[slot] ?? [];
|
||||
|
||||
// Storage holds the archived entries followed by the in-memory window.
|
||||
final currentOffset =
|
||||
(_channelMessageStore.archivedCount(channelId) ??
|
||||
allMessages.length - currentMessages.length)
|
||||
.clamp(0, allMessages.length);
|
||||
if (currentOffset == 0) {
|
||||
return []; // No more messages to load
|
||||
}
|
||||
|
||||
final fetchCount = count.clamp(0, currentOffset);
|
||||
final startIndex = currentOffset - fetchCount;
|
||||
|
||||
final olderMessages = _bindToSlot(
|
||||
allMessages.sublist(startIndex, currentOffset),
|
||||
slot,
|
||||
);
|
||||
_channelMessageStore.unarchiveNewest(channelId, olderMessages.length);
|
||||
|
||||
// Rules may have changed since these were stored.
|
||||
if (page == null) return [];
|
||||
_channelMessageStore.setArchivedCount(channelId, page.start);
|
||||
final olderMessages = _bindToSlot(page.messages, slot);
|
||||
if (olderMessages.isEmpty) return [];
|
||||
final retagged = _applyFilterRules(slot, olderMessages);
|
||||
// Prepend to current conversation
|
||||
final currentMessages = _channelMessages[slot] ?? const <ChannelMessage>[];
|
||||
_channelMessages[slot] = [...olderMessages, ...currentMessages];
|
||||
if (retagged) _scheduleChannelSave(slot);
|
||||
notifyListeners();
|
||||
|
||||
return olderMessages;
|
||||
}
|
||||
|
||||
@@ -4305,6 +4428,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
_txCharacteristic = null;
|
||||
_deviceDisplayName = null;
|
||||
_deviceId = null;
|
||||
await _coalescedWrites.flush();
|
||||
_contacts.clear();
|
||||
_discoveredContacts.clear();
|
||||
_clearSessionMessageState();
|
||||
@@ -6333,7 +6457,8 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
}
|
||||
// Queued channel writes find their channel by slot; land them before
|
||||
// the map moves, or a channel whose slot changed would never be saved.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
await _coalescedWrites.flush();
|
||||
if (generation != _channelSessionGeneration) return;
|
||||
_slotChannelIds
|
||||
..clear()
|
||||
..addAll(next);
|
||||
@@ -6455,18 +6580,32 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
/// Runs the one-shot storage migration, then preloads this radio's channel
|
||||
/// state from the saved slot map so it shows before the channel sync ends.
|
||||
Future<void> _prepareChannelStorage() async {
|
||||
final generation = _channelSessionGeneration;
|
||||
final scope = _channelStore.publicKeyHex;
|
||||
bool current() =>
|
||||
!_disposed &&
|
||||
generation == _channelSessionGeneration &&
|
||||
scope == _channelStore.publicKeyHex;
|
||||
try {
|
||||
// First: the channel sync is already running and carries unread counts
|
||||
// over from these. The migration never touches the channel cache.
|
||||
await loadCachedChannels();
|
||||
await ChannelStorageMigration.migrate(
|
||||
_channelStore.publicKeyHex,
|
||||
beforeDone: (slotIds) async =>
|
||||
_receivedImageStore?.stampLegacyChannelIds(slotIds),
|
||||
);
|
||||
try {
|
||||
await ChannelStorageMigration.migrate(
|
||||
scope,
|
||||
beforeDone: (slotIds) async =>
|
||||
_receivedImageStore?.stampLegacyChannelIds(slotIds),
|
||||
);
|
||||
} catch (e) {
|
||||
// It repeats on the next connect; what is already stored under
|
||||
// channel IDs still preloads.
|
||||
appLogger.warn('Channel storage migration failed: $e');
|
||||
}
|
||||
await _loadChannelOrder();
|
||||
final saved = await _channelStore.loadSlotChannelIds();
|
||||
unawaited(_coalescedWrites.flush());
|
||||
await _coalescedWrites.flush();
|
||||
// The radio may have disconnected or changed while writes landed.
|
||||
if (!current()) return;
|
||||
_slotChannelIds
|
||||
..clear()
|
||||
..addAll(saved);
|
||||
@@ -6541,7 +6680,7 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
await sendFrame(buildSetChannelFrame(index, '', Uint8List(16)));
|
||||
// A twin slot with the same PSK keeps this history, so queued writes of
|
||||
// it land before the list is dropped; a full delete clears them below.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
await _coalescedWrites.flush();
|
||||
_channelMessages.remove(index);
|
||||
_processedChannelReactions.remove(index);
|
||||
try {
|
||||
@@ -9441,6 +9580,9 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
/// Drops the conversation and channel history held in memory, so a
|
||||
/// different radio never shows or persists another radio's messages.
|
||||
void _clearSessionMessageState() {
|
||||
_messageHistoryGeneration++;
|
||||
_conversationPageLoads.clear();
|
||||
_channelPageLoads.clear();
|
||||
// Writes start synchronously, so they still read this radio's history and
|
||||
// store keys before both change below.
|
||||
unawaited(_coalescedWrites.flush());
|
||||
@@ -9536,6 +9678,8 @@ class MeshCoreConnector extends ChangeNotifier {
|
||||
generation != _offlineLoadGeneration ||
|
||||
_state != MeshCoreConnectionState.disconnected;
|
||||
|
||||
await _coalescedWrites.flush();
|
||||
if (superseded()) return;
|
||||
_clearSessionMessageState();
|
||||
_bindStorageScope(keyHex);
|
||||
// A connect to this radio keeps what is loaded here; a different radio's
|
||||
|
||||
@@ -41,6 +41,7 @@ import 'services/ui_view_state_service.dart';
|
||||
import 'services/chat_background_service.dart';
|
||||
import 'services/timeout_prediction_service.dart';
|
||||
import 'storage/prefs_manager.dart';
|
||||
import 'storage/history_store.dart';
|
||||
import 'theme/mesh_theme.dart';
|
||||
import 'utils/app_logger.dart';
|
||||
import 'widgets/image_send_codec_binding.dart';
|
||||
@@ -68,6 +69,7 @@ void main() async {
|
||||
|
||||
// Initialize SharedPreferences cache
|
||||
await PrefsManager.initialize();
|
||||
await HistoryStore.initialize();
|
||||
|
||||
// Initialize services
|
||||
final storage = StorageService();
|
||||
|
||||
@@ -6,6 +6,7 @@ import '../services/storage_service.dart';
|
||||
import '../services/timeout_prediction_service.dart';
|
||||
import '../storage/legacy_key_migration.dart';
|
||||
import '../storage/prefs_manager.dart';
|
||||
import '../storage/history_store.dart';
|
||||
import 'review_radio.dart';
|
||||
|
||||
/// Channel notification modes (JSON map of channel name to mode name) as they
|
||||
@@ -26,9 +27,16 @@ const _savedGlobalKeyPrefix = 'review_mode_saved_global_';
|
||||
Future<void> clearReviewModeData() async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefix = ReviewRadio.storagePrefix;
|
||||
final keys = prefs.getKeys().where((key) => key.contains(prefix)).toList();
|
||||
final keys = {
|
||||
...prefs.getKeys(),
|
||||
...await HistoryStore.instance.getKeys(),
|
||||
}.where((key) => key.contains(prefix)).toList();
|
||||
for (final key in keys) {
|
||||
await prefs.remove(key);
|
||||
if (HistoryStore.isHistoryKey(key)) {
|
||||
await HistoryStore.instance.remove(key);
|
||||
} else {
|
||||
await prefs.remove(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+64
-18
@@ -75,7 +75,7 @@ class MapScreen extends StatefulWidget {
|
||||
State<MapScreen> createState() => _MapScreenState();
|
||||
}
|
||||
|
||||
class _MapScreenState extends State<MapScreen> {
|
||||
class _MapScreenState extends State<MapScreen> with WidgetsBindingObserver {
|
||||
// Zoom level at which node labels start to appear
|
||||
static const double _labelZoomThreshold = 14.0;
|
||||
// Below this zoom, nearby nodes collapse into clusters.
|
||||
@@ -135,6 +135,9 @@ class _MapScreenState extends State<MapScreen> {
|
||||
({LatLng center, double zoom})? _initialCamera;
|
||||
|
||||
static const String _lastCameraKey = 'map_last_camera';
|
||||
static const Duration _cameraSaveDelay = Duration(milliseconds: 500);
|
||||
Timer? _cameraSaveTimer;
|
||||
List<String>? _pendingCamera;
|
||||
|
||||
({LatLng center, double zoom}) _fallbackCamera(MeshCoreConnector connector) {
|
||||
final lat = connector.selfLatitude;
|
||||
@@ -152,23 +155,58 @@ class _MapScreenState extends State<MapScreen> {
|
||||
return (center: const LatLng(20, 0), zoom: _mapMinZoom);
|
||||
}
|
||||
|
||||
void _saveLastCamera() {
|
||||
void _scheduleCameraSave() {
|
||||
try {
|
||||
final camera = _mapController.camera;
|
||||
PrefsManager.instance.setStringList(_lastCameraKey, [
|
||||
final value = [
|
||||
camera.center.latitude.toString(),
|
||||
camera.center.longitude.toString(),
|
||||
camera.zoom.toString(),
|
||||
]);
|
||||
];
|
||||
_cameraSaveTimer?.cancel();
|
||||
_cameraSaveTimer = null;
|
||||
_pendingCamera =
|
||||
listEquals(value, PrefsManager.instance.getStringList(_lastCameraKey))
|
||||
? null
|
||||
: value;
|
||||
if (_pendingCamera != null) {
|
||||
_cameraSaveTimer = Timer(_cameraSaveDelay, _flushCameraSave);
|
||||
}
|
||||
} catch (_) {}
|
||||
}
|
||||
|
||||
void _flushCameraSave() {
|
||||
_cameraSaveTimer?.cancel();
|
||||
_cameraSaveTimer = null;
|
||||
final value = _pendingCamera;
|
||||
_pendingCamera = null;
|
||||
if (value == null) return;
|
||||
final prefs = PrefsManager.instance;
|
||||
if (listEquals(value, prefs.getStringList(_lastCameraKey))) return;
|
||||
unawaited(
|
||||
prefs.setStringList(_lastCameraKey, value).catchError((Object error) {
|
||||
debugPrint('Saving map camera failed: $error');
|
||||
return false;
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
void didChangeAppLifecycleState(AppLifecycleState state) {
|
||||
if (state != AppLifecycleState.resumed) {
|
||||
_scheduleCameraSave();
|
||||
_flushCameraSave();
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
WidgetsBinding.instance.removeObserver(this);
|
||||
_ageTimer?.cancel();
|
||||
_online.removeListener(_onOnlineChanged);
|
||||
_online.dispose();
|
||||
_saveLastCamera();
|
||||
_scheduleCameraSave();
|
||||
_flushCameraSave();
|
||||
_searchController.dispose();
|
||||
_searchFocus.dispose();
|
||||
_mapController.dispose();
|
||||
@@ -278,6 +316,7 @@ class _MapScreenState extends State<MapScreen> {
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
WidgetsBinding.instance.addObserver(this);
|
||||
_loadRemovedMarkers();
|
||||
_online.addListener(_onOnlineChanged);
|
||||
_ageTimer = Timer.periodic(const Duration(seconds: 60), (_) {
|
||||
@@ -531,7 +570,7 @@ class _MapScreenState extends State<MapScreen> {
|
||||
final tileCache = context.read<MapTileCacheService>();
|
||||
final scheme = Theme.of(context).colorScheme;
|
||||
final isDesktop = _isDesktopPlatform(defaultTargetPlatform);
|
||||
final allContacts = connector.allContacts;
|
||||
final allContacts = connectorSnapshot.allContacts;
|
||||
|
||||
final contacts = settings.mapShowDiscoveryContacts
|
||||
? allContacts
|
||||
@@ -912,11 +951,12 @@ class _MapScreenState extends State<MapScreen> {
|
||||
event is MapEventFlingAnimationEnd ||
|
||||
event is MapEventScrollWheelZoom ||
|
||||
event is MapEventDoubleTapZoomEnd) {
|
||||
_saveLastCamera();
|
||||
_scheduleCameraSave();
|
||||
if (showOnline) _requestOnlineData();
|
||||
}
|
||||
},
|
||||
onPositionChanged: (camera, hasGesture) {
|
||||
_scheduleCameraSave();
|
||||
// Track zoom in half-step buckets so cluster/marker
|
||||
// detail levels update without rebuilding every frame.
|
||||
final bucket = (camera.zoom * 2).roundToDouble() / 2;
|
||||
@@ -1087,13 +1127,19 @@ class _MapScreenState extends State<MapScreen> {
|
||||
),
|
||||
bottomNavigationBar: SafeArea(
|
||||
top: false,
|
||||
child: QuickSwitchBar(
|
||||
selectedIndex: 2,
|
||||
onDestinationSelected: (index) =>
|
||||
_handleQuickSwitch(index, context),
|
||||
contactsUnreadCount: connector.getTotalContactsUnreadCount(),
|
||||
channelsUnreadCount: connector.getTotalChannelsUnreadCount(),
|
||||
highContrast: _usePaletteOverlay,
|
||||
child: Selector<MeshCoreConnector, (int, int)>(
|
||||
selector: (_, connector) => (
|
||||
connector.getTotalContactsUnreadCount(),
|
||||
connector.getTotalChannelsUnreadCount(),
|
||||
),
|
||||
builder: (context, unread, child) => QuickSwitchBar(
|
||||
selectedIndex: 2,
|
||||
onDestinationSelected: (index) =>
|
||||
_handleQuickSwitch(index, context),
|
||||
contactsUnreadCount: unread.$1,
|
||||
channelsUnreadCount: unread.$2,
|
||||
highContrast: _usePaletteOverlay,
|
||||
),
|
||||
),
|
||||
),
|
||||
floatingActionButton:
|
||||
@@ -1130,8 +1176,7 @@ class _MapScreenState extends State<MapScreen> {
|
||||
}) {
|
||||
final visibleContactsSignature = Object.hashAll(
|
||||
contacts.map(
|
||||
(contact) =>
|
||||
Object.hash(_mapContactSignature(contact), _ageOf(contact)),
|
||||
(contact) => Object.hash(contact.publicKeyHex, _ageOf(contact)),
|
||||
),
|
||||
);
|
||||
final key = _NodeMarkersCacheKey(
|
||||
@@ -4226,6 +4271,7 @@ int _mapContactSignature(Contact contact) {
|
||||
|
||||
class _MapConnectorSnapshot {
|
||||
final MeshCoreConnector connector;
|
||||
final List<Contact> allContacts;
|
||||
final int contactsSignature;
|
||||
final int markerSignature;
|
||||
final int batterySignature;
|
||||
@@ -4233,6 +4279,7 @@ class _MapConnectorSnapshot {
|
||||
|
||||
const _MapConnectorSnapshot({
|
||||
required this.connector,
|
||||
required this.allContacts,
|
||||
required this.contactsSignature,
|
||||
required this.markerSignature,
|
||||
required this.batterySignature,
|
||||
@@ -4285,6 +4332,7 @@ class _MapConnectorSnapshot {
|
||||
|
||||
return _MapConnectorSnapshot(
|
||||
connector: connector,
|
||||
allContacts: allContacts,
|
||||
contactsSignature: contactsSignature,
|
||||
markerSignature: Object.hashAll(markerParts),
|
||||
batterySignature: batterySignature,
|
||||
@@ -4296,8 +4344,6 @@ class _MapConnectorSnapshot {
|
||||
connector.currentBwHz,
|
||||
connector.currentSf,
|
||||
connector.currentTxPower,
|
||||
connector.getTotalContactsUnreadCount(),
|
||||
connector.getTotalChannelsUnreadCount(),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -13,6 +13,7 @@ import 'app_settings_service.dart';
|
||||
import '../storage/channel_store.dart';
|
||||
import '../storage/contact_store.dart';
|
||||
import '../storage/prefs_manager.dart';
|
||||
import '../storage/history_store.dart';
|
||||
|
||||
const int _backupVersion = 1;
|
||||
const int _pbkdf2Iterations = 310000;
|
||||
@@ -134,6 +135,7 @@ class BackupService {
|
||||
required String password,
|
||||
}) async {
|
||||
if (items.isEmpty) throw StateError('Select at least one backup item');
|
||||
await connector.flushPendingWrites();
|
||||
final includedItems = Set<BackupItem>.of(items);
|
||||
final customVars = connector.currentCustomVars ?? const <String, String>{};
|
||||
if (includedItems.isEmpty) {
|
||||
@@ -175,7 +177,9 @@ class BackupService {
|
||||
};
|
||||
}
|
||||
if (includedItems.contains(BackupItem.regions)) {
|
||||
node['preferences'] = _snapshotPreferences((key) => key == 'regions');
|
||||
node['preferences'] = await _snapshotPreferences(
|
||||
(key) => key == 'regions',
|
||||
);
|
||||
}
|
||||
sections[BackupSection.nodeSettings.name] = node;
|
||||
}
|
||||
@@ -239,8 +243,8 @@ class BackupService {
|
||||
}
|
||||
sections[section.name] = {
|
||||
'preferences': section == BackupSection.appSettings
|
||||
? _snapshotAppSettingsPreferences(sectionItems)
|
||||
: _snapshotPreferences(
|
||||
? await _snapshotAppSettingsPreferences(sectionItems)
|
||||
: await _snapshotPreferences(
|
||||
(key) =>
|
||||
_preferenceBelongsToItems(key, sectionItems, devicePrefix),
|
||||
),
|
||||
@@ -266,6 +270,7 @@ class BackupService {
|
||||
required AppSettingsService appSettingsService,
|
||||
}) async {
|
||||
if (items.isEmpty) throw StateError('Select at least one item to restore');
|
||||
await connector.flushPendingWrites();
|
||||
final payload = await _decodeImport(contents, password: password);
|
||||
final sectionData = payload['sections'];
|
||||
if (sectionData is! Map) throw const FormatException('Missing backup data');
|
||||
@@ -956,14 +961,19 @@ class BackupService {
|
||||
static int _intOr(Object? value, int fallback) =>
|
||||
value is int ? value : fallback;
|
||||
|
||||
static Map<String, Object?> _snapshotPreferences(
|
||||
static Future<Map<String, Object?>> _snapshotPreferences(
|
||||
bool Function(String) include,
|
||||
) {
|
||||
) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final values = <String, Object?>{};
|
||||
for (final key in prefs.getKeys()) {
|
||||
for (final key in {
|
||||
...prefs.getKeys(),
|
||||
...await HistoryStore.instance.getKeys(),
|
||||
}) {
|
||||
if (!include(key)) continue;
|
||||
final value = prefs.get(key);
|
||||
final value = HistoryStore.isHistoryKey(key)
|
||||
? await HistoryStore.instance.getString(key)
|
||||
: prefs.get(key);
|
||||
if (value is String) {
|
||||
values[key] = _expandJsonPreference(value);
|
||||
} else if (value is bool || value is int || value is double) {
|
||||
@@ -1003,10 +1013,10 @@ class BackupService {
|
||||
return value;
|
||||
}
|
||||
|
||||
static Map<String, Object?> _snapshotAppSettingsPreferences(
|
||||
static Future<Map<String, Object?>> _snapshotAppSettingsPreferences(
|
||||
Set<BackupItem> items,
|
||||
) {
|
||||
final values = _snapshotPreferences(
|
||||
) async {
|
||||
final values = await _snapshotPreferences(
|
||||
(key) => _preferenceBelongsToItems(key, items, ''),
|
||||
);
|
||||
final appSettings = _asMap(values['app_settings']);
|
||||
@@ -1224,30 +1234,37 @@ class BackupService {
|
||||
final existingAppSettings = _asJsonMapPreference(
|
||||
prefs.getString('app_settings'),
|
||||
);
|
||||
final matching = prefs.getKeys().where((key) {
|
||||
if (section == BackupSection.appSettings &&
|
||||
key == 'app_settings' &&
|
||||
!items.contains(BackupItem.appSettings)) {
|
||||
return false;
|
||||
}
|
||||
if (!_preferenceBelongsToSection(
|
||||
key,
|
||||
section,
|
||||
devicePrefix: destinationPrefix,
|
||||
) ||
|
||||
!_preferenceBelongsToItems(key, items, destinationPrefix)) {
|
||||
return false;
|
||||
}
|
||||
if (section == BackupSection.appSettings ||
|
||||
section == BackupSection.nodeSettings) {
|
||||
return true;
|
||||
}
|
||||
return _hasDevicePrefix(key, section, destinationPrefix) ||
|
||||
(section == BackupSection.channels &&
|
||||
key.startsWith('message_filter_'));
|
||||
}).toList();
|
||||
final matching =
|
||||
{...prefs.getKeys(), ...await HistoryStore.instance.getKeys()}.where((
|
||||
key,
|
||||
) {
|
||||
if (section == BackupSection.appSettings &&
|
||||
key == 'app_settings' &&
|
||||
!items.contains(BackupItem.appSettings)) {
|
||||
return false;
|
||||
}
|
||||
if (!_preferenceBelongsToSection(
|
||||
key,
|
||||
section,
|
||||
devicePrefix: destinationPrefix,
|
||||
) ||
|
||||
!_preferenceBelongsToItems(key, items, destinationPrefix)) {
|
||||
return false;
|
||||
}
|
||||
if (section == BackupSection.appSettings ||
|
||||
section == BackupSection.nodeSettings) {
|
||||
return true;
|
||||
}
|
||||
return _hasDevicePrefix(key, section, destinationPrefix) ||
|
||||
(section == BackupSection.channels &&
|
||||
key.startsWith('message_filter_'));
|
||||
}).toList();
|
||||
for (final key in matching) {
|
||||
await prefs.remove(key);
|
||||
if (HistoryStore.isHistoryKey(key)) {
|
||||
await HistoryStore.instance.remove(key);
|
||||
} else {
|
||||
await prefs.remove(key);
|
||||
}
|
||||
}
|
||||
for (final entry in values.entries) {
|
||||
if (!_preferenceBelongsToItems(entry.key, items, sourcePrefix)) {
|
||||
@@ -1260,7 +1277,13 @@ class BackupService {
|
||||
destinationPrefix,
|
||||
);
|
||||
final value = entry.value;
|
||||
if (section == BackupSection.appSettings && key == 'app_settings') {
|
||||
if (HistoryStore.isHistoryKey(key)) {
|
||||
await HistoryStore.instance.setString(
|
||||
key,
|
||||
value is String ? value : jsonEncode(value),
|
||||
);
|
||||
} else if (section == BackupSection.appSettings &&
|
||||
key == 'app_settings') {
|
||||
final storedIncoming = _asJsonMapPreference(value);
|
||||
if (storedIncoming == null) {
|
||||
throw const FormatException('Invalid app settings in backup');
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
export 'map_tile_cache_repository_stub.dart'
|
||||
if (dart.library.io) 'map_tile_cache_repository_io.dart';
|
||||
@@ -0,0 +1,312 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
||||
import 'package:path_provider/path_provider.dart';
|
||||
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
|
||||
|
||||
CacheInfoRepository createMapTileCacheRepository(String cacheKey) {
|
||||
if (!Platform.isLinux && !Platform.isWindows) {
|
||||
return CacheObjectProvider(databaseName: cacheKey);
|
||||
}
|
||||
sqfliteFfiInit();
|
||||
return SqliteMapTileCacheRepository(databaseName: cacheKey);
|
||||
}
|
||||
|
||||
/// Tile metadata stays in SQLite; only queried rows become Dart objects.
|
||||
class SqliteMapTileCacheRepository implements CacheInfoRepository {
|
||||
SqliteMapTileCacheRepository({
|
||||
required this.databaseName,
|
||||
Future<Directory> Function()? directory,
|
||||
DatabaseFactory? factory,
|
||||
}) : _directory = directory ?? getApplicationSupportDirectory,
|
||||
_factory = factory ?? databaseFactoryFfi;
|
||||
|
||||
static const int schemaVersion = 1;
|
||||
static const int legacyImportVersion = 1;
|
||||
static const String _table = 'cacheObject';
|
||||
static const String _migrationTable = 'cacheMigration';
|
||||
static const String _legacyMigration = 'legacyJson';
|
||||
static const String _unreadableSuffix = '.unreadable';
|
||||
|
||||
final String databaseName;
|
||||
final Future<Directory> Function() _directory;
|
||||
final DatabaseFactory _factory;
|
||||
Future<Directory>? _resolvedDirectory;
|
||||
Future<Database>? _opening;
|
||||
int _connections = 0;
|
||||
|
||||
Future<Directory> _baseDirectory() => _resolvedDirectory ??= _directory();
|
||||
|
||||
Future<String> _databasePath() async =>
|
||||
'${(await _baseDirectory()).path}${Platform.pathSeparator}$databaseName.db';
|
||||
|
||||
Future<File> _legacyFile() async => File(
|
||||
'${(await _baseDirectory()).path}${Platform.pathSeparator}$databaseName.json',
|
||||
);
|
||||
|
||||
Future<Database> _database() async {
|
||||
final pending = _opening;
|
||||
if (pending != null) return pending;
|
||||
final started = _openDatabase();
|
||||
_opening = started;
|
||||
try {
|
||||
return await started;
|
||||
} catch (_) {
|
||||
if (identical(_opening, started)) _opening = null;
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
Future<Database> _openDatabase() async {
|
||||
final path = await _databasePath();
|
||||
await File(path).parent.create(recursive: true);
|
||||
final db = await _factory.openDatabase(
|
||||
path,
|
||||
options: OpenDatabaseOptions(
|
||||
version: schemaVersion,
|
||||
onCreate: (db, version) async {
|
||||
await db.execute('''
|
||||
CREATE TABLE $_table (
|
||||
_id INTEGER PRIMARY KEY,
|
||||
url TEXT NOT NULL,
|
||||
key TEXT NOT NULL UNIQUE,
|
||||
relativePath TEXT NOT NULL,
|
||||
eTag TEXT,
|
||||
validTill INTEGER NOT NULL,
|
||||
touched INTEGER NOT NULL,
|
||||
length INTEGER
|
||||
)
|
||||
''');
|
||||
await db.execute('CREATE INDEX cacheTouched ON $_table (touched)');
|
||||
await db.execute('''
|
||||
CREATE TABLE $_migrationTable (
|
||||
name TEXT PRIMARY KEY,
|
||||
version INTEGER NOT NULL
|
||||
)
|
||||
''');
|
||||
},
|
||||
),
|
||||
);
|
||||
try {
|
||||
await _importLegacyJson(db);
|
||||
return db;
|
||||
} catch (_) {
|
||||
await db.close();
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _importLegacyJson(Database db) async {
|
||||
final versions = await db.query(
|
||||
_migrationTable,
|
||||
where: 'name = ?',
|
||||
whereArgs: [_legacyMigration],
|
||||
);
|
||||
final version = versions.isEmpty ? 0 : versions.single['version'] as int;
|
||||
if (version > legacyImportVersion) return;
|
||||
final legacy = await _legacyFile();
|
||||
var unreadable = false;
|
||||
if (version < legacyImportVersion) {
|
||||
final List<Map<String, Object?>> records;
|
||||
(records, unreadable) = await compute(_readLegacyRecords, legacy.path);
|
||||
await db.transaction((transaction) async {
|
||||
final batch = transaction.batch();
|
||||
for (final record in records) {
|
||||
batch.insert(
|
||||
_table,
|
||||
record,
|
||||
conflictAlgorithm: ConflictAlgorithm.ignore,
|
||||
);
|
||||
}
|
||||
batch.insert(_migrationTable, {
|
||||
'name': _legacyMigration,
|
||||
'version': legacyImportVersion,
|
||||
}, conflictAlgorithm: ConflictAlgorithm.replace);
|
||||
await batch.commit(noResult: true);
|
||||
});
|
||||
}
|
||||
// A committed version marker makes a crash before cleanup safe to retry.
|
||||
try {
|
||||
if (unreadable && await legacy.exists()) {
|
||||
// Kept for inspection rather than deleted; it is never imported again.
|
||||
debugPrint('Map metadata migration skipped unreadable records');
|
||||
await legacy.rename('${legacy.path}$_unreadableSuffix');
|
||||
}
|
||||
for (final file in [legacy, File('${legacy.path}.tmp')]) {
|
||||
if (await file.exists()) await file.delete();
|
||||
}
|
||||
} on FileSystemException catch (error) {
|
||||
debugPrint('Map metadata migration cleanup: $error');
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> open() async {
|
||||
_connections++;
|
||||
try {
|
||||
await _database();
|
||||
return true;
|
||||
} catch (_) {
|
||||
_connections--;
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> close() async {
|
||||
if (_connections == 0 || --_connections > 0) return false;
|
||||
final pending = _opening;
|
||||
_opening = null;
|
||||
if (pending != null) await (await pending).close();
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> exists() async => File(await _databasePath()).exists();
|
||||
|
||||
@override
|
||||
Future<void> deleteDataFile() async {
|
||||
if (_connections != 0) {
|
||||
throw StateError('Close map metadata connections before deleting it.');
|
||||
}
|
||||
await _factory.deleteDatabase(await _databasePath());
|
||||
final legacy = await _legacyFile();
|
||||
for (final file in [
|
||||
legacy,
|
||||
File('${legacy.path}.tmp'),
|
||||
File('${legacy.path}$_unreadableSuffix'),
|
||||
]) {
|
||||
if (await file.exists()) await file.delete();
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<CacheObject?> get(String key) async {
|
||||
final rows = await (await _database()).query(
|
||||
_table,
|
||||
where: 'key = ?',
|
||||
whereArgs: [key],
|
||||
limit: 1,
|
||||
);
|
||||
return rows.isEmpty ? null : CacheObject.fromMap(rows.single);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<CacheObject> insert(
|
||||
CacheObject cacheObject, {
|
||||
bool setTouchedToNow = true,
|
||||
}) async {
|
||||
if (cacheObject.id != null) {
|
||||
throw ArgumentError('Inserted cache objects must not have an ID.');
|
||||
}
|
||||
final map = cacheObject.toMap(setTouchedToNow: setTouchedToNow);
|
||||
final id = await (await _database()).insert(_table, map);
|
||||
return CacheObject.fromMap({...map, CacheObject.columnId: id});
|
||||
}
|
||||
|
||||
@override
|
||||
Future<int> update(
|
||||
CacheObject cacheObject, {
|
||||
bool setTouchedToNow = true,
|
||||
}) async {
|
||||
if (cacheObject.id == null) {
|
||||
throw ArgumentError('Updated cache objects must have an ID.');
|
||||
}
|
||||
return (await _database()).update(
|
||||
_table,
|
||||
cacheObject.toMap(setTouchedToNow: setTouchedToNow),
|
||||
where: '_id = ?',
|
||||
whereArgs: [cacheObject.id],
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<dynamic> updateOrInsert(CacheObject cacheObject) =>
|
||||
cacheObject.id == null ? insert(cacheObject) : update(cacheObject);
|
||||
|
||||
@override
|
||||
Future<int> delete(int id) async =>
|
||||
(await _database()).delete(_table, where: '_id = ?', whereArgs: [id]);
|
||||
|
||||
@override
|
||||
Future<int> deleteAll(Iterable<int> ids) async {
|
||||
final unique = ids.toSet().toList();
|
||||
if (unique.isEmpty) return 0;
|
||||
final db = await _database();
|
||||
return db.transaction((transaction) async {
|
||||
var deleted = 0;
|
||||
for (var start = 0; start < unique.length; start += 500) {
|
||||
final chunk = unique.skip(start).take(500).toList();
|
||||
deleted += await transaction.delete(
|
||||
_table,
|
||||
where: '_id IN (${List.filled(chunk.length, '?').join(',')})',
|
||||
whereArgs: chunk,
|
||||
);
|
||||
}
|
||||
return deleted;
|
||||
});
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<CacheObject>> getAllObjects() async =>
|
||||
CacheObject.fromMapList(await (await _database()).query(_table));
|
||||
|
||||
@override
|
||||
Future<List<CacheObject>> getObjectsOverCapacity(int capacity) async =>
|
||||
CacheObject.fromMapList(
|
||||
await (await _database()).query(
|
||||
_table,
|
||||
where: 'touched < ?',
|
||||
whereArgs: [
|
||||
DateTime.now()
|
||||
.subtract(const Duration(days: 1))
|
||||
.millisecondsSinceEpoch,
|
||||
],
|
||||
orderBy: 'touched DESC, _id DESC',
|
||||
offset: capacity,
|
||||
limit: 100,
|
||||
),
|
||||
);
|
||||
|
||||
@override
|
||||
Future<List<CacheObject>> getOldObjects(Duration maxAge) async =>
|
||||
CacheObject.fromMapList(
|
||||
await (await _database()).query(
|
||||
_table,
|
||||
where: 'touched < ?',
|
||||
whereArgs: [DateTime.now().subtract(maxAge).millisecondsSinceEpoch],
|
||||
orderBy: 'touched ASC, _id ASC',
|
||||
limit: 100,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/// Returns the importable records and whether any part of the file was
|
||||
/// unreadable. A broken file must not keep the tile cache from opening.
|
||||
(List<Map<String, Object?>>, bool) _readLegacyRecords(String path) {
|
||||
final file = File(path);
|
||||
if (!file.existsSync()) return ([], false);
|
||||
final Object? decoded;
|
||||
try {
|
||||
decoded = jsonDecode(file.readAsStringSync());
|
||||
} on Exception {
|
||||
return ([], true);
|
||||
}
|
||||
if (decoded is! List) return ([], true);
|
||||
final records = <Map<String, Object?>>[];
|
||||
var unreadable = false;
|
||||
for (final value in decoded) {
|
||||
try {
|
||||
records.add(
|
||||
CacheObject.fromMap(
|
||||
(value as Map).cast<String, dynamic>(),
|
||||
).toMap(setTouchedToNow: false)..remove(CacheObject.columnId),
|
||||
);
|
||||
} catch (_) {
|
||||
unreadable = true;
|
||||
}
|
||||
}
|
||||
return (records, unreadable);
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
||||
|
||||
CacheInfoRepository createMapTileCacheRepository(String cacheKey) =>
|
||||
NonStoringObjectProvider();
|
||||
@@ -8,6 +8,7 @@ import 'package:flutter_map/flutter_map.dart';
|
||||
import '../models/app_settings.dart';
|
||||
import '../theme/mesh_theme.dart';
|
||||
import 'app_settings_service.dart';
|
||||
import 'map_tile_cache_repository.dart';
|
||||
|
||||
enum MapRasterSourcePreset {
|
||||
osmAuto('osm_auto'),
|
||||
@@ -347,6 +348,7 @@ class MapTileCacheService extends ChangeNotifier {
|
||||
cacheKey,
|
||||
stalePeriod: const Duration(days: 365),
|
||||
maxNrOfCacheObjects: 200000,
|
||||
repo: createMapTileCacheRepository(cacheKey),
|
||||
),
|
||||
) {
|
||||
tileProvider = CachedNetworkTileProvider(cacheManager: this.cacheManager);
|
||||
@@ -534,19 +536,23 @@ class MapTileCacheService extends ChangeNotifier {
|
||||
Future<CachedTileInventory> getCachedTileInventory() async {
|
||||
final repo = _concreteCacheManager.config.repo;
|
||||
await repo.open();
|
||||
final objects = await repo.getAllObjects();
|
||||
final tiles = <CachedTileInfo>[];
|
||||
int totalBytes = 0;
|
||||
try {
|
||||
final objects = await repo.getAllObjects();
|
||||
final tiles = <CachedTileInfo>[];
|
||||
int totalBytes = 0;
|
||||
|
||||
for (final object in objects) {
|
||||
totalBytes += object.length ?? 0;
|
||||
final tile = _parseCachedTile(object);
|
||||
if (tile != null) {
|
||||
tiles.add(tile);
|
||||
for (final object in objects) {
|
||||
totalBytes += object.length ?? 0;
|
||||
final tile = _parseCachedTile(object);
|
||||
if (tile != null) {
|
||||
tiles.add(tile);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return CachedTileInventory(tiles: tiles, totalBytes: totalBytes);
|
||||
return CachedTileInventory(tiles: tiles, totalBytes: totalBytes);
|
||||
} finally {
|
||||
await repo.close();
|
||||
}
|
||||
}
|
||||
|
||||
List<CachedTileInfo> filterTilesForActiveSource(
|
||||
|
||||
@@ -5,6 +5,7 @@ import 'package:flutter/foundation.dart';
|
||||
import '../models/contact.dart';
|
||||
import '../models/path_history.dart';
|
||||
import '../models/path_selection.dart';
|
||||
import '../utils/app_logger.dart';
|
||||
import '../utils/coalesced_writes.dart';
|
||||
import 'route_chooser.dart';
|
||||
import 'storage_service.dart';
|
||||
@@ -13,7 +14,10 @@ class PathHistoryService extends ChangeNotifier {
|
||||
final StorageService _storage;
|
||||
final Map<String, ContactPathHistory> _cache = {};
|
||||
final Map<String, _FloodStats> _floodStats = {};
|
||||
final Map<String, Future<void>> _pendingLoads = {};
|
||||
final Map<String, Future<bool>> _pendingLoads = {};
|
||||
int _generation = 0;
|
||||
bool _disposed = false;
|
||||
Future<void> _clearing = Future<void>.value();
|
||||
// A path record lands for most received messages, so saves are batched.
|
||||
final CoalescedWrites _writes = CoalescedWrites(
|
||||
delay: const Duration(seconds: 5),
|
||||
@@ -43,9 +47,12 @@ class PathHistoryService extends ChangeNotifier {
|
||||
_now = clock ?? DateTime.now;
|
||||
|
||||
void setDevicePublicKey(String publicKeyHex) {
|
||||
if (_disposed) return;
|
||||
// Queued saves use the storage key on entry, so they still land under
|
||||
// the previous radio's key.
|
||||
unawaited(_writes.flush());
|
||||
_generation++;
|
||||
_pendingLoads.clear();
|
||||
_storage.setPublicKeyHex = publicKeyHex;
|
||||
_cache.clear();
|
||||
_cacheAccessOrder.clear();
|
||||
@@ -59,6 +66,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void handlePathUpdated(Contact contact, {double initialWeight = 1.0}) {
|
||||
if (_disposed) return;
|
||||
if (contact.pathLength < 0 && contact.path.isEmpty) return;
|
||||
final hopCount = contact.pathLength < 0
|
||||
? contact.path.length
|
||||
@@ -77,6 +85,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
|
||||
void recordPathAttempt(String contactPubKeyHex, PathSelection selection) {
|
||||
if (_disposed) return;
|
||||
if (selection.useFlood) {
|
||||
_updateFloodStats(contactPubKeyHex);
|
||||
return;
|
||||
@@ -104,11 +113,18 @@ class PathHistoryService extends ChangeNotifier {
|
||||
double successIncrement = 0.5,
|
||||
double maxWeight = 5.0,
|
||||
}) {
|
||||
if (_disposed) return;
|
||||
// A flood answered directly credits the direct (zero-hop) path.
|
||||
if (hopCount < 0 || (pathBytes.isEmpty && hopCount != 0)) return;
|
||||
if (!_cache.containsKey(contactPubKeyHex)) {
|
||||
_ensureLoaded(contactPubKeyHex).then((_) {
|
||||
if (!_cache.containsKey(contactPubKeyHex)) return;
|
||||
final generation = _generation;
|
||||
_ensureLoaded(contactPubKeyHex).then((loaded) {
|
||||
if (!loaded ||
|
||||
_disposed ||
|
||||
generation != _generation ||
|
||||
!_cache.containsKey(contactPubKeyHex)) {
|
||||
return;
|
||||
}
|
||||
recordFloodPathAttribution(
|
||||
contactPubKeyHex: contactPubKeyHex,
|
||||
pathBytes: pathBytes,
|
||||
@@ -160,6 +176,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
double failureDecrement = 0.5,
|
||||
double maxWeight = 5.0,
|
||||
}) {
|
||||
if (_disposed) return;
|
||||
if (selection.useFlood) {
|
||||
final stats = _floodStats.putIfAbsent(
|
||||
contactPubKeyHex,
|
||||
@@ -176,8 +193,14 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
|
||||
if (!_cache.containsKey(contactPubKeyHex)) {
|
||||
_ensureLoaded(contactPubKeyHex).then((_) {
|
||||
if (!_cache.containsKey(contactPubKeyHex)) return;
|
||||
final generation = _generation;
|
||||
_ensureLoaded(contactPubKeyHex).then((loaded) {
|
||||
if (!loaded ||
|
||||
_disposed ||
|
||||
generation != _generation ||
|
||||
!_cache.containsKey(contactPubKeyHex)) {
|
||||
return;
|
||||
}
|
||||
recordPathResult(
|
||||
contactPubKeyHex,
|
||||
selection,
|
||||
@@ -294,6 +317,8 @@ class PathHistoryService extends ChangeNotifier {
|
||||
double? recentFailure,
|
||||
DateTime? statsAt,
|
||||
}) {
|
||||
if (_disposed) return;
|
||||
final generation = _generation;
|
||||
void add() => _addPathRecordInternal(
|
||||
contactPubKeyHex,
|
||||
hopCount,
|
||||
@@ -313,27 +338,43 @@ class PathHistoryService extends ChangeNotifier {
|
||||
if (_cache.containsKey(contactPubKeyHex)) {
|
||||
add();
|
||||
} else {
|
||||
_ensureLoaded(contactPubKeyHex).then((_) => add());
|
||||
_ensureLoaded(contactPubKeyHex).then((loaded) {
|
||||
if (loaded && !_disposed && generation == _generation) add();
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _ensureLoaded(String contactPubKeyHex) {
|
||||
if (_cache.containsKey(contactPubKeyHex)) return Future.value();
|
||||
return _pendingLoads[contactPubKeyHex] ??=
|
||||
_loadHistoryFromStorage(contactPubKeyHex)
|
||||
.then((loaded) {
|
||||
_cache[contactPubKeyHex] ??=
|
||||
loaded ??
|
||||
ContactPathHistory(
|
||||
contactPubKeyHex: contactPubKeyHex,
|
||||
recentPaths: [],
|
||||
);
|
||||
_trackAccess(contactPubKeyHex);
|
||||
_evictIfNeeded();
|
||||
})
|
||||
.whenComplete(() {
|
||||
_pendingLoads.remove(contactPubKeyHex);
|
||||
});
|
||||
Future<bool> _ensureLoaded(String contactPubKeyHex) {
|
||||
if (_disposed) return Future.value(false);
|
||||
if (_cache.containsKey(contactPubKeyHex)) return Future.value(true);
|
||||
final existing = _pendingLoads[contactPubKeyHex];
|
||||
if (existing != null) return existing;
|
||||
final generation = _generation;
|
||||
late final Future<bool> pending;
|
||||
pending = _loadHistoryFromStorage(contactPubKeyHex)
|
||||
.then((loaded) {
|
||||
if (_disposed ||
|
||||
generation != _generation ||
|
||||
!identical(_pendingLoads[contactPubKeyHex], pending)) {
|
||||
return false;
|
||||
}
|
||||
_cache[contactPubKeyHex] ??=
|
||||
loaded ??
|
||||
ContactPathHistory(
|
||||
contactPubKeyHex: contactPubKeyHex,
|
||||
recentPaths: [],
|
||||
);
|
||||
_trackAccess(contactPubKeyHex);
|
||||
_evictIfNeeded();
|
||||
return true;
|
||||
})
|
||||
.whenComplete(() {
|
||||
if (identical(_pendingLoads[contactPubKeyHex], pending)) {
|
||||
_pendingLoads.remove(contactPubKeyHex);
|
||||
}
|
||||
});
|
||||
_pendingLoads[contactPubKeyHex] = pending;
|
||||
return pending;
|
||||
}
|
||||
|
||||
void _addPathRecordInternal(
|
||||
@@ -351,6 +392,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
double? recentFailure,
|
||||
DateTime? statsAt,
|
||||
}) {
|
||||
if (_disposed) return;
|
||||
var history = _cache[contactPubKeyHex];
|
||||
if (history == null) return;
|
||||
_version++;
|
||||
@@ -429,6 +471,7 @@ class PathHistoryService extends ChangeNotifier {
|
||||
/// Reads saved paths straight from storage without adding them to the
|
||||
/// cache, evicting anything, or notifying listeners.
|
||||
Future<List<PathRecord>> readStoredPaths(String contactPubKeyHex) async {
|
||||
if (_disposed) return [];
|
||||
final cached = _cache[contactPubKeyHex];
|
||||
if (cached != null) return cached.recentPaths;
|
||||
final stored = await _loadHistoryFromStorage(contactPubKeyHex);
|
||||
@@ -436,13 +479,16 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
|
||||
List<PathRecord> getRecentPaths(String contactPubKeyHex) {
|
||||
if (_disposed) return [];
|
||||
final history = _cache[contactPubKeyHex];
|
||||
if (history != null) {
|
||||
_trackAccess(contactPubKeyHex);
|
||||
return history.recentPaths;
|
||||
}
|
||||
|
||||
_ensureLoaded(contactPubKeyHex).then((_) {
|
||||
final generation = _generation;
|
||||
_ensureLoaded(contactPubKeyHex).then((loaded) {
|
||||
if (!loaded || _disposed || generation != _generation) return;
|
||||
if (_cache[contactPubKeyHex]?.recentPaths.isNotEmpty ?? false) {
|
||||
_version++;
|
||||
notifyListeners();
|
||||
@@ -455,10 +501,12 @@ class PathHistoryService extends ChangeNotifier {
|
||||
Future<ContactPathHistory?> _loadHistoryFromStorage(
|
||||
String contactPubKeyHex,
|
||||
) async {
|
||||
// An evicted contact may still have a queued save; it reaches the prefs
|
||||
// cache synchronously, so the load below reads it.
|
||||
unawaited(_writes.flush());
|
||||
return await _storage.loadPathHistory(contactPubKeyHex);
|
||||
final generation = _generation;
|
||||
await _clearing;
|
||||
await _writes.flush();
|
||||
if (_disposed || generation != _generation) return null;
|
||||
final history = await _storage.loadPathHistory(contactPubKeyHex);
|
||||
return _disposed || generation != _generation ? null : history;
|
||||
}
|
||||
|
||||
PathRecord? getFastestPath(String contactPubKeyHex) {
|
||||
@@ -494,12 +542,38 @@ class PathHistoryService extends ChangeNotifier {
|
||||
);
|
||||
}
|
||||
|
||||
/// Runs [clear] after earlier clears and queued saves. [_clearing] itself
|
||||
/// never fails, so one failed clear cannot break later loads and flushes;
|
||||
/// the returned future still reports the failure to its caller.
|
||||
Future<void> _queueClear(int generation, Future<void> Function() clear) {
|
||||
final previous = _clearing;
|
||||
final run = () async {
|
||||
await previous;
|
||||
await _writes.flush();
|
||||
if (_disposed || generation != _generation) return;
|
||||
await clear();
|
||||
}();
|
||||
_clearing = run.then<void>(
|
||||
(_) {},
|
||||
onError: (Object error, StackTrace _) {
|
||||
appLogger.warn('Clearing path history failed: $error', tag: 'Storage');
|
||||
},
|
||||
);
|
||||
return run;
|
||||
}
|
||||
|
||||
Future<void> clearPathHistory(String contactPubKeyHex) async {
|
||||
if (_disposed) return;
|
||||
final generation = _generation;
|
||||
_pendingLoads.remove(contactPubKeyHex);
|
||||
_cache.remove(contactPubKeyHex);
|
||||
_cacheAccessOrder.remove(contactPubKeyHex);
|
||||
_floodStats.remove(contactPubKeyHex);
|
||||
_writes.cancel(contactPubKeyHex);
|
||||
await _storage.clearPathHistory(contactPubKeyHex);
|
||||
await _queueClear(generation, () {
|
||||
return _storage.clearPathHistory(contactPubKeyHex);
|
||||
});
|
||||
if (_disposed || generation != _generation) return;
|
||||
_version++;
|
||||
notifyListeners();
|
||||
}
|
||||
@@ -508,6 +582,8 @@ class PathHistoryService extends ChangeNotifier {
|
||||
String contactPubKeyHex,
|
||||
List<int> pathBytes,
|
||||
) async {
|
||||
if (_disposed) return;
|
||||
final generation = _generation;
|
||||
final history = _cache[contactPubKeyHex];
|
||||
if (history == null) return;
|
||||
|
||||
@@ -519,8 +595,12 @@ class PathHistoryService extends ChangeNotifier {
|
||||
recentPaths: updatedPaths,
|
||||
);
|
||||
|
||||
final updated = _cache[contactPubKeyHex]!;
|
||||
_writes.cancel(contactPubKeyHex);
|
||||
await _storage.savePathHistory(contactPubKeyHex, _cache[contactPubKeyHex]!);
|
||||
await _writes.flush();
|
||||
if (_disposed || generation != _generation) return;
|
||||
await _storage.savePathHistory(contactPubKeyHex, updated);
|
||||
if (_disposed || generation != _generation) return;
|
||||
_version++;
|
||||
notifyListeners();
|
||||
}
|
||||
@@ -607,20 +687,39 @@ class PathHistoryService extends ChangeNotifier {
|
||||
}
|
||||
|
||||
/// Runs queued saves now, e.g. before the app is backgrounded.
|
||||
Future<void> flushPendingWrites() => _writes.flush();
|
||||
Future<void> flushPendingWrites() async {
|
||||
await _clearing;
|
||||
await _writes.flush();
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
if (_disposed) return;
|
||||
unawaited(_writes.flush());
|
||||
_disposed = true;
|
||||
_generation++;
|
||||
_pendingLoads.clear();
|
||||
_cache.clear();
|
||||
_cacheAccessOrder.clear();
|
||||
_floodStats.clear();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
void clearAllHistories() {
|
||||
if (_disposed) return;
|
||||
final generation = ++_generation;
|
||||
_pendingLoads.clear();
|
||||
_cache.clear();
|
||||
_cacheAccessOrder.clear();
|
||||
_floodStats.clear();
|
||||
_writes.dispose();
|
||||
_storage.clearAllPathHistories();
|
||||
// Nothing awaits this one; _queueClear logs a failure.
|
||||
unawaited(
|
||||
_queueClear(
|
||||
generation,
|
||||
_storage.clearAllPathHistories,
|
||||
).catchError((Object _) {}),
|
||||
);
|
||||
_version = 0;
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ import '../models/delivery_observation.dart';
|
||||
import '../models/path_history.dart';
|
||||
import '../storage/legacy_key_migration.dart';
|
||||
import '../storage/prefs_manager.dart';
|
||||
import '../storage/history_store.dart';
|
||||
import '../utils/app_logger.dart';
|
||||
|
||||
class StorageService {
|
||||
@@ -64,30 +65,32 @@ class StorageService {
|
||||
String contactPubKeyHex,
|
||||
ContactPathHistory history,
|
||||
) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefs = HistoryStore.instance;
|
||||
final key = _pathHistoryKey(contactPubKeyHex);
|
||||
final jsonStr = jsonEncode(history.toJson());
|
||||
await prefs.setString(key, jsonStr);
|
||||
}
|
||||
|
||||
Future<ContactPathHistory?> loadPathHistory(String contactPubKeyHex) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefs = HistoryStore.instance;
|
||||
final scope = _publicKeyHex;
|
||||
final allowLegacyMigration =
|
||||
scope.isNotEmpty && canMigrateLegacyKeys(scope);
|
||||
final key = _pathHistoryKey(contactPubKeyHex);
|
||||
var jsonStr = prefs.getString(key);
|
||||
var jsonStr = await prefs.getString(key);
|
||||
final legacyKey = '$_pathHistoryPrefix$contactPubKeyHex';
|
||||
if (jsonStr == null &&
|
||||
_publicKeyHex.isNotEmpty &&
|
||||
canMigrateLegacyKeys(_publicKeyHex)) {
|
||||
if (jsonStr == null && allowLegacyMigration) {
|
||||
// Move the pre-scoping history into the first radio that loads it so
|
||||
// learned routes survive the upgrade without leaking into other radios.
|
||||
final legacy = prefs.getString(legacyKey);
|
||||
final legacy = await prefs.getString(legacyKey);
|
||||
if (legacy != null) {
|
||||
await prefs.setString(key, legacy);
|
||||
await prefs.remove(legacyKey);
|
||||
if (await prefs.setString(key, legacy)) {
|
||||
await prefs.remove(legacyKey);
|
||||
}
|
||||
jsonStr = legacy;
|
||||
}
|
||||
} else if (jsonStr == null && _publicKeyHex.isEmpty) {
|
||||
jsonStr = prefs.getString(legacyKey);
|
||||
} else if (jsonStr == null && scope.isEmpty) {
|
||||
jsonStr = await prefs.getString(legacyKey);
|
||||
}
|
||||
|
||||
if (jsonStr == null) return null;
|
||||
@@ -101,7 +104,7 @@ class StorageService {
|
||||
}
|
||||
|
||||
Future<void> clearPathHistory(String contactPubKeyHex) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefs = HistoryStore.instance;
|
||||
await prefs.remove(_pathHistoryKey(contactPubKeyHex));
|
||||
await prefs.remove('$_pathHistoryPrefix$contactPubKeyHex');
|
||||
}
|
||||
@@ -109,7 +112,7 @@ class StorageService {
|
||||
/// Clears the path histories of the connected radio only. Histories of other
|
||||
/// radios are left alone; with no radio scope set, everything is cleared.
|
||||
Future<void> clearAllPathHistories() async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefs = HistoryStore.instance;
|
||||
final scopedPrefix = _publicKeyHex.isEmpty
|
||||
? _pathHistoryPrefix
|
||||
: '$_pathHistoryPrefix${_publicKeyHex}_';
|
||||
@@ -117,7 +120,7 @@ class StorageService {
|
||||
// radio on the next load and bring the cleared routes back.
|
||||
final clearLegacy =
|
||||
_publicKeyHex.isNotEmpty && canMigrateLegacyKeys(_publicKeyHex);
|
||||
final pathHistoryKeys = prefs.getKeys().where((key) {
|
||||
final pathHistoryKeys = (await prefs.getKeys()).where((key) {
|
||||
if (key.startsWith(scopedPrefix)) return true;
|
||||
return clearLegacy &&
|
||||
key.startsWith(_pathHistoryPrefix) &&
|
||||
|
||||
@@ -6,7 +6,8 @@ import '../models/channel_message.dart';
|
||||
import '../models/message.dart' show legacyAwareReceivedAt;
|
||||
import '../models/translation_support.dart';
|
||||
import '../helpers/smaz.dart';
|
||||
import 'prefs_manager.dart';
|
||||
import 'history_archive.dart';
|
||||
import 'history_store.dart';
|
||||
|
||||
class ChannelMessageStore {
|
||||
static const String _keyPrefix = 'channel_messages_';
|
||||
@@ -21,153 +22,117 @@ class ChannelMessageStore {
|
||||
/// beyond it are dropped on save.
|
||||
static const int maxStoredMessages = 1000;
|
||||
|
||||
/// Encoded entries persisted ahead of the connector's in-memory window,
|
||||
/// keyed by scoped storage key. A missing entry means the window has not
|
||||
/// been reconciled with storage yet, so the next save keeps what is already
|
||||
/// stored instead of replacing it. Shared across instances so a store
|
||||
/// created by a screen to clear a key also resets the connector's view.
|
||||
static final Map<String, List<String>> _archived = {};
|
||||
static final HistoryArchive _archive = HistoryArchive(
|
||||
mergeKey: _storedMergeKey,
|
||||
maxEntries: maxStoredMessages,
|
||||
);
|
||||
|
||||
String _keyForChannel(String channelId) => '${keyFor}_$channelId';
|
||||
|
||||
/// Save messages for a specific channel: [messages] is the in-memory
|
||||
/// window (oldest first) and is written after the archived entries that
|
||||
/// sit ahead of it in storage.
|
||||
Future<void> saveChannelMessages(
|
||||
String channelId,
|
||||
List<ChannelMessage> messages,
|
||||
) async {
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn(
|
||||
'Public key hex is not set. Cannot save channel messages.',
|
||||
);
|
||||
return;
|
||||
}
|
||||
final prefs = PrefsManager.instance;
|
||||
final key = _keyForChannel(channelId);
|
||||
final visibleJson = messages.map(_messageToJson).toList();
|
||||
final archived =
|
||||
_archived[key] ??
|
||||
_unreconciledArchive(prefs.getString(key), visibleJson);
|
||||
final overflow = archived.length + visibleJson.length - maxStoredMessages;
|
||||
if (overflow > 0) {
|
||||
archived.removeRange(0, overflow.clamp(0, archived.length));
|
||||
}
|
||||
_archived[key] = archived;
|
||||
final entries = [...archived, ...visibleJson.map(jsonEncode)];
|
||||
await prefs.setString(key, '[${entries.join(',')}]');
|
||||
}
|
||||
|
||||
/// Records [olderMessages] as the stored entries that precede the
|
||||
/// in-memory window for [channelId].
|
||||
void setArchived(String channelId, List<ChannelMessage> olderMessages) {
|
||||
_archived[_keyForChannel(channelId)] = olderMessages
|
||||
.map((message) => jsonEncode(_messageToJson(message)))
|
||||
.toList();
|
||||
}
|
||||
|
||||
/// Number of stored entries ahead of the in-memory window, or null when
|
||||
/// the window has not been reconciled with storage.
|
||||
int? archivedCount(String channelId) =>
|
||||
_archived[_keyForChannel(channelId)]?.length;
|
||||
|
||||
/// Removes the newest [count] archived entries after they were paged back
|
||||
/// into the in-memory window.
|
||||
void unarchiveNewest(String channelId, int count) {
|
||||
final archived = _archived[_keyForChannel(channelId)];
|
||||
if (archived == null || count <= 0) return;
|
||||
archived.removeRange(
|
||||
(archived.length - count).clamp(0, archived.length),
|
||||
archived.length,
|
||||
);
|
||||
}
|
||||
|
||||
/// Drops the archive bookkeeping, for one channel or all of them, when the
|
||||
/// matching in-memory window is discarded.
|
||||
void forgetArchive([String? channelId]) {
|
||||
if (channelId == null) {
|
||||
_archived.clear();
|
||||
} else {
|
||||
_archived.remove(_keyForChannel(channelId));
|
||||
}
|
||||
}
|
||||
|
||||
List<String> _unreconciledArchive(
|
||||
String? storedJson,
|
||||
List<Map<String, dynamic>> visibleJson,
|
||||
) {
|
||||
if (storedJson == null || storedJson.isEmpty) return [];
|
||||
final List<dynamic> stored;
|
||||
try {
|
||||
stored = jsonDecode(storedJson) as List<dynamic>;
|
||||
} catch (_) {
|
||||
return [];
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn('Public key hex is not set. Cannot save messages.');
|
||||
return Future<void>.value();
|
||||
}
|
||||
final visibleKeys = visibleJson.map(_storedMergeKey).toSet();
|
||||
return [
|
||||
for (final entry in stored)
|
||||
if (entry is Map<String, dynamic> &&
|
||||
!visibleKeys.contains(_storedMergeKey(entry)))
|
||||
jsonEncode(entry),
|
||||
];
|
||||
return _archive.save(_keyForChannel(channelId), [
|
||||
for (final message in messages) jsonEncode(_messageToJson(message)),
|
||||
]);
|
||||
}
|
||||
|
||||
/// The stored prefix stays in the database, rather than another JSON cache.
|
||||
void setArchivedCount(String channelId, int count) =>
|
||||
_archive.setArchivedCount(_keyForChannel(channelId), count);
|
||||
|
||||
void archive(String channelId, List<ChannelMessage> messages) =>
|
||||
_archive.archive(
|
||||
_keyForChannel(channelId),
|
||||
messages.map((message) => jsonEncode(_messageToJson(message))),
|
||||
);
|
||||
|
||||
int? archivedCount(String channelId) =>
|
||||
_archive.archivedCount(_keyForChannel(channelId));
|
||||
|
||||
void forgetArchive([String? channelId]) =>
|
||||
_archive.forget(channelId == null ? null : _keyForChannel(channelId));
|
||||
|
||||
static String _storedMergeKey(Map<String, dynamic> json) {
|
||||
final messageId = json['messageId'];
|
||||
if (messageId is String && messageId.isNotEmpty) return 'id:$messageId';
|
||||
return 'fallback:${json['timestamp']}:${json['senderName']}:${json['text']}';
|
||||
}
|
||||
|
||||
/// Load messages for a specific channel
|
||||
Future<List<ChannelMessage>> loadChannelMessages(String channelId) async {
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn(
|
||||
'Public key hex is not set. Cannot load channel messages.',
|
||||
);
|
||||
return [];
|
||||
}
|
||||
final jsonString = PrefsManager.instance.getString(
|
||||
_keyForChannel(channelId),
|
||||
);
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
return [];
|
||||
}
|
||||
final List<dynamic> jsonList;
|
||||
Future<List<ChannelMessage>> loadChannelMessages(
|
||||
String channelId, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
if (publicKeyHex.isEmpty) return [];
|
||||
final key = _keyForChannel(channelId);
|
||||
try {
|
||||
jsonList = jsonDecode(jsonString) as List<dynamic>;
|
||||
} catch (e) {
|
||||
final entries = await HistoryStore.instance.readEntries(
|
||||
key,
|
||||
offset: offset,
|
||||
limit: limit,
|
||||
);
|
||||
return _decodeMessages(entries);
|
||||
} catch (error) {
|
||||
appLogger.warn(
|
||||
'Stored messages for channel $channelId are unreadable: $e',
|
||||
'Stored messages for channel $channelId are unreadable: $error',
|
||||
);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
Future<({List<ChannelMessage> messages, int start, int end, int total})>
|
||||
loadMessagePage(String channelId, {int? before, int limit = 50}) async {
|
||||
RangeError.checkNotNegative(limit, 'limit');
|
||||
if (publicKeyHex.isEmpty) {
|
||||
return (messages: <ChannelMessage>[], start: 0, end: 0, total: 0);
|
||||
}
|
||||
final key = _keyForChannel(channelId);
|
||||
try {
|
||||
return await _archive.readPage(
|
||||
key,
|
||||
await HistoryStore.instance.entryCount(key),
|
||||
_decodeMessages,
|
||||
before: before,
|
||||
limit: limit,
|
||||
);
|
||||
} on FormatException catch (error) {
|
||||
appLogger.warn(
|
||||
'Stored messages for channel $channelId are unreadable: $error',
|
||||
);
|
||||
return (messages: <ChannelMessage>[], start: 0, end: 0, total: 0);
|
||||
}
|
||||
}
|
||||
|
||||
List<ChannelMessage> _decodeMessages(List<String> entries) {
|
||||
final messages = <ChannelMessage>[];
|
||||
for (final json in jsonList) {
|
||||
for (final entry in entries) {
|
||||
try {
|
||||
messages.add(_messageFromJson(json as Map<String, dynamic>));
|
||||
} catch (e) {
|
||||
appLogger.warn('Skipping malformed stored channel message: $e');
|
||||
messages.add(
|
||||
_messageFromJson(jsonDecode(entry) as Map<String, dynamic>),
|
||||
);
|
||||
} catch (error) {
|
||||
appLogger.warn('Skipping malformed stored channel message: $error');
|
||||
}
|
||||
}
|
||||
return messages;
|
||||
}
|
||||
|
||||
/// Clear messages for a specific channel
|
||||
Future<void> clearChannelMessages(String channelId) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final key = _keyForChannel(channelId);
|
||||
_archived[key] = [];
|
||||
await prefs.remove(key);
|
||||
}
|
||||
Future<void> clearChannelMessages(String channelId) =>
|
||||
_archive.clear(HistoryStore.instance, _keyForChannel(channelId));
|
||||
|
||||
/// Clear all channel messages
|
||||
Future<void> clearAllChannelMessages() async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final keys = prefs.getKeys().where((k) => k.startsWith(keyFor)).toList();
|
||||
_archived.clear();
|
||||
for (var key in keys) {
|
||||
await prefs.remove(key);
|
||||
}
|
||||
final store = HistoryStore.instance;
|
||||
final prefix = keyFor;
|
||||
final keys = (await store.getKeys())
|
||||
.where((key) => key.startsWith(prefix))
|
||||
.toList();
|
||||
await Future.wait(keys.map((key) => _archive.clear(store, key)));
|
||||
}
|
||||
|
||||
/// Convert ChannelMessage to JSON map
|
||||
|
||||
@@ -5,13 +5,15 @@ import 'channel_message_store.dart';
|
||||
import 'channel_store.dart';
|
||||
import 'legacy_key_migration.dart';
|
||||
import 'prefs_manager.dart';
|
||||
import 'history_store.dart';
|
||||
|
||||
/// One-shot move of a radio's per-channel data from slot-index keys
|
||||
/// (`<prefix><scope><slot>`) to channel-ID keys (`<prefix><scope>_<id>`).
|
||||
///
|
||||
/// The slot -> PSK mapping comes from the radio's cached channel list, which is
|
||||
/// the mapping the legacy data was written under. Legacy keys of slots with no
|
||||
/// cached PSK are left alone and never read again.
|
||||
/// cached PSK are left alone and never read again, and so is a legacy history
|
||||
/// that cannot be parsed.
|
||||
class ChannelStorageMigration {
|
||||
static const String _doneKeyPrefix = 'channel_storage_v2_';
|
||||
|
||||
@@ -70,8 +72,8 @@ class ChannelStorageMigration {
|
||||
await _migrateOrder(scope, slotIds);
|
||||
if (slotIds.isNotEmpty) await beforeDone?.call(slotIds);
|
||||
|
||||
await prefs.setBool(doneKey, true);
|
||||
await channelStore.saveSlotChannelIds(slotIds);
|
||||
await _requireWrite(prefs.setBool(doneKey, true));
|
||||
if (slotIds.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Moved channel data for ${slotIds.length} slots of $scope to channel IDs',
|
||||
@@ -81,38 +83,60 @@ class ChannelStorageMigration {
|
||||
}
|
||||
|
||||
static Future<void> _moveMessages(String scope, int slot, String id) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final prefs = HistoryStore.instance;
|
||||
final oldKey = '$_messagesPrefix$scope$slot';
|
||||
final legacyKey = '$_messagesPrefix$slot';
|
||||
final newKey = '$_messagesPrefix${scope}_$id';
|
||||
var json = prefs.getString(oldKey);
|
||||
if (json == null || json.isEmpty) json = prefs.getString(legacyKey);
|
||||
var json = await prefs.getString(oldKey);
|
||||
if (json == null || json.isEmpty) json = await prefs.getString(legacyKey);
|
||||
if (json != null && json.isNotEmpty) {
|
||||
final existing = prefs.getString(newKey);
|
||||
// Two slots holding the same PSK now share one history.
|
||||
await prefs.setString(
|
||||
newKey,
|
||||
existing == null || existing.isEmpty
|
||||
final String moved;
|
||||
try {
|
||||
if (jsonDecode(json) is! List) {
|
||||
throw const FormatException('Channel history is not an array');
|
||||
}
|
||||
final existing = await prefs.getString(newKey);
|
||||
// Two slots holding the same PSK now share one history.
|
||||
moved = existing == null || existing.isEmpty
|
||||
? json
|
||||
: _mergeMessages(existing, json),
|
||||
);
|
||||
: _mergeMessages(existing, json);
|
||||
} on FormatException catch (error) {
|
||||
// One unreadable history must not hold back the other slots. It
|
||||
// stays under its old key, which nothing reads again.
|
||||
appLogger.warn(
|
||||
'Leaving unreadable channel history of slot $slot in place: $error',
|
||||
);
|
||||
return;
|
||||
}
|
||||
await _requireWrite(prefs.setString(newKey, moved));
|
||||
}
|
||||
// Old keys go only after the new one is written, so an interrupted run
|
||||
// loses nothing; the next launch repeats it.
|
||||
await prefs.remove(oldKey);
|
||||
await prefs.remove(legacyKey);
|
||||
await _requireWrite(prefs.remove(oldKey));
|
||||
await _requireWrite(prefs.remove(legacyKey));
|
||||
}
|
||||
|
||||
static String _mergeMessages(String a, String b) {
|
||||
try {
|
||||
// A rerun after an interrupted migration merges a history into
|
||||
// itself, so drop entries already present.
|
||||
final existing = jsonDecode(a);
|
||||
final incoming = jsonDecode(b);
|
||||
if (existing is! List ||
|
||||
incoming is! List ||
|
||||
![
|
||||
...existing,
|
||||
...incoming,
|
||||
].every((entry) => entry is Map<String, dynamic>)) {
|
||||
throw const FormatException(
|
||||
'Cannot merge unreadable channel histories',
|
||||
);
|
||||
}
|
||||
final seen = <String>{};
|
||||
final merged =
|
||||
[...jsonDecode(a) as List<dynamic>, ...jsonDecode(b) as List<dynamic>]
|
||||
.whereType<Map<String, dynamic>>()
|
||||
.where((m) => seen.add(_mergeKey(m)))
|
||||
.toList();
|
||||
final merged = [...existing, ...incoming]
|
||||
.cast<Map<String, dynamic>>()
|
||||
.where((m) => seen.add(_mergeKey(m)))
|
||||
.toList();
|
||||
merged.sort(
|
||||
(x, y) => ((x['timestamp'] as int?) ?? 0).compareTo(
|
||||
(y['timestamp'] as int?) ?? 0,
|
||||
@@ -122,7 +146,7 @@ class ChannelStorageMigration {
|
||||
if (overflow > 0) merged.removeRange(0, overflow);
|
||||
return jsonEncode(merged);
|
||||
} catch (_) {
|
||||
return a;
|
||||
throw const FormatException('Cannot merge unreadable channel histories');
|
||||
}
|
||||
}
|
||||
|
||||
@@ -145,19 +169,19 @@ class ChannelStorageMigration {
|
||||
var value = prefs.get(oldKey);
|
||||
if (value == null && legacyKey != null) value = prefs.get(legacyKey);
|
||||
if (value is bool && !prefs.containsKey(newKey)) {
|
||||
await prefs.setBool(newKey, value);
|
||||
await _requireWrite(prefs.setBool(newKey, value));
|
||||
}
|
||||
await prefs.remove(oldKey);
|
||||
if (legacyKey != null) await prefs.remove(legacyKey);
|
||||
await _removeIfPresent(oldKey);
|
||||
if (legacyKey != null) await _removeIfPresent(legacyKey);
|
||||
}
|
||||
|
||||
static Future<void> _moveString(String oldKey, String newKey) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final value = prefs.get(oldKey);
|
||||
if (value is String && !prefs.containsKey(newKey)) {
|
||||
await prefs.setString(newKey, value);
|
||||
await _requireWrite(prefs.setString(newKey, value));
|
||||
}
|
||||
await prefs.remove(oldKey);
|
||||
await _removeIfPresent(oldKey);
|
||||
}
|
||||
|
||||
static Future<void> _migrateOrder(
|
||||
@@ -188,7 +212,18 @@ class ChannelStorageMigration {
|
||||
final id = slotIds[slot];
|
||||
if (id != null && !ids.contains(id)) ids.add(id);
|
||||
}
|
||||
await prefs.setString(key, jsonEncode(ids));
|
||||
await prefs.remove(_orderPrefix);
|
||||
await _requireWrite(prefs.setString(key, jsonEncode(ids)));
|
||||
await _removeIfPresent(_orderPrefix);
|
||||
}
|
||||
|
||||
static Future<void> _removeIfPresent(String key) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
if (prefs.containsKey(key)) await prefs.remove(key);
|
||||
}
|
||||
|
||||
static Future<void> _requireWrite(Future<bool> write) async {
|
||||
if (!await write) {
|
||||
throw StateError('Could not persist channel storage migration');
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -24,16 +24,7 @@ class ChannelStore {
|
||||
String? jsonString = prefs.getString(keyFor);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(_keyPrefix);
|
||||
prefs.remove(_keyPrefix);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating channel messages from legacy key $_keyPrefix to scoped key $keyFor',
|
||||
);
|
||||
await prefs.setString(keyFor, legacyJsonString);
|
||||
jsonString = legacyJsonString;
|
||||
}
|
||||
jsonString = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
@@ -97,10 +88,11 @@ class ChannelStore {
|
||||
|
||||
Future<void> saveSlotChannelIds(Map<int, String> ids) async {
|
||||
if (publicKeyHex.isEmpty) return;
|
||||
await PrefsManager.instance.setString(
|
||||
final saved = await PrefsManager.instance.setString(
|
||||
_slotIdsKey,
|
||||
jsonEncode({for (final e in ids.entries) '${e.key}': e.value}),
|
||||
);
|
||||
if (!saved) throw StateError('Could not persist channel slot map');
|
||||
}
|
||||
|
||||
Map<String, dynamic> _toJson(Channel channel) {
|
||||
|
||||
@@ -29,16 +29,7 @@ class CommunityStore {
|
||||
String? jsonString = prefs.getString(keyFor);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(_keyPrefix);
|
||||
prefs.remove(_keyPrefix);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating communities from legacy key $_keyPrefix to scoped key $keyFor',
|
||||
);
|
||||
await prefs.setString(keyFor, legacyJsonString);
|
||||
jsonString = legacyJsonString;
|
||||
}
|
||||
jsonString = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
jsonString = prefs.getString(keyFor);
|
||||
|
||||
@@ -20,11 +20,7 @@ class ContactDiscoveryStore {
|
||||
final prefs = PrefsManager.instance;
|
||||
var jsonStr = prefs.getString(keyFor);
|
||||
if (jsonStr == null && canMigrateLegacyKeys(publicKeyHex)) {
|
||||
jsonStr = prefs.getString(_keyPrefix);
|
||||
if (jsonStr != null) {
|
||||
await prefs.setString(keyFor, jsonStr);
|
||||
await prefs.remove(_keyPrefix);
|
||||
}
|
||||
jsonStr = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
if (jsonStr == null) return [];
|
||||
|
||||
|
||||
@@ -22,16 +22,7 @@ class ContactGroupStore {
|
||||
String? jsonString = prefs.getString(keyFor);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(_keyPrefix);
|
||||
prefs.remove(_keyPrefix);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating channel messages from legacy key $_keyPrefix to scoped key $keyFor',
|
||||
);
|
||||
await prefs.setString(keyFor, legacyJsonString);
|
||||
jsonString = legacyJsonString;
|
||||
}
|
||||
jsonString = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
jsonString = prefs.getString(keyFor);
|
||||
|
||||
@@ -29,15 +29,16 @@ class ContactSettingsStore {
|
||||
if (enabled == null && canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
enabled = prefs.getBool(oldKey);
|
||||
prefs.remove(oldKey);
|
||||
if (enabled != null) {
|
||||
appLogger.info(
|
||||
'Migrating contact settings from legacy key $oldKey to scoped key $key',
|
||||
);
|
||||
await prefs.setBool(key, enabled);
|
||||
if (await prefs.setBool(key, enabled)) {
|
||||
await prefs.remove(oldKey);
|
||||
}
|
||||
}
|
||||
}
|
||||
return prefs.getBool(key) ?? false;
|
||||
return enabled ?? false;
|
||||
}
|
||||
|
||||
Future<void> saveSmazEnabled(String contactKeyHex, bool enabled) async {
|
||||
|
||||
@@ -24,16 +24,7 @@ class ContactStore {
|
||||
String? jsonString = prefs.getString(keyFor);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(_keyPrefix);
|
||||
prefs.remove(_keyPrefix);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating contacts from legacy key $_keyPrefix to scoped key $keyFor',
|
||||
);
|
||||
await prefs.setString(keyFor, legacyJsonString);
|
||||
jsonString = legacyJsonString;
|
||||
}
|
||||
jsonString = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
jsonString = prefs.getString(keyFor);
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
|
||||
import '../utils/app_logger.dart';
|
||||
import 'history_store.dart';
|
||||
|
||||
typedef HistoryPage<T> = ({List<T> messages, int start, int end, int total});
|
||||
|
||||
/// Archive bookkeeping, ordered writes and paging shared by the direct and
|
||||
/// channel message stores. Entries are JSON-encoded messages; the stored
|
||||
/// prefix older than the in-memory window stays in the [HistoryStore].
|
||||
class HistoryArchive {
|
||||
HistoryArchive({required this.mergeKey, required this.maxEntries});
|
||||
|
||||
/// Identifies a stored entry so an unreconciled save can drop overlaps.
|
||||
final String Function(Map<String, dynamic> json) mergeKey;
|
||||
final int maxEntries;
|
||||
|
||||
final Expando<Map<String, _ArchiveState>> _archives = Expando();
|
||||
final Expando<Map<String, Future<void>>> _writes = Expando();
|
||||
|
||||
_ArchiveState _stateFor(HistoryStore store, String key) =>
|
||||
(_archives[store] ??= {}).putIfAbsent(key, () => _ArchiveState());
|
||||
|
||||
Future<void> _serialize(
|
||||
HistoryStore store,
|
||||
String key,
|
||||
Future<void> Function() operation,
|
||||
) {
|
||||
final writes = _writes[store] ??= {};
|
||||
final previous = writes[key] ?? Future<void>.value();
|
||||
final result = previous.then((_) => operation());
|
||||
final completion = result.then<void>(
|
||||
(_) {},
|
||||
onError: (Object _, StackTrace _) {},
|
||||
);
|
||||
writes[key] = completion;
|
||||
unawaited(
|
||||
completion.whenComplete(() {
|
||||
if (identical(writes[key], completion)) writes.remove(key);
|
||||
}),
|
||||
);
|
||||
return result;
|
||||
}
|
||||
|
||||
/// Saves the [visible] window after the archived prefix. [readStored]
|
||||
/// supplies the stored JSON when the prefix is not reconciled yet; it
|
||||
/// defaults to the value under [key].
|
||||
Future<void> save(
|
||||
String key,
|
||||
List<String> visible, {
|
||||
Future<String?> Function(HistoryStore store)? readStored,
|
||||
}) {
|
||||
final store = HistoryStore.instance;
|
||||
final state = _stateFor(store, key);
|
||||
final pendingBefore = state.nextId;
|
||||
return _serialize(store, key, () async {
|
||||
final pending = state.pending
|
||||
.where((entry) => entry.$1 < pendingBefore)
|
||||
.toList();
|
||||
final tail = [...pending.map((entry) => entry.$2), ...visible];
|
||||
final room = (maxEntries - visible.length).clamp(0, maxEntries);
|
||||
var preserved = state.persistedCount;
|
||||
if (preserved == null) {
|
||||
final raw = await (readStored?.call(store) ?? store.getString(key));
|
||||
final prefix = _unreconciledPrefix(key, raw, tail);
|
||||
await store.replaceTail(key, 0, [
|
||||
...prefix,
|
||||
...tail,
|
||||
], maxEntries: maxEntries);
|
||||
preserved = (prefix.length + pending.length).clamp(0, room);
|
||||
} else {
|
||||
final remaining = await store.replaceTail(
|
||||
key,
|
||||
preserved,
|
||||
tail,
|
||||
maxEntries: maxEntries,
|
||||
);
|
||||
preserved = remaining + pending.length.clamp(0, room);
|
||||
}
|
||||
state.persistedCount = preserved;
|
||||
state.pending.removeWhere((entry) => entry.$1 < pendingBefore);
|
||||
});
|
||||
}
|
||||
|
||||
/// Stored entries not repeated in [tail]. Unreadable stored history counts
|
||||
/// as empty, so it cannot block every later save.
|
||||
List<String> _unreconciledPrefix(String key, String? raw, List<String> tail) {
|
||||
if (raw == null || raw.isEmpty) return [];
|
||||
final Object? stored;
|
||||
try {
|
||||
stored = jsonDecode(raw);
|
||||
} on FormatException catch (error) {
|
||||
appLogger.warn('Saving over unreadable history $key: $error');
|
||||
return [];
|
||||
}
|
||||
if (stored is! List) {
|
||||
appLogger.warn('Saving over history $key that is not a list');
|
||||
return [];
|
||||
}
|
||||
final overlaps = <String, int>{};
|
||||
for (final entry in tail) {
|
||||
final id = mergeKey(jsonDecode(entry) as Map<String, dynamic>);
|
||||
overlaps[id] = (overlaps[id] ?? 0) + 1;
|
||||
}
|
||||
final kept = <String>[];
|
||||
for (final entry in stored.reversed) {
|
||||
final id = entry is Map<String, dynamic> ? mergeKey(entry) : null;
|
||||
final remaining = id == null ? 0 : overlaps[id] ?? 0;
|
||||
if (remaining > 0) {
|
||||
overlaps[id!] = remaining - 1;
|
||||
} else {
|
||||
kept.add(jsonEncode(entry));
|
||||
}
|
||||
}
|
||||
return kept.reversed.toList();
|
||||
}
|
||||
|
||||
void setArchivedCount(String key, int count) {
|
||||
RangeError.checkNotNegative(count, 'count');
|
||||
(_archives[HistoryStore.instance] ??= {})[key] = _ArchiveState(count);
|
||||
}
|
||||
|
||||
/// Only entries trimmed since the last successful save need buffering.
|
||||
void archive(String key, Iterable<String> entries) {
|
||||
final state = _stateFor(HistoryStore.instance, key);
|
||||
for (final entry in entries) {
|
||||
state.pending.add((state.nextId++, entry));
|
||||
}
|
||||
}
|
||||
|
||||
int? archivedCount(String key) {
|
||||
final state = _archives[HistoryStore.instance]?[key];
|
||||
final count = state?.persistedCount;
|
||||
return count == null ? null : count + state!.pending.length;
|
||||
}
|
||||
|
||||
void forget([String? key]) {
|
||||
final states = _archives[HistoryStore.instance];
|
||||
if (key == null) {
|
||||
states?.clear();
|
||||
} else {
|
||||
states?.remove(key);
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> clear(HistoryStore store, String key) {
|
||||
final state = _ArchiveState(0);
|
||||
(_archives[store] ??= {})[key] = state;
|
||||
return _serialize(store, key, () async {
|
||||
if (!await store.remove(key)) {
|
||||
state.persistedCount = null;
|
||||
throw StateError('Could not clear message history');
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// Reads a page backwards using physical stored-row offsets, so entries
|
||||
/// [decode] skips do not make earlier valid history unreachable.
|
||||
Future<HistoryPage<T>> readPage<T>(
|
||||
String key,
|
||||
int total,
|
||||
List<T> Function(List<String> entries) decode, {
|
||||
int? before,
|
||||
required int limit,
|
||||
}) async {
|
||||
final store = HistoryStore.instance;
|
||||
final end = (before ?? total).clamp(0, total);
|
||||
var start = end;
|
||||
var messages = <T>[];
|
||||
while (start > 0 && messages.length < limit) {
|
||||
final batchSize = (limit - messages.length).clamp(0, start);
|
||||
final next = start - batchSize;
|
||||
final entries = await store.readEntries(
|
||||
key,
|
||||
offset: next,
|
||||
limit: batchSize,
|
||||
);
|
||||
messages = [...decode(entries), ...messages];
|
||||
start = next;
|
||||
}
|
||||
return (messages: messages, start: start, end: end, total: total);
|
||||
}
|
||||
}
|
||||
|
||||
class _ArchiveState {
|
||||
_ArchiveState([this.persistedCount]);
|
||||
|
||||
int? persistedCount;
|
||||
int nextId = 0;
|
||||
final List<(int, String)> pending = [];
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
import '../utils/app_logger.dart';
|
||||
import 'history_store_stub.dart'
|
||||
if (dart.library.io) 'history_store_io.dart'
|
||||
as platform;
|
||||
import 'prefs_manager.dart';
|
||||
|
||||
/// Histories use an indexed native store; preferences remain the web backend.
|
||||
abstract class HistoryStore {
|
||||
static HistoryStore _instance = PreferencesHistoryStore();
|
||||
static HistoryStore get instance => _instance;
|
||||
|
||||
static bool isHistoryKey(String key) =>
|
||||
key.startsWith('messages_') ||
|
||||
key.startsWith('channel_messages_') ||
|
||||
key.startsWith('path_history_');
|
||||
|
||||
static bool isSequenceKey(String key) =>
|
||||
key.startsWith('messages_') || key.startsWith('channel_messages_');
|
||||
|
||||
/// Set while a run had to keep histories in preferences because the
|
||||
/// database could not be opened; the next launch that opens it merges them.
|
||||
static const String fallbackRunKey = 'history_fallback_run';
|
||||
|
||||
/// Never throws: a database that cannot be opened must not keep the app
|
||||
/// from starting, so this run keeps histories in preferences instead.
|
||||
static Future<void> initialize() async {
|
||||
try {
|
||||
_instance = await platform.createHistoryStore();
|
||||
} catch (error) {
|
||||
// The app logger is not set up this early.
|
||||
debugPrint('History database unavailable: $error');
|
||||
_instance = PreferencesHistoryStore();
|
||||
await PrefsManager.instance.setBool(fallbackRunKey, true);
|
||||
}
|
||||
}
|
||||
|
||||
static void use(HistoryStore store) => _instance = store;
|
||||
static void reset() => _instance = PreferencesHistoryStore();
|
||||
|
||||
Future<String?> getString(String key);
|
||||
Future<bool> setString(String key, String value);
|
||||
Future<bool> remove(String key);
|
||||
Future<Set<String>> getKeys();
|
||||
Future<int> entryCount(String key);
|
||||
Future<List<String>> readEntries(String key, {int offset = 0, int? limit});
|
||||
|
||||
/// Replaces the visible tail, preserving the first [preservedCount] entries.
|
||||
/// Returns the number of preserved entries remaining after the storage cap.
|
||||
Future<int> replaceTail(
|
||||
String key,
|
||||
int preservedCount,
|
||||
List<String> entries, {
|
||||
int maxEntries = 1000,
|
||||
});
|
||||
|
||||
Future<void> close() async {}
|
||||
}
|
||||
|
||||
class PreferencesHistoryStore extends HistoryStore {
|
||||
SharedPreferences? _preferences;
|
||||
SharedPreferences get _prefs => _preferences ??= PrefsManager.instance;
|
||||
@override
|
||||
Future<String?> getString(String key) async => _prefs.getString(key);
|
||||
|
||||
@override
|
||||
Future<bool> setString(String key, String value) =>
|
||||
_prefs.setString(key, value);
|
||||
|
||||
@override
|
||||
Future<bool> remove(String key) async {
|
||||
final prefs = _prefs;
|
||||
return !prefs.containsKey(key) || await prefs.remove(key);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Set<String>> getKeys() async =>
|
||||
_prefs.getKeys().where(HistoryStore.isHistoryKey).toSet();
|
||||
|
||||
/// Encoded entries of recently used histories, so paging and saves do not
|
||||
/// re-parse the blob or re-encode the preserved prefix each time. An entry
|
||||
/// is used only while the stored string is the one it was split from.
|
||||
static const int _maxDecoded = 8;
|
||||
final Map<String, (String, List<String>)> _decoded = {};
|
||||
|
||||
Future<List<String>> _entries(String key) async {
|
||||
final raw = await getString(key);
|
||||
if (raw == null || raw.isEmpty) return const [];
|
||||
final cached = _decoded[key];
|
||||
if (cached != null && cached.$1 == raw) return cached.$2;
|
||||
final decoded = jsonDecode(raw);
|
||||
if (decoded is! List) throw const FormatException('Expected message array');
|
||||
return _remember(key, raw, decoded.map(jsonEncode).toList());
|
||||
}
|
||||
|
||||
List<String> _remember(String key, String raw, List<String> entries) {
|
||||
_decoded.remove(key);
|
||||
_decoded[key] = (raw, entries);
|
||||
if (_decoded.length > _maxDecoded) _decoded.remove(_decoded.keys.first);
|
||||
return entries;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<String>> readEntries(
|
||||
String key, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
RangeError.checkNotNegative(offset, 'offset');
|
||||
if (limit != null) RangeError.checkNotNegative(limit, 'limit');
|
||||
final selected = (await _entries(key)).skip(offset);
|
||||
return (limit == null ? selected : selected.take(limit)).toList();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<int> entryCount(String key) async => (await _entries(key)).length;
|
||||
|
||||
@override
|
||||
Future<int> replaceTail(
|
||||
String key,
|
||||
int preservedCount,
|
||||
List<String> entries, {
|
||||
int maxEntries = 1000,
|
||||
}) async {
|
||||
RangeError.checkNotNegative(preservedCount, 'preservedCount');
|
||||
RangeError.checkNotNegative(maxEntries, 'maxEntries');
|
||||
List<String> previous;
|
||||
try {
|
||||
previous = (await _entries(key)).take(preservedCount).toList();
|
||||
} on FormatException catch (error) {
|
||||
// Preferences hold one value per key, so the save replaces it.
|
||||
appLogger.warn('Replacing unreadable history $key: $error');
|
||||
previous = [];
|
||||
}
|
||||
final combined = [...previous, ...entries];
|
||||
final overflow = (combined.length - maxEntries).clamp(0, combined.length);
|
||||
final kept = combined.sublist(overflow);
|
||||
final raw = '[${kept.join(',')}]';
|
||||
if (!await setString(key, raw)) {
|
||||
throw StateError('Could not save message history');
|
||||
}
|
||||
_remember(key, raw, kept);
|
||||
return (previous.length - overflow).clamp(0, previous.length);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:path_provider/path_provider.dart';
|
||||
import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
|
||||
import 'package:shared_preferences_platform_interface/types.dart';
|
||||
import 'package:sqflite/sqflite.dart' as sqlite;
|
||||
import 'package:sqflite_common_ffi/sqflite_ffi.dart' as ffi;
|
||||
|
||||
import '../utils/app_logger.dart';
|
||||
import 'history_store.dart';
|
||||
import 'prefs_manager.dart';
|
||||
|
||||
Future<HistoryStore> createHistoryStore() async {
|
||||
final directory = await getApplicationSupportDirectory();
|
||||
if (Platform.isLinux || Platform.isWindows) ffi.sqfliteFfiInit();
|
||||
final store = await SqliteHistoryStore.open(
|
||||
'${directory.path}${Platform.pathSeparator}history_v1.db',
|
||||
factory: Platform.isLinux || Platform.isWindows
|
||||
? ffi.databaseFactoryFfi
|
||||
: sqlite.databaseFactory,
|
||||
);
|
||||
// The database is usable even when an import step fails: reads fall back
|
||||
// to preferences for keys it does not hold, and the step repeats next launch.
|
||||
try {
|
||||
final prefs = PrefsManager.instance;
|
||||
if (prefs.getBool(HistoryStore.fallbackRunKey) == true) {
|
||||
await store.adoptFallbackHistories();
|
||||
await prefs.remove(HistoryStore.fallbackRunKey);
|
||||
}
|
||||
await store.migratePreferences();
|
||||
} catch (error) {
|
||||
// The app logger is not set up this early.
|
||||
debugPrint('History import incomplete: $error');
|
||||
}
|
||||
return store;
|
||||
}
|
||||
|
||||
class SqliteHistoryStore extends HistoryStore {
|
||||
SqliteHistoryStore._(this.database);
|
||||
|
||||
static const schemaVersion = 1;
|
||||
final sqlite.Database database;
|
||||
|
||||
static Future<SqliteHistoryStore> open(
|
||||
String path, {
|
||||
required sqlite.DatabaseFactory factory,
|
||||
}) async {
|
||||
final database = await factory.openDatabase(
|
||||
path,
|
||||
options: sqlite.OpenDatabaseOptions(
|
||||
version: schemaVersion,
|
||||
onConfigure: (db) => db.execute('PRAGMA foreign_keys = ON'),
|
||||
onCreate: (db, version) async {
|
||||
await db.execute(
|
||||
'CREATE TABLE history_keys (key TEXT PRIMARY KEY, value TEXT)',
|
||||
);
|
||||
await db.execute(
|
||||
'CREATE TABLE history_entries ('
|
||||
'key TEXT NOT NULL REFERENCES history_keys(key) ON DELETE CASCADE, '
|
||||
'position INTEGER NOT NULL, value TEXT NOT NULL, '
|
||||
'PRIMARY KEY (key, position))',
|
||||
);
|
||||
await db.execute(
|
||||
'CREATE TABLE history_metadata (key TEXT PRIMARY KEY, value INTEGER NOT NULL)',
|
||||
);
|
||||
},
|
||||
),
|
||||
);
|
||||
return SqliteHistoryStore._(database);
|
||||
}
|
||||
|
||||
Future<void> migratePreferences() async {
|
||||
final versions = await database.query(
|
||||
'history_metadata',
|
||||
where: 'key = ?',
|
||||
whereArgs: ['preferences_import_version'],
|
||||
);
|
||||
final version = versions.isEmpty ? null : versions.first['value'] as int;
|
||||
if (version != null && version >= schemaVersion) return;
|
||||
|
||||
final prefs = PrefsManager.instance;
|
||||
final imported = <String>{};
|
||||
for (final key in prefs.getKeys().where(HistoryStore.isHistoryKey)) {
|
||||
final value = prefs.get(key);
|
||||
if (value is! String || value.isEmpty) continue;
|
||||
try {
|
||||
final decoded = jsonDecode(value);
|
||||
if (HistoryStore.isSequenceKey(key)
|
||||
? decoded is! List
|
||||
: decoded is! Map) {
|
||||
continue;
|
||||
}
|
||||
} on FormatException {
|
||||
appLogger.warn('Leaving unreadable history $key in preferences');
|
||||
continue;
|
||||
}
|
||||
// Rows from an interrupted earlier import may have been saved to since.
|
||||
if ((await _header(key)).isEmpty) await setString(key, value);
|
||||
imported.add(key);
|
||||
}
|
||||
if (imported.isNotEmpty) {
|
||||
final removed = await SharedPreferencesStorePlatform.instance
|
||||
.clearWithParameters(
|
||||
ClearParameters(
|
||||
filter: PreferencesFilter(
|
||||
prefix: 'flutter.',
|
||||
allowList: imported.map((key) => 'flutter.$key').toSet(),
|
||||
),
|
||||
),
|
||||
);
|
||||
if (!removed) throw StateError('Could not finish history migration');
|
||||
await prefs.reload();
|
||||
}
|
||||
await database.insert('history_metadata', {
|
||||
'key': 'preferences_import_version',
|
||||
'value': schemaVersion,
|
||||
}, conflictAlgorithm: sqlite.ConflictAlgorithm.replace);
|
||||
}
|
||||
|
||||
/// Merges histories that a run without the database saved to preferences.
|
||||
/// That run could not see the database rows, so its message lists hold
|
||||
/// what it saved itself and are appended; a message it rewrote replaces the
|
||||
/// stored copy. Route histories already in the database are kept.
|
||||
Future<void> adoptFallbackHistories() async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final keys = prefs.getKeys().where(HistoryStore.isHistoryKey).toList();
|
||||
for (final key in keys) {
|
||||
final value = prefs.get(key);
|
||||
if (value is! String || value.isEmpty) continue;
|
||||
final sequence = HistoryStore.isSequenceKey(key);
|
||||
final Object? decoded;
|
||||
try {
|
||||
decoded = jsonDecode(value);
|
||||
} on FormatException {
|
||||
continue;
|
||||
}
|
||||
if (sequence ? decoded is! List : decoded is! Map) continue;
|
||||
if ((await _header(key)).isEmpty) {
|
||||
await setString(key, value);
|
||||
} else if (sequence) {
|
||||
final merged = await readEntries(key);
|
||||
final positions = {
|
||||
for (var i = 0; i < merged.length; i++) _entryId(merged[i]): i,
|
||||
};
|
||||
for (final entry in (decoded as List).map(jsonEncode)) {
|
||||
final id = _entryId(entry);
|
||||
final position = positions[id];
|
||||
if (position == null) {
|
||||
positions[id] = merged.length;
|
||||
merged.add(entry);
|
||||
} else {
|
||||
merged[position] = entry;
|
||||
}
|
||||
}
|
||||
await replaceTail(key, 0, merged);
|
||||
}
|
||||
if (!await prefs.remove(key)) {
|
||||
throw StateError('Could not finish merging fallback histories');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static String _entryId(String entry) {
|
||||
final decoded = jsonDecode(entry);
|
||||
final id = decoded is Map ? decoded['messageId'] : null;
|
||||
return id is String && id.isNotEmpty ? 'id:$id' : entry;
|
||||
}
|
||||
|
||||
Future<List<Map<String, Object?>>> _header(String key) => database.query(
|
||||
'history_keys',
|
||||
columns: ['value'],
|
||||
where: 'key = ?',
|
||||
whereArgs: [key],
|
||||
);
|
||||
|
||||
@override
|
||||
Future<String?> getString(String key) async {
|
||||
final header = await _header(key);
|
||||
if (header.isEmpty) return PrefsManager.instance.getString(key);
|
||||
final scalar = header.first['value'];
|
||||
if (scalar is String) return scalar;
|
||||
return '[${(await readEntries(key)).join(',')}]';
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> setString(String key, String value) async {
|
||||
final entries = HistoryStore.isSequenceKey(key)
|
||||
? (jsonDecode(value) as List).map(jsonEncode).toList()
|
||||
: null;
|
||||
await database.transaction((txn) async {
|
||||
await txn.insert('history_keys', {
|
||||
'key': key,
|
||||
'value': entries == null ? value : null,
|
||||
}, conflictAlgorithm: sqlite.ConflictAlgorithm.replace);
|
||||
if (entries != null) {
|
||||
final batch = txn.batch();
|
||||
for (var index = 0; index < entries.length; index++) {
|
||||
batch.insert('history_entries', {
|
||||
'key': key,
|
||||
'position': index,
|
||||
'value': entries[index],
|
||||
});
|
||||
}
|
||||
await batch.commit(noResult: true);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> remove(String key) async {
|
||||
await database.delete('history_keys', where: 'key = ?', whereArgs: [key]);
|
||||
final prefs = PrefsManager.instance;
|
||||
return !prefs.containsKey(key) || await prefs.remove(key);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Set<String>> getKeys() async => {
|
||||
for (final row in await database.query('history_keys', columns: ['key']))
|
||||
row['key'] as String,
|
||||
...PrefsManager.instance.getKeys().where(HistoryStore.isHistoryKey),
|
||||
};
|
||||
|
||||
@override
|
||||
Future<int> entryCount(String key) async {
|
||||
if ((await _header(key)).isEmpty) {
|
||||
return PreferencesHistoryStore().entryCount(key);
|
||||
}
|
||||
return sqlite.Sqflite.firstIntValue(
|
||||
await database.rawQuery(
|
||||
'SELECT COUNT(*) FROM history_entries WHERE key = ?',
|
||||
[key],
|
||||
),
|
||||
) ??
|
||||
0;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<String>> readEntries(
|
||||
String key, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
RangeError.checkNotNegative(offset, 'offset');
|
||||
if (limit != null) RangeError.checkNotNegative(limit, 'limit');
|
||||
if ((await _header(key)).isEmpty) {
|
||||
return PreferencesHistoryStore().readEntries(
|
||||
key,
|
||||
offset: offset,
|
||||
limit: limit,
|
||||
);
|
||||
}
|
||||
final rows = await database.rawQuery(
|
||||
'SELECT value FROM history_entries WHERE key = ? ORDER BY position '
|
||||
'LIMIT ? OFFSET ?',
|
||||
[key, limit ?? -1, offset],
|
||||
);
|
||||
return [for (final row in rows) row['value'] as String];
|
||||
}
|
||||
|
||||
@override
|
||||
Future<int> replaceTail(
|
||||
String key,
|
||||
int preservedCount,
|
||||
List<String> entries, {
|
||||
int maxEntries = 1000,
|
||||
}) async {
|
||||
RangeError.checkNotNegative(preservedCount, 'preservedCount');
|
||||
RangeError.checkNotNegative(maxEntries, 'maxEntries');
|
||||
// A readable preference left by the import is adopted first. An
|
||||
// unreadable one stays in preferences, where a save never erases it; the
|
||||
// database rows written below are what later reads return.
|
||||
if ((await _header(key)).isEmpty) {
|
||||
final legacy = PrefsManager.instance.getString(key);
|
||||
if (legacy != null && legacy.isNotEmpty) {
|
||||
if (_isJsonList(legacy)) {
|
||||
await setString(key, legacy);
|
||||
} else {
|
||||
appLogger.warn('Saving $key beside its unreadable preference');
|
||||
}
|
||||
}
|
||||
}
|
||||
return database.transaction((txn) async {
|
||||
await txn.rawInsert(
|
||||
'INSERT OR IGNORE INTO history_keys (key, value) VALUES (?, NULL)',
|
||||
[key],
|
||||
);
|
||||
final prefix = preservedCount == 0
|
||||
? <Map<String, Object?>>[]
|
||||
: await txn.rawQuery(
|
||||
'SELECT position FROM history_entries WHERE key = ? '
|
||||
'ORDER BY position LIMIT 1 OFFSET ?',
|
||||
[key, preservedCount - 1],
|
||||
);
|
||||
final count =
|
||||
sqlite.Sqflite.firstIntValue(
|
||||
await txn.rawQuery(
|
||||
'SELECT COUNT(*) FROM history_entries WHERE key = ?',
|
||||
[key],
|
||||
),
|
||||
) ??
|
||||
0;
|
||||
final preserved = preservedCount.clamp(0, count);
|
||||
final lastPosition = prefix.isNotEmpty
|
||||
? prefix.first['position'] as int
|
||||
: preserved == 0
|
||||
? -1
|
||||
: sqlite.Sqflite.firstIntValue(
|
||||
await txn.rawQuery(
|
||||
'SELECT MAX(position) FROM history_entries WHERE key = ?',
|
||||
[key],
|
||||
),
|
||||
)!;
|
||||
await txn.delete(
|
||||
'history_entries',
|
||||
where: 'key = ? AND position > ?',
|
||||
whereArgs: [key, lastPosition],
|
||||
);
|
||||
final batch = txn.batch();
|
||||
for (var index = 0; index < entries.length; index++) {
|
||||
batch.insert('history_entries', {
|
||||
'key': key,
|
||||
'position': lastPosition + index + 1,
|
||||
'value': entries[index],
|
||||
});
|
||||
}
|
||||
await batch.commit(noResult: true);
|
||||
final overflow = (preserved + entries.length - maxEntries).clamp(
|
||||
0,
|
||||
preserved + entries.length,
|
||||
);
|
||||
if (overflow > 0) {
|
||||
await txn.rawDelete(
|
||||
'DELETE FROM history_entries WHERE key = ? AND position IN '
|
||||
'(SELECT position FROM history_entries WHERE key = ? '
|
||||
'ORDER BY position LIMIT ?)',
|
||||
[key, key, overflow],
|
||||
);
|
||||
}
|
||||
return (preserved - overflow).clamp(0, preserved);
|
||||
});
|
||||
}
|
||||
|
||||
static bool _isJsonList(String value) {
|
||||
try {
|
||||
return jsonDecode(value) is List;
|
||||
} on FormatException {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> close() => database.close();
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
import 'history_store.dart';
|
||||
|
||||
Future<HistoryStore> createHistoryStore() async => PreferencesHistoryStore();
|
||||
@@ -1,3 +1,5 @@
|
||||
import 'prefs_manager.dart';
|
||||
|
||||
/// Storage scopes (first 10 hex chars of a radio's public key) that must
|
||||
/// never adopt data from the legacy unscoped keys.
|
||||
///
|
||||
@@ -8,3 +10,16 @@ final Set<String> scopesWithoutLegacyMigration = {};
|
||||
|
||||
bool canMigrateLegacyKeys(String scopeHex) =>
|
||||
!scopesWithoutLegacyMigration.contains(scopeHex);
|
||||
|
||||
Future<String?> migrateLegacyStringPreference(
|
||||
String oldKey,
|
||||
String newKey,
|
||||
) async {
|
||||
final prefs = PrefsManager.instance;
|
||||
final value = prefs.getString(oldKey);
|
||||
if (value == null || value.isEmpty) return value;
|
||||
if (await prefs.setString(newKey, value)) {
|
||||
await prefs.remove(oldKey);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
+124
-135
@@ -1,14 +1,13 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
import '../models/message.dart';
|
||||
import '../models/translation_support.dart';
|
||||
import '../helpers/smaz.dart';
|
||||
import '../utils/app_logger.dart';
|
||||
import 'legacy_key_migration.dart';
|
||||
import 'prefs_manager.dart';
|
||||
import 'history_archive.dart';
|
||||
import 'history_store.dart';
|
||||
|
||||
class MessageStore {
|
||||
static const String _keyPrefix = 'messages_';
|
||||
@@ -23,102 +22,41 @@ class MessageStore {
|
||||
/// beyond it are dropped on save.
|
||||
static const int maxStoredMessages = 1000;
|
||||
|
||||
/// Encoded entries persisted ahead of the connector's in-memory window,
|
||||
/// keyed by scoped storage key. A missing entry means the window has not
|
||||
/// been reconciled with storage yet, so the next save keeps what is already
|
||||
/// stored instead of replacing it. Shared across instances so a store
|
||||
/// created by a screen to clear a key also resets the connector's view.
|
||||
static final Map<String, List<String>> _archived = {};
|
||||
static final HistoryArchive _archive = HistoryArchive(
|
||||
mergeKey: _storedMergeKey,
|
||||
maxEntries: maxStoredMessages,
|
||||
);
|
||||
|
||||
/// Persists [messages] (the in-memory window, oldest first) after the
|
||||
/// archived entries that sit ahead of it in storage.
|
||||
Future<void> saveMessages(
|
||||
String contactKeyHex,
|
||||
List<Message> messages,
|
||||
) async {
|
||||
Future<void> saveMessages(String contactKeyHex, List<Message> messages) {
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn('Public key hex is not set. Cannot save messages.');
|
||||
return;
|
||||
return Future<void>.value();
|
||||
}
|
||||
final prefs = PrefsManager.instance;
|
||||
final key = '$keyFor$contactKeyHex';
|
||||
final visibleJson = messages.map(_messageToJson).toList();
|
||||
final archived =
|
||||
_archived[key] ??
|
||||
_unreconciledArchive(_readStored(prefs, contactKeyHex), visibleJson);
|
||||
final overflow = archived.length + visibleJson.length - maxStoredMessages;
|
||||
if (overflow > 0) {
|
||||
archived.removeRange(0, overflow.clamp(0, archived.length));
|
||||
}
|
||||
_archived[key] = archived;
|
||||
final entries = [...archived, ...visibleJson.map(jsonEncode)];
|
||||
await prefs.setString(key, '[${entries.join(',')}]');
|
||||
}
|
||||
|
||||
/// Records [olderMessages] as the stored entries that precede the
|
||||
/// in-memory window for [contactKeyHex].
|
||||
void setArchived(String contactKeyHex, List<Message> olderMessages) {
|
||||
_archived['$keyFor$contactKeyHex'] = olderMessages
|
||||
.map((message) => jsonEncode(_messageToJson(message)))
|
||||
.toList();
|
||||
}
|
||||
|
||||
/// Moves [messages], just trimmed from the front of the in-memory window,
|
||||
/// into the archive so the next save keeps them.
|
||||
void archive(String contactKeyHex, List<Message> messages) {
|
||||
final archived = _archived['$keyFor$contactKeyHex'];
|
||||
// Unreconciled saves keep everything already stored anyway.
|
||||
if (archived == null) return;
|
||||
archived.addAll(
|
||||
messages.map((message) => jsonEncode(_messageToJson(message))),
|
||||
final scope = publicKeyHex;
|
||||
return _archive.save(
|
||||
key,
|
||||
[for (final message in messages) jsonEncode(_messageToJson(message))],
|
||||
readStored: (store) =>
|
||||
_readStored(store, key, '$_keyPrefix$contactKeyHex', scope),
|
||||
);
|
||||
}
|
||||
|
||||
/// Number of stored entries ahead of the in-memory window, or null when
|
||||
/// the window has not been reconciled with storage.
|
||||
/// The stored prefix stays in the database, rather than another JSON cache.
|
||||
void setArchivedCount(String contactKeyHex, int count) =>
|
||||
_archive.setArchivedCount('$keyFor$contactKeyHex', count);
|
||||
|
||||
void archive(String contactKeyHex, List<Message> messages) =>
|
||||
_archive.archive(
|
||||
'$keyFor$contactKeyHex',
|
||||
messages.map((message) => jsonEncode(_messageToJson(message))),
|
||||
);
|
||||
|
||||
int? archivedCount(String contactKeyHex) =>
|
||||
_archived['$keyFor$contactKeyHex']?.length;
|
||||
_archive.archivedCount('$keyFor$contactKeyHex');
|
||||
|
||||
/// Removes the newest [count] archived entries after they were paged back
|
||||
/// into the in-memory window.
|
||||
void unarchiveNewest(String contactKeyHex, int count) {
|
||||
final archived = _archived['$keyFor$contactKeyHex'];
|
||||
if (archived == null || count <= 0) return;
|
||||
archived.removeRange(
|
||||
(archived.length - count).clamp(0, archived.length),
|
||||
archived.length,
|
||||
);
|
||||
}
|
||||
|
||||
/// Drops the archive bookkeeping, for one conversation or all of them,
|
||||
/// when the matching in-memory window is discarded.
|
||||
void forgetArchive([String? contactKeyHex]) {
|
||||
if (contactKeyHex == null) {
|
||||
_archived.clear();
|
||||
} else {
|
||||
_archived.remove('$keyFor$contactKeyHex');
|
||||
}
|
||||
}
|
||||
|
||||
List<String> _unreconciledArchive(
|
||||
String? storedJson,
|
||||
List<Map<String, dynamic>> visibleJson,
|
||||
) {
|
||||
if (storedJson == null || storedJson.isEmpty) return [];
|
||||
final List<dynamic> stored;
|
||||
try {
|
||||
stored = jsonDecode(storedJson) as List<dynamic>;
|
||||
} catch (_) {
|
||||
return [];
|
||||
}
|
||||
final visibleKeys = visibleJson.map(_storedMergeKey).toSet();
|
||||
return [
|
||||
for (final entry in stored)
|
||||
if (entry is Map<String, dynamic> &&
|
||||
!visibleKeys.contains(_storedMergeKey(entry)))
|
||||
jsonEncode(entry),
|
||||
];
|
||||
}
|
||||
void forgetArchive([String? contactKeyHex]) =>
|
||||
_archive.forget(contactKeyHex == null ? null : '$keyFor$contactKeyHex');
|
||||
|
||||
static String _storedMergeKey(Map<String, dynamic> json) {
|
||||
final messageId = json['messageId'];
|
||||
@@ -126,69 +64,120 @@ class MessageStore {
|
||||
return 'fallback:${json['timestamp']}:${json['isOutgoing']}:${json['text']}';
|
||||
}
|
||||
|
||||
/// Reads the stored JSON for [contactKeyHex], migrating the legacy unscoped
|
||||
/// key on first access.
|
||||
String? _readStored(SharedPreferences prefs, String contactKeyHex) {
|
||||
final key = '$keyFor$contactKeyHex';
|
||||
final oldKey = '$_keyPrefix$contactKeyHex';
|
||||
final jsonString = prefs.getString(key);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(oldKey);
|
||||
prefs.remove(oldKey);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating messages from legacy key $oldKey to scoped key $key',
|
||||
);
|
||||
prefs.setString(key, legacyJsonString);
|
||||
return legacyJsonString;
|
||||
Future<String?> _readStored(
|
||||
HistoryStore store,
|
||||
String key,
|
||||
String oldKey,
|
||||
String scope,
|
||||
) async {
|
||||
final raw = await store.getString(key);
|
||||
if ((raw == null || raw.isEmpty) && canMigrateLegacyKeys(scope)) {
|
||||
final legacy = await store.getString(oldKey);
|
||||
if (legacy != null && legacy.isNotEmpty) {
|
||||
if (await store.setString(key, legacy)) await store.remove(oldKey);
|
||||
}
|
||||
return legacy;
|
||||
}
|
||||
return jsonString;
|
||||
return raw;
|
||||
}
|
||||
|
||||
Future<List<Message>> loadMessages(String contactKeyHex) async {
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn('Public key hex is not set. Cannot load messages.');
|
||||
return [];
|
||||
Future<({String key, int count})> _storedHistory(String contactKeyHex) async {
|
||||
final store = HistoryStore.instance;
|
||||
final scope = publicKeyHex;
|
||||
final key = '$keyFor$contactKeyHex';
|
||||
var count = await store.entryCount(key);
|
||||
if (count > 0) return (key: key, count: count);
|
||||
final raw = await store.getString(key);
|
||||
if ((raw == null || raw.isEmpty) && canMigrateLegacyKeys(scope)) {
|
||||
final oldKey = '$_keyPrefix$contactKeyHex';
|
||||
final legacy = await store.getString(oldKey);
|
||||
if (legacy != null && legacy.isNotEmpty) {
|
||||
if (await store.setString(key, legacy)) {
|
||||
await store.remove(oldKey);
|
||||
count = await store.entryCount(key);
|
||||
} else {
|
||||
throw StateError('Could not migrate stored message history');
|
||||
}
|
||||
}
|
||||
}
|
||||
final prefs = PrefsManager.instance;
|
||||
String? jsonString = _readStored(prefs, contactKeyHex);
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
jsonString = prefs.getString(keyFor);
|
||||
}
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
return [];
|
||||
if (raw == null && count == 0) {
|
||||
final fallback = '$_keyPrefix$scope';
|
||||
final fallbackCount = await store.entryCount(fallback);
|
||||
if (fallbackCount > 0) {
|
||||
final fallbackJson = await store.getString(fallback);
|
||||
if (fallbackJson == null || !await store.setString(key, fallbackJson)) {
|
||||
throw StateError('Could not migrate fallback message history');
|
||||
}
|
||||
return (key: key, count: fallbackCount);
|
||||
}
|
||||
}
|
||||
return (key: key, count: count);
|
||||
}
|
||||
|
||||
final List<dynamic> jsonList;
|
||||
Future<List<Message>> loadMessages(
|
||||
String contactKeyHex, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
if (publicKeyHex.isEmpty) return [];
|
||||
try {
|
||||
jsonList = jsonDecode(jsonString) as List<dynamic>;
|
||||
} catch (e) {
|
||||
appLogger.warn('Stored messages for $contactKeyHex are unreadable: $e');
|
||||
final history = await _storedHistory(contactKeyHex);
|
||||
final entries = await HistoryStore.instance.readEntries(
|
||||
history.key,
|
||||
offset: offset,
|
||||
limit: limit,
|
||||
);
|
||||
return _decodeMessages(entries);
|
||||
} catch (error) {
|
||||
appLogger.warn(
|
||||
'Stored messages for $contactKeyHex are unreadable: $error',
|
||||
);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
/// Reads a page backwards using physical stored-row offsets. Malformed
|
||||
/// records are skipped without making earlier valid history unreachable.
|
||||
Future<({List<Message> messages, int start, int end, int total})>
|
||||
loadMessagePage(String contactKeyHex, {int? before, int limit = 50}) async {
|
||||
RangeError.checkNotNegative(limit, 'limit');
|
||||
if (publicKeyHex.isEmpty) {
|
||||
return (messages: <Message>[], start: 0, end: 0, total: 0);
|
||||
}
|
||||
try {
|
||||
final history = await _storedHistory(contactKeyHex);
|
||||
return await _archive.readPage(
|
||||
history.key,
|
||||
history.count,
|
||||
_decodeMessages,
|
||||
before: before,
|
||||
limit: limit,
|
||||
);
|
||||
} on FormatException catch (error) {
|
||||
appLogger.warn(
|
||||
'Stored messages for $contactKeyHex are unreadable: $error',
|
||||
);
|
||||
return (messages: <Message>[], start: 0, end: 0, total: 0);
|
||||
}
|
||||
}
|
||||
|
||||
List<Message> _decodeMessages(List<String> entries) {
|
||||
final messages = <Message>[];
|
||||
for (final json in jsonList) {
|
||||
for (final entry in entries) {
|
||||
try {
|
||||
messages.add(_messageFromJson(json as Map<String, dynamic>));
|
||||
} catch (e) {
|
||||
appLogger.warn('Skipping malformed stored message: $e');
|
||||
messages.add(
|
||||
_messageFromJson(jsonDecode(entry) as Map<String, dynamic>),
|
||||
);
|
||||
} catch (error) {
|
||||
appLogger.warn('Skipping malformed stored message: $error');
|
||||
}
|
||||
}
|
||||
return messages;
|
||||
}
|
||||
|
||||
Future<void> clearMessages(String contactKeyHex) async {
|
||||
if (publicKeyHex.isEmpty) {
|
||||
appLogger.warn('Public key hex is not set. Cannot clear messages.');
|
||||
return;
|
||||
}
|
||||
final prefs = PrefsManager.instance;
|
||||
final key = '$keyFor$contactKeyHex';
|
||||
_archived[key] = [];
|
||||
await prefs.remove(key);
|
||||
Future<void> clearMessages(String contactKeyHex) {
|
||||
if (publicKeyHex.isEmpty) return Future<void>.value();
|
||||
return _archive.clear(HistoryStore.instance, '$keyFor$contactKeyHex');
|
||||
}
|
||||
|
||||
Map<String, dynamic> _messageToJson(Message msg) {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
import 'history_store.dart';
|
||||
|
||||
/// Singleton wrapper for SharedPreferences to avoid redundant getInstance() calls.
|
||||
///
|
||||
/// BEFORE: Every storage operation called SharedPreferences.getInstance()
|
||||
@@ -30,5 +32,6 @@ class PrefsManager {
|
||||
/// For testing: reset the instance
|
||||
static void reset() {
|
||||
_instance = null;
|
||||
HistoryStore.reset();
|
||||
}
|
||||
}
|
||||
@@ -36,16 +36,7 @@ class UnreadStore {
|
||||
String? jsonString = prefs.getString(keyFor);
|
||||
if ((jsonString == null || jsonString.isEmpty) &&
|
||||
canMigrateLegacyKeys(publicKeyHex)) {
|
||||
// Attempt migration from legacy unscoped key on first load
|
||||
final legacyJsonString = prefs.getString(_keyPrefix);
|
||||
prefs.remove(_keyPrefix);
|
||||
if (legacyJsonString != null && legacyJsonString.isNotEmpty) {
|
||||
appLogger.info(
|
||||
'Migrating channel messages from legacy key $_keyPrefix to scoped key $keyFor',
|
||||
);
|
||||
await prefs.setString(keyFor, legacyJsonString);
|
||||
jsonString = legacyJsonString;
|
||||
}
|
||||
jsonString = await migrateLegacyStringPreference(_keyPrefix, keyFor);
|
||||
}
|
||||
if (jsonString == null || jsonString.isEmpty) {
|
||||
jsonString = prefs.getString(keyFor);
|
||||
|
||||
@@ -15,6 +15,7 @@ class CoalescedWrites {
|
||||
|
||||
final Duration delay;
|
||||
final Map<String, Future<void> Function()> _pending = {};
|
||||
final Set<Future<void>> _inFlight = {};
|
||||
Timer? _timer;
|
||||
|
||||
bool get hasPending => _pending.isNotEmpty;
|
||||
@@ -38,20 +39,20 @@ class CoalescedWrites {
|
||||
Future<void> flush() {
|
||||
_timer?.cancel();
|
||||
_timer = null;
|
||||
if (_pending.isEmpty) return Future<void>.value();
|
||||
final writes = _pending.values.toList();
|
||||
_pending.clear();
|
||||
// Callers fire and forget, so a failed write is logged rather than left
|
||||
// as an unhandled async error, and never stops the other writes.
|
||||
final futures = <Future<void>>[];
|
||||
for (final write in writes) {
|
||||
try {
|
||||
futures.add(write().catchError(_logFailure));
|
||||
final future = write().catchError(_logFailure);
|
||||
_inFlight.add(future);
|
||||
unawaited(future.whenComplete(() => _inFlight.remove(future)));
|
||||
} catch (error) {
|
||||
_logFailure(error);
|
||||
}
|
||||
}
|
||||
return Future.wait(futures).then((_) {});
|
||||
return Future.wait(_inFlight.toList()).then((_) {});
|
||||
}
|
||||
|
||||
static void _logFailure(Object error) {
|
||||
|
||||
@@ -50,6 +50,9 @@ dependencies:
|
||||
ffi: ^2.1.3 # calloc.free for flserial's native I/O buffers
|
||||
provider: ^6.1.5+1
|
||||
shared_preferences: ^2.2.2
|
||||
shared_preferences_platform_interface: ^2.4.2
|
||||
sqflite: ^2.4.5
|
||||
sqflite_common_ffi: ^2.4.0
|
||||
uuid: ^4.3.3
|
||||
flutter_map: ^8.3.2
|
||||
latlong2: ^0.9.1
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
Future<void> main(List<String> arguments) async {
|
||||
if (arguments.length != 1) {
|
||||
stderr.writeln(
|
||||
'Usage: dart run scripts/reset_http_profile.dart <Dart VM service URI>',
|
||||
);
|
||||
exitCode = 64;
|
||||
return;
|
||||
}
|
||||
try {
|
||||
final remaining = await resetHttpProfile(Uri.parse(arguments.single));
|
||||
stdout.writeln('HTTP recording stopped; retained HTTP profile cleared.');
|
||||
if (remaining > 0) {
|
||||
stdout.writeln(
|
||||
'$remaining requests remain in a separate HTTP profiling provider.',
|
||||
);
|
||||
}
|
||||
} catch (error) {
|
||||
stderr.writeln('Could not reset HTTP profiling: $error');
|
||||
exitCode = 1;
|
||||
}
|
||||
}
|
||||
|
||||
/// Stops recording before clearing captured bodies; normal networking continues.
|
||||
/// Returns records still reported by other HTTP profiling providers.
|
||||
Future<int> resetHttpProfile(Uri serviceUri) async {
|
||||
final scheme = switch (serviceUri.scheme) {
|
||||
'http' || 'ws' => 'ws',
|
||||
'https' || 'wss' => 'wss',
|
||||
_ => throw const FormatException(
|
||||
'Expected an HTTP or WebSocket service URI',
|
||||
),
|
||||
};
|
||||
final path = serviceUri.path.endsWith('/ws')
|
||||
? serviceUri.path
|
||||
: '${serviceUri.path.endsWith('/') ? serviceUri.path : '${serviceUri.path}/'}ws';
|
||||
final socket = await WebSocket.connect(
|
||||
serviceUri.replace(scheme: scheme, path: path).toString(),
|
||||
).timeout(const Duration(seconds: 10));
|
||||
final messages = StreamIterator<dynamic>(socket);
|
||||
var nextId = 0;
|
||||
|
||||
Future<Map<String, dynamic>> call(
|
||||
String method, [
|
||||
Map<String, Object> parameters = const {},
|
||||
]) async {
|
||||
final id = '${++nextId}';
|
||||
socket.add(
|
||||
jsonEncode({
|
||||
'jsonrpc': '2.0',
|
||||
'id': id,
|
||||
'method': method,
|
||||
'params': parameters,
|
||||
}),
|
||||
);
|
||||
while (await messages.moveNext().timeout(const Duration(seconds: 10))) {
|
||||
if (messages.current is! String) continue;
|
||||
final response = jsonDecode(messages.current as String) as Map;
|
||||
if (response['id'] != id) continue;
|
||||
if (response['error'] case final Map error) {
|
||||
throw StateError('$method: ${error['message']}');
|
||||
}
|
||||
return Map<String, dynamic>.from(response['result'] as Map);
|
||||
}
|
||||
throw StateError('The Dart VM service disconnected');
|
||||
}
|
||||
|
||||
try {
|
||||
final vm = await call('getVM');
|
||||
final isolates = (vm['isolates'] as List).cast<Map>();
|
||||
final mainIsolates = isolates.where((isolate) => isolate['name'] == 'main');
|
||||
if (mainIsolates.length != 1) {
|
||||
throw StateError('Expected one running main isolate');
|
||||
}
|
||||
final parameters = <String, Object>{
|
||||
'isolateId': mainIsolates.single['id'] as String,
|
||||
};
|
||||
await call('ext.dart.io.httpEnableTimelineLogging', {
|
||||
...parameters,
|
||||
'enabled': 'false',
|
||||
});
|
||||
await call('ext.dart.io.clearHttpProfile', parameters);
|
||||
final state = await call(
|
||||
'ext.dart.io.httpEnableTimelineLogging',
|
||||
parameters,
|
||||
);
|
||||
if (state['enabled'] != false) {
|
||||
throw StateError('HTTP recording was enabled again by another client');
|
||||
}
|
||||
final profile = await call('ext.dart.io.getHttpProfile', parameters);
|
||||
return (profile['requests'] as List).length;
|
||||
} finally {
|
||||
await messages.cancel();
|
||||
await socket.close();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,372 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_connector.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_protocol.dart';
|
||||
import 'package:meshcore_open/models/channel.dart';
|
||||
import 'package:meshcore_open/models/channel_message.dart';
|
||||
import 'package:meshcore_open/models/contact.dart';
|
||||
import 'package:meshcore_open/storage/channel_message_store.dart';
|
||||
import 'package:meshcore_open/storage/channel_store.dart';
|
||||
import 'package:meshcore_open/storage/contact_store.dart';
|
||||
import 'package:meshcore_open/storage/history_store.dart';
|
||||
import 'package:meshcore_open/storage/last_radio_store.dart';
|
||||
import 'package:meshcore_open/storage/message_store.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
const _radioA =
|
||||
'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
|
||||
const _radioB =
|
||||
'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
|
||||
final _contactKey = Uint8List.fromList(List.generate(32, (i) => i + 1));
|
||||
final _contactHex = pubKeyToHex(_contactKey);
|
||||
final _channel = Channel(
|
||||
index: 0,
|
||||
name: 'Test',
|
||||
psk: Uint8List.fromList(List.filled(16, 1)),
|
||||
);
|
||||
|
||||
String _dmKey(String radio) => 'messages_${radio.substring(0, 10)}$_contactHex';
|
||||
String _channelKey(String radio) =>
|
||||
'channel_messages_${radio.substring(0, 10)}_${_channel.storageId}';
|
||||
|
||||
Map<String, Object?> _dm(int i, {String prefix = 'dm'}) => {
|
||||
'senderKey': base64Encode(_contactKey),
|
||||
'text': '$prefix-$i',
|
||||
'timestamp': 1000 * (i + 1),
|
||||
'isOutgoing': false,
|
||||
'status': 2,
|
||||
'messageId': '$prefix-$i',
|
||||
'plainText': true,
|
||||
};
|
||||
Map<String, Object?> _ch(int i, {String prefix = 'ch'}) => {
|
||||
'senderName': 'Bob',
|
||||
'text': '$prefix-$i',
|
||||
'timestamp': 1000 * (i + 1),
|
||||
'isOutgoing': false,
|
||||
'status': 1,
|
||||
'channelIndex': 0,
|
||||
'messageId': '$prefix-$i',
|
||||
'plainText': true,
|
||||
};
|
||||
|
||||
class _TrackingHistory extends HistoryStore {
|
||||
final data = <String, String>{};
|
||||
final reads = <({String key, int offset, int? limit})>[];
|
||||
final fullReads = <String>[];
|
||||
String? delayedKey;
|
||||
Completer<void>? gate;
|
||||
Completer<void>? started;
|
||||
String? failedKey;
|
||||
|
||||
@override
|
||||
Future<String?> getString(String key) async {
|
||||
fullReads.add(key);
|
||||
return data[key];
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> setString(String key, String value) async {
|
||||
data[key] = value;
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> remove(String key) async {
|
||||
data.remove(key);
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Set<String>> getKeys() async => data.keys.toSet();
|
||||
|
||||
List<String> _entries(String key) =>
|
||||
((jsonDecode(data[key] ?? '[]')) as List).map(jsonEncode).toList();
|
||||
|
||||
@override
|
||||
Future<int> entryCount(String key) async => _entries(key).length;
|
||||
|
||||
@override
|
||||
Future<List<String>> readEntries(
|
||||
String key, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
if (key == failedKey) throw StateError('History storage unavailable');
|
||||
reads.add((key: key, offset: offset, limit: limit));
|
||||
final selected = _entries(key).skip(offset);
|
||||
final snapshot = (limit == null ? selected : selected.take(limit)).toList();
|
||||
if (key == delayedKey && gate != null) {
|
||||
final wait = gate!;
|
||||
gate = null;
|
||||
started?.complete();
|
||||
await wait.future;
|
||||
}
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<int> replaceTail(
|
||||
String key,
|
||||
int preservedCount,
|
||||
List<String> entries, {
|
||||
int maxEntries = 1000,
|
||||
}) async {
|
||||
final prefix = _entries(key).take(preservedCount).toList();
|
||||
final combined = [...prefix, ...entries];
|
||||
final overflow = (combined.length - maxEntries).clamp(0, combined.length);
|
||||
data[key] = '[${combined.skip(overflow).join(',')}]';
|
||||
return (prefix.length - overflow).clamp(0, prefix.length);
|
||||
}
|
||||
|
||||
Completer<void> delayNextRead(String key) {
|
||||
delayedKey = key;
|
||||
gate = Completer<void>();
|
||||
started = Completer<void>();
|
||||
return gate!;
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> _seedRadio(String radio) async {
|
||||
final contact = Contact(
|
||||
publicKey: _contactKey,
|
||||
name: 'Alice',
|
||||
type: advTypeChat,
|
||||
pathLength: 0,
|
||||
path: Uint8List(0),
|
||||
lastSeen: DateTime.fromMillisecondsSinceEpoch(1000),
|
||||
);
|
||||
await (ContactStore()..setPublicKeyHex = radio).saveContacts([contact]);
|
||||
final channels = ChannelStore()..setPublicKeyHex = radio;
|
||||
await channels.saveChannels([_channel]);
|
||||
await channels.saveSlotChannelIds({0: _channel.storageId!});
|
||||
await PrefsManager.instance.setBool(
|
||||
'channel_storage_v2_${radio.substring(0, 10)}',
|
||||
true,
|
||||
);
|
||||
await LastRadioStore().save(
|
||||
LastRadio(
|
||||
publicKeyHex: radio,
|
||||
name: 'Saved',
|
||||
transport: LastRadio.transportBle,
|
||||
bleRemoteId: 'AA:BB:CC:DD:EE:FF',
|
||||
savedAt: DateTime.fromMillisecondsSinceEpoch(1000),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
late _TrackingHistory history;
|
||||
late MeshCoreConnector connector;
|
||||
|
||||
setUp(() async {
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
PrefsManager.reset();
|
||||
await PrefsManager.initialize();
|
||||
await _seedRadio(_radioA);
|
||||
history = _TrackingHistory();
|
||||
history.data[_dmKey(_radioA)] = jsonEncode([
|
||||
for (var i = 0; i < 620; i++) _dm(i),
|
||||
]);
|
||||
history.data[_channelKey(_radioA)] = jsonEncode([
|
||||
for (var i = 0; i < 620; i++) _ch(i),
|
||||
]);
|
||||
HistoryStore.use(history);
|
||||
MessageStore().forgetArchive();
|
||||
ChannelMessageStore().forgetArchive();
|
||||
connector = MeshCoreConnector();
|
||||
addTearDown(connector.dispose);
|
||||
});
|
||||
|
||||
test(
|
||||
'initial loads and older pages read only the requested stored rows',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
final contact = connector.contacts.single;
|
||||
final channel = connector.channels.single;
|
||||
expect(connector.getMessages(contact).map((m) => m.text), [
|
||||
for (var i = 420; i < 620; i++) 'dm-$i',
|
||||
]);
|
||||
expect(connector.getChannelMessages(channel).map((m) => m.text), [
|
||||
for (var i = 420; i < 620; i++) 'ch-$i',
|
||||
]);
|
||||
expect(
|
||||
history.reads,
|
||||
containsAll([
|
||||
(key: _dmKey(_radioA), offset: 420, limit: 200),
|
||||
(key: _channelKey(_radioA), offset: 420, limit: 200),
|
||||
]),
|
||||
);
|
||||
expect(
|
||||
history.fullReads.where(
|
||||
(key) => key == _dmKey(_radioA) || key == _channelKey(_radioA),
|
||||
),
|
||||
isEmpty,
|
||||
);
|
||||
history.reads.clear();
|
||||
final dms = await connector.loadOlderMessages(_contactHex);
|
||||
final channels = await connector.loadOlderChannelMessages(0);
|
||||
expect(dms.map((m) => m.text), [for (var i = 370; i < 420; i++) 'dm-$i']);
|
||||
expect(channels.map((m) => m.text), [
|
||||
for (var i = 370; i < 420; i++) 'ch-$i',
|
||||
]);
|
||||
expect(history.reads, [
|
||||
(key: _dmKey(_radioA), offset: 370, limit: 50),
|
||||
(key: _channelKey(_radioA), offset: 370, limit: 50),
|
||||
]);
|
||||
final next = await connector.loadOlderMessages(_contactHex);
|
||||
expect(next.map((m) => m.text), [
|
||||
for (var i = 320; i < 370; i++) 'dm-$i',
|
||||
]);
|
||||
expect(
|
||||
connector.getMessages(contact).map((m) => m.messageId).toSet(),
|
||||
hasLength(300),
|
||||
);
|
||||
final search = await connector.allMessagesForSearch(_contactHex);
|
||||
expect(search.map((m) => m.text), [
|
||||
for (var i = 0; i < 620; i++) 'dm-$i',
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'older pages start before the window when the archive is unreconciled',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
MessageStore().forgetArchive();
|
||||
ChannelMessageStore().forgetArchive();
|
||||
final dms = await connector.loadOlderMessages(_contactHex);
|
||||
final channels = await connector.loadOlderChannelMessages(0);
|
||||
expect(dms.map((m) => m.text), [for (var i = 370; i < 420; i++) 'dm-$i']);
|
||||
expect(channels.map((m) => m.text), [
|
||||
for (var i = 370; i < 420; i++) 'ch-$i',
|
||||
]);
|
||||
expect(
|
||||
connector.getMessages(connector.contacts.single).map((m) => m.text),
|
||||
[for (var i = 370; i < 620; i++) 'dm-$i'],
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'malformed rows consume physical offsets and do not hide older pages',
|
||||
() async {
|
||||
history.data[_dmKey(_radioA)] = jsonEncode([
|
||||
for (var i = 0; i < 620; i++)
|
||||
if (i >= 400 && i < 600) {'text': 1} else _dm(i),
|
||||
]);
|
||||
await connector.restoreLastRadio();
|
||||
expect(connector.getMessages(connector.contacts.single), hasLength(200));
|
||||
final older = await connector.loadOlderMessages(_contactHex);
|
||||
expect(older.map((m) => m.text), [
|
||||
for (var i = 170; i < 220; i++) 'dm-$i',
|
||||
]);
|
||||
final stored = await connector.allMessagesForSearch(_contactHex);
|
||||
expect(stored.map((m) => m.text), [
|
||||
for (var i = 0; i < 620; i++)
|
||||
if (i < 400 || i >= 600) 'dm-$i',
|
||||
]);
|
||||
expect(history.reads.last, (
|
||||
key: _dmKey(_radioA),
|
||||
offset: 0,
|
||||
limit: 170,
|
||||
), reason: 'Search reads the remaining prefix before the loaded window');
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'a storage read failure keeps the loaded window and archive cursor',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
final before = List.of(connector.getMessages(connector.contacts.single));
|
||||
final store = MessageStore()..setPublicKeyHex = _radioA;
|
||||
expect(store.archivedCount(_contactHex), 420);
|
||||
history.failedKey = _dmKey(_radioA);
|
||||
|
||||
await expectLater(
|
||||
connector.loadOlderMessages(_contactHex),
|
||||
throwsStateError,
|
||||
);
|
||||
expect(connector.getMessages(connector.contacts.single), before);
|
||||
expect(store.archivedCount(_contactHex), 420);
|
||||
history.failedKey = null;
|
||||
expect(await connector.loadOlderMessages(_contactHex), hasLength(50));
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'overlapping requests share a page rather than prepending it twice',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
history.reads.clear();
|
||||
final gate = history.delayNextRead(_dmKey(_radioA));
|
||||
final first = connector.loadOlderMessages(_contactHex);
|
||||
await history.started!.future;
|
||||
final second = connector.loadOlderMessages(_contactHex);
|
||||
gate.complete();
|
||||
await Future.wait([first, second]);
|
||||
expect(
|
||||
history.reads.where((r) => r.key == _dmKey(_radioA)),
|
||||
hasLength(1),
|
||||
);
|
||||
expect(connector.getMessages(connector.contacts.single), hasLength(250));
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'a delayed old-radio page cannot enter a newly restored radio',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
final gate = history.delayNextRead(_dmKey(_radioA));
|
||||
final oldPage = connector.loadOlderMessages(_contactHex);
|
||||
await history.started!.future;
|
||||
await _seedRadio(_radioB);
|
||||
history.data[_dmKey(_radioB)] = jsonEncode([
|
||||
for (var i = 0; i < 10; i++) _dm(i, prefix: 'new'),
|
||||
]);
|
||||
history.data[_channelKey(_radioB)] = '[]';
|
||||
await connector.restoreLastRadio();
|
||||
gate.complete();
|
||||
expect(await oldPage, isEmpty);
|
||||
expect(connector.storageKeyHex, _radioB);
|
||||
expect(
|
||||
connector.getMessages(connector.contacts.single).map((m) => m.text),
|
||||
[for (var i = 0; i < 10; i++) 'new-$i'],
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'channel edits during an asynchronous reload survive the stale read',
|
||||
() async {
|
||||
await connector.restoreLastRadio();
|
||||
final channel = connector.channels.single;
|
||||
final gate = history.delayNextRead(_channelKey(_radioA));
|
||||
final reload = connector.loadAllChannelMessages();
|
||||
await history.started!.future;
|
||||
final current = connector.getChannelMessages(channel);
|
||||
final removed = current.first;
|
||||
current.add(
|
||||
ChannelMessage(
|
||||
senderName: 'Live',
|
||||
text: 'arrived during read',
|
||||
timestamp: DateTime.fromMillisecondsSinceEpoch(1000000),
|
||||
isOutgoing: false,
|
||||
status: ChannelMessageStatus.sent,
|
||||
channelIndex: 0,
|
||||
messageId: 'live',
|
||||
),
|
||||
);
|
||||
await connector.deleteChannelMessage(removed);
|
||||
gate.complete();
|
||||
await reload;
|
||||
final messages = connector.getChannelMessages(channel);
|
||||
expect(messages.any((m) => m.messageId == 'live'), isTrue);
|
||||
expect(messages.any((m) => m.messageId == removed.messageId), isFalse);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -78,6 +78,8 @@ void main() {
|
||||
expect(connector.contacts, isNotEmpty);
|
||||
expect(listed(), isFalse);
|
||||
|
||||
// Contact saves are batched; land them before reading the store.
|
||||
await connector.flushPendingWrites();
|
||||
final store = ContactStore()..setPublicKeyHex = connector.selfPublicKeyHex;
|
||||
final saved = await store.loadContacts();
|
||||
expect(saved.any((c) => c.publicKeyHex == contact.publicKeyHex), isFalse);
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter/services.dart';
|
||||
import 'package:flutter_map/flutter_map.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
||||
import 'package:latlong2/latlong.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_connector.dart';
|
||||
import 'package:meshcore_open/l10n/app_localizations.dart';
|
||||
import 'package:meshcore_open/screens/map_screen.dart';
|
||||
import 'package:meshcore_open/services/app_settings_service.dart';
|
||||
import 'package:meshcore_open/services/map_tile_cache_service.dart';
|
||||
import 'package:meshcore_open/services/path_history_service.dart';
|
||||
import 'package:meshcore_open/services/storage_service.dart';
|
||||
import 'package:meshcore_open/services/ui_view_state_service.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:meshcore_open/theme/mesh_theme.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
const _cameraKey = 'flutter.map_last_camera';
|
||||
const _preferencesChannel = MethodChannel(
|
||||
'plugins.flutter.io/shared_preferences',
|
||||
);
|
||||
|
||||
class _UnusedCacheManager implements BaseCacheManager {
|
||||
@override
|
||||
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||||
}
|
||||
|
||||
class _MapWithoutTiles extends MapTileCacheService {
|
||||
_MapWithoutTiles(AppSettingsService settings)
|
||||
: super(appSettingsService: settings, cacheManager: _UnusedCacheManager());
|
||||
|
||||
@override
|
||||
Widget buildTileLayer(BuildContext context, {double opacity = 1}) =>
|
||||
const SizedBox.shrink();
|
||||
}
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
late Map<String, Object> persisted;
|
||||
late List<List<String>> cameraWrites;
|
||||
|
||||
setUp(() async {
|
||||
persisted = {};
|
||||
cameraWrites = [];
|
||||
SharedPreferences.resetStatic();
|
||||
PrefsManager.reset();
|
||||
TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
|
||||
.setMockMethodCallHandler(_preferencesChannel, (call) async {
|
||||
if (call.method == 'getAll') return persisted;
|
||||
final args = call.arguments as Map<dynamic, dynamic>;
|
||||
final key = args['key'] as String;
|
||||
if (call.method == 'remove') {
|
||||
persisted.remove(key);
|
||||
} else {
|
||||
persisted[key] = args['value'] as Object;
|
||||
if (key == _cameraKey) {
|
||||
cameraWrites.add(List<String>.from(args['value'] as List));
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
await PrefsManager.initialize();
|
||||
});
|
||||
|
||||
Future<MapController> openMap(WidgetTester tester) async {
|
||||
final settings = AppSettingsService();
|
||||
final connector = MeshCoreConnector();
|
||||
final paths = PathHistoryService(StorageService());
|
||||
final tiles = _MapWithoutTiles(settings);
|
||||
addTearDown(() {
|
||||
connector.dispose();
|
||||
paths.dispose();
|
||||
tiles.dispose();
|
||||
settings.dispose();
|
||||
});
|
||||
await tester.pumpWidget(
|
||||
MultiProvider(
|
||||
providers: [
|
||||
ChangeNotifierProvider.value(value: connector),
|
||||
ChangeNotifierProvider.value(value: settings),
|
||||
ChangeNotifierProvider.value(value: paths),
|
||||
ChangeNotifierProvider.value(value: UiViewStateService()),
|
||||
ChangeNotifierProvider<MapTileCacheService>.value(value: tiles),
|
||||
],
|
||||
child: MaterialApp(
|
||||
theme: MeshTheme.light(),
|
||||
localizationsDelegates: AppLocalizations.localizationsDelegates,
|
||||
supportedLocales: AppLocalizations.supportedLocales,
|
||||
home: const MapScreen(),
|
||||
),
|
||||
),
|
||||
);
|
||||
await tester.pump();
|
||||
return tester.widget<FlutterMap>(find.byType(FlutterMap)).mapController!;
|
||||
}
|
||||
|
||||
testWidgets('camera movements persist once after interaction settles', (
|
||||
tester,
|
||||
) async {
|
||||
final controller = await openMap(tester);
|
||||
controller.move(const LatLng(35, -112), 9);
|
||||
await tester.pump(const Duration(milliseconds: 300));
|
||||
controller.move(const LatLng(36, -113), 10);
|
||||
await tester.pump(const Duration(milliseconds: 300));
|
||||
expect(cameraWrites, isEmpty);
|
||||
await tester.pump(const Duration(milliseconds: 201));
|
||||
expect(cameraWrites, [
|
||||
['36.0', '-113.0', '10.0'],
|
||||
]);
|
||||
|
||||
// Duplicate end events and disposal must not rewrite an unchanged camera.
|
||||
final map = tester.widget<FlutterMap>(find.byType(FlutterMap));
|
||||
map.options.onMapEvent!(
|
||||
MapEventMoveEnd(
|
||||
source: MapEventSource.mapController,
|
||||
camera: controller.camera,
|
||||
),
|
||||
);
|
||||
await tester.pump(const Duration(milliseconds: 600));
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pump();
|
||||
expect(cameraWrites, hasLength(1));
|
||||
});
|
||||
|
||||
testWidgets(
|
||||
'leaving the map flushes the latest camera and cancels its timer',
|
||||
(tester) async {
|
||||
final controller = await openMap(tester);
|
||||
controller.move(const LatLng(37, -114), 11);
|
||||
await tester.pump(const Duration(milliseconds: 100));
|
||||
expect(cameraWrites, isEmpty);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pump();
|
||||
expect(cameraWrites, [
|
||||
['37.0', '-114.0', '11.0'],
|
||||
]);
|
||||
await tester.pump(const Duration(seconds: 1));
|
||||
expect(cameraWrites, hasLength(1));
|
||||
},
|
||||
);
|
||||
|
||||
testWidgets('backgrounding the app flushes without waiting for debounce', (
|
||||
tester,
|
||||
) async {
|
||||
final controller = await openMap(tester);
|
||||
controller.move(const LatLng(38, -115), 12);
|
||||
await tester.pump(const Duration(milliseconds: 100));
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
|
||||
await tester.pump();
|
||||
expect(cameraWrites, [
|
||||
['38.0', '-115.0', '12.0'],
|
||||
]);
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pump();
|
||||
expect(cameraWrites, hasLength(1));
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
||||
import 'package:flutter_map/flutter_map.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:latlong2/latlong.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_connector.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_protocol.dart';
|
||||
import 'package:meshcore_open/l10n/app_localizations.dart';
|
||||
import 'package:meshcore_open/models/contact.dart';
|
||||
import 'package:meshcore_open/screens/map_screen.dart';
|
||||
import 'package:meshcore_open/services/app_settings_service.dart';
|
||||
import 'package:meshcore_open/services/map_tile_cache_service.dart';
|
||||
import 'package:meshcore_open/services/path_history_service.dart';
|
||||
import 'package:meshcore_open/services/storage_service.dart';
|
||||
import 'package:meshcore_open/services/ui_view_state_service.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:meshcore_open/theme/mesh_theme.dart';
|
||||
import 'package:meshcore_open/widgets/quick_switch_bar.dart';
|
||||
import 'package:provider/provider.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
|
||||
class _Connector extends MeshCoreConnector {
|
||||
List<Contact> nodes = [];
|
||||
int contactUnread = 0;
|
||||
int channelUnread = 0;
|
||||
|
||||
@override
|
||||
List<Contact> get allContacts => List.unmodifiable(nodes);
|
||||
|
||||
@override
|
||||
List<Contact> get contacts => List.unmodifiable(nodes);
|
||||
|
||||
@override
|
||||
int getTotalContactsUnreadCount() => contactUnread;
|
||||
|
||||
@override
|
||||
int getTotalChannelsUnreadCount() => channelUnread;
|
||||
}
|
||||
|
||||
class _UnusedCacheManager implements BaseCacheManager {
|
||||
@override
|
||||
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
||||
}
|
||||
|
||||
class _CountingTiles extends MapTileCacheService {
|
||||
_CountingTiles(AppSettingsService settings)
|
||||
: super(appSettingsService: settings, cacheManager: _UnusedCacheManager());
|
||||
|
||||
int builds = 0;
|
||||
|
||||
@override
|
||||
Widget buildTileLayer(BuildContext context, {double opacity = 1}) {
|
||||
builds++;
|
||||
return const SizedBox.shrink();
|
||||
}
|
||||
}
|
||||
|
||||
Contact _node({double latitude = 35, DateTime? lastSeen}) => Contact(
|
||||
publicKey: Uint8List.fromList(List.filled(32, 1)),
|
||||
name: 'Repeater',
|
||||
type: advTypeRepeater,
|
||||
pathLength: 0,
|
||||
path: Uint8List(0),
|
||||
latitude: latitude,
|
||||
longitude: -112,
|
||||
lastSeen: lastSeen ?? DateTime.now(),
|
||||
);
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
late _Connector connector;
|
||||
late AppSettingsService settings;
|
||||
late _CountingTiles tiles;
|
||||
late PathHistoryService paths;
|
||||
late UiViewStateService viewState;
|
||||
|
||||
setUp(() async {
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
PrefsManager.reset();
|
||||
await PrefsManager.initialize();
|
||||
connector = _Connector();
|
||||
settings = AppSettingsService();
|
||||
tiles = _CountingTiles(settings);
|
||||
paths = PathHistoryService(StorageService());
|
||||
viewState = UiViewStateService();
|
||||
});
|
||||
|
||||
tearDown(() {
|
||||
connector.dispose();
|
||||
settings.dispose();
|
||||
tiles.dispose();
|
||||
paths.dispose();
|
||||
viewState.dispose();
|
||||
});
|
||||
|
||||
Future<void> openMap(WidgetTester tester) async {
|
||||
await tester.pumpWidget(
|
||||
MultiProvider(
|
||||
providers: [
|
||||
ChangeNotifierProvider<MeshCoreConnector>.value(value: connector),
|
||||
ChangeNotifierProvider.value(value: settings),
|
||||
ChangeNotifierProvider.value(value: paths),
|
||||
ChangeNotifierProvider.value(value: viewState),
|
||||
ChangeNotifierProvider<MapTileCacheService>.value(value: tiles),
|
||||
],
|
||||
child: MaterialApp(
|
||||
theme: MeshTheme.light(),
|
||||
localizationsDelegates: AppLocalizations.localizationsDelegates,
|
||||
supportedLocales: AppLocalizations.supportedLocales,
|
||||
home: const MapScreen(),
|
||||
),
|
||||
),
|
||||
);
|
||||
await tester.pump();
|
||||
await tester.pump(const Duration(milliseconds: 60));
|
||||
await tester.pump();
|
||||
}
|
||||
|
||||
Iterable<LatLng> markerPoints(WidgetTester tester) => tester
|
||||
.widgetList<MarkerLayer>(find.byType(MarkerLayer))
|
||||
.expand((layer) => layer.markers)
|
||||
.map((marker) => marker.point);
|
||||
|
||||
testWidgets('unread badges update without rebuilding the map', (
|
||||
tester,
|
||||
) async {
|
||||
connector.nodes = [_node()];
|
||||
await openMap(tester);
|
||||
final originalBuilds = tiles.builds;
|
||||
|
||||
connector.contactUnread = 3;
|
||||
connector.channelUnread = 5;
|
||||
connector.notifyListeners();
|
||||
await tester.pump(const Duration(milliseconds: 60));
|
||||
await tester.pump();
|
||||
|
||||
final navigation = tester.widget<QuickSwitchBar>(
|
||||
find.byType(QuickSwitchBar),
|
||||
);
|
||||
expect(navigation.contactsUnreadCount, 3);
|
||||
expect(navigation.channelsUnreadCount, 5);
|
||||
expect(tiles.builds, originalBuilds);
|
||||
|
||||
connector.notifyListeners();
|
||||
await tester.pump(const Duration(milliseconds: 60));
|
||||
await tester.pump();
|
||||
expect(tiles.builds, originalBuilds);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
|
||||
testWidgets('contact movement invalidates cached markers', (tester) async {
|
||||
connector.nodes = [_node()];
|
||||
await openMap(tester);
|
||||
expect(markerPoints(tester), contains(const LatLng(35, -112)));
|
||||
final originalBuilds = tiles.builds;
|
||||
|
||||
connector.nodes = [connector.nodes.single.copyWith(latitude: 36)];
|
||||
connector.notifyListeners();
|
||||
await tester.pump(const Duration(milliseconds: 60));
|
||||
await tester.pump();
|
||||
|
||||
expect(tiles.builds, greaterThan(originalBuilds));
|
||||
expect(markerPoints(tester), contains(const LatLng(36, -112)));
|
||||
expect(markerPoints(tester), isNot(contains(const LatLng(35, -112))));
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
|
||||
testWidgets('time filters invalidate the visible marker cache', (
|
||||
tester,
|
||||
) async {
|
||||
connector.nodes = [
|
||||
_node(lastSeen: DateTime.now().subtract(const Duration(hours: 3))),
|
||||
];
|
||||
await openMap(tester);
|
||||
expect(markerPoints(tester), contains(const LatLng(35, -112)));
|
||||
|
||||
await settings.setMapTimeFilterHours(1);
|
||||
await tester.pump();
|
||||
expect(markerPoints(tester), isNot(contains(const LatLng(35, -112))));
|
||||
|
||||
await settings.setMapTimeFilterHours(0);
|
||||
await tester.pump();
|
||||
expect(markerPoints(tester), contains(const LatLng(35, -112)));
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
|
||||
import '../../scripts/reset_http_profile.dart';
|
||||
|
||||
void main() {
|
||||
test('stops recording before clearing and verifies the result', () async {
|
||||
final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
|
||||
final calls = <Map<String, dynamic>>[];
|
||||
final paths = <String>[];
|
||||
var recording = true;
|
||||
var requests = <Object>[
|
||||
{'id': 'captured-request'},
|
||||
];
|
||||
final subscription = server.listen((request) async {
|
||||
paths.add(request.uri.path);
|
||||
final socket = await WebSocketTransformer.upgrade(request);
|
||||
socket.listen((data) {
|
||||
final call = jsonDecode(data as String) as Map<String, dynamic>;
|
||||
calls.add(call);
|
||||
final parameters = call['params'] as Map;
|
||||
Map<String, dynamic> result;
|
||||
switch (call['method']) {
|
||||
case 'getVM':
|
||||
result = {
|
||||
'isolates': [
|
||||
{'name': 'worker', 'id': 'worker'},
|
||||
{'name': 'main', 'id': 'main-isolate'},
|
||||
],
|
||||
};
|
||||
case 'ext.dart.io.httpEnableTimelineLogging':
|
||||
if (parameters['enabled'] == 'false') recording = false;
|
||||
result = {'enabled': recording};
|
||||
case 'ext.dart.io.clearHttpProfile':
|
||||
expect(recording, isFalse);
|
||||
requests = [];
|
||||
result = {'type': 'Success'};
|
||||
case 'ext.dart.io.getHttpProfile':
|
||||
result = {'requests': requests};
|
||||
default:
|
||||
fail('Unexpected service method ${call['method']}');
|
||||
}
|
||||
socket.add(jsonEncode({'id': call['id'], 'result': result}));
|
||||
});
|
||||
});
|
||||
addTearDown(() async {
|
||||
await subscription.cancel();
|
||||
await server.close(force: true);
|
||||
});
|
||||
|
||||
expect(
|
||||
await resetHttpProfile(
|
||||
Uri.parse('http://127.0.0.1:${server.port}/service-token=/'),
|
||||
),
|
||||
0,
|
||||
);
|
||||
expect(paths, ['/service-token=/ws']);
|
||||
expect(calls.map((call) => call['method']), [
|
||||
'getVM',
|
||||
'ext.dart.io.httpEnableTimelineLogging',
|
||||
'ext.dart.io.clearHttpProfile',
|
||||
'ext.dart.io.httpEnableTimelineLogging',
|
||||
'ext.dart.io.getHttpProfile',
|
||||
]);
|
||||
for (final call in calls.skip(1)) {
|
||||
expect((call['params'] as Map)['isolateId'], 'main-isolate');
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects unsupported URIs before connecting', () async {
|
||||
await expectLater(
|
||||
resetHttpProfile(Uri.parse('file:///tmp/service')),
|
||||
throwsFormatException,
|
||||
);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,264 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/services/map_tile_cache_repository_io.dart';
|
||||
import 'package:meshcore_open/services/map_tile_cache_repository_stub.dart'
|
||||
as web;
|
||||
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
|
||||
|
||||
void main() {
|
||||
late Directory directory;
|
||||
late SqliteMapTileCacheRepository repository;
|
||||
final factory = databaseFactoryFfiNoIsolate;
|
||||
|
||||
SqliteMapTileCacheRepository createRepository() =>
|
||||
SqliteMapTileCacheRepository(
|
||||
databaseName: 'map_tile_cache',
|
||||
directory: () async => directory,
|
||||
factory: factory,
|
||||
);
|
||||
|
||||
CacheObject tile(String key, {int daysOld = 0, int? id}) => CacheObject(
|
||||
'https://tile.openstreetmap.org/$key.png',
|
||||
key: key,
|
||||
id: id,
|
||||
relativePath: '$key.png',
|
||||
validTill: DateTime(2030),
|
||||
touched: DateTime.now().subtract(Duration(days: daysOld)),
|
||||
length: 123,
|
||||
eTag: 'etag-$key',
|
||||
);
|
||||
|
||||
setUpAll(sqfliteFfiInit);
|
||||
setUp(() async {
|
||||
directory = await Directory.systemTemp.createTemp('meshcore-map-metadata-');
|
||||
repository = createRepository();
|
||||
});
|
||||
tearDown(() async {
|
||||
await repository.close();
|
||||
await directory.delete(recursive: true);
|
||||
});
|
||||
|
||||
test('desktop selects SQLite and web keeps its platform default', () {
|
||||
expect(
|
||||
createMapTileCacheRepository('map_tile_cache'),
|
||||
Platform.isLinux || Platform.isWindows
|
||||
? isA<SqliteMapTileCacheRepository>()
|
||||
: isNot(isA<SqliteMapTileCacheRepository>()),
|
||||
);
|
||||
expect(
|
||||
web.createMapTileCacheRepository('map_tile_cache'),
|
||||
isA<NonStoringObjectProvider>(),
|
||||
);
|
||||
});
|
||||
|
||||
test('metadata survives reopen and supports updates and deletes', () async {
|
||||
await repository.open();
|
||||
final inserted = await repository.insert(tile('a'));
|
||||
expect(inserted.id, isNotNull);
|
||||
expect(inserted.touched, isNotNull);
|
||||
await repository.update(inserted.copyWith(length: 456));
|
||||
expect((await repository.get('a'))!.length, 456);
|
||||
await repository.close();
|
||||
|
||||
repository = createRepository();
|
||||
await repository.open();
|
||||
final restored = (await repository.get('a'))!;
|
||||
expect(restored.relativePath, 'a.png');
|
||||
expect(restored.eTag, 'etag-a');
|
||||
expect(restored.length, 456);
|
||||
expect(await repository.deleteAll([]), 0);
|
||||
expect(await repository.deleteAll([restored.id!, restored.id!]), 1);
|
||||
expect(await repository.get('a'), isNull);
|
||||
});
|
||||
|
||||
test('age and capacity queries select oldest metadata in SQLite', () async {
|
||||
await repository.open();
|
||||
for (var days = 2; days <= 5; days++) {
|
||||
await repository.insert(
|
||||
tile('tile-$days', daysOld: days),
|
||||
setTouchedToNow: false,
|
||||
);
|
||||
}
|
||||
expect(
|
||||
(await repository.getObjectsOverCapacity(2)).map((entry) => entry.key),
|
||||
['tile-4', 'tile-5'],
|
||||
);
|
||||
expect(
|
||||
(await repository.getOldObjects(
|
||||
const Duration(days: 3),
|
||||
)).map((entry) => entry.key),
|
||||
['tile-5', 'tile-4', 'tile-3'],
|
||||
);
|
||||
});
|
||||
|
||||
test('legacy JSON migrates without altering downloaded tile files', () async {
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
final oldTile = tile('10/1/2', daysOld: 2, id: 88);
|
||||
final downloaded = File('${directory.path}/tile-bytes.png');
|
||||
await downloaded.writeAsBytes([1, 2, 3]);
|
||||
await legacy.writeAsString(
|
||||
jsonEncode([oldTile.toMap(setTouchedToNow: false)]),
|
||||
);
|
||||
|
||||
await repository.open();
|
||||
final imported = (await repository.get(oldTile.key))!;
|
||||
expect(imported.url, oldTile.url);
|
||||
expect(imported.relativePath, oldTile.relativePath);
|
||||
expect(
|
||||
imported.touched!.millisecondsSinceEpoch,
|
||||
oldTile.touched!.millisecondsSinceEpoch,
|
||||
);
|
||||
expect(imported.length, oldTile.length);
|
||||
expect(imported.eTag, oldTile.eTag);
|
||||
expect(await downloaded.readAsBytes(), [1, 2, 3]);
|
||||
expect(await legacy.exists(), isFalse);
|
||||
await repository.close();
|
||||
|
||||
// A crash after commit but before cleanup must not replay stale metadata.
|
||||
await legacy.writeAsString(
|
||||
jsonEncode([tile('stale', id: 99).toMap(setTouchedToNow: false)]),
|
||||
);
|
||||
repository = createRepository();
|
||||
await repository.open();
|
||||
expect(await repository.get('stale'), isNull);
|
||||
expect((await repository.getAllObjects()).length, 1);
|
||||
expect(await legacy.exists(), isFalse);
|
||||
});
|
||||
|
||||
test(
|
||||
'malformed migration imports readable records and sets the file aside',
|
||||
() async {
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
final aside = File('${legacy.path}.unreadable');
|
||||
final content = jsonEncode([
|
||||
{'invalid': true},
|
||||
tile('readable', id: 1).toMap(setTouchedToNow: false),
|
||||
]);
|
||||
await legacy.writeAsString(content);
|
||||
await repository.open();
|
||||
expect((await repository.getAllObjects()).single.key, 'readable');
|
||||
expect(await legacy.exists(), isFalse);
|
||||
expect(await aside.readAsString(), content);
|
||||
await repository.close();
|
||||
|
||||
// The file that was set aside is not imported again.
|
||||
repository = createRepository();
|
||||
await repository.open();
|
||||
expect((await repository.getAllObjects()).length, 1);
|
||||
await repository.close();
|
||||
await repository.deleteDataFile();
|
||||
expect(await aside.exists(), isFalse);
|
||||
},
|
||||
);
|
||||
|
||||
test('a legacy file that is not JSON does not block opening', () async {
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
await legacy.writeAsString('{broken');
|
||||
await repository.open();
|
||||
expect(await repository.getAllObjects(), isEmpty);
|
||||
expect(await legacy.exists(), isFalse);
|
||||
expect(await File('${legacy.path}.unreadable').readAsString(), '{broken');
|
||||
});
|
||||
|
||||
test(
|
||||
'failed SQL import rolls back rows and preserves original JSON',
|
||||
() async {
|
||||
await repository.open();
|
||||
await repository.close();
|
||||
final db = await factory.openDatabase(
|
||||
'${directory.path}/map_tile_cache.db',
|
||||
);
|
||||
await db.delete('cacheMigration');
|
||||
await db.execute('''
|
||||
CREATE TRIGGER fail_import BEFORE INSERT ON cacheObject
|
||||
WHEN NEW.key = 'bad' BEGIN SELECT RAISE(ABORT, 'test failure'); END
|
||||
''');
|
||||
await db.close();
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
await legacy.writeAsString(
|
||||
jsonEncode([
|
||||
tile('good', id: 1).toMap(setTouchedToNow: false),
|
||||
tile('bad', id: 2).toMap(setTouchedToNow: false),
|
||||
]),
|
||||
);
|
||||
await expectLater(repository.open(), throwsA(isA<DatabaseException>()));
|
||||
expect(await legacy.exists(), isTrue);
|
||||
|
||||
final failed = await factory.openDatabase(
|
||||
'${directory.path}/map_tile_cache.db',
|
||||
);
|
||||
expect(await failed.query('cacheObject'), isEmpty);
|
||||
expect(await failed.query('cacheMigration'), isEmpty);
|
||||
await failed.execute('DROP TRIGGER fail_import');
|
||||
await failed.close();
|
||||
await repository.open();
|
||||
expect((await repository.getAllObjects()).length, 2);
|
||||
expect(await legacy.exists(), isFalse);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'newer database versions are rejected without deleting legacy data',
|
||||
() async {
|
||||
final db = await factory.openDatabase(
|
||||
'${directory.path}/map_tile_cache.db',
|
||||
options: OpenDatabaseOptions(
|
||||
version: SqliteMapTileCacheRepository.schemaVersion + 1,
|
||||
),
|
||||
);
|
||||
await db.close();
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
await legacy.writeAsString('[]');
|
||||
await expectLater(repository.open(), throwsA(isA<DatabaseException>()));
|
||||
expect(await legacy.exists(), isTrue);
|
||||
},
|
||||
);
|
||||
|
||||
test('newer import markers are not overwritten or replayed', () async {
|
||||
await repository.open();
|
||||
await repository.insert(tile('current'));
|
||||
await repository.close();
|
||||
final db = await factory.openDatabase(
|
||||
'${directory.path}/map_tile_cache.db',
|
||||
);
|
||||
await db.update('cacheMigration', {
|
||||
'version': SqliteMapTileCacheRepository.legacyImportVersion + 1,
|
||||
});
|
||||
await db.close();
|
||||
final legacy = File('${directory.path}/map_tile_cache.json');
|
||||
await legacy.writeAsString(
|
||||
jsonEncode([tile('legacy', id: 1).toMap(setTouchedToNow: false)]),
|
||||
);
|
||||
await repository.open();
|
||||
expect((await repository.getAllObjects()).map((entry) => entry.key), [
|
||||
'current',
|
||||
]);
|
||||
expect(await legacy.exists(), isTrue);
|
||||
await repository.close();
|
||||
final reopened = await factory.openDatabase(
|
||||
'${directory.path}/map_tile_cache.db',
|
||||
);
|
||||
expect(
|
||||
(await reopened.query('cacheMigration')).single['version'],
|
||||
SqliteMapTileCacheRepository.legacyImportVersion + 1,
|
||||
);
|
||||
await reopened.close();
|
||||
});
|
||||
|
||||
test(
|
||||
'inventory connections do not close the cache-manager connection',
|
||||
() async {
|
||||
await repository.open();
|
||||
await repository.open();
|
||||
expect(await repository.close(), isFalse);
|
||||
final inserted = await repository.insert(tile('a'));
|
||||
expect((await repository.get('a'))!.id, inserted.id);
|
||||
expect(await repository.close(), isTrue);
|
||||
await repository.deleteDataFile();
|
||||
expect(await repository.exists(), isFalse);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
import 'dart:async';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/models/contact.dart';
|
||||
import 'package:meshcore_open/models/path_history.dart';
|
||||
import 'package:meshcore_open/services/path_history_service.dart';
|
||||
import 'package:meshcore_open/services/storage_service.dart';
|
||||
|
||||
class _Load {
|
||||
_Load(this.scope, this.contact);
|
||||
final String scope;
|
||||
final String contact;
|
||||
final result = Completer<ContactPathHistory?>();
|
||||
}
|
||||
|
||||
class _Storage extends StorageService {
|
||||
String scope = 'a';
|
||||
bool delayLoads = true;
|
||||
Completer<void>? saveGate;
|
||||
bool failClears = false;
|
||||
final loads = <_Load>[];
|
||||
final saved = <String, ContactPathHistory>{};
|
||||
|
||||
@override
|
||||
set setPublicKeyHex(String value) => scope = value;
|
||||
|
||||
@override
|
||||
Future<ContactPathHistory?> loadPathHistory(String contactPubKeyHex) async {
|
||||
final load = _Load(scope, contactPubKeyHex);
|
||||
loads.add(load);
|
||||
if (delayLoads) return load.result.future;
|
||||
return saved['${load.scope}:$contactPubKeyHex'];
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> savePathHistory(
|
||||
String contactPubKeyHex,
|
||||
ContactPathHistory history,
|
||||
) async {
|
||||
final key = '$scope:$contactPubKeyHex';
|
||||
await saveGate?.future;
|
||||
saved[key] = history;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> clearPathHistory(String contactPubKeyHex) async {
|
||||
if (failClears) throw StateError('clear failed');
|
||||
saved.remove('$scope:$contactPubKeyHex');
|
||||
}
|
||||
|
||||
@override
|
||||
Future<void> clearAllPathHistories() async {
|
||||
if (failClears) throw StateError('clear failed');
|
||||
saved.removeWhere((key, value) => key.startsWith('$scope:'));
|
||||
}
|
||||
}
|
||||
|
||||
ContactPathHistory _history(String key, int hop) => ContactPathHistory(
|
||||
contactPubKeyHex: key,
|
||||
recentPaths: [
|
||||
PathRecord(
|
||||
hopCount: 1,
|
||||
tripTimeMs: 1,
|
||||
timestamp: DateTime(2026),
|
||||
wasFloodDiscovery: true,
|
||||
pathBytes: [hop],
|
||||
successCount: 1,
|
||||
failureCount: 0,
|
||||
),
|
||||
],
|
||||
);
|
||||
|
||||
Contact _contact(int hop) => Contact(
|
||||
publicKey: Uint8List(32),
|
||||
name: 'Test',
|
||||
type: 1,
|
||||
pathLength: 1,
|
||||
path: Uint8List.fromList([hop]),
|
||||
lastSeen: DateTime(2026),
|
||||
);
|
||||
|
||||
Future<void> _settle() => Future<void>.delayed(Duration.zero);
|
||||
|
||||
void main() {
|
||||
late _Storage storage;
|
||||
late PathHistoryService service;
|
||||
setUp(() {
|
||||
storage = _Storage();
|
||||
service = PathHistoryService(storage);
|
||||
});
|
||||
tearDown(() => service.dispose());
|
||||
|
||||
test(
|
||||
'an old load cannot populate the next radio or remove its pending load',
|
||||
() async {
|
||||
service.getRecentPaths('contact');
|
||||
await _settle();
|
||||
service.setDevicePublicKey('b');
|
||||
service.getRecentPaths('contact');
|
||||
await _settle();
|
||||
expect(storage.loads.map((load) => load.scope), ['a', 'b']);
|
||||
storage.loads[0].result.complete(_history('contact', 1));
|
||||
await _settle();
|
||||
expect(service.isCached('contact'), isFalse);
|
||||
service.getRecentPaths('contact');
|
||||
await _settle();
|
||||
expect(storage.loads, hasLength(2));
|
||||
storage.loads[1].result.complete(_history('contact', 2));
|
||||
await _settle();
|
||||
expect(service.peekRecentPaths('contact').single.pathBytes, [2]);
|
||||
},
|
||||
);
|
||||
|
||||
test('an old pending path event cannot be added to the next radio', () async {
|
||||
final contact = _contact(1);
|
||||
service.handlePathUpdated(contact);
|
||||
await _settle();
|
||||
service.setDevicePublicKey('b');
|
||||
service.getRecentPaths(contact.publicKeyHex);
|
||||
await _settle();
|
||||
storage.loads[1].result.complete(_history(contact.publicKeyHex, 2));
|
||||
await _settle();
|
||||
storage.loads[0].result.complete(null);
|
||||
await _settle();
|
||||
expect(service.peekRecentPaths(contact.publicKeyHex).single.pathBytes, [2]);
|
||||
});
|
||||
|
||||
test('clearing a contact invalidates an outstanding read', () async {
|
||||
service.getRecentPaths('contact');
|
||||
await _settle();
|
||||
await service.clearPathHistory('contact');
|
||||
storage.loads.single.result.complete(_history('contact', 1));
|
||||
await _settle();
|
||||
expect(service.isCached('contact'), isFalse);
|
||||
});
|
||||
|
||||
for (final dispose in [false, true]) {
|
||||
test(
|
||||
'${dispose ? 'disposing' : 'clearing all'} prevents delayed load notifications',
|
||||
() async {
|
||||
var notifications = 0;
|
||||
service.addListener(() => notifications++);
|
||||
service.getRecentPaths('contact');
|
||||
await _settle();
|
||||
if (dispose) {
|
||||
service.dispose();
|
||||
} else {
|
||||
service.clearAllHistories();
|
||||
}
|
||||
final before = notifications;
|
||||
storage.loads.single.result.complete(_history('contact', 1));
|
||||
await _settle();
|
||||
expect(service.isCached('contact'), isFalse);
|
||||
expect(notifications, before);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
test('reads wait for an already-started history save', () async {
|
||||
storage.delayLoads = false;
|
||||
service.handlePathUpdated(_contact(1));
|
||||
await _settle();
|
||||
storage.saveGate = Completer<void>();
|
||||
final save = service.flushPendingWrites();
|
||||
await _settle();
|
||||
final read = service.readStoredPaths('other');
|
||||
await _settle();
|
||||
expect(storage.loads.where((load) => load.contact == 'other'), isEmpty);
|
||||
storage.saveGate!.complete();
|
||||
await save;
|
||||
expect(await read, isEmpty);
|
||||
expect(
|
||||
storage.loads.where((load) => load.contact == 'other'),
|
||||
hasLength(1),
|
||||
);
|
||||
});
|
||||
|
||||
test(
|
||||
'clearing all waits for in-flight saves before allowing a new read',
|
||||
() async {
|
||||
storage.delayLoads = false;
|
||||
final contact = _contact(1);
|
||||
service.handlePathUpdated(contact);
|
||||
await _settle();
|
||||
storage.saveGate = Completer<void>();
|
||||
final save = service.flushPendingWrites();
|
||||
await _settle();
|
||||
service.clearAllHistories();
|
||||
final read = service.readStoredPaths(contact.publicKeyHex);
|
||||
storage.saveGate!.complete();
|
||||
await save;
|
||||
expect(await read, isEmpty);
|
||||
expect(storage.saved, isEmpty);
|
||||
},
|
||||
);
|
||||
|
||||
test('a scope switch while waiting for saves skips the old read', () async {
|
||||
storage.delayLoads = false;
|
||||
service.handlePathUpdated(_contact(1));
|
||||
await _settle();
|
||||
storage.saveGate = Completer<void>();
|
||||
final save = service.flushPendingWrites();
|
||||
final read = service.readStoredPaths('other');
|
||||
service.setDevicePublicKey('b');
|
||||
storage.saveGate!.complete();
|
||||
await save;
|
||||
expect(await read, isEmpty);
|
||||
expect(storage.loads.where((load) => load.contact == 'other'), isEmpty);
|
||||
expect(storage.saved.keys.single, startsWith('a:'));
|
||||
});
|
||||
|
||||
test(
|
||||
'a failed clear does not break later loads, clears or flushes',
|
||||
() async {
|
||||
storage.delayLoads = false;
|
||||
storage.failClears = true;
|
||||
await expectLater(service.clearPathHistory('contact'), throwsStateError);
|
||||
service.clearAllHistories();
|
||||
await _settle();
|
||||
|
||||
storage.failClears = false;
|
||||
storage.saved['a:contact'] = _history('contact', 3);
|
||||
await service.flushPendingWrites();
|
||||
expect((await service.readStoredPaths('contact')).single.pathBytes, [3]);
|
||||
await service.clearPathHistory('contact');
|
||||
expect(storage.saved, isEmpty);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -119,7 +119,8 @@ void main() {
|
||||
test('the archive follows the channel ID', () async {
|
||||
await _init();
|
||||
final store = ChannelMessageStore()..setPublicKeyHex = _deviceA;
|
||||
store.setArchived(_idOne, [_ch('old', 1), _ch('older', 2)]);
|
||||
await store.saveChannelMessages(_idOne, [_ch('old', 1), _ch('older', 2)]);
|
||||
store.setArchivedCount(_idOne, 2);
|
||||
expect(store.archivedCount(_idOne), 2);
|
||||
expect(store.archivedCount(_idTwo), isNull);
|
||||
|
||||
|
||||
@@ -0,0 +1,511 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/connector/meshcore_connector.dart';
|
||||
import 'package:meshcore_open/models/app_settings.dart';
|
||||
import 'dart:typed_data';
|
||||
import 'package:meshcore_open/models/channel.dart';
|
||||
import 'package:meshcore_open/storage/channel_storage_migration.dart';
|
||||
import 'package:meshcore_open/storage/channel_store.dart';
|
||||
import 'package:meshcore_open/services/app_settings_service.dart';
|
||||
import 'package:meshcore_open/services/backup_service.dart';
|
||||
import 'package:meshcore_open/review_mode/review_mode_storage.dart';
|
||||
import 'package:meshcore_open/review_mode/review_radio.dart';
|
||||
import 'package:meshcore_open/services/storage_service.dart';
|
||||
import 'package:meshcore_open/models/path_history.dart';
|
||||
import 'package:meshcore_open/storage/history_store.dart';
|
||||
import 'package:meshcore_open/storage/legacy_key_migration.dart';
|
||||
import 'package:meshcore_open/storage/history_store_io.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
|
||||
import 'package:shared_preferences_platform_interface/types.dart';
|
||||
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
|
||||
|
||||
class _DelayedHistoryStore extends PreferencesHistoryStore {
|
||||
_DelayedHistoryStore(this.delayedKey, this.gate);
|
||||
final String delayedKey;
|
||||
final Completer<void> gate;
|
||||
@override
|
||||
Future<String?> getString(String key) async {
|
||||
if (key == delayedKey) await gate.future;
|
||||
return super.getString(key);
|
||||
}
|
||||
}
|
||||
|
||||
class _FailingCleanupPreferences extends InMemorySharedPreferencesStore {
|
||||
_FailingCleanupPreferences() : super.withData({'flutter.messages_a': '[1]'});
|
||||
bool fail = true;
|
||||
@override
|
||||
Future<bool> clearWithParameters(ClearParameters parameters) async =>
|
||||
fail ? false : super.clearWithParameters(parameters);
|
||||
}
|
||||
|
||||
class _BackupConnector extends MeshCoreConnector {
|
||||
_BackupConnector(this.radioKey);
|
||||
final String radioKey;
|
||||
@override
|
||||
bool get isConnected => true;
|
||||
@override
|
||||
String get selfPublicKeyHex => radioKey;
|
||||
}
|
||||
|
||||
void main() {
|
||||
TestWidgetsFlutterBinding.ensureInitialized();
|
||||
late SqliteHistoryStore store;
|
||||
|
||||
setUp(() async {
|
||||
sqfliteFfiInit();
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
PrefsManager.reset();
|
||||
await PrefsManager.initialize();
|
||||
store = await SqliteHistoryStore.open(
|
||||
inMemoryDatabasePath,
|
||||
factory: databaseFactoryFfiNoIsolate,
|
||||
);
|
||||
HistoryStore.use(store);
|
||||
});
|
||||
|
||||
tearDown(() async {
|
||||
await store.close();
|
||||
PrefsManager.reset();
|
||||
});
|
||||
|
||||
test('native history writes leave small preferences untouched', () async {
|
||||
await PrefsManager.instance.setString('theme', 'dark');
|
||||
await store.setString('messages_a', '[{"text":"hello"}]');
|
||||
await store.setString('path_history_a', '{"recentPaths":[]}');
|
||||
expect(PrefsManager.instance.getKeys(), {'theme'});
|
||||
expect(await store.getString('messages_a'), '[{"text":"hello"}]');
|
||||
expect(await store.getString('path_history_a'), '{"recentPaths":[]}');
|
||||
});
|
||||
|
||||
test('sequence reads return only the requested ordered page', () async {
|
||||
await store.setString(
|
||||
'channel_messages_a',
|
||||
jsonEncode([
|
||||
for (var i = 0; i < 1000; i++) {'id': i},
|
||||
]),
|
||||
);
|
||||
expect(await store.entryCount('channel_messages_a'), 1000);
|
||||
expect(
|
||||
await store.readEntries('channel_messages_a', offset: 950, limit: 3),
|
||||
['{"id":950}', '{"id":951}', '{"id":952}'],
|
||||
);
|
||||
expect(
|
||||
await store.readEntries('channel_messages_a', offset: 1000, limit: 3),
|
||||
isEmpty,
|
||||
);
|
||||
expect(await store.readEntries('channel_messages_a', limit: 0), isEmpty);
|
||||
});
|
||||
|
||||
test(
|
||||
'tail replacement preserves history, deletes and storage limits',
|
||||
() async {
|
||||
await store.setString('messages_a', '[0,1,2,3,4]');
|
||||
expect(
|
||||
await store.replaceTail('messages_a', 3, ['4', '5'], maxEntries: 4),
|
||||
2,
|
||||
);
|
||||
expect(await store.readEntries('messages_a'), ['1', '2', '4', '5']);
|
||||
expect(await store.replaceTail('messages_a', 2, ['6'], maxEntries: 4), 2);
|
||||
expect(await store.readEntries('messages_a'), ['1', '2', '6']);
|
||||
expect(
|
||||
await store.replaceTail('messages_a', 50, ['7'], maxEntries: 4),
|
||||
3,
|
||||
);
|
||||
expect(await store.readEntries('messages_a'), ['1', '2', '6', '7']);
|
||||
expect(await store.replaceTail('messages_a', 0, [], maxEntries: 4), 0);
|
||||
expect(await store.getString('messages_a'), '[]');
|
||||
},
|
||||
);
|
||||
|
||||
test('history data survives database reopen', () async {
|
||||
final dir = await Directory.systemTemp.createTemp('meshcore-history-test-');
|
||||
addTearDown(() => dir.delete(recursive: true));
|
||||
final path = '${dir.path}/history_v1.db';
|
||||
final disk = await SqliteHistoryStore.open(
|
||||
path,
|
||||
factory: databaseFactoryFfiNoIsolate,
|
||||
);
|
||||
await disk.setString('messages_a', '[1,2,3]');
|
||||
await disk.setString('path_history_a', '{"sample":true}');
|
||||
await disk.close();
|
||||
final reopened = await SqliteHistoryStore.open(
|
||||
path,
|
||||
factory: databaseFactoryFfiNoIsolate,
|
||||
);
|
||||
addTearDown(reopened.close);
|
||||
expect(await reopened.getString('messages_a'), '[1,2,3]');
|
||||
expect(await reopened.getString('path_history_a'), '{"sample":true}');
|
||||
});
|
||||
|
||||
test('versioned import removes only committed valid histories', () async {
|
||||
final prefs = PrefsManager.instance;
|
||||
await prefs.setString('messages_a', '[{"text":"hello"},42]');
|
||||
await prefs.setString('path_history_a', '{"recentPaths":[]}');
|
||||
await prefs.setString('messages_unreadable', '{broken');
|
||||
await prefs.setString('path_history_wrong_shape', '[]');
|
||||
await prefs.setBool('notification', true);
|
||||
await store.migratePreferences();
|
||||
expect(prefs.getKeys(), {
|
||||
'messages_unreadable',
|
||||
'path_history_wrong_shape',
|
||||
'notification',
|
||||
});
|
||||
expect(await store.readEntries('messages_a'), ['{"text":"hello"}', '42']);
|
||||
expect(await store.getString('messages_unreadable'), '{broken');
|
||||
expect(
|
||||
await store.getKeys(),
|
||||
containsAll(['messages_a', 'path_history_a', 'messages_unreadable']),
|
||||
);
|
||||
final metadata = await store.database.query('history_metadata');
|
||||
expect(metadata.single['value'], SqliteHistoryStore.schemaVersion);
|
||||
// Current versions skip another scan/import.
|
||||
await prefs.setString('messages_added_later', '[1]');
|
||||
await store.migratePreferences();
|
||||
expect(prefs.containsKey('messages_added_later'), isTrue);
|
||||
expect(
|
||||
await store.database.query(
|
||||
'history_keys',
|
||||
where: 'key = ?',
|
||||
whereArgs: ['messages_added_later'],
|
||||
),
|
||||
isEmpty,
|
||||
);
|
||||
});
|
||||
|
||||
test(
|
||||
'interrupted import does not replace committed newer database values',
|
||||
() async {
|
||||
await store.setString('messages_a', '[2]');
|
||||
await PrefsManager.instance.setString('messages_a', '[1]');
|
||||
await store.migratePreferences();
|
||||
expect(await store.getString('messages_a'), '[2]');
|
||||
expect(PrefsManager.instance.containsKey('messages_a'), isFalse);
|
||||
},
|
||||
);
|
||||
|
||||
test('histories saved by a run without the database are merged', () async {
|
||||
final prefs = PrefsManager.instance;
|
||||
await store.migratePreferences();
|
||||
await store.setString(
|
||||
'messages_a',
|
||||
'[{"messageId":"1","text":"old"},{"messageId":"2","text":"sent"}]',
|
||||
);
|
||||
await store.setString('path_history_a', '{"stored":true}');
|
||||
// What the fallback run saved: it started from an empty history.
|
||||
await prefs.setString(
|
||||
'messages_a',
|
||||
'[{"messageId":"2","text":"delivered"},{"messageId":"3","text":"new"}]',
|
||||
);
|
||||
await prefs.setString('messages_b', '[{"messageId":"4"}]');
|
||||
await prefs.setString('path_history_a', '{"stored":false}');
|
||||
await prefs.setString('messages_unreadable', '{broken');
|
||||
|
||||
await store.adoptFallbackHistories();
|
||||
|
||||
expect(await store.readEntries('messages_a'), [
|
||||
'{"messageId":"1","text":"old"}',
|
||||
'{"messageId":"2","text":"delivered"}',
|
||||
'{"messageId":"3","text":"new"}',
|
||||
]);
|
||||
expect(await store.readEntries('messages_b'), ['{"messageId":"4"}']);
|
||||
expect(await store.getString('path_history_a'), '{"stored":true}');
|
||||
expect(prefs.getKeys(), {'messages_unreadable'});
|
||||
});
|
||||
|
||||
test('initialize falls back to preferences and flags the run', () async {
|
||||
// No path provider is registered here, so the database cannot be opened.
|
||||
await HistoryStore.initialize();
|
||||
addTearDown(HistoryStore.reset);
|
||||
expect(HistoryStore.instance, isA<PreferencesHistoryStore>());
|
||||
expect(PrefsManager.instance.getBool(HistoryStore.fallbackRunKey), isTrue);
|
||||
});
|
||||
|
||||
test('a save lands beside an unreadable preference', () async {
|
||||
await PrefsManager.instance.setString('messages_a', '{broken');
|
||||
await store.migratePreferences();
|
||||
expect(await store.replaceTail('messages_a', 0, ['1', '2']), 0);
|
||||
expect(await store.readEntries('messages_a'), ['1', '2']);
|
||||
expect(await store.replaceTail('messages_a', 2, ['3']), 2);
|
||||
expect(await store.getString('messages_a'), '[1,2,3]');
|
||||
expect(PrefsManager.instance.getString('messages_a'), '{broken');
|
||||
});
|
||||
|
||||
test('the preferences store replaces an unreadable history', () async {
|
||||
final prefs = PreferencesHistoryStore();
|
||||
await PrefsManager.instance.setString('messages_a', '{broken');
|
||||
expect(await prefs.replaceTail('messages_a', 3, ['1', '2']), 0);
|
||||
expect(
|
||||
await prefs.replaceTail('messages_a', 2, ['3', '4'], maxEntries: 3),
|
||||
1,
|
||||
);
|
||||
expect(await prefs.getString('messages_a'), '[2,3,4]');
|
||||
// A value written behind the store's back is read fresh.
|
||||
await PrefsManager.instance.setString('messages_a', '[9]');
|
||||
expect(await prefs.readEntries('messages_a'), ['9']);
|
||||
expect(await prefs.entryCount('messages_a'), 1);
|
||||
});
|
||||
|
||||
test('future import versions are left untouched', () async {
|
||||
await store.database.insert('history_metadata', {
|
||||
'key': 'preferences_import_version',
|
||||
'value': 99,
|
||||
});
|
||||
await PrefsManager.instance.setString('messages_a', '[1]');
|
||||
await store.migratePreferences();
|
||||
expect(PrefsManager.instance.containsKey('messages_a'), isTrue);
|
||||
expect(
|
||||
(await store.database.query('history_metadata')).single['value'],
|
||||
99,
|
||||
);
|
||||
});
|
||||
|
||||
test('review cleanup removes only its database histories', () async {
|
||||
final prefix = ReviewRadio.storagePrefix;
|
||||
await store.setString('messages_${prefix}c1', '[1]');
|
||||
await store.setString('channel_messages_${prefix}_id', '[2]');
|
||||
await store.setString('messages_real_c1', '[3]');
|
||||
await clearReviewModeData();
|
||||
expect(await store.getKeys(), {'messages_real_c1'});
|
||||
});
|
||||
|
||||
test(
|
||||
'path history scoping and clearing work through database storage',
|
||||
() async {
|
||||
final a = StorageService()..setPublicKeyHex = 'aaaaaaaaaaaa';
|
||||
final b = StorageService()..setPublicKeyHex = 'bbbbbbbbbbbb';
|
||||
await store.setString(
|
||||
'path_history_c1',
|
||||
jsonEncode(
|
||||
ContactPathHistory(contactPubKeyHex: 'c1', recentPaths: []).toJson(),
|
||||
),
|
||||
);
|
||||
expect(await a.loadPathHistory('c1'), isNotNull);
|
||||
expect(await b.loadPathHistory('c1'), isNull);
|
||||
await b.savePathHistory(
|
||||
'c1',
|
||||
ContactPathHistory(contactPubKeyHex: 'c1', recentPaths: []),
|
||||
);
|
||||
await a.clearAllPathHistories();
|
||||
expect(await store.getKeys(), {'path_history_bbbbbbbbbb_c1'});
|
||||
},
|
||||
);
|
||||
test(
|
||||
'backup exports native histories and restores into the destination scope',
|
||||
() async {
|
||||
final source = _BackupConnector('a' * 64);
|
||||
final destination = _BackupConnector('b' * 64);
|
||||
final settings = AppSettingsService();
|
||||
addTearDown(source.dispose);
|
||||
addTearDown(destination.dispose);
|
||||
addTearDown(settings.dispose);
|
||||
await store.setString('messages_aaaaaaaaaac1', '[{"text":"original"}]');
|
||||
await store.setString(
|
||||
'channel_messages_aaaaaaaaaa_0123456789abcdef',
|
||||
'[{"text":"channel"}]',
|
||||
);
|
||||
const service = BackupService();
|
||||
final backup = await service.createBackup(
|
||||
items: {BackupItem.contactHistory, BackupItem.channelHistory},
|
||||
connector: source,
|
||||
settings: AppSettings(),
|
||||
password: '',
|
||||
);
|
||||
final decoded = jsonDecode(backup) as Map<String, dynamic>;
|
||||
final contacts = decoded['sections']['contacts']['preferences'] as Map;
|
||||
expect(contacts['messages_aaaaaaaaaac1'], [
|
||||
{'text': 'original'},
|
||||
]);
|
||||
await store.setString('messages_bbbbbbbbbbc1', '[{"text":"old"}]');
|
||||
await service.restoreBackup(
|
||||
contents: backup,
|
||||
password: '',
|
||||
items: {BackupItem.contactHistory, BackupItem.channelHistory},
|
||||
connector: destination,
|
||||
appSettingsService: settings,
|
||||
);
|
||||
expect(
|
||||
await store.getString('messages_bbbbbbbbbbc1'),
|
||||
'[{"text":"original"}]',
|
||||
);
|
||||
expect(
|
||||
await store.getString('channel_messages_bbbbbbbbbb_0123456789abcdef'),
|
||||
'[{"text":"channel"}]',
|
||||
);
|
||||
expect(
|
||||
await store.getString('messages_aaaaaaaaaac1'),
|
||||
'[{"text":"original"}]',
|
||||
);
|
||||
expect(
|
||||
PrefsManager.instance.getKeys().where(HistoryStore.isHistoryKey),
|
||||
isEmpty,
|
||||
);
|
||||
},
|
||||
);
|
||||
test(
|
||||
'failed preference cleanup leaves source and import version available for retry',
|
||||
() async {
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
final platform = _FailingCleanupPreferences();
|
||||
SharedPreferencesStorePlatform.instance = platform;
|
||||
PrefsManager.reset();
|
||||
await PrefsManager.initialize();
|
||||
HistoryStore.use(store);
|
||||
await expectLater(store.migratePreferences(), throwsStateError);
|
||||
expect(PrefsManager.instance.getString('messages_a'), '[1]');
|
||||
expect(await store.getString('messages_a'), '[1]');
|
||||
expect(await store.database.query('history_metadata'), isEmpty);
|
||||
platform.fail = false;
|
||||
await store.migratePreferences();
|
||||
expect(PrefsManager.instance.containsKey('messages_a'), isFalse);
|
||||
expect(
|
||||
(await store.database.query('history_metadata')).single['value'],
|
||||
1,
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'failed database import preserves original preferences and can retry',
|
||||
() async {
|
||||
await PrefsManager.instance.setString('messages_a', '[1]');
|
||||
await PrefsManager.instance.setString('messages_b', '[2]');
|
||||
await store.database.execute(
|
||||
"CREATE TRIGGER fail_history BEFORE INSERT ON history_entries WHEN NEW.key = 'messages_b' BEGIN SELECT RAISE(ABORT, 'test failure'); END",
|
||||
);
|
||||
await expectLater(
|
||||
store.migratePreferences(),
|
||||
throwsA(isA<DatabaseException>()),
|
||||
);
|
||||
expect(PrefsManager.instance.getString('messages_a'), '[1]');
|
||||
expect(PrefsManager.instance.getString('messages_b'), '[2]');
|
||||
expect(await store.database.query('history_metadata'), isEmpty);
|
||||
await store.database.execute('DROP TRIGGER fail_history');
|
||||
await store.migratePreferences();
|
||||
expect(await store.readEntries('messages_a'), ['1']);
|
||||
expect(await store.readEntries('messages_b'), ['2']);
|
||||
expect(PrefsManager.instance.getKeys(), isEmpty);
|
||||
},
|
||||
);
|
||||
test(
|
||||
'channel migration removes old database keys after committing the new ID',
|
||||
() async {
|
||||
const scope = 'aaaaaaaaaa';
|
||||
final channel = Channel(
|
||||
index: 0,
|
||||
name: 'Public',
|
||||
psk: Uint8List.fromList(List.filled(16, 1)),
|
||||
);
|
||||
await (ChannelStore()..setPublicKeyHex = '${scope}xx').saveChannels([
|
||||
channel,
|
||||
]);
|
||||
final oldKey = 'channel_messages_${scope}0';
|
||||
final newKey = 'channel_messages_${scope}_${channel.storageId}';
|
||||
await store.setString(oldKey, '[{"messageId":"legacy","text":"keep"}]');
|
||||
|
||||
await ChannelStorageMigration.migrate(scope);
|
||||
|
||||
expect(await store.getKeys(), {newKey});
|
||||
expect(
|
||||
await store.getString(newKey),
|
||||
'[{"messageId":"legacy","text":"keep"}]',
|
||||
);
|
||||
expect(
|
||||
PrefsManager.instance.getBool('channel_storage_v2_$scope'),
|
||||
isTrue,
|
||||
);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'channel migration leaves malformed sources in place and still completes',
|
||||
() async {
|
||||
const scope = 'aaaaaaaaaa';
|
||||
final psk = Uint8List.fromList(List.filled(16, 1));
|
||||
final id = Channel.storageIdForPsk(psk)!;
|
||||
await PrefsManager.instance.setString(
|
||||
'channels$scope',
|
||||
jsonEncode([
|
||||
{
|
||||
'index': 0,
|
||||
'name': 'Public',
|
||||
'psk': base64Encode(psk),
|
||||
'unreadCount': 0,
|
||||
},
|
||||
]),
|
||||
);
|
||||
await PrefsManager.instance.setString(
|
||||
'channel_messages_${scope}0',
|
||||
'{broken',
|
||||
);
|
||||
await store.setString(
|
||||
'channel_messages_${scope}_$id',
|
||||
'[{"messageId":"existing","text":"keep"}]',
|
||||
);
|
||||
await ChannelStorageMigration.migrate(scope);
|
||||
expect(
|
||||
PrefsManager.instance.getString('channel_messages_${scope}0'),
|
||||
'{broken',
|
||||
);
|
||||
expect(
|
||||
await store.getString('channel_messages_${scope}_$id'),
|
||||
'[{"messageId":"existing","text":"keep"}]',
|
||||
);
|
||||
expect(
|
||||
PrefsManager.instance.getBool('channel_storage_v2_$scope'),
|
||||
isTrue,
|
||||
);
|
||||
// An array that cannot be merged safely is left alone as well.
|
||||
await PrefsManager.instance.remove('channel_storage_v2_$scope');
|
||||
await PrefsManager.instance.setString(
|
||||
'channel_messages_${scope}0',
|
||||
'[42]',
|
||||
);
|
||||
await ChannelStorageMigration.migrate(scope);
|
||||
expect(
|
||||
PrefsManager.instance.getString('channel_messages_${scope}0'),
|
||||
'[42]',
|
||||
);
|
||||
expect(
|
||||
await store.getString('channel_messages_${scope}_$id'),
|
||||
'[{"messageId":"existing","text":"keep"}]',
|
||||
);
|
||||
expect(
|
||||
PrefsManager.instance.getBool('channel_storage_v2_$scope'),
|
||||
isTrue,
|
||||
);
|
||||
},
|
||||
);
|
||||
test(
|
||||
'path migration keeps the original scope policy while reading asynchronously',
|
||||
() async {
|
||||
final reviewScope = ReviewRadio.storagePrefix;
|
||||
scopesWithoutLegacyMigration.add(reviewScope);
|
||||
addTearDown(() => scopesWithoutLegacyMigration.remove(reviewScope));
|
||||
await PrefsManager.instance.setString(
|
||||
'path_history_c1',
|
||||
jsonEncode(
|
||||
ContactPathHistory(contactPubKeyHex: 'c1', recentPaths: []).toJson(),
|
||||
),
|
||||
);
|
||||
final gate = Completer<void>();
|
||||
HistoryStore.use(
|
||||
_DelayedHistoryStore('path_history_${reviewScope}_c1', gate),
|
||||
);
|
||||
final service = StorageService()..setPublicKeyHex = '${reviewScope}xx';
|
||||
final pending = service.loadPathHistory('c1');
|
||||
service.setPublicKeyHex = 'bbbbbbbbbbbb';
|
||||
gate.complete();
|
||||
expect(await pending, isNull);
|
||||
expect(PrefsManager.instance.containsKey('path_history_c1'), isTrue);
|
||||
expect(
|
||||
PrefsManager.instance.containsKey('path_history_${reviewScope}_c1'),
|
||||
isFalse,
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/models/channel.dart';
|
||||
import 'package:meshcore_open/storage/channel_storage_migration.dart';
|
||||
import 'package:meshcore_open/storage/channel_store.dart';
|
||||
import 'package:meshcore_open/storage/community_store.dart';
|
||||
import 'package:meshcore_open/storage/contact_discovery_store.dart';
|
||||
import 'package:meshcore_open/storage/contact_group_store.dart';
|
||||
import 'package:meshcore_open/storage/contact_settings_store.dart';
|
||||
import 'package:meshcore_open/storage/contact_store.dart';
|
||||
import 'package:meshcore_open/storage/legacy_key_migration.dart';
|
||||
import 'package:meshcore_open/storage/message_store.dart';
|
||||
import 'package:meshcore_open/storage/prefs_manager.dart';
|
||||
import 'package:meshcore_open/storage/unread_store.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
|
||||
|
||||
const _device = 'aaaaaaaaaa012345';
|
||||
const _scope = 'aaaaaaaaaa';
|
||||
|
||||
class _RecordingPreferences extends InMemorySharedPreferencesStore {
|
||||
_RecordingPreferences(Map<String, Object> values)
|
||||
: super.withData({
|
||||
for (final e in values.entries) 'flutter.${e.key}': e.value,
|
||||
});
|
||||
|
||||
final calls = <(String, String)>[];
|
||||
final failedKeys = <String>{};
|
||||
Completer<void>? writeGate;
|
||||
|
||||
@override
|
||||
Future<bool> setValue(String valueType, String key, Object value) async {
|
||||
calls.add(('set', key));
|
||||
if (failedKeys.contains(key)) return false;
|
||||
await writeGate?.future;
|
||||
return super.setValue(valueType, key, value);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> remove(String key) async {
|
||||
calls.add(('remove', key));
|
||||
return super.remove(key);
|
||||
}
|
||||
}
|
||||
|
||||
Future<_RecordingPreferences> _init([
|
||||
Map<String, Object> values = const {},
|
||||
]) async {
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
final platform = _RecordingPreferences(values);
|
||||
SharedPreferencesStorePlatform.instance = platform;
|
||||
PrefsManager.reset();
|
||||
await PrefsManager.initialize();
|
||||
return platform;
|
||||
}
|
||||
|
||||
String _cachedChannel(Uint8List psk) => jsonEncode([
|
||||
{'index': 0, 'name': 'Public', 'psk': base64Encode(psk), 'unreadCount': 0},
|
||||
]);
|
||||
|
||||
void main() {
|
||||
tearDown(() {
|
||||
scopesWithoutLegacyMigration.clear();
|
||||
PrefsManager.reset();
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
});
|
||||
|
||||
test('loading absent legacy data performs no platform writes', () async {
|
||||
final platform = await _init();
|
||||
await (MessageStore()..setPublicKeyHex = _device).loadMessages('c1');
|
||||
await (ContactSettingsStore()..setPublicKeyHex = _device).loadSmazEnabled(
|
||||
'c1',
|
||||
);
|
||||
await (ContactStore()..setPublicKeyHex = _device).loadContacts();
|
||||
await (ChannelStore()..setPublicKeyHex = _device).loadChannels();
|
||||
await (CommunityStore()..setPublicKeyHex = _device).loadCommunities();
|
||||
await (ContactGroupStore()..setPublicKeyHex = _device).loadGroups();
|
||||
await (UnreadStore()..setPublicKeyHex = _device).loadContactUnreadCount();
|
||||
await (ContactDiscoveryStore()..setPublicKeyHex = _device).loadContacts();
|
||||
expect(platform.calls, isEmpty);
|
||||
});
|
||||
|
||||
test(
|
||||
'string migration waits for persistence before deleting the source',
|
||||
() async {
|
||||
final platform = await _init({'messages_c1': '[]'});
|
||||
final gate = Completer<void>();
|
||||
platform.writeGate = gate;
|
||||
final pending = (MessageStore()..setPublicKeyHex = _device).loadMessages(
|
||||
'c1',
|
||||
);
|
||||
await Future<void>.delayed(Duration.zero);
|
||||
expect(platform.calls, [('set', 'flutter.messages_${_scope}c1')]);
|
||||
expect((await platform.getAll())['flutter.messages_c1'], '[]');
|
||||
gate.complete();
|
||||
await pending;
|
||||
expect(platform.calls, [
|
||||
('set', 'flutter.messages_${_scope}c1'),
|
||||
('remove', 'flutter.messages_c1'),
|
||||
]);
|
||||
await (MessageStore()..setPublicKeyHex = _device).loadMessages('c1');
|
||||
expect(platform.calls, hasLength(2));
|
||||
},
|
||||
);
|
||||
|
||||
test('a failed string migration retains persisted legacy data', () async {
|
||||
final platform = await _init({'messages_c1': '[]'});
|
||||
platform.failedKeys.add('flutter.messages_${_scope}c1');
|
||||
await (MessageStore()..setPublicKeyHex = _device).loadMessages('c1');
|
||||
expect(platform.calls, [('set', 'flutter.messages_${_scope}c1')]);
|
||||
final persisted = await platform.getAll();
|
||||
expect(persisted['flutter.messages_c1'], '[]');
|
||||
expect(persisted, isNot(contains('flutter.messages_${_scope}c1')));
|
||||
});
|
||||
|
||||
test(
|
||||
'false legacy settings migrate, but stay persisted when writing fails',
|
||||
() async {
|
||||
final platform = await _init({'contact_smaz_c1': false});
|
||||
platform.failedKeys.add('flutter.contact_smaz_${_scope}c1');
|
||||
expect(
|
||||
await (ContactSettingsStore()..setPublicKeyHex = _device)
|
||||
.loadSmazEnabled('c1'),
|
||||
isFalse,
|
||||
);
|
||||
expect(platform.calls, [('set', 'flutter.contact_smaz_${_scope}c1')]);
|
||||
expect((await platform.getAll())['flutter.contact_smaz_c1'], isFalse);
|
||||
},
|
||||
);
|
||||
|
||||
test('review scopes never adopt legacy strings or settings', () async {
|
||||
final platform = await _init({
|
||||
'messages_c1': '[]',
|
||||
'contact_smaz_c1': true,
|
||||
});
|
||||
scopesWithoutLegacyMigration.add(_scope);
|
||||
expect(
|
||||
await (MessageStore()..setPublicKeyHex = _device).loadMessages('c1'),
|
||||
isEmpty,
|
||||
);
|
||||
expect(
|
||||
await (ContactSettingsStore()..setPublicKeyHex = _device).loadSmazEnabled(
|
||||
'c1',
|
||||
),
|
||||
isFalse,
|
||||
);
|
||||
expect(platform.calls, isEmpty);
|
||||
});
|
||||
|
||||
test('channel migration skips removals of absent old keys', () async {
|
||||
final psk = Uint8List.fromList(List.filled(16, 1));
|
||||
final platform = await _init({'channels$_scope': _cachedChannel(psk)});
|
||||
await ChannelStorageMigration.migrate(_scope);
|
||||
expect(platform.calls.where((c) => c.$1 == 'remove'), isEmpty);
|
||||
expect(PrefsManager.instance.getBool('channel_storage_v2_$_scope'), isTrue);
|
||||
});
|
||||
|
||||
test(
|
||||
'channel migration keeps sources and stays unfinished when a write fails',
|
||||
() async {
|
||||
final psk = Uint8List.fromList(List.filled(16, 1));
|
||||
final id = Channel.storageIdForPsk(psk)!;
|
||||
final sourceKey = 'channel_messages_${_scope}0';
|
||||
final platform = await _init({
|
||||
'channels$_scope': _cachedChannel(psk),
|
||||
sourceKey: '[]',
|
||||
});
|
||||
platform.failedKeys.add('flutter.channel_messages_${_scope}_$id');
|
||||
await expectLater(
|
||||
ChannelStorageMigration.migrate(_scope),
|
||||
throwsStateError,
|
||||
);
|
||||
expect((await platform.getAll())['flutter.$sourceKey'], '[]');
|
||||
expect(
|
||||
PrefsManager.instance.getBool('channel_storage_v2_$_scope'),
|
||||
isNull,
|
||||
);
|
||||
expect(platform.calls.where((c) => c.$1 == 'remove'), isEmpty);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'false legacy settings migrate successfully without extra writes',
|
||||
() async {
|
||||
final platform = await _init({'contact_smaz_c1': false});
|
||||
final store = ContactSettingsStore()..setPublicKeyHex = _device;
|
||||
expect(await store.loadSmazEnabled('c1'), isFalse);
|
||||
expect(await store.loadSmazEnabled('c1'), isFalse);
|
||||
expect(platform.calls, [
|
||||
('set', 'flutter.contact_smaz_${_scope}c1'),
|
||||
('remove', 'flutter.contact_smaz_c1'),
|
||||
]);
|
||||
final persisted = await platform.getAll();
|
||||
expect(persisted['flutter.contact_smaz_${_scope}c1'], isFalse);
|
||||
expect(persisted, isNot(contains('flutter.contact_smaz_c1')));
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'channel migration is not marked done before its slot map is durable',
|
||||
() async {
|
||||
final psk = Uint8List.fromList(List.filled(16, 1));
|
||||
final platform = await _init({'channels$_scope': _cachedChannel(psk)});
|
||||
platform.failedKeys.add('flutter.channel_slot_ids_$_scope');
|
||||
await expectLater(
|
||||
ChannelStorageMigration.migrate(_scope),
|
||||
throwsStateError,
|
||||
);
|
||||
expect(
|
||||
PrefsManager.instance.getBool('channel_storage_v2_$_scope'),
|
||||
isNull,
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,285 @@
|
||||
import 'dart:async';
|
||||
import 'dart:convert';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/models/channel_message.dart';
|
||||
import 'package:meshcore_open/models/message.dart';
|
||||
import 'package:meshcore_open/storage/channel_message_store.dart';
|
||||
import 'package:meshcore_open/storage/history_store.dart';
|
||||
import 'package:meshcore_open/storage/message_store.dart';
|
||||
|
||||
const _device = 'abcdef012345';
|
||||
const _contact = 'contact';
|
||||
const _channel = 'channel';
|
||||
|
||||
class _History extends HistoryStore {
|
||||
final data = <String, List<String>>{};
|
||||
int reads = 0;
|
||||
bool failNextWrite = false;
|
||||
bool failNextRemove = false;
|
||||
Completer<void>? nextWriteGate;
|
||||
Completer<void>? nextWriteStarted;
|
||||
|
||||
@override
|
||||
Future<String?> getString(String key) async {
|
||||
reads++;
|
||||
final entries = data[key];
|
||||
return entries == null ? null : '[${entries.join(',')}]';
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> setString(String key, String value) async {
|
||||
data[key] = (jsonDecode(value) as List).map(jsonEncode).toList();
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<bool> remove(String key) async {
|
||||
if (failNextRemove) {
|
||||
failNextRemove = false;
|
||||
return false;
|
||||
}
|
||||
data.remove(key);
|
||||
return true;
|
||||
}
|
||||
|
||||
@override
|
||||
Future<Set<String>> getKeys() async => data.keys.toSet();
|
||||
|
||||
@override
|
||||
Future<int> entryCount(String key) async => data[key]?.length ?? 0;
|
||||
|
||||
@override
|
||||
Future<List<String>> readEntries(
|
||||
String key, {
|
||||
int offset = 0,
|
||||
int? limit,
|
||||
}) async {
|
||||
reads++;
|
||||
final entries = (data[key] ?? []).skip(offset);
|
||||
return (limit == null ? entries : entries.take(limit)).toList();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<int> replaceTail(
|
||||
String key,
|
||||
int preservedCount,
|
||||
List<String> entries, {
|
||||
int maxEntries = 1000,
|
||||
}) async {
|
||||
final gate = nextWriteGate;
|
||||
nextWriteGate = null;
|
||||
nextWriteStarted?.complete();
|
||||
nextWriteStarted = null;
|
||||
await gate?.future;
|
||||
if (failNextWrite) {
|
||||
failNextWrite = false;
|
||||
throw StateError('Disk unavailable');
|
||||
}
|
||||
final prefix = (data[key] ?? []).take(preservedCount).toList();
|
||||
final all = [...prefix, ...entries];
|
||||
final dropped = (all.length - maxEntries).clamp(0, all.length);
|
||||
data[key] = all.skip(dropped).toList();
|
||||
return (prefix.length - dropped).clamp(0, prefix.length);
|
||||
}
|
||||
|
||||
List<String> texts(String key) => [
|
||||
for (final entry in data[key] ?? [])
|
||||
(jsonDecode(entry) as Map)['text'] as String,
|
||||
];
|
||||
}
|
||||
|
||||
Message _dm(int i, {String? id, String? text}) => Message(
|
||||
senderKey: Uint8List.fromList([1, 2, 3]),
|
||||
text: text ?? 'm$i',
|
||||
timestamp: DateTime.fromMillisecondsSinceEpoch(1000 * i),
|
||||
isOutgoing: false,
|
||||
messageId: id ?? 'id$i',
|
||||
);
|
||||
|
||||
ChannelMessage _ch(int i) => ChannelMessage(
|
||||
senderKey: null,
|
||||
senderName: 'Bob',
|
||||
text: 'c$i',
|
||||
timestamp: DateTime.fromMillisecondsSinceEpoch(1000 * i),
|
||||
isOutgoing: false,
|
||||
status: ChannelMessageStatus.sent,
|
||||
channelIndex: 0,
|
||||
messageId: 'cid$i',
|
||||
);
|
||||
|
||||
void main() {
|
||||
late _History history;
|
||||
late MessageStore direct;
|
||||
late ChannelMessageStore channel;
|
||||
late String directKey;
|
||||
late String channelKey;
|
||||
|
||||
setUp(() {
|
||||
history = _History();
|
||||
HistoryStore.use(history);
|
||||
direct = MessageStore()..setPublicKeyHex = _device;
|
||||
channel = ChannelMessageStore()..setPublicKeyHex = _device;
|
||||
directKey = '${direct.keyFor}$_contact';
|
||||
channelKey = '${channel.keyFor}_$_channel';
|
||||
});
|
||||
|
||||
tearDown(HistoryStore.reset);
|
||||
|
||||
test(
|
||||
'reconciled saves preserve prefixes without reading archived JSON',
|
||||
() async {
|
||||
await direct.saveMessages(_contact, [for (var i = 0; i < 8; i++) _dm(i)]);
|
||||
await channel.saveChannelMessages(_channel, [
|
||||
for (var i = 0; i < 8; i++) _ch(i),
|
||||
]);
|
||||
direct.setArchivedCount(_contact, 6);
|
||||
channel.setArchivedCount(_channel, 6);
|
||||
history.reads = 0;
|
||||
|
||||
await direct.saveMessages(_contact, [_dm(6), _dm(8)]);
|
||||
await channel.saveChannelMessages(_channel, [_ch(6), _ch(8)]);
|
||||
|
||||
expect(history.reads, 0);
|
||||
expect(history.texts(directKey), [
|
||||
for (var i = 0; i <= 6; i++) 'm$i',
|
||||
'm8',
|
||||
]);
|
||||
expect(history.texts(channelKey), [
|
||||
for (var i = 0; i <= 6; i++) 'c$i',
|
||||
'c8',
|
||||
]);
|
||||
},
|
||||
);
|
||||
|
||||
test('overlapping saves consume each unsaved trim once', () async {
|
||||
direct.setArchivedCount(_contact, 0);
|
||||
await direct.saveMessages(_contact, [_dm(0), _dm(1), _dm(2)]);
|
||||
direct.archive(_contact, [_dm(0)]);
|
||||
final gate = Completer<void>();
|
||||
final started = Completer<void>();
|
||||
history.nextWriteGate = gate;
|
||||
history.nextWriteStarted = started;
|
||||
final first = direct.saveMessages(_contact, [_dm(1), _dm(2), _dm(3)]);
|
||||
await started.future;
|
||||
|
||||
direct.archive(_contact, [_dm(1)]);
|
||||
final second = direct.saveMessages(_contact, [_dm(2), _dm(3), _dm(4)]);
|
||||
gate.complete();
|
||||
await Future.wait([first, second]);
|
||||
|
||||
expect(history.texts(directKey), [for (var i = 0; i <= 4; i++) 'm$i']);
|
||||
expect(direct.archivedCount(_contact), 2);
|
||||
});
|
||||
|
||||
test('failed writes retain unsaved trims for retry', () async {
|
||||
direct.setArchivedCount(_contact, 0);
|
||||
await direct.saveMessages(_contact, [_dm(0), _dm(1)]);
|
||||
direct.archive(_contact, [_dm(0)]);
|
||||
history.failNextWrite = true;
|
||||
await expectLater(
|
||||
direct.saveMessages(_contact, [_dm(1), _dm(2)]),
|
||||
throwsStateError,
|
||||
);
|
||||
expect(direct.archivedCount(_contact), 1);
|
||||
expect(history.texts(directKey), ['m0', 'm1']);
|
||||
|
||||
await direct.saveMessages(_contact, [_dm(1), _dm(2)]);
|
||||
expect(history.texts(directKey), ['m0', 'm1', 'm2']);
|
||||
expect(direct.archivedCount(_contact), 1);
|
||||
});
|
||||
|
||||
test(
|
||||
'queued snapshots survive scope switches without restoring old bookkeeping',
|
||||
() async {
|
||||
direct.setArchivedCount(_contact, 0);
|
||||
final messages = [_dm(0)];
|
||||
final gate = Completer<void>();
|
||||
final started = Completer<void>();
|
||||
history.nextWriteGate = gate;
|
||||
history.nextWriteStarted = started;
|
||||
final pending = direct.saveMessages(_contact, messages);
|
||||
await started.future;
|
||||
messages.clear();
|
||||
direct.forgetArchive();
|
||||
direct.setPublicKeyHex = '0123456789abcd';
|
||||
final newKey = '${direct.keyFor}$_contact';
|
||||
await direct.saveMessages(_contact, [_dm(1)]);
|
||||
gate.complete();
|
||||
await pending;
|
||||
|
||||
expect(history.texts(directKey), ['m0']);
|
||||
expect(history.texts(newKey), ['m1']);
|
||||
direct.setPublicKeyHex = _device;
|
||||
expect(direct.archivedCount(_contact), isNull);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'a clear through another instance is ordered after in-flight saves',
|
||||
() async {
|
||||
channel.setArchivedCount(_channel, 0);
|
||||
final gate = Completer<void>();
|
||||
final started = Completer<void>();
|
||||
history.nextWriteGate = gate;
|
||||
history.nextWriteStarted = started;
|
||||
final save = channel.saveChannelMessages(_channel, [_ch(0)]);
|
||||
await started.future;
|
||||
final clear = (ChannelMessageStore()..setPublicKeyHex = _device)
|
||||
.clearChannelMessages(_channel);
|
||||
final laterSave = channel.saveChannelMessages(_channel, [_ch(1)]);
|
||||
gate.complete();
|
||||
await Future.wait([save, clear, laterSave]);
|
||||
|
||||
expect(history.texts(channelKey), ['c1']);
|
||||
expect(channel.archivedCount(_channel), 0);
|
||||
},
|
||||
);
|
||||
|
||||
test('cap reductions remain correct across queued saves', () async {
|
||||
const cap = MessageStore.maxStoredMessages;
|
||||
await direct.saveMessages(_contact, [for (var i = 0; i < cap; i++) _dm(i)]);
|
||||
direct.setArchivedCount(_contact, cap - 2);
|
||||
final first = direct.saveMessages(_contact, [
|
||||
_dm(cap - 2),
|
||||
_dm(cap - 1),
|
||||
_dm(cap),
|
||||
]);
|
||||
final second = direct.saveMessages(_contact, [
|
||||
_dm(cap - 2),
|
||||
_dm(cap - 1),
|
||||
_dm(cap),
|
||||
_dm(cap + 1),
|
||||
]);
|
||||
await Future.wait([first, second]);
|
||||
|
||||
expect(history.texts(directKey).first, 'm2');
|
||||
expect(history.texts(directKey).last, 'm${cap + 1}');
|
||||
expect(history.data[directKey], hasLength(cap));
|
||||
expect(direct.archivedCount(_contact), cap - 4);
|
||||
});
|
||||
|
||||
test(
|
||||
'unreconciled merge preserves distinct duplicates without message IDs',
|
||||
() async {
|
||||
final duplicate = _dm(0, id: '', text: 'same');
|
||||
await direct.saveMessages(_contact, [duplicate, duplicate]);
|
||||
direct.forgetArchive();
|
||||
await direct.saveMessages(_contact, [duplicate, _dm(1)]);
|
||||
expect(history.texts(directKey), ['same', 'same', 'm1']);
|
||||
},
|
||||
);
|
||||
|
||||
test(
|
||||
'backend replacement cannot reuse another backend archive counts',
|
||||
() async {
|
||||
direct.setArchivedCount(_contact, 100);
|
||||
final replacement = _History();
|
||||
HistoryStore.use(replacement);
|
||||
expect(direct.archivedCount(_contact), isNull);
|
||||
await direct.saveMessages(_contact, [_dm(0)]);
|
||||
expect(replacement.texts(directKey), ['m0']);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -55,7 +55,7 @@ void main() {
|
||||
|
||||
final loaded = await store.loadMessages(_contact);
|
||||
final window = loaded.sublist(6);
|
||||
store.setArchived(_contact, loaded.sublist(0, 6));
|
||||
store.setArchivedCount(_contact, 6);
|
||||
await store.saveMessages(_contact, [...window, _dm(10)]);
|
||||
|
||||
final reloaded = await store.loadMessages(_contact);
|
||||
@@ -67,7 +67,7 @@ void main() {
|
||||
test('trimmed messages are archived, deletes stay deleted', () async {
|
||||
await _init();
|
||||
final store = _messageStore();
|
||||
store.setArchived(_contact, const []);
|
||||
store.setArchivedCount(_contact, 0);
|
||||
final window = [for (var i = 0; i < 4; i++) _dm(i)];
|
||||
await store.saveMessages(_contact, window);
|
||||
|
||||
@@ -79,9 +79,23 @@ void main() {
|
||||
final reloaded = await store.loadMessages(_contact);
|
||||
expect(reloaded.map((m) => m.text), ['m0', 'm1', 'm3', 'm4']);
|
||||
expect(store.archivedCount(_contact), 2);
|
||||
});
|
||||
|
||||
store.unarchiveNewest(_contact, 1);
|
||||
expect(store.archivedCount(_contact), 1);
|
||||
test('an unreadable stored history does not block later saves', () async {
|
||||
await _init();
|
||||
final store = _messageStore();
|
||||
final key = '${store.keyFor}$_contact';
|
||||
await PrefsManager.instance.setString(key, '{broken');
|
||||
|
||||
// Unreconciled: nothing was loaded before the first save.
|
||||
await store.saveMessages(_contact, [_dm(0)]);
|
||||
expect((await store.loadMessages(_contact)).map((m) => m.text), ['m0']);
|
||||
|
||||
// Reconciled to zero by a load that found nothing readable.
|
||||
await PrefsManager.instance.setString(key, '{broken');
|
||||
store.setArchivedCount(_contact, 0);
|
||||
await store.saveMessages(_contact, [_dm(1)]);
|
||||
expect((await store.loadMessages(_contact)).map((m) => m.text), ['m1']);
|
||||
});
|
||||
|
||||
test('an unreconciled save merges with what is stored', () async {
|
||||
@@ -100,8 +114,8 @@ void main() {
|
||||
test('clearMessages wipes archived history too', () async {
|
||||
await _init();
|
||||
final store = _messageStore();
|
||||
store.setArchived(_contact, [_dm(0), _dm(1)]);
|
||||
await store.saveMessages(_contact, [_dm(2)]);
|
||||
await store.saveMessages(_contact, [_dm(0), _dm(1), _dm(2)]);
|
||||
store.setArchivedCount(_contact, 2);
|
||||
|
||||
await store.clearMessages(_contact);
|
||||
await store.saveMessages(_contact, [_dm(3)]);
|
||||
@@ -114,7 +128,10 @@ void main() {
|
||||
await _init();
|
||||
final store = _messageStore();
|
||||
const cap = MessageStore.maxStoredMessages;
|
||||
store.setArchived(_contact, [for (var i = 0; i < cap; i++) _dm(i)]);
|
||||
await store.saveMessages(_contact, [
|
||||
for (var i = 0; i < cap; i++) _dm(i),
|
||||
]);
|
||||
store.setArchivedCount(_contact, cap);
|
||||
await store.saveMessages(_contact, [_dm(cap), _dm(cap + 1)]);
|
||||
|
||||
final reloaded = await store.loadMessages(_contact);
|
||||
@@ -184,7 +201,7 @@ void main() {
|
||||
await store.saveChannelMessages(_channelId, all);
|
||||
|
||||
final loaded = await store.loadChannelMessages(_channelId);
|
||||
store.setArchived(_channelId, loaded.sublist(0, 5));
|
||||
store.setArchivedCount(_channelId, 5);
|
||||
await store.saveChannelMessages(_channelId, [
|
||||
...loaded.sublist(5),
|
||||
_ch(8),
|
||||
@@ -197,8 +214,8 @@ void main() {
|
||||
test('clearing through another instance resets the archive', () async {
|
||||
await _init();
|
||||
final store = ChannelMessageStore()..setPublicKeyHex = _device;
|
||||
store.setArchived(_channelId, [_ch(0), _ch(1)]);
|
||||
await store.saveChannelMessages(_channelId, [_ch(2)]);
|
||||
await store.saveChannelMessages(_channelId, [_ch(0), _ch(1), _ch(2)]);
|
||||
store.setArchivedCount(_channelId, 2);
|
||||
|
||||
await (ChannelMessageStore()..setPublicKeyHex = _device)
|
||||
.clearChannelMessages(_channelId);
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:meshcore_open/utils/coalesced_writes.dart';
|
||||
|
||||
@@ -63,4 +65,44 @@ void main() {
|
||||
await writes.flush();
|
||||
expect(ran, isTrue);
|
||||
});
|
||||
|
||||
test('flush waits for writes already started by the timer', () async {
|
||||
final writes = CoalescedWrites(delay: Duration.zero);
|
||||
final started = Completer<void>();
|
||||
final persisted = Completer<void>();
|
||||
writes.schedule('history', () {
|
||||
started.complete();
|
||||
return persisted.future;
|
||||
});
|
||||
await started.future;
|
||||
|
||||
var finished = false;
|
||||
final flush = writes.flush().then((_) => finished = true);
|
||||
await _wait(0);
|
||||
expect(finished, isFalse);
|
||||
persisted.complete();
|
||||
await flush;
|
||||
expect(finished, isTrue);
|
||||
});
|
||||
|
||||
test(
|
||||
'a later flush waits for both existing and newly queued writes',
|
||||
() async {
|
||||
final writes = CoalescedWrites();
|
||||
final first = Completer<void>();
|
||||
final second = Completer<void>();
|
||||
writes.schedule('first', () => first.future);
|
||||
final firstFlush = writes.flush();
|
||||
writes.schedule('second', () => second.future);
|
||||
var finished = false;
|
||||
final secondFlush = writes.flush().then((_) => finished = true);
|
||||
|
||||
second.complete();
|
||||
await _wait(0);
|
||||
expect(finished, isFalse);
|
||||
first.complete();
|
||||
await Future.wait([firstFlush, secondFlush]);
|
||||
expect(finished, isTrue);
|
||||
},
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user