fix : solving concurrent access

Author: BraCR10

lib/background/background.dart

@@ -17,9 +17,9 @@ String currentLanguage = 'en';
 @pragma('vm:entry-point')
 Future<void> serviceMain(ServiceInstance service) async {
   // Initialize persistent logging for background isolate
-  final logsDb = await openMostroDatabase('logs.db');
+  final logsDb = await openMostroDatabase(getLogsDatabaseName(LogContext.mobile));
   final logStorage = LogStorage(db: logsDb);
-  initializeLogger(logStorage);
+  initializeLogger(logStorage, LogContext.mobile);
 
   final Map<String, Map<String, dynamic>> activeSubscriptions = {};
   final nostrService = NostrService();

lib/background/desktop_background_service.dart

@@ -30,9 +30,9 @@ class DesktopBackgroundService implements BackgroundService {
     BackgroundIsolateBinaryMessenger.ensureInitialized(token);
 
     // Initialize persistent logging for desktop background isolate
-    final logsDb = await openMostroDatabase('logs.db');
+    final logsDb = await openMostroDatabase(getLogsDatabaseName(LogContext.desktop));
     final logStorage = LogStorage(db: logsDb);
-    initializeLogger(logStorage);
+    initializeLogger(logStorage, LogContext.desktop);
 
     final nostrService = NostrService();
 

lib/main.dart

@@ -29,10 +29,10 @@ Future<void> main() async {
 
   final mostroDatabase = await openMostroDatabase('mostro.db');
   final eventsDatabase = await openMostroDatabase('events.db');
-  final logsDatabase = await openMostroDatabase('logs.db');
+  final logsDatabase = await openMostroDatabase(getLogsDatabaseName(LogContext.main));
 
   final logStorage = LogStorage(db: logsDatabase);
-  initializeLogger(logStorage);
+  initializeLogger(logStorage, LogContext.main);
 
   final settings = SettingsNotifier(sharedPreferences);
   await settings.init();

lib/services/logger_service.dart

@@ -208,13 +208,39 @@ class _AlwaysStackTraceFilter extends LogFilter {
   bool shouldLog(LogEvent event) => true;
 }
 
-// Global storage reference for persistent logging
-LogStorage? _globalLogStorage;
+/// Isolate context for logging
+enum LogContext {
+  main,
+  mobile,
+  desktop,
+}
+
+// Global storage references for isolated logging (one per isolate)
+final Map<LogContext, LogStorage> _logStorages = {};
+LogContext? _currentContext;
+
+/// Get the database filename for a specific context
+String getLogsDatabaseName(LogContext context) {
+  switch (context) {
+    case LogContext.main:
+      return 'logs_main.db';
+    case LogContext.mobile:
+      return 'logs_mobile.db';
+    case LogContext.desktop:
+      return 'logs_desktop.db';
+  }
+}
 
-/// Initialize the logger with persistent storage
-/// MUST be called before using the logger
-void initializeLogger(LogStorage logStorage) {
-  _globalLogStorage = logStorage;
+/// Initialize the logger with persistent storage for a specific isolate context
+/// MUST be called before using the logger in each isolate
+///
+/// Example:
+/// - Main app: initializeLogger(logStorage, LogContext.main)
+/// - Mobile background: initializeLogger(logStorage, LogContext.mobile)
+/// - Desktop background: initializeLogger(logStorage, LogContext.desktop)
+void initializeLogger(LogStorage logStorage, LogContext context) {
+  _logStorages[context] = logStorage;
+  _currentContext = context;
   // Reset cached loggers to pick up new storage
   _cachedSimpleLogger = null;
   _cachedFullLogger = null;
@@ -224,9 +250,9 @@ Logger? _cachedSimpleLogger;
 Logger? _cachedFullLogger;
 
 Logger get logger {
-  // Use persistent storage if initialized, otherwise fallback to memory
-  final LogOutput primaryOutput = _globalLogStorage != null
-      ? PersistentLogOutput(_globalLogStorage!)
+  // Use persistent storage if initialized for current context, otherwise fallback to memory
+  final LogOutput primaryOutput = _currentContext != null && _logStorages.containsKey(_currentContext)
+      ? PersistentLogOutput(_logStorages[_currentContext]!)
       : MemoryLogOutput.instance;
 
   if (Config.fullLogsInfo) {
@@ -255,38 +281,64 @@ Logger get logger {
 }
 
 
-/// Get all logs from storage
+/// Get all logs from ALL storages (main, mobile, desktop) merged and sorted
 Future<List<LogEntry>> getAllLogs() async {
-  if (_globalLogStorage == null) {
+  if (_logStorages.isEmpty) {
     // Fallback to memory buffer if storage not initialized
     return MemoryLogOutput.instance.getAllLogs();
   }
-  return await _globalLogStorage!.getAllLogs();
+
+  // Collect logs from all isolate storages
+  final allLogs = <LogEntry>[];
+  for (final storage in _logStorages.values) {
+    final logs = await storage.getAllLogs();
+    allLogs.addAll(logs);
+  }
+
+  // Sort by timestamp descending (newest first)
+  allLogs.sort((a, b) => b.timestamp.compareTo(a.timestamp));
+
+  return allLogs;
 }
 
-/// Watch logs with real-time updates
-Stream<List<LogEntry>> watchLogs() {
-  if (_globalLogStorage == null) {
+/// Watch logs with real-time updates from ALL storages
+Stream<List<LogEntry>> watchLogs() async* {
+  if (_logStorages.isEmpty) {
     // Fallback: return memory buffer as stream
-    return Stream.value(MemoryLogOutput.instance.getAllLogs());
+    yield MemoryLogOutput.instance.getAllLogs();
+    return;
+  }
+
+  // Periodically fetch and merge logs from all storages
+  await for (final _ in Stream.periodic(const Duration(milliseconds: 500))) {
+    final allLogs = await getAllLogs();
+    yield allLogs;
   }
-  return _globalLogStorage!.watchLogs();
 }
 
-/// Clear all logs
+/// Clear all logs from ALL storages
 Future<void> clearAllLogs() async {
-  if (_globalLogStorage == null) {
+  if (_logStorages.isEmpty) {
     MemoryLogOutput.instance.clear();
     return;
   }
-  await _globalLogStorage!.clearAll();
+
+  // Clear all isolate storages
+  for (final storage in _logStorages.values) {
+    await storage.clearAll();
+  }
 }
 
-/// Get total log count
+/// Get total log count from ALL storages
 Future<int> getLogCount() async {
-  if (_globalLogStorage == null) {
+  if (_logStorages.isEmpty) {
     return MemoryLogOutput.instance.logCount;
   }
-  return await _globalLogStorage!.getLogCount();
+
+  int total = 0;
+  for (final storage in _logStorages.values) {
+    total += await storage.getLogCount();
+  }
+  return total;
 }