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

213 lines
6.7 KiB
Dart

import 'dart:convert';
import '../models/delivery_observation.dart';
import '../models/path_history.dart';
import '../storage/prefs_manager.dart';
import '../utils/app_logger.dart';
class StorageService {
static const String _pathHistoryPrefix = 'path_history_';
static const String _pendingMessagesKey = 'pending_messages';
static const String _repeaterPasswordsKey = 'repeater_passwords';
static const String _repeaterAutoClockSyncAfterLoginKey =
'repeater_auto_clock_sync_after_login';
static const String _deliveryObservationsKey = 'delivery_observations';
String _publicKeyHex = '';
set setPublicKeyHex(String value) =>
_publicKeyHex = value.length > 10 ? value.substring(0, 10) : '';
String _pathHistoryKey(String contactPubKeyHex) => _publicKeyHex.isEmpty
? '$_pathHistoryPrefix$contactPubKeyHex'
: '$_pathHistoryPrefix${_publicKeyHex}_$contactPubKeyHex';
Future<Map<String, bool>> _loadRepeaterAutoClockSyncAfterLogin() async {
final prefs = PrefsManager.instance;
final jsonStr = prefs.getString(_repeaterAutoClockSyncAfterLoginKey);
if (jsonStr == null) return {};
try {
final json = jsonDecode(jsonStr) as Map<String, dynamic>;
return json.map((key, value) => MapEntry(key, value == true));
} catch (e) {
return {};
}
}
Future<bool> getRepeaterAutoClockSyncAfterLoginEnabled(
String repeaterPubKeyHex,
) async {
final settings = await _loadRepeaterAutoClockSyncAfterLogin();
return settings[repeaterPubKeyHex] ?? false;
}
Future<void> setRepeaterAutoClockSyncAfterLoginEnabled(
String repeaterPubKeyHex,
bool enabled,
) async {
final prefs = PrefsManager.instance;
final settings = await _loadRepeaterAutoClockSyncAfterLogin();
settings[repeaterPubKeyHex] = enabled;
final jsonStr = jsonEncode(settings);
await prefs.setString(_repeaterAutoClockSyncAfterLoginKey, jsonStr);
}
Future<void> savePathHistory(
String contactPubKeyHex,
ContactPathHistory history,
) async {
final prefs = PrefsManager.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 key = _pathHistoryKey(contactPubKeyHex);
// Fall back to the pre-scoping key so learned routes survive the upgrade.
final jsonStr =
prefs.getString(key) ??
prefs.getString('$_pathHistoryPrefix$contactPubKeyHex');
if (jsonStr == null) return null;
try {
final json = jsonDecode(jsonStr) as Map<String, dynamic>;
return ContactPathHistory.fromJson(contactPubKeyHex, json);
} catch (e) {
return null;
}
}
Future<void> clearPathHistory(String contactPubKeyHex) async {
final prefs = PrefsManager.instance;
await prefs.remove(_pathHistoryKey(contactPubKeyHex));
await prefs.remove('$_pathHistoryPrefix$contactPubKeyHex');
}
Future<void> clearAllPathHistories() async {
final prefs = PrefsManager.instance;
final keys = prefs.getKeys();
final pathHistoryKeys = keys.where(
(key) => key.startsWith(_pathHistoryPrefix),
);
for (final key in pathHistoryKeys) {
await prefs.remove(key);
}
}
Future<Map<String, String>> loadPendingMessages() async {
final prefs = PrefsManager.instance;
final jsonStr = prefs.getString(_pendingMessagesKey);
if (jsonStr == null) return {};
try {
final json = jsonDecode(jsonStr) as Map<String, dynamic>;
return json.map((key, value) => MapEntry(key, value as String));
} catch (e) {
return {};
}
}
Future<void> savePendingMessages(Map<String, String> pending) async {
final prefs = PrefsManager.instance;
final jsonStr = jsonEncode(pending);
await prefs.setString(_pendingMessagesKey, jsonStr);
}
Future<void> clearPendingMessages() async {
final prefs = PrefsManager.instance;
await prefs.remove(_pendingMessagesKey);
}
/// Save a repeater password by public key hex
Future<void> saveRepeaterPassword(
String repeaterPubKeyHex,
String password,
) async {
final prefs = PrefsManager.instance;
final passwords = await loadRepeaterPasswords();
passwords[repeaterPubKeyHex] = password;
final jsonStr = jsonEncode(passwords);
await prefs.setString(_repeaterPasswordsKey, jsonStr);
}
/// Load all saved repeater passwords (map of pubKeyHex -> password)
Future<Map<String, String>> loadRepeaterPasswords() async {
final prefs = PrefsManager.instance;
final jsonStr = prefs.getString(_repeaterPasswordsKey);
if (jsonStr == null) return {};
try {
final json = jsonDecode(jsonStr) as Map<String, dynamic>;
return json.map((key, value) => MapEntry(key, value as String));
} catch (e) {
return {};
}
}
/// Get a specific repeater's saved password
Future<String?> getRepeaterPassword(String repeaterPubKeyHex) async {
final passwords = await loadRepeaterPasswords();
return passwords[repeaterPubKeyHex];
}
/// Remove a saved repeater password
Future<void> removeRepeaterPassword(String repeaterPubKeyHex) async {
final prefs = PrefsManager.instance;
final passwords = await loadRepeaterPasswords();
passwords.remove(repeaterPubKeyHex);
final jsonStr = jsonEncode(passwords);
await prefs.setString(_repeaterPasswordsKey, jsonStr);
}
/// Clear all saved repeater passwords
Future<void> clearAllRepeaterPasswords() async {
final prefs = PrefsManager.instance;
await prefs.remove(_repeaterPasswordsKey);
}
Future<void> saveDeliveryObservations(
List<DeliveryObservation> observations,
) async {
final prefs = PrefsManager.instance;
final jsonStr = jsonEncode(observations.map((o) => o.toJson()).toList());
await prefs.setString(_deliveryObservationsKey, jsonStr);
}
Future<List<DeliveryObservation>> loadDeliveryObservations() async {
final prefs = PrefsManager.instance;
final jsonStr = prefs.getString(_deliveryObservationsKey);
if (jsonStr == null) return [];
final List<dynamic> list;
try {
list = jsonDecode(jsonStr) as List<dynamic>;
} catch (e) {
appLogger.warn('Stored delivery observations are unreadable: $e');
return [];
}
final observations = <DeliveryObservation>[];
for (final e in list) {
try {
observations.add(
DeliveryObservation.fromJson(e as Map<String, dynamic>),
);
} catch (err) {
appLogger.warn('Skipping malformed delivery observation: $err');
}
}
return observations;
}
Future<void> clearDeliveryObservations() async {
final prefs = PrefsManager.instance;
await prefs.remove(_deliveryObservationsKey);
}
}