feat: MeshCore SAR - Flutter BLE mesh radio companion app

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

lib/providers/app_provider.dart

@@ -0,0 +1,700 @@
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'connection_provider.dart';
+import 'contacts_provider.dart';
+import 'messages_provider.dart';
+import 'drawing_provider.dart';
+import 'channels_provider.dart';
+import '../services/tile_cache_service.dart';
+import '../services/location_tracking_service.dart';
+import '../models/contact.dart';
+import '../models/message.dart';
+import '../utils/drawing_message_parser.dart';
+
+/// Main App Provider - coordinates all other providers
+class AppProvider with ChangeNotifier {
+  final ConnectionProvider connectionProvider;
+  final ContactsProvider contactsProvider;
+  final MessagesProvider messagesProvider;
+  final DrawingProvider drawingProvider;
+  final ChannelsProvider channelsProvider;
+  final TileCacheService tileCacheService;
+  final LocationTrackingService locationTrackingService = LocationTrackingService();
+
+  bool _isInitialized = false;
+  bool get isInitialized => _isInitialized;
+
+  bool _isSimpleMode = true;
+  bool get isSimpleMode => _isSimpleMode;
+
+  bool _isMapEnabled = true;
+  bool get isMapEnabled => _isMapEnabled;
+
+  AppProvider({
+    required this.connectionProvider,
+    required this.contactsProvider,
+    required this.messagesProvider,
+    required this.drawingProvider,
+    required this.channelsProvider,
+    required this.tileCacheService,
+  }) {
+    _setupCallbacks();
+    _initializeTileCache();
+    _initializeLocationTracking();
+    _loadSimpleMode();
+    _loadMapEnabled();
+    _syncDrawingsOnStartup(); // Sync drawings immediately after providers load
+    _isInitialized = true;
+  }
+
+  /// Sync drawings from messages on app startup (before BLE connection)
+  Future<void> _syncDrawingsOnStartup() async {
+    // Wait for MessagesProvider to finish initializing
+    // DrawingProvider loads around the same time
+    int attempts = 0;
+    while (!messagesProvider.isInitialized && attempts < 20) {
+      await Future.delayed(const Duration(milliseconds: 50));
+      attempts++;
+    }
+
+    // Give DrawingProvider a moment to finish loading too
+    await Future.delayed(const Duration(milliseconds: 100));
+
+    debugPrint('🔄 [AppProvider] Early sync: syncing drawings from messages...');
+    messagesProvider.syncDrawingsWithProvider(drawingProvider);
+  }
+
+  /// Load simple mode setting from shared preferences
+  Future<void> _loadSimpleMode() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      _isSimpleMode = prefs.getBool('simple_mode') ?? true;
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error loading simple mode setting: $e');
+    }
+  }
+
+  /// Toggle simple mode on/off
+  Future<void> toggleSimpleMode(bool enabled) async {
+    try {
+      _isSimpleMode = enabled;
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setBool('simple_mode', enabled);
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error saving simple mode setting: $e');
+    }
+  }
+
+  /// Load map enabled setting from shared preferences
+  Future<void> _loadMapEnabled() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      _isMapEnabled = prefs.getBool('map_enabled') ?? true;
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error loading map enabled setting: $e');
+    }
+  }
+
+  /// Toggle map on/off
+  Future<void> toggleMapEnabled(bool enabled) async {
+    try {
+      _isMapEnabled = enabled;
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setBool('map_enabled', enabled);
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error saving map enabled setting: $e');
+    }
+  }
+
+  /// Initialize tile cache service
+  Future<void> _initializeTileCache() async {
+    try {
+      await tileCacheService.initialize();
+      debugPrint('Tile cache initialized');
+    } catch (e) {
+      debugPrint('Error initializing tile cache: $e');
+    }
+  }
+
+  /// Initialize location tracking service
+  Future<void> _initializeLocationTracking() async {
+    try {
+      // Initialize location tracking with BLE service
+      await locationTrackingService.initialize(connectionProvider.bleService);
+
+      // Setup callbacks
+      locationTrackingService.onPositionUpdate = (position) {
+        debugPrint('📍 [AppProvider] Position updated: ${position.latitude}, ${position.longitude}');
+      };
+
+      locationTrackingService.onBroadcastSent = (position) {
+        debugPrint('📡 [AppProvider] Position broadcast to mesh network');
+      };
+
+      locationTrackingService.onError = (error) {
+        debugPrint('❌ [AppProvider] Location tracking error: $error');
+      };
+
+      locationTrackingService.onTrackingStateChanged = (isTracking) {
+        debugPrint('🔄 [AppProvider] Location tracking state: ${isTracking ? "started" : "stopped"}');
+      };
+
+      debugPrint('✅ [AppProvider] Location tracking service initialized');
+    } catch (e) {
+      debugPrint('❌ [AppProvider] Error initializing location tracking: $e');
+    }
+  }
+
+  /// Setup callbacks between providers
+  void _setupCallbacks() {
+    // Monitor connection state changes to start/stop location tracking
+    connectionProvider.addListener(_handleConnectionStateChange);
+    // When a contact is received from BLE
+    connectionProvider.onContactReceived = (contact) {
+      // Pass device public key to filter out our own contact
+      contactsProvider.addOrUpdateContact(
+        contact,
+        devicePublicKey: connectionProvider.deviceInfo.publicKey,
+      );
+
+      // Broadcast to SSE clients if server is running
+      connectionProvider.broadcastContactToSseClients(contact);
+    };
+
+    // When all contacts are received
+    connectionProvider.onContactsComplete = (contacts) {
+      // Pass device public key to filter out our own contact
+      contactsProvider.addContacts(
+        contacts,
+        devicePublicKey: connectionProvider.deviceInfo.publicKey,
+      );
+      debugPrint('Received ${contacts.length} contacts');
+
+      // Broadcast all contacts to SSE clients if server is running
+      for (final contact in contacts) {
+        connectionProvider.broadcastContactToSseClients(contact);
+      }
+    };
+
+    // Setup callback for ConnectionProvider to query channel info
+    connectionProvider.getChannelInfo = (int channelIdx) {
+      return channelsProvider.getChannel(channelIdx);
+    };
+
+    // When channel info is received
+    connectionProvider.onChannelInfoReceived = (int channelIdx, String channelName, Uint8List secret, int? flags) {
+      try {
+        debugPrint('🔔 [AppProvider] onChannelInfoReceived called: idx=$channelIdx, name="$channelName"');
+        
+        // Check if this is a channel deletion (empty name)
+        if (channelName.isEmpty && channelIdx != 0) {
+          debugPrint('   🗑️  Channel $channelIdx deleted - removing from providers');
+          
+          // Remove from ChannelsProvider
+          channelsProvider.removeChannel(channelIdx);
+          debugPrint('   ✅ Removed from ChannelsProvider');
+          
+          // Remove from ContactsProvider using pseudo public key
+          final publicKeyBytes = Uint8List(32);
+          publicKeyBytes[0] = 0xFF; // Special marker for channels
+          publicKeyBytes[1] = channelIdx; // Channel index
+          final publicKeyHex = publicKeyBytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join('');
+          
+          contactsProvider.removeContact(publicKeyHex);
+          debugPrint('   ✅ Removed from ContactsProvider');
+          
+          return;
+        }
+        
+        // Add/update in ChannelsProvider
+        channelsProvider.addOrUpdateChannel(
+          index: channelIdx,
+          name: channelName,
+          secret: secret,
+          flags: flags,
+        );
+        debugPrint('   ✅ Added to ChannelsProvider');
+        
+        // Also add as Contact to ContactsProvider (for UI display)
+        // Skip if it's public channel (already exists)
+        debugPrint('📻 [AppProvider] Channel $channelIdx: "$channelName" (isEmpty: ${channelName.isEmpty}, isHashChannel: ${channelName.startsWith('#')})');
+        
+        if (channelName.isNotEmpty && channelIdx != 0) {
+          debugPrint('   ✅ Adding channel $channelIdx to ContactsProvider as Contact');
+          
+          // Create a pseudo public key for the channel based on its index
+          // Use channel index as a unique identifier (pad to 32 bytes)
+          final publicKeyBytes = Uint8List(32);
+          publicKeyBytes[0] = 0xFF; // Special marker for channels
+          publicKeyBytes[1] = channelIdx; // Channel index
+          
+          final now = DateTime.now().millisecondsSinceEpoch ~/ 1000;
+          
+          contactsProvider.addOrUpdateContact(
+            Contact(
+              publicKey: publicKeyBytes,
+              type: ContactType.channel,
+              flags: flags ?? 0,
+              outPathLen: -1, // Flood mode for channels
+              outPath: Uint8List(0), // Empty path for channels
+              advName: channelName,
+              lastAdvert: now,
+              advLat: 0, // Channels don't have location
+              advLon: 0,
+              lastMod: now,
+              isNew: false, // Don't mark channels as new
+            ),
+          );
+          
+          debugPrint('   ✅ Channel contact added. Total channels in ContactsProvider: ${contactsProvider.channels.length}');
+        } else {
+          debugPrint('   ⏭️  Skipping channel $channelIdx (empty: ${channelName.isEmpty}, isPublic: ${channelIdx == 0})');
+        }
+      } catch (e, stackTrace) {
+        debugPrint('❌ [AppProvider] Error in onChannelInfoReceived: $e');
+        debugPrint('   Stack trace: $stackTrace');
+      }
+    };
+
+    // When a message is received
+    connectionProvider.onMessageReceived = (message) {
+      // Enrich message with sender name from contacts first
+      Message enrichedMessage = message;
+      if (message.senderPublicKeyPrefix != null && message.senderName == null) {
+        final contact = contactsProvider
+            .findContactByKey(message.senderPublicKeyPrefix!);
+        if (contact != null) {
+          enrichedMessage = message.copyWith(senderName: contact.advName);
+        }
+      }
+
+      // Check if message is a drawing broadcast
+      if (DrawingMessageParser.isDrawingMessage(enrichedMessage.text)) {
+        debugPrint('🎨 [AppProvider] Drawing message received, parsing...');
+        // Extract sender name from message packet metadata
+        final senderName = enrichedMessage.senderName ?? 'unknown';
+        final drawing = DrawingMessageParser.parseDrawingMessage(
+          enrichedMessage.text,
+          senderName: senderName,
+          messageId: enrichedMessage.id, // Pass message ID for navigation linking
+        );
+        if (drawing != null) {
+          debugPrint('🎨 [AppProvider] Drawing parsed successfully: ${drawing.type.name} from ${drawing.senderName ?? "unknown"}');
+          debugPrint('   Drawing linked to message ID: ${enrichedMessage.id}');
+          drawingProvider.addReceivedDrawing(drawing);
+
+          // Update message to mark as drawing and link to drawing ID
+          final updatedMessage = enrichedMessage.copyWith(
+            isDrawing: true,
+            drawingId: drawing.id,
+          );
+
+          // Add the drawing message to chat with drawing metadata
+          // This allows users to click on the drawing message to navigate to it
+          messagesProvider.addMessage(
+            updatedMessage,
+            contactLookup: (name) => '',
+          );
+
+          // Broadcast drawing message to SSE clients if server is running
+          connectionProvider.broadcastMessageToSseClients(updatedMessage);
+        } else {
+          debugPrint('⚠️ [AppProvider] Failed to parse drawing message');
+        }
+        return;
+      }
+
+      // Pass contact lookup function to link channel messages with contacts
+      messagesProvider.addMessage(
+        enrichedMessage,
+        contactLookup: (name) {
+          // Find contact by name and return their public key hex (first 12 chars for 6 bytes)
+          try {
+            final contact = contactsProvider.contacts.firstWhere(
+              (c) => c.advName == name,
+            );
+            return contact.publicKeyHex.isNotEmpty && contact.publicKeyHex.length >= 12
+                ? contact.publicKeyHex.substring(0, 12)
+                : '';
+          } catch (e) {
+            // No matching contact found
+            return '';
+          }
+        },
+      );
+
+      // Broadcast message to SSE clients if server is running
+      connectionProvider.broadcastMessageToSseClients(enrichedMessage);
+    };
+
+    // When telemetry is received via PUSH_CODE_TELEMETRY_RESPONSE (0x8B)
+    // Used by older firmware versions for telemetry responses
+    connectionProvider.onTelemetryReceived = (publicKey, lppData) {
+      debugPrint('📊 [AppProvider] Telemetry response (0x8B) received - updating contact');
+      contactsProvider.updateTelemetry(publicKey, lppData);
+    };
+
+    // When binary response is received via PUSH_CODE_BINARY_RESPONSE (0x8C)
+    // Used by newer firmware versions for telemetry and other binary data
+    // BOTH callbacks (0x8B and 0x8C) must be handled for device compatibility
+    connectionProvider.onBinaryResponse = (publicKeyPrefix, tag, responseData) {
+      debugPrint('📊 [AppProvider] Binary response (0x8C) received - updating contact telemetry');
+      // Binary response tag 0 = telemetry data (Cayenne LPP format)
+      // Other tags may be used for different data types in the future
+      contactsProvider.updateTelemetry(publicKeyPrefix, responseData);
+    };
+
+    // When a contact's routing path is updated in the mesh network
+    connectionProvider.onPathUpdated = (publicKey) {
+      debugPrint('🔄 [AppProvider] Path updated for contact: ${publicKey.sublist(0, 6).map((b) => b.toRadixString(16).padLeft(2, '0')).join(':')}...');
+      // Trigger a single contact fetch to get the updated path information
+      // This is much more efficient than fetching all contacts
+      // This happens asynchronously to avoid blocking the event handler
+      Future.delayed(const Duration(milliseconds: 100), () {
+        if (connectionProvider.deviceInfo.isConnected) {
+          connectionProvider.getContact(publicKey);
+        }
+      });
+    };
+
+    // When an advertisement is received (PUSH_CODE_ADVERT 0x80)
+    // This may be sent by the radio for existing contacts instead of PUSH_CODE_NEW_ADVERT (0x8A)
+    connectionProvider.onAdvertReceived = (publicKey) {
+      debugPrint('📡 [AppProvider] Advertisement received: ${publicKey.sublist(0, 6).map((b) => b.toRadixString(16).padLeft(2, '0')).join(':')}...');
+      // Check if this is an existing contact that might have updated location
+      final contact = contactsProvider.findContactByKey(publicKey);
+      if (contact != null) {
+        debugPrint('   Existing contact "${contact.advName}" - fetching updated contact info (optimized)');
+        // Trigger a single contact fetch to get the updated contact information
+        // This is much more efficient than fetching all contacts
+        Future.delayed(const Duration(milliseconds: 100), () {
+          if (connectionProvider.deviceInfo.isConnected) {
+            connectionProvider.getContact(publicKey);
+          }
+        });
+      } else {
+        debugPrint('   New contact - waiting for PUSH_CODE_NEW_ADVERT (0x8A) with full details');
+      }
+    };
+
+    // When a message is sent (RESP_CODE_SENT received)
+    connectionProvider.onMessageSent = (messageId, expectedAckTag, suggestedTimeoutMs) {
+      debugPrint('📤 [AppProvider] Message sent - Message ID: $messageId, ACK tag: $expectedAckTag');
+      messagesProvider.markMessageSent(messageId, expectedAckTag, suggestedTimeoutMs);
+    };
+
+    // When a message is delivered (PUSH_CODE_SEND_CONFIRMED received)
+    connectionProvider.onMessageDelivered = (ackCode, roundTripTimeMs) {
+      debugPrint('✅ [AppProvider] Message delivered - ACK: $ackCode, RTT: ${roundTripTimeMs}ms');
+      messagesProvider.markMessageDelivered(ackCode, roundTripTimeMs);
+    };
+
+    // When an echo is detected for a public channel message (PUSH_CODE_LOG_RX_DATA matched)
+    connectionProvider.onMessageEchoDetected = (messageId, echoCount, snrRaw, rssiDbm) {
+      debugPrint('🔊 [AppProvider] Echo detected - Message: $messageId, Count: $echoCount');
+      messagesProvider.handleMessageEcho(messageId, echoCount, snrRaw, rssiDbm);
+    };
+
+    // Wire up MessagesProvider's sendMessageCallback for retry logic
+    messagesProvider.sendMessageCallback = ({
+      required contactPublicKey,
+      required text,
+      required messageId,
+      required contact,
+      retryAttempt = 0,
+    }) async {
+      return await connectionProvider.sendTextMessage(
+        contactPublicKey: contactPublicKey,
+        text: text,
+        messageId: messageId,
+        contact: contact,
+        retryAttempt: retryAttempt,
+      );
+    };
+  }
+
+  /// Initialize the app (load contacts, sync time, etc.)
+  Future<void> initialize() async {
+    if (!connectionProvider.deviceInfo.isConnected) return;
+
+    try {
+      // Initialize contacts provider with device public key to exclude self
+      // If already initialized (from early load), this will just filter out self-contact
+      // This must happen before getContacts to ensure proper filtering
+      await contactsProvider.initialize(
+        devicePublicKey: connectionProvider.deviceInfo.publicKey,
+      );
+
+      // Note: Device clock is automatically synced during connection in MeshCoreBleService
+      // No need to sync it again here
+
+      // Get battery and storage information
+      await connectionProvider.getBatteryAndStorage();
+
+      // Load contacts
+      await connectionProvider.getContacts();
+
+      // Small delay to ensure contacts are fully loaded
+      await Future.delayed(const Duration(milliseconds: 500));
+
+      // Sync channels to get channel names
+      // In simple mode: only sync first 5 channels for faster startup
+      // In normal mode: sync all channels (up to device max)
+      final channelsToSync = _isSimpleMode ? 5 : null;
+      debugPrint('📻 [AppProvider] Syncing channels${_isSimpleMode ? ' (simple mode: max 5)' : ''}...');
+      await connectionProvider.syncChannels(maxChannels: channelsToSync);
+      debugPrint('✅ [AppProvider] Channel sync complete');
+
+      // Configure the default public channel (channel 0)
+      // This must be done before sending any channel messages
+      // Note: Some firmware versions may have this pre-configured
+      debugPrint('📻 [AppProvider] Configuring default public channel (channel 0)...');
+      try {
+        await connectionProvider.configureDefaultPublicChannel();
+        debugPrint('✅ [AppProvider] Public channel configured successfully');
+      } catch (e) {
+        debugPrint('⚠️ [AppProvider] Public channel configuration failed (may already be configured): $e');
+        // Continue anyway - channel might already be configured in firmware
+      }
+
+      // Automatically login to all saved rooms
+      await _autoLoginToRooms();
+
+      // FALLBACK: Sync messages once after connection to catch any missed push notifications
+      // This handles the case where messages arrived while the app was disconnected
+      debugPrint('🔄 [AppProvider] Performing initial message sync (fallback for missed pushes)');
+      final initialMessageCount = await connectionProvider.syncAllMessages();
+      debugPrint('📥 [AppProvider] Initial sync retrieved $initialMessageCount message(s)');
+
+      // Note: Future messages are synced automatically via PUSH_CODE_MSG_WAITING events
+
+      // Start location tracking AFTER all initialization is complete
+      debugPrint('📍 [AppProvider] Starting location tracking after successful initialization');
+      await _startLocationTracking();
+
+      // Sync drawing messages with DrawingProvider
+      // This restores any drawings that may be missing from storage
+      debugPrint('🎨 [AppProvider] Syncing drawing messages with DrawingProvider...');
+      messagesProvider.syncDrawingsWithProvider(drawingProvider);
+
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Initialization error: $e');
+    }
+  }
+
+  /// Automatically login to all rooms with saved passwords on cold connect
+  Future<void> _autoLoginToRooms() async {
+    if (!connectionProvider.deviceInfo.isConnected) return;
+
+    try {
+      // Get all room contacts (excluding Public Channel)
+      final rooms = contactsProvider.rooms
+          .where((room) => !room.isPublicChannel)
+          .toList();
+
+      if (rooms.isEmpty) {
+        debugPrint('📂 [AppProvider] No rooms found to auto-login');
+        return;
+      }
+
+      debugPrint('📂 [AppProvider] Found ${rooms.length} room(s), attempting auto-login...');
+
+      final prefs = await SharedPreferences.getInstance();
+
+      for (final room in rooms) {
+        try {
+          // Load saved password for this room
+          final roomKey = 'room_password_${room.publicKeyHex}';
+          final savedPassword = prefs.getString(roomKey) ?? 'hello';
+
+          debugPrint('🔑 [AppProvider] Auto-logging into room: ${room.advName}');
+
+          // Set up one-time callbacks for this room login
+          await _loginToRoomWithCallback(room, savedPassword);
+
+          // Small delay between logins to avoid overwhelming the device
+          await Future.delayed(const Duration(milliseconds: 300));
+        } catch (e) {
+          debugPrint('❌ [AppProvider] Failed to auto-login to ${room.advName}: $e');
+        }
+      }
+    } catch (e) {
+      debugPrint('❌ [AppProvider] Auto-login error: $e');
+    }
+  }
+
+  /// Login to a specific room with callback handling
+  Future<void> _loginToRoomWithCallback(Contact room, String password) async {
+    // Create a completer to wait for login result
+    final completer = Completer<bool>();
+
+    // Store original callbacks
+    final originalOnSuccess = connectionProvider.onLoginSuccess;
+    final originalOnFail = connectionProvider.onLoginFail;
+
+    // Set up temporary callbacks
+    connectionProvider.onLoginSuccess = (publicKeyPrefix, permissions, isAdmin, tag) async {
+      // Restore original callbacks
+      connectionProvider.onLoginSuccess = originalOnSuccess;
+      connectionProvider.onLoginFail = originalOnFail;
+
+      debugPrint('✅ [AppProvider] Auto-login successful for ${room.advName}');
+      debugPrint('📡 [AppProvider] Room server will push messages automatically via PUSH_CODE_MSG_WAITING');
+
+      completer.complete(true);
+    };
+
+    connectionProvider.onLoginFail = (publicKeyPrefix) {
+      // Restore original callbacks
+      connectionProvider.onLoginSuccess = originalOnSuccess;
+      connectionProvider.onLoginFail = originalOnFail;
+
+      debugPrint('❌ [AppProvider] Auto-login failed for ${room.advName} (incorrect password)');
+      completer.complete(false);
+    };
+
+    try {
+      // Send login request
+      await connectionProvider.loginToRoom(
+        roomPublicKey: room.publicKey,
+        password: password,
+      );
+
+      // Wait for login result with timeout
+      await completer.future.timeout(
+        const Duration(seconds: 10),
+        onTimeout: () {
+          // Restore callbacks on timeout
+          connectionProvider.onLoginSuccess = originalOnSuccess;
+          connectionProvider.onLoginFail = originalOnFail;
+          debugPrint('⏱️ [AppProvider] Auto-login timeout for ${room.advName}');
+          return false;
+        },
+      );
+    } catch (e) {
+      // Restore callbacks on error
+      connectionProvider.onLoginSuccess = originalOnSuccess;
+      connectionProvider.onLoginFail = originalOnFail;
+      debugPrint('❌ [AppProvider] Error during auto-login to ${room.advName}: $e');
+    }
+  }
+
+  // Removed _syncMessages() - messages are automatically synced via PUSH_CODE_MSG_WAITING events
+  // The ConnectionProvider's onMessageWaiting callback handles automatic message fetching
+
+  /// Refresh data (contacts and channels - messages are handled via events)
+  Future<void> refresh() async {
+    if (!connectionProvider.deviceInfo.isConnected) return;
+
+    try {
+      // Sync contacts
+      await connectionProvider.getContacts();
+      
+      // Sync channels (respect simple mode settings)
+      final channelsToSync = _isSimpleMode ? 5 : null;
+      await connectionProvider.syncChannels(maxChannels: channelsToSync);
+      
+      // Messages are automatically synced via PUSH_CODE_MSG_WAITING events
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Refresh error: $e');
+    }
+  }
+
+  /// Manually sync messages (only for explicit user pull-to-refresh)
+  /// Note: Messages are automatically synced via PUSH_CODE_MSG_WAITING events
+  /// This method should ONLY be called when the user explicitly pulls to refresh
+  Future<int> syncMessages() async {
+    if (!connectionProvider.deviceInfo.isConnected) return 0;
+
+    try {
+      debugPrint('🔄 [AppProvider] Manual message sync requested (user initiated)');
+      final messageCount = await connectionProvider.syncAllMessages();
+      debugPrint('✅ [AppProvider] Manual sync completed: $messageCount messages');
+      notifyListeners();
+      return messageCount;
+    } catch (e) {
+      debugPrint('❌ [AppProvider] Message sync error: $e');
+      return 0;
+    }
+  }
+
+  /// Handle connection state changes to manage location tracking
+  void _handleConnectionStateChange() {
+    final isConnected = connectionProvider.deviceInfo.isConnected;
+    final wasTracking = locationTrackingService.isTracking;
+
+    // Only stop tracking on disconnect - DON'T start on connect
+    // Location tracking will be started AFTER initialization completes
+    if (!isConnected && wasTracking) {
+      // Connection lost - stop location tracking
+      debugPrint('🔴 [AppProvider] BLE disconnected - stopping location tracking');
+      _stopLocationTracking();
+    }
+  }
+
+  /// Start location tracking
+  Future<void> _startLocationTracking() async {
+    try {
+      final started = await locationTrackingService.startTracking();
+      if (started) {
+        debugPrint('✅ [AppProvider] Location tracking started successfully');
+      } else {
+        debugPrint('⚠️ [AppProvider] Failed to start location tracking');
+      }
+    } catch (e) {
+      debugPrint('❌ [AppProvider] Error starting location tracking: $e');
+    }
+  }
+
+  /// Stop location tracking
+  Future<void> _stopLocationTracking() async {
+    try {
+      await locationTrackingService.stopTracking();
+      debugPrint('✅ [AppProvider] Location tracking stopped');
+    } catch (e) {
+      debugPrint('❌ [AppProvider] Error stopping location tracking: $e');
+    }
+  }
+
+  /// Clear all data
+  void clearAllData() {
+    contactsProvider.clearContacts();
+    messagesProvider.clearAll();
+    notifyListeners();
+  }
+
+  /// Get app statistics
+  Map<String, dynamic> get statistics {
+    return {
+      'connection': {
+        'isConnected': connectionProvider.deviceInfo.isConnected,
+        'deviceName': connectionProvider.deviceInfo.deviceName,
+        'battery': connectionProvider.deviceInfo.batteryPercent,
+      },
+      'contacts': contactsProvider.contactCounts,
+      'messages': messagesProvider.messageStats,
+      'sarMarkers': messagesProvider.sarMarkerStats,
+    };
+  }
+
+  @override
+  void dispose() {
+    // Remove connection state listener
+    connectionProvider.removeListener(_handleConnectionStateChange);
+    // Clear location service callbacks
+    locationTrackingService.onPositionUpdate = null;
+    locationTrackingService.onBroadcastSent = null;
+    locationTrackingService.onError = null;
+    locationTrackingService.onTrackingStateChanged = null;
+    // Dispose the location tracking service to stop GPS stream and clean up resources
+    locationTrackingService.dispose();
+    super.dispose();
+  }
+}

lib/providers/channels_provider.dart

@@ -0,0 +1,110 @@
+import 'package:flutter/foundation.dart';
+import '../models/channel.dart';
+
+/// Manages channel information from the MeshCore device
+class ChannelsProvider with ChangeNotifier {
+  final Map<int, Channel> _channels = {};
+  int _selectedChannelIndex = 0; // Default to public channel
+
+  /// Get all channels
+  List<Channel> get channels => _channels.values.toList()..sort((a, b) => a.index.compareTo(b.index));
+
+  /// Get a specific channel by index
+  Channel? getChannel(int index) => _channels[index];
+
+  /// Get the currently selected channel
+  Channel? get selectedChannel => _channels[_selectedChannelIndex];
+
+  /// Get the selected channel index
+  int get selectedChannelIndex => _selectedChannelIndex;
+
+  /// Get the display name for a channel
+  String getChannelDisplayName(int index) {
+    final channel = _channels[index];
+    if (channel != null) {
+      return channel.displayName;
+    }
+    // Fallback if channel hasn't been synced yet
+    return index == 0 ? 'Public' : 'Channel $index';
+  }
+
+  /// Add or update a channel
+  void addOrUpdateChannel({
+    required int index,
+    required String name,
+    required Uint8List secret,
+    int? flags,
+  }) {
+    _channels[index] = Channel(
+      index: index,
+      name: name,
+      secret: secret,
+      flags: flags,
+    );
+    notifyListeners();
+  }
+
+  /// Add or update a channel using Channel object
+  void addOrUpdateChannelObject(Channel channel) {
+    _channels[channel.index] = channel;
+    notifyListeners();
+  }
+
+  /// Remove a channel by index
+  void removeChannel(int index) {
+    if (_channels.containsKey(index)) {
+      _channels.remove(index);
+      
+      // If the deleted channel was selected, switch to public channel
+      if (_selectedChannelIndex == index) {
+        _selectedChannelIndex = 0;
+      }
+      
+      notifyListeners();
+    }
+  }
+
+  /// Select a channel for sending messages
+  void selectChannel(int index) {
+    if (_channels.containsKey(index) || index == 0) {
+      _selectedChannelIndex = index;
+      notifyListeners();
+    }
+  }
+
+  /// Get channels by type (hash-based vs normal)
+  List<Channel> getHashChannels() {
+    return channels.where((c) => c.isHashChannel).toList();
+  }
+
+  List<Channel> getNormalChannels() {
+    return channels.where((c) => !c.isHashChannel).toList();
+  }
+
+  /// Initialize default public channel
+  void initializePublicChannel() {
+    if (!_channels.containsKey(0)) {
+      _channels[0] = Channel.publicChannel();
+      notifyListeners();
+    }
+  }
+
+  /// Clear all channels
+  void clear() {
+    _channels.clear();
+    _selectedChannelIndex = 0;
+    notifyListeners();
+  }
+
+  /// Check if channels have been loaded
+  bool get hasChannels => _channels.isNotEmpty;
+
+  /// Get the number of channels
+  int get channelCount => _channels.length;
+
+  @override
+  void dispose() {
+    _channels.clear();
+    super.dispose();
+  }
+}

lib/providers/contacts_provider.dart

@@ -0,0 +1,446 @@
+import 'package:flutter/foundation.dart';
+import '../models/contact.dart';
+import '../services/cayenne_lpp_parser.dart';
+import '../services/contact_storage_service.dart';
+import '../utils/key_comparison.dart';
+
+/// Contacts Provider - manages contact list and telemetry
+class ContactsProvider with ChangeNotifier {
+  final Map<String, Contact> _contacts = {};
+  final ContactStorageService _storageService = ContactStorageService();
+  bool _isInitialized = false;
+
+  // Add default public channel on initialization
+  ContactsProvider() {
+    _ensurePublicChannelExists();
+  }
+
+  bool get isInitialized => _isInitialized;
+
+  /// Initialize and load persisted contacts at app startup
+  /// This loads contacts without filtering, allowing offline viewing
+  Future<void> initializeEarly() async {
+    if (_isInitialized) return;
+
+    try {
+      debugPrint(
+        '📦 [ContactsProvider] Early loading persisted contacts (no filtering)...',
+      );
+      final storedContacts = await _storageService.loadContacts();
+
+      // Add stored contacts (excluding any with all-zeros public key)
+      const publicChannelKey =
+          '0000000000000000000000000000000000000000000000000000000000000000';
+      for (final contact in storedContacts) {
+        // Skip any contacts with all-zeros public key (shouldn't happen, but safety check)
+        if (contact.publicKeyHex == publicChannelKey) {
+          continue;
+        }
+        _contacts[contact.publicKeyHex] = contact;
+      }
+
+      _isInitialized = true;
+      debugPrint(
+        '✅ [ContactsProvider] Early loaded ${storedContacts.length} persisted contacts',
+      );
+
+      // Ensure public channel exists after loading
+      _ensurePublicChannelExists();
+
+      notifyListeners();
+    } catch (e) {
+      debugPrint('❌ [ContactsProvider] Error in early initialization: $e');
+      _isInitialized = true; // Mark as initialized even on error
+      _ensurePublicChannelExists();
+    }
+  }
+
+  /// Initialize and load persisted contacts
+  /// [devicePublicKey] - device's own public key to exclude from loaded contacts
+  Future<void> initialize({Uint8List? devicePublicKey}) async {
+    if (_isInitialized) {
+      // If already initialized (from early load), just filter out self-contact
+      if (devicePublicKey != null) {
+        _removeSelfContact(devicePublicKey);
+      }
+      return;
+    }
+
+    try {
+      debugPrint('📦 [ContactsProvider] Loading persisted contacts...');
+      final storedContacts = await _storageService.loadContacts(
+        excludePublicKey: devicePublicKey,
+      );
+
+      // Add stored contacts (excluding any with all-zeros public key)
+      const publicChannelKey =
+          '0000000000000000000000000000000000000000000000000000000000000000';
+      for (final contact in storedContacts) {
+        // Skip any contacts with all-zeros public key (shouldn't happen, but safety check)
+        if (contact.publicKeyHex == publicChannelKey) {
+          continue;
+        }
+        _contacts[contact.publicKeyHex] = contact;
+      }
+
+      _isInitialized = true;
+      debugPrint(
+        '✅ [ContactsProvider] Loaded ${storedContacts.length} persisted contacts',
+      );
+
+      // Ensure public channel exists after loading
+      _ensurePublicChannelExists();
+
+      notifyListeners();
+    } catch (e) {
+      debugPrint('❌ [ContactsProvider] Error initializing: $e');
+      _isInitialized = true; // Mark as initialized even on error
+      _ensurePublicChannelExists();
+    }
+  }
+
+  /// Remove self-contact from loaded contacts (called after BLE connection established)
+  void _removeSelfContact(Uint8List devicePublicKey) {
+    final selfKeyHex = devicePublicKey
+        .map((b) => b.toRadixString(16).padLeft(2, '0'))
+        .join('');
+    if (_contacts.containsKey(selfKeyHex)) {
+      final selfContact = _contacts[selfKeyHex]!;
+      debugPrint(
+        '🗑️ [ContactsProvider] Removing self-contact: ${selfContact.advName}',
+      );
+      _contacts.remove(selfKeyHex);
+      _persistContacts();
+      notifyListeners();
+    }
+  }
+
+  /// Ensure public channel always exists in the list
+  void _ensurePublicChannelExists() {
+    // Public channel has all-zeros public key (32 bytes = 64 hex chars)
+    const publicChannelKey =
+        '0000000000000000000000000000000000000000000000000000000000000000';
+    if (!_contacts.containsKey(publicChannelKey)) {
+      // Create a pseudo-contact for the public channel (ephemeral broadcast)
+      _contacts[publicChannelKey] = Contact(
+        publicKey: Uint8List.fromList(
+          List.filled(32, 0),
+        ), // Zero key for public
+        type: ContactType.channel, // Channel type (not room!)
+        flags: 0,
+        outPathLen: 0,
+        outPath: Uint8List(64),
+        advName: 'Public Channel',
+        lastAdvert: DateTime.now().millisecondsSinceEpoch ~/ 1000,
+        advLat: 0,
+        advLon: 0,
+        lastMod: DateTime.now().millisecondsSinceEpoch ~/ 1000,
+      );
+    }
+  }
+
+  /// Persist contacts to storage (async, non-blocking)
+  Future<void> _persistContacts() async {
+    try {
+      // Don't persist the public channel pseudo-contact (all zeros key)
+      const publicChannelKey =
+          '0000000000000000000000000000000000000000000000000000000000000000';
+      final contactsToSave = _contacts.entries
+          .where((entry) => entry.key != publicChannelKey)
+          .map((entry) => entry.value)
+          .toList();
+      await _storageService.saveContacts(contactsToSave);
+    } catch (e) {
+      debugPrint('❌ [ContactsProvider] Error persisting contacts: $e');
+    }
+  }
+
+  List<Contact> get contacts => _contacts.values.toList();
+
+  List<Contact> get chatContacts =>
+      contacts.where((c) => c.isChat).toList()..sort(_sortByLastSeen);
+
+  List<Contact> get repeaters =>
+      contacts.where((c) => c.isRepeater).toList()..sort(_sortByLastSeen);
+
+  List<Contact> get rooms =>
+      contacts.where((c) => c.isRoom).toList()..sort(_sortByLastSeen);
+
+  List<Contact> get channels {
+    // Always ensure public channel exists when getting channels
+    _ensurePublicChannelExists();
+    return contacts.where((c) => c.isChannel).toList()..sort(_sortByLastSeen);
+  }
+
+  /// Get both rooms and channels (destinations for SAR markers)
+  List<Contact> get roomsAndChannels {
+    _ensurePublicChannelExists();
+    return contacts.where((c) => c.isRoom || c.isChannel).toList()
+      ..sort(_sortByLastSeen);
+  }
+
+  /// Get contacts with location (for map display)
+  List<Contact> get contactsWithLocation =>
+      contacts.where((c) => c.displayLocation != null).toList();
+
+  /// Get chat contacts with location (team members on map)
+  List<Contact> get chatContactsWithLocation =>
+      chatContacts.where((c) => c.displayLocation != null).toList();
+
+  /// Sort contacts by last seen (most recent first)
+  int _sortByLastSeen(Contact a, Contact b) {
+    return b.lastSeenTime.compareTo(a.lastSeenTime);
+  }
+
+  /// Add or update a contact
+  /// Excludes contacts that match the device's own public key
+  void addOrUpdateContact(Contact contact, {Uint8List? devicePublicKey}) {
+    debugPrint('📝 [ContactsProvider] addOrUpdateContact called: ${contact.advName} (type: ${contact.type.displayName}, key: ${contact.publicKeyHex.substring(0, 8)}...)');
+    
+    // Don't add contacts that match our device's public key
+    if (devicePublicKey != null &&
+        contact.publicKey.matches(devicePublicKey)) {
+      debugPrint(
+        'ℹ️ [ContactsProvider] Ignoring contact with device\'s own public key: ${contact.advName}',
+      );
+      return;
+    }
+
+    // Check if this is a new contact
+    final isNewContact = !_contacts.containsKey(contact.publicKeyHex);
+    debugPrint('   isNew: $isNewContact, total contacts before: ${_contacts.length}');
+
+    Contact updatedContact;
+    if (isNewContact) {
+      // New contact - add initial location to history if available
+      updatedContact = contact.copyWith(isNew: true);
+      if (contact.advertLocation != null) {
+        final timestamp = DateTime.fromMillisecondsSinceEpoch(
+          contact.lastAdvert * 1000,
+        );
+        updatedContact = updatedContact.addAdvertLocation(
+          contact.advertLocation!,
+          timestamp,
+        );
+      }
+    } else {
+      // Existing contact - preserve history and isNew status
+      final existingContact = _contacts[contact.publicKeyHex]!;
+
+      // Start with existing contact
+      updatedContact = contact.copyWith(
+        isNew: existingContact.isNew,
+        advertHistory: existingContact.advertHistory,
+      );
+
+      // Add new location to history if location has changed
+      if (contact.advertLocation != null) {
+        final timestamp = DateTime.fromMillisecondsSinceEpoch(
+          contact.lastAdvert * 1000,
+        );
+        updatedContact = updatedContact.addAdvertLocation(
+          contact.advertLocation!,
+          timestamp,
+        );
+      }
+    }
+
+    _contacts[contact.publicKeyHex] = updatedContact;
+    debugPrint('   ✅ Contact added/updated. Total contacts: ${_contacts.length}, channels: ${channels.length}');
+    _persistContacts();
+    notifyListeners();
+    debugPrint('   🔔 notifyListeners() called');
+  }
+
+  /// Add multiple contacts
+  /// Excludes contacts that match the device's own public key
+  void addContacts(List<Contact> contacts, {Uint8List? devicePublicKey}) {
+    int excluded = 0;
+    for (final contact in contacts) {
+      // Don't add contacts that match our device's public key
+      if (devicePublicKey != null &&
+          contact.publicKey.matches(devicePublicKey)) {
+        debugPrint(
+          'ℹ️ [ContactsProvider] Ignoring contact with device\'s own public key: ${contact.advName}',
+        );
+        excluded++;
+        continue;
+      }
+      _contacts[contact.publicKeyHex] = contact;
+    }
+    if (excluded > 0) {
+      debugPrint(
+        'ℹ️ [ContactsProvider] Excluded $excluded contact(s) matching device public key',
+      );
+    }
+    _persistContacts();
+    notifyListeners();
+  }
+
+  /// Update contact telemetry
+  void updateTelemetry(Uint8List publicKeyPrefix, Uint8List lppData) {
+    debugPrint('📊 [ContactsProvider] updateTelemetry() called');
+    debugPrint(
+      '  Public key prefix (hex): ${publicKeyPrefix.map((b) => b.toRadixString(16).padLeft(2, '0')).join(':')}',
+    );
+    debugPrint('  LPP data size: ${lppData.length} bytes');
+
+    // Find contact by public key prefix
+    final contact = _findContactByPrefix(publicKeyPrefix);
+    if (contact == null) {
+      debugPrint('  ❌ Contact not found for this prefix');
+      return;
+    }
+
+    debugPrint('  ✅ Found contact: ${contact.advName}');
+    debugPrint('  Old telemetry timestamp: ${contact.telemetry?.timestamp}');
+
+    try {
+      // Parse Cayenne LPP data
+      final telemetry = CayenneLppParser.parse(lppData);
+      debugPrint('  ✅ Parsed new telemetry');
+      debugPrint('  New telemetry timestamp: ${telemetry.timestamp}');
+
+      // Update contact with new telemetry AND last seen time
+      // lastAdvert is Unix timestamp in seconds
+      final currentTimestamp =
+          (DateTime.now().millisecondsSinceEpoch / 1000).round();
+      debugPrint('  Old lastAdvert: ${contact.lastAdvert}');
+      debugPrint('  New lastAdvert: $currentTimestamp');
+
+      final updatedContact = contact.copyWith(
+        telemetry: telemetry,
+        lastAdvert: currentTimestamp, // Update last seen time
+      );
+      _contacts[contact.publicKeyHex] = updatedContact;
+      debugPrint('  ✅ Updated contact in map (with new lastAdvert)');
+
+      _persistContacts();
+      debugPrint('  ✅ Persisted contacts to storage');
+
+      notifyListeners();
+      debugPrint('  ✅ Notified listeners - UI should update');
+    } catch (e) {
+      debugPrint('  ❌ Failed to parse telemetry: $e');
+      debugPrint('Failed to parse telemetry: $e');
+    }
+  }
+
+  /// Find contact by public key prefix (6 bytes)
+  Contact? _findContactByPrefix(Uint8List prefix) {
+    if (prefix.length < 6) return null;
+
+    final prefixHex = prefix
+        .sublist(0, 6)
+        .map((b) => b.toRadixString(16).padLeft(2, '0'))
+        .join('');
+
+    for (final contact in contacts) {
+      if (contact.publicKeyHex.startsWith(prefixHex)) {
+        return contact;
+      }
+    }
+    return null;
+  }
+
+  /// Find contact by public key
+  Contact? findContactByKey(Uint8List publicKey) {
+    final keyHex = publicKey
+        .map((b) => b.toRadixString(16).padLeft(2, '0'))
+        .join('');
+    return _contacts[keyHex];
+  }
+
+  /// Find contact by name
+  Contact? findContactByName(String name) {
+    return contacts.firstWhere(
+      (c) => c.advName == name,
+      orElse: () => contacts.first,
+    );
+  }
+
+  /// Get contacts with low battery
+  List<Contact> get lowBatteryContacts {
+    return contacts.where((c) {
+      final battery = c.displayBattery;
+      return battery != null && battery < 20.0;
+    }).toList();
+  }
+
+  /// Get recently seen contacts (within last 10 minutes)
+  List<Contact> get recentlySeenContacts {
+    return contacts.where((c) => c.isRecentlySeen).toList();
+  }
+
+  /// Get count of new contacts (not yet viewed)
+  int get newContactsCount =>
+      contacts.where((c) => c.isNew && !c.isChannel).length;
+
+  /// Mark all contacts as viewed (not new)
+  void markAllAsViewed() {
+    bool hasChanges = false;
+    _contacts.forEach((key, contact) {
+      if (contact.isNew && !contact.isChannel) {
+        _contacts[key] = contact.copyWith(isNew: false);
+        hasChanges = true;
+      }
+    });
+    if (hasChanges) {
+      _persistContacts();
+      notifyListeners();
+    }
+  }
+
+  /// Mark a specific contact as viewed (not new)
+  void markAsViewed(String publicKeyHex) {
+    final contact = _contacts[publicKeyHex];
+    if (contact != null && contact.isNew) {
+      _contacts[publicKeyHex] = contact.copyWith(isNew: false);
+      _persistContacts();
+      notifyListeners();
+    }
+  }
+
+  /// Clear all contacts
+  void clearContacts() {
+    _contacts.clear();
+    _persistContacts();
+    notifyListeners();
+  }
+
+  /// Remove a contact
+  /// [onRemoveFromDevice] - Optional callback to remove contact from BLE device
+  Future<void> removeContact(
+    String publicKeyHex, {
+    Future<void> Function(Uint8List)? onRemoveFromDevice,
+  }) async {
+    // Get the contact before removing
+    final contact = _contacts[publicKeyHex];
+    if (contact == null) return;
+
+    // Remove from device first if callback provided
+    if (onRemoveFromDevice != null) {
+      await onRemoveFromDevice(contact.publicKey);
+    }
+
+    // Then remove from local storage
+    _contacts.remove(publicKeyHex);
+    _persistContacts();
+    notifyListeners();
+  }
+
+  /// Get storage statistics
+  Future<Map<String, dynamic>> getStorageStats() async {
+    return await _storageService.getStorageStats();
+  }
+
+  /// Get contact count by type
+  Map<String, int> get contactCounts {
+    return {
+      'chat': chatContacts.length,
+      'repeater': repeaters.length,
+      'room': rooms.length,
+      'total': contacts.length,
+    };
+  }
+}

lib/providers/drawing_provider.dart

@@ -0,0 +1,496 @@
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:latlong2/latlong.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/map_drawing.dart';
+import '../utils/drawing_message_parser.dart';
+
+/// Drawing mode state
+enum DrawingMode { none, line, rectangle, measure }
+
+/// Provider for managing map drawings
+class DrawingProvider with ChangeNotifier {
+  static const String _storageKey = 'map_drawings';
+
+  // Drawing state
+  DrawingMode _drawingMode = DrawingMode.none;
+  Color _selectedColor = DrawingColors.palette[0];
+  bool _showReceivedDrawings = true;
+  bool _showSarMarkers = true;
+
+  // Completed drawings
+  final List<MapDrawing> _drawings = [];
+
+  // In-progress drawing
+  MapDrawing? _currentDrawing;
+  List<LatLng> _currentLinePoints = [];
+  LatLng? _rectangleStartPoint;
+
+  // Distance measurement state
+  LatLng? _measurementPoint1;
+  LatLng? _measurementPoint2;
+  double? _measuredDistance; // in meters
+
+  // Getters
+  DrawingMode get drawingMode => _drawingMode;
+  Color get selectedColor => _selectedColor;
+  bool get showReceivedDrawings => _showReceivedDrawings;
+  bool get showSarMarkers => _showSarMarkers;
+  List<MapDrawing> get drawings {
+    // Filter out hidden drawings first
+    var visibleDrawings = _drawings.where((d) => !d.isHidden);
+
+    // Then filter by received status if needed
+    if (!_showReceivedDrawings) {
+      visibleDrawings = visibleDrawings.where((d) => !d.isReceived);
+    }
+
+    return List.unmodifiable(visibleDrawings.toList());
+  }
+  MapDrawing? get currentDrawing => _currentDrawing;
+  List<LatLng> get currentLinePoints => List.unmodifiable(_currentLinePoints);
+  LatLng? get rectangleStartPoint => _rectangleStartPoint;
+  bool get isDrawing => _drawingMode != DrawingMode.none;
+  LatLng? get measurementPoint1 => _measurementPoint1;
+  LatLng? get measurementPoint2 => _measurementPoint2;
+  double? get measuredDistance => _measuredDistance;
+
+  /// Initialize and load saved drawings
+  Future<void> initialize() async {
+    await _loadDrawings();
+  }
+
+  /// Set drawing mode
+  void setDrawingMode(DrawingMode mode) {
+    if (_drawingMode != mode) {
+      // Cancel any in-progress drawing when switching modes
+      _cancelCurrentDrawing();
+      _drawingMode = mode;
+      notifyListeners();
+    }
+  }
+
+  /// Set selected color
+  void setColor(Color color) {
+    _selectedColor = color;
+    notifyListeners();
+  }
+
+  /// Toggle visibility of received drawings
+  void toggleReceivedDrawings() {
+    _showReceivedDrawings = !_showReceivedDrawings;
+    notifyListeners();
+  }
+
+  /// Toggle visibility of SAR markers
+  void toggleSarMarkers() {
+    _showSarMarkers = !_showSarMarkers;
+    notifyListeners();
+  }
+
+  /// Start drawing a line
+  void startLine(LatLng point) {
+    if (_drawingMode != DrawingMode.line) return;
+
+    _currentLinePoints = [point];
+    notifyListeners();
+  }
+
+  /// Add point to current line
+  void addLinePoint(LatLng point) {
+    if (_drawingMode != DrawingMode.line || _currentLinePoints.isEmpty) return;
+
+    _currentLinePoints.add(point);
+    notifyListeners();
+  }
+
+  /// Complete current line drawing
+  void completeLine() {
+    if (_drawingMode != DrawingMode.line || _currentLinePoints.length < 2) {
+      _cancelCurrentDrawing();
+      return;
+    }
+
+    final drawing = LineDrawing(
+      id: DateTime.now().millisecondsSinceEpoch.toString(),
+      color: _selectedColor,
+      createdAt: DateTime.now(),
+      points: List.from(_currentLinePoints),
+    );
+
+    _drawings.add(drawing);
+    _currentLinePoints = [];
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Start drawing a rectangle
+  void startRectangle(LatLng point) {
+    if (_drawingMode != DrawingMode.rectangle) return;
+
+    _rectangleStartPoint = point;
+    notifyListeners();
+  }
+
+  /// Update rectangle end point (for preview)
+  void updateRectangleEndPoint(LatLng endPoint) {
+    if (_drawingMode != DrawingMode.rectangle || _rectangleStartPoint == null) {
+      return;
+    }
+
+    // Create preview rectangle
+    _currentDrawing = RectangleDrawing(
+      id: 'preview',
+      color: _selectedColor,
+      createdAt: DateTime.now(),
+      topLeft: LatLng(
+        _rectangleStartPoint!.latitude > endPoint.latitude
+            ? endPoint.latitude
+            : _rectangleStartPoint!.latitude,
+        _rectangleStartPoint!.longitude < endPoint.longitude
+            ? _rectangleStartPoint!.longitude
+            : endPoint.longitude,
+      ),
+      bottomRight: LatLng(
+        _rectangleStartPoint!.latitude < endPoint.latitude
+            ? endPoint.latitude
+            : _rectangleStartPoint!.latitude,
+        _rectangleStartPoint!.longitude > endPoint.longitude
+            ? _rectangleStartPoint!.longitude
+            : endPoint.longitude,
+      ),
+    );
+    notifyListeners();
+  }
+
+  /// Complete current rectangle drawing
+  void completeRectangle(LatLng endPoint) {
+    if (_drawingMode != DrawingMode.rectangle || _rectangleStartPoint == null) {
+      _cancelCurrentDrawing();
+      return;
+    }
+
+    // Calculate top-left and bottom-right corners
+    final topLeft = LatLng(
+      _rectangleStartPoint!.latitude > endPoint.latitude
+          ? endPoint.latitude
+          : _rectangleStartPoint!.latitude,
+      _rectangleStartPoint!.longitude < endPoint.longitude
+          ? _rectangleStartPoint!.longitude
+          : endPoint.longitude,
+    );
+
+    final bottomRight = LatLng(
+      _rectangleStartPoint!.latitude < endPoint.latitude
+          ? endPoint.latitude
+          : _rectangleStartPoint!.latitude,
+      _rectangleStartPoint!.longitude > endPoint.longitude
+          ? _rectangleStartPoint!.longitude
+          : endPoint.longitude,
+    );
+
+    final drawing = RectangleDrawing(
+      id: DateTime.now().millisecondsSinceEpoch.toString(),
+      color: _selectedColor,
+      createdAt: DateTime.now(),
+      topLeft: topLeft,
+      bottomRight: bottomRight,
+    );
+
+    _drawings.add(drawing);
+    _rectangleStartPoint = null;
+    _currentDrawing = null;
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Set first measurement point
+  void setMeasurementPoint1(LatLng point) {
+    if (_drawingMode != DrawingMode.measure) return;
+
+    _measurementPoint1 = point;
+    _measurementPoint2 = null;
+    _measuredDistance = null;
+    notifyListeners();
+  }
+
+  /// Set second measurement point and calculate distance
+  void setMeasurementPoint2(LatLng point) {
+    if (_drawingMode != DrawingMode.measure || _measurementPoint1 == null) return;
+
+    _measurementPoint2 = point;
+    _measuredDistance = _calculateDistance(_measurementPoint1!, point);
+    notifyListeners();
+  }
+
+  /// Calculate distance between two points using Haversine formula
+  double _calculateDistance(LatLng point1, LatLng point2) {
+    const Distance distance = Distance();
+    return distance.as(LengthUnit.Meter, point1, point2);
+  }
+
+  /// Clear measurement points
+  void clearMeasurement() {
+    _measurementPoint1 = null;
+    _measurementPoint2 = null;
+    _measuredDistance = null;
+    notifyListeners();
+  }
+
+  /// Cancel current drawing in progress
+  void _cancelCurrentDrawing() {
+    _currentLinePoints = [];
+    _rectangleStartPoint = null;
+    _currentDrawing = null;
+    _measurementPoint1 = null;
+    _measurementPoint2 = null;
+    _measuredDistance = null;
+  }
+
+  /// Clear current drawing (public method)
+  void cancelCurrentDrawing() {
+    _cancelCurrentDrawing();
+    notifyListeners();
+  }
+
+  /// Remove a specific drawing
+  void removeDrawing(String id) {
+    _drawings.removeWhere((d) => d.id == id);
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Clear all drawings
+  void clearAllDrawings() {
+    _drawings.clear();
+    _cancelCurrentDrawing();
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Exit drawing mode
+  void exitDrawingMode() {
+    _cancelCurrentDrawing();
+    _drawingMode = DrawingMode.none;
+    notifyListeners();
+  }
+
+  /// Save drawings to persistent storage
+  Future<void> _saveDrawings() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final jsonList = _drawings.map((d) => d.toJson()).toList();
+      final jsonString = jsonEncode(jsonList);
+      await prefs.setString(_storageKey, jsonString);
+    } catch (e) {
+      debugPrint('Error saving drawings: $e');
+    }
+  }
+
+  /// Load drawings from persistent storage
+  Future<void> _loadDrawings() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final jsonString = prefs.getString(_storageKey);
+      if (jsonString == null) return;
+
+      final jsonList = jsonDecode(jsonString) as List<dynamic>;
+      _drawings.clear();
+
+      for (final json in jsonList) {
+        final drawing = MapDrawing.fromJson(json as Map<String, dynamic>);
+        if (drawing != null) {
+          _drawings.add(drawing);
+        }
+      }
+
+      notifyListeners();
+    } catch (e) {
+      debugPrint('Error loading drawings: $e');
+    }
+  }
+
+  /// Get the current preview drawing for rendering
+  MapDrawing? getPreviewDrawing() {
+    if (_drawingMode == DrawingMode.line && _currentLinePoints.length >= 2) {
+      return LineDrawing(
+        id: 'preview',
+        color: _selectedColor,
+        createdAt: DateTime.now(),
+        points: _currentLinePoints,
+      );
+    } else if (_drawingMode == DrawingMode.rectangle &&
+        _currentDrawing != null) {
+      return _currentDrawing;
+    }
+    return null;
+  }
+
+  /// Add received drawing from another node
+  void addReceivedDrawing(MapDrawing drawing) {
+    // Check if drawing with this ID already exists
+    if (_drawings.any((d) => d.id == drawing.id)) {
+      debugPrint('Drawing ${drawing.id} already exists, skipping');
+      return;
+    }
+
+    // Mark as received when adding
+    final receivedDrawing = _createReceivedCopy(drawing);
+    _drawings.add(receivedDrawing);
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Create a copy of a drawing marked as received
+  MapDrawing _createReceivedCopy(MapDrawing drawing) {
+    if (drawing is LineDrawing) {
+      return LineDrawing(
+        id: drawing.id,
+        color: drawing.color,
+        createdAt: drawing.createdAt,
+        points: drawing.points,
+        senderName: drawing.senderName,
+        isReceived: true,
+        messageId: drawing.messageId,
+        isShared: drawing.isShared,
+        isSent: drawing.isSent,
+        isHidden: drawing.isHidden,
+      );
+    } else if (drawing is RectangleDrawing) {
+      return RectangleDrawing(
+        id: drawing.id,
+        color: drawing.color,
+        createdAt: drawing.createdAt,
+        topLeft: drawing.topLeft,
+        bottomRight: drawing.bottomRight,
+        senderName: drawing.senderName,
+        isReceived: true,
+        messageId: drawing.messageId,
+        isShared: drawing.isShared,
+        isSent: drawing.isSent,
+        isHidden: drawing.isHidden,
+      );
+    }
+    return drawing;
+  }
+
+  /// Get a drawing by its ID
+  MapDrawing? getDrawingById(String id) {
+    try {
+      return _drawings.firstWhere((d) => d.id == id);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /// Get all unshared drawings (local drawings not yet sent)
+  List<MapDrawing> getUnsharedDrawings() {
+    return _drawings.where((d) => !d.isShared && !d.isReceived).toList();
+  }
+
+  /// Mark a drawing as shared
+  void markDrawingAsShared(String id) {
+    final index = _drawings.indexWhere((d) => d.id == id);
+    if (index != -1) {
+      final drawing = _drawings[index];
+
+      // Create a copy with isShared = true
+      if (drawing is LineDrawing) {
+        _drawings[index] = LineDrawing(
+          id: drawing.id,
+          color: drawing.color,
+          createdAt: drawing.createdAt,
+          points: drawing.points,
+          senderName: drawing.senderName,
+          isReceived: drawing.isReceived,
+          messageId: drawing.messageId,
+          isShared: true,
+          isSent: drawing.isSent,
+          isHidden: drawing.isHidden,
+        );
+      } else if (drawing is RectangleDrawing) {
+        _drawings[index] = RectangleDrawing(
+          id: drawing.id,
+          color: drawing.color,
+          createdAt: drawing.createdAt,
+          topLeft: drawing.topLeft,
+          bottomRight: drawing.bottomRight,
+          senderName: drawing.senderName,
+          isReceived: drawing.isReceived,
+          messageId: drawing.messageId,
+          isShared: true,
+          isSent: drawing.isSent,
+          isHidden: drawing.isHidden,
+        );
+      }
+
+      _saveDrawings();
+      notifyListeners();
+    }
+  }
+
+  /// Toggle visibility of a drawing (doesn't save to storage)
+  void toggleDrawingVisibility(String id) {
+    final index = _drawings.indexWhere((d) => d.id == id);
+    if (index != -1) {
+      final drawing = _drawings[index];
+
+      // Create a copy with toggled isHidden flag
+      if (drawing is LineDrawing) {
+        _drawings[index] = LineDrawing(
+          id: drawing.id,
+          color: drawing.color,
+          createdAt: drawing.createdAt,
+          points: drawing.points,
+          senderName: drawing.senderName,
+          isReceived: drawing.isReceived,
+          messageId: drawing.messageId,
+          isShared: drawing.isShared,
+          isSent: drawing.isSent,
+          isHidden: !drawing.isHidden,
+        );
+      } else if (drawing is RectangleDrawing) {
+        _drawings[index] = RectangleDrawing(
+          id: drawing.id,
+          color: drawing.color,
+          createdAt: drawing.createdAt,
+          topLeft: drawing.topLeft,
+          bottomRight: drawing.bottomRight,
+          senderName: drawing.senderName,
+          isReceived: drawing.isReceived,
+          messageId: drawing.messageId,
+          isShared: drawing.isShared,
+          isSent: drawing.isSent,
+          isHidden: !drawing.isHidden,
+        );
+      }
+
+      // Don't save to storage - visibility toggle is temporary
+      notifyListeners();
+    }
+  }
+
+  /// Remove a drawing and its linked message
+  void removeDrawingAndMessage(String drawingId, dynamic messagesProvider) {
+    final drawing = getDrawingById(drawingId);
+    if (drawing == null) return;
+
+    // Remove the drawing
+    _drawings.removeWhere((d) => d.id == drawingId);
+
+    // If the drawing has a linked message, remove it too
+    if (drawing.messageId != null && messagesProvider != null) {
+      messagesProvider.deleteMessage(drawing.messageId!);
+    }
+
+    _saveDrawings();
+    notifyListeners();
+  }
+
+  /// Broadcast a drawing to contacts
+  /// Returns the formatted message string ready to send
+  /// Sender will be determined from packet metadata on receiving end
+  String createDrawingBroadcastMessage(MapDrawing drawing) {
+    return DrawingMessageParser.createDrawingMessage(drawing);
+  }
+}

lib/providers/helpers/message_delivery_tracker.dart

@@ -0,0 +1,150 @@
+/// Message delivery tracking helper
+///
+/// Manages message delivery tracking for sent messages, including:
+/// - FIFO queue for matching RESP_CODE_SENT with message IDs
+/// - ACK tag to message ID mapping
+/// - Timeout tracking for stale ACK mappings
+/// - Message sent/delivered coordination
+///
+/// IMPORTANT: Based on MeshCore firmware analysis:
+/// - Firmware tracks max 8 pending ACKs in circular buffer
+/// - ACK entries overwritten after 8 messages → need rate limiting
+/// - Duplicate ACKs suppressed after first match
+/// - No automatic retry → app must implement
+class MessageDeliveryTracker {
+  /// FIFO queue of pending message IDs
+  /// Messages tracked here before sending, popped when RESP_CODE_SENT arrives
+  final List<String> _pendingMessageIds = [];
+
+  /// Map of ACK tag to message ID for delivery confirmation
+  final Map<int, String> _ackTagToMessageId = {};
+
+  /// Map of message ID to ACK tag (reverse mapping for cleanup)
+  final Map<String, int> _messageIdToAckTag = {};
+
+  /// Map of ACK tag to timestamp for timeout cleanup
+  final Map<int, DateTime> _ackTagTimestamps = {};
+
+  /// Track a pending message ID before sending
+  ///
+  /// This is called BEFORE sending the message. When RESP_CODE_SENT
+  /// arrives, we pop from this FIFO queue to match with the ACK tag.
+  void trackPendingMessage(String messageId) {
+    _pendingMessageIds.add(messageId);
+  }
+
+  /// Pop the next pending message ID from FIFO queue
+  ///
+  /// Called when RESP_CODE_SENT arrives. Returns null if queue empty.
+  String? popPendingMessageId() {
+    if (_pendingMessageIds.isEmpty) {
+      return null;
+    }
+    return _pendingMessageIds.removeAt(0);
+  }
+
+  /// Map ACK tag to message ID after RESP_CODE_SENT received
+  ///
+  /// Creates bidirectional mapping for efficient cleanup and tracking.
+  ///
+  /// WARNING: Firmware only tracks 8 pending ACKs! Caller should
+  /// enforce rate limiting before calling this.
+  void mapAckTagToMessageId(int ackTag, String messageId) {
+    // Store bidirectional mapping
+    _ackTagToMessageId[ackTag] = messageId;
+    _messageIdToAckTag[messageId] = ackTag;
+    _ackTagTimestamps[ackTag] = DateTime.now();
+  }
+
+  /// Get message ID for ACK code
+  ///
+  /// Called when SEND_CONFIRMED arrives. Returns the message ID
+  /// that corresponds to this ACK code.
+  ///
+  /// Returns null if ACK tag not found.
+  String? getMessageIdForAck(int ackCode) {
+    return _ackTagToMessageId[ackCode];
+  }
+
+  /// Remove ACK tag mapping after delivery confirmed or timeout
+  ///
+  /// Cleans up both forward and reverse mappings.
+  void removeAckTag(int ackCode) {
+    final messageId = _ackTagToMessageId.remove(ackCode);
+    if (messageId != null) {
+      _messageIdToAckTag.remove(messageId);
+    }
+    _ackTagTimestamps.remove(ackCode);
+  }
+
+  /// Remove ACK tag mapping by message ID
+  ///
+  /// Used when message times out or is cancelled.
+  void removeByMessageId(String messageId) {
+    final ackTag = _messageIdToAckTag.remove(messageId);
+    if (ackTag != null) {
+      _ackTagToMessageId.remove(ackTag);
+      _ackTagTimestamps.remove(ackTag);
+    }
+  }
+
+  /// Clean up stale ACK mappings
+  ///
+  /// Removes ACK tags that haven't received delivery confirmation
+  /// within the specified timeout (default: 5 minutes).
+  ///
+  /// Returns count of cleaned up entries.
+  int cleanupStaleAcks({Duration timeout = const Duration(minutes: 5)}) {
+    final now = DateTime.now();
+    final staleAcks = <int>[];
+
+    for (final entry in _ackTagTimestamps.entries) {
+      if (now.difference(entry.value) > timeout) {
+        staleAcks.add(entry.key);
+      }
+    }
+
+    for (final ackTag in staleAcks) {
+      removeAckTag(ackTag);
+    }
+
+    return staleAcks.length;
+  }
+
+  /// Clear all tracking state
+  void clearTracking() {
+    _pendingMessageIds.clear();
+    _ackTagToMessageId.clear();
+    _messageIdToAckTag.clear();
+    _ackTagTimestamps.clear();
+  }
+
+  /// Get count of pending ACK tags
+  ///
+  /// WARNING: Firmware only tracks 8 pending ACKs in circular buffer.
+  /// If this exceeds 7, message sending should be rate limited.
+  int get pendingCount => _ackTagToMessageId.length;
+
+  /// Check if should rate limit message sending
+  ///
+  /// Returns true if >= 7 pending ACKs (stay under firmware limit of 8)
+  bool get shouldRateLimit => pendingCount >= 7;
+
+  /// Get oldest pending ACK timestamp (for debugging)
+  DateTime? get oldestPendingTimestamp {
+    if (_ackTagTimestamps.isEmpty) return null;
+    return _ackTagTimestamps.values.reduce(
+      (a, b) => a.isBefore(b) ? a : b,
+    );
+  }
+
+  /// Get diagnostic info for debugging
+  Map<String, dynamic> getDiagnostics() {
+    return {
+      'pendingCount': pendingCount,
+      'shouldRateLimit': shouldRateLimit,
+      'oldestPending': oldestPendingTimestamp?.toIso8601String(),
+      'ackTags': _ackTagToMessageId.keys.toList(),
+    };
+  }
+}

lib/providers/helpers/message_retry_manager.dart

@@ -0,0 +1,101 @@
+import '../../models/message.dart';
+import '../../models/contact.dart';
+
+/// Manages message retry state and logic
+///
+/// This helper class centralizes retry logic for direct messages, implementing
+/// a progressive timeout strategy (4s, 8s, 12s) for messages sent to contacts
+/// with learned routing paths.
+///
+/// IMPORTANT: Based on MeshCore firmware analysis:
+/// - Firmware calculates timeout based on path length and airtime
+/// - Direct mode: ~(path_len * airtime * 2) + margin
+/// - Flood mode: ~10-30 seconds for multi-hop
+/// - Our timeouts (4s, 8s, 12s) are conservative for direct paths
+/// - Firmware does NOT automatically retry - app must implement
+class MessageRetryManager {
+  // Track retry state for each message ID
+  final Map<String, int> _retryAttempts = {};
+  final Map<String, DateTime> _lastRetryTimes = {};
+
+  // Progressive timeout values in milliseconds
+  // These are app-level timeouts, separate from firmware's suggested timeout
+  // Firmware timeout is for ACK arrival, these are for retry attempts
+  static const List<int> _timeouts = [4000, 8000, 12000];
+
+  /// Get timeout for a specific retry attempt (0-2)
+  /// Returns: 4000ms for attempt 0, 8000ms for attempt 1, 12000ms for attempt 2
+  int getTimeoutForAttempt(int attempt) {
+    if (attempt < 0 || attempt >= _timeouts.length) {
+      return _timeouts.last; // Default to last timeout if out of range
+    }
+    return _timeouts[attempt];
+  }
+
+  /// Check if a message is eligible for retry
+  ///
+  /// Returns true if:
+  /// - The message has retryAttempt < 3
+  /// - The contact has a learned path (contact.hasPath == true)
+  /// - The message hasn't used flood fallback yet
+  ///
+  /// Messages to contacts without paths should NOT retry (flood mode already broadcasts)
+  bool canRetry(Message message, Contact contact) {
+    // Never retry if already tried flood mode
+    if (message.usedFloodFallback) {
+      return false;
+    }
+
+    // Never retry beyond 3 attempts
+    if (message.retryAttempt >= 3) {
+      return false;
+    }
+
+    // Only retry if contact has a learned path
+    // If no path, the device uses flood mode automatically - retrying won't help
+    return contact.hasPath;
+  }
+
+  /// Check if should fall back to flood mode
+  ///
+  /// Returns true if:
+  /// - Message has exhausted all 3 retry attempts with direct mode
+  /// - Contact HAS a learned path (so direct mode was used)
+  /// - Hasn't already used flood fallback
+  ///
+  /// IMPORTANT: Only contacts WITH paths need flood fallback.
+  /// Contacts without paths already use flood mode automatically.
+  bool shouldUseFloodFallback(Message message, Contact contact) {
+    return message.retryAttempt >= 3 &&
+           contact.hasPath &&  // ✅ FIXED: Flood fallback for failed direct paths
+           !message.usedFloodFallback;
+  }
+
+  /// Track a retry attempt for a message
+  void trackRetry(String messageId, int attempt) {
+    _retryAttempts[messageId] = attempt;
+    _lastRetryTimes[messageId] = DateTime.now();
+  }
+
+  /// Clear retry tracking for a message (on success or permanent failure)
+  void clearRetry(String messageId) {
+    _retryAttempts.remove(messageId);
+    _lastRetryTimes.remove(messageId);
+  }
+
+  /// Clear all retry tracking (on disconnect)
+  void clearAll() {
+    _retryAttempts.clear();
+    _lastRetryTimes.clear();
+  }
+
+  /// Get current retry attempt for a message (for debugging)
+  int? getRetryAttempt(String messageId) {
+    return _retryAttempts[messageId];
+  }
+
+  /// Get last retry time for a message (for debugging)
+  DateTime? getLastRetryTime(String messageId) {
+    return _lastRetryTimes[messageId];
+  }
+}

lib/providers/helpers/ping_tracker.dart

@@ -0,0 +1,103 @@
+import 'dart:async';
+import 'package:flutter/foundation.dart';
+
+/// Helper class to track pending ping (telemetry) requests
+/// and implement automatic fallback to flooding if no response received
+class PingTracker {
+  // Map of public key hex string to ping request state
+  final Map<String, _PingRequest> _pendingPings = {};
+
+  // Timeout duration for ping responses (seconds)
+  static const int _pingTimeoutSeconds = 5;
+
+  /// Track a new ping request
+  /// Returns a Future that completes when either:
+  /// - A response is received (completes with true)
+  /// - Timeout occurs (completes with false)
+  Future<bool> trackPing({
+    required Uint8List publicKey,
+    required bool wasDirectAttempt,
+  }) {
+    final String keyHex = _publicKeyToHex(publicKey);
+
+    // Cancel any existing pending ping for this contact
+    _pendingPings[keyHex]?.cancel();
+
+    // Create new ping request tracker
+    final completer = Completer<bool>();
+    final timer = Timer(const Duration(seconds: _pingTimeoutSeconds), () {
+      // Timeout occurred - mark as failed
+      _pendingPings.remove(keyHex);
+      if (!completer.isCompleted) {
+        completer.complete(false);
+      }
+    });
+
+    _pendingPings[keyHex] = _PingRequest(
+      publicKey: publicKey,
+      wasDirectAttempt: wasDirectAttempt,
+      timer: timer,
+      completer: completer,
+    );
+
+    return completer.future;
+  }
+
+  /// Mark a ping as successful (response received)
+  /// Should be called when telemetry response arrives
+  void markPingSuccessful(Uint8List publicKey) {
+    final String keyHex = _publicKeyToHex(publicKey);
+    final request = _pendingPings.remove(keyHex);
+
+    if (request != null) {
+      request.cancel();
+      if (!request.completer.isCompleted) {
+        request.completer.complete(true);
+      }
+    }
+  }
+
+  /// Check if there's a pending ping for this contact
+  bool hasPendingPing(Uint8List publicKey) {
+    final String keyHex = _publicKeyToHex(publicKey);
+    return _pendingPings.containsKey(keyHex);
+  }
+
+  /// Get pending ping info (was it a direct attempt?)
+  bool? wasPingDirect(Uint8List publicKey) {
+    final String keyHex = _publicKeyToHex(publicKey);
+    return _pendingPings[keyHex]?.wasDirectAttempt;
+  }
+
+  /// Clear all pending pings (useful on disconnect)
+  void clearAll() {
+    for (final request in _pendingPings.values) {
+      request.cancel();
+    }
+    _pendingPings.clear();
+  }
+
+  /// Convert public key to hex string for map key
+  String _publicKeyToHex(Uint8List publicKey) {
+    return publicKey.map((b) => b.toRadixString(16).padLeft(2, '0')).join('');
+  }
+}
+
+/// Internal class to track a single ping request
+class _PingRequest {
+  final Uint8List publicKey;
+  final bool wasDirectAttempt;
+  final Timer timer;
+  final Completer<bool> completer;
+
+  _PingRequest({
+    required this.publicKey,
+    required this.wasDirectAttempt,
+    required this.timer,
+    required this.completer,
+  });
+
+  void cancel() {
+    timer.cancel();
+  }
+}

lib/providers/helpers/room_login_manager.dart

@@ -0,0 +1,84 @@
+import 'package:flutter/foundation.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../../models/room_login_state.dart';
+
+/// Room login state management helper
+///
+/// Manages login state tracking for room contacts, including:
+/// - Room login state per contact (Map of String to RoomLoginState)
+/// - Password checking logic
+/// - Login success/fail state updates
+class RoomLoginManager {
+  /// Map of room public key prefix (hex string) to login state
+  final Map<String, RoomLoginState> _roomLoginStates = {};
+
+  /// Get all room login states (unmodifiable view)
+  Map<String, RoomLoginState> get roomLoginStates => Map.unmodifiable(_roomLoginStates);
+
+  /// Get login state for a room by public key prefix
+  RoomLoginState? getRoomLoginState(Uint8List publicKeyPrefix) {
+    final prefixHex = _publicKeyPrefixToHex(publicKeyPrefix);
+    return _roomLoginStates[prefixHex];
+  }
+
+  /// Check if logged into a specific room
+  bool isLoggedIntoRoom(Uint8List publicKeyPrefix) {
+    final state = getRoomLoginState(publicKeyPrefix);
+    return state?.isLoggedIn ?? false;
+  }
+
+  /// Update room login state after successful login
+  Future<void> handleLoginSuccess({
+    required Uint8List publicKeyPrefix,
+    required int permissions,
+    required bool isAdmin,
+    required int tag,
+  }) async {
+    final prefixHex = _publicKeyPrefixToHex(publicKeyPrefix);
+    final hasPassword = await _hasPasswordForRoom(publicKeyPrefix);
+
+    _roomLoginStates[prefixHex] = RoomLoginState.loggedIn(
+      publicKeyPrefix: publicKeyPrefix,
+      permissions: permissions,
+      isAdmin: isAdmin,
+      tag: tag,
+      hasPassword: hasPassword,
+    );
+  }
+
+  /// Update room login state after failed login
+  void handleLoginFail({
+    required Uint8List publicKeyPrefix,
+  }) {
+    final prefixHex = _publicKeyPrefixToHex(publicKeyPrefix);
+
+    _roomLoginStates[prefixHex] = RoomLoginState.loggedOut(
+      publicKeyPrefix: publicKeyPrefix,
+      hasPassword: false, // Password was incorrect
+    );
+  }
+
+  /// Clear all room login states (call on disconnect)
+  void clearRoomLoginStates() {
+    _roomLoginStates.clear();
+  }
+
+  /// Check if a password exists for a room (by public key prefix)
+  Future<bool> _hasPasswordForRoom(Uint8List publicKeyPrefix) async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      // Convert prefix to hex string for storage key
+      final prefixHex = _publicKeyPrefixToHex(publicKeyPrefix);
+      final roomKey = 'room_password_$prefixHex';
+      return prefs.getString(roomKey) != null;
+    } catch (e) {
+      debugPrint('Error checking password for room: $e');
+      return false;
+    }
+  }
+
+  /// Convert public key prefix to hex string (colon-separated)
+  String _publicKeyPrefixToHex(Uint8List publicKeyPrefix) {
+    return publicKeyPrefix.map((b) => b.toRadixString(16).padLeft(2, '0')).join(':');
+  }
+}

lib/providers/map_provider.dart

@@ -0,0 +1,433 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter_map/flutter_map.dart';
+import 'package:latlong2/latlong.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import '../models/location_trail.dart';
+import '../models/map_drawing.dart';
+
+class MapProvider with ChangeNotifier {
+  LatLng? _targetLocation;
+  double? _targetZoom;
+  bool _shouldAnimate = false;
+
+  // Track which contact paths are currently visible
+  final Set<String> _visibleContactPaths = {};
+
+  // Location trail tracking
+  LocationTrail? _currentTrail;
+  bool _isTrailVisible = true;
+  final List<LocationTrail> _trailHistory = [];
+
+  // WMS overlay toggles
+  bool _showCadastralOverlay = false;
+  bool _showForestRoadsOverlay = false;
+  bool _showHikingTrailsOverlay = false;
+  bool _showMainRoadsOverlay = false;
+  bool _showHouseNumbersOverlay = false;
+  bool _showFireHazardZonesOverlay = false;
+  bool _showHistoricalFiresOverlay = false;
+  bool _showFirebreaksOverlay = false;
+  bool _showKrasFireZonesOverlay = false;
+  bool _showPlaceNamesOverlay = false;
+  bool _showMunicipalityBordersOverlay = false;
+
+  // Contact trail toggles
+  bool _showAllContactTrails = true; // Default to showing all contact trails
+
+  // Imported trail (from GPX)
+  LocationTrail? _importedTrail;
+
+  // Download area selection
+  bool _isSelectingDownloadArea = false;
+  LatLngBounds? _downloadAreaBounds;
+
+  LatLng? get targetLocation => _targetLocation;
+  double? get targetZoom => _targetZoom;
+  bool get shouldAnimate => _shouldAnimate;
+  Set<String> get visibleContactPaths => Set.unmodifiable(_visibleContactPaths);
+
+  // Trail getters
+  LocationTrail? get currentTrail => _currentTrail;
+  bool get isTrailVisible => _isTrailVisible;
+  List<LocationTrail> get trailHistory => List.unmodifiable(_trailHistory);
+  bool get isTrailActive => _currentTrail?.isActive ?? false;
+
+  // WMS overlay getters
+  bool get showCadastralOverlay => _showCadastralOverlay;
+  bool get showForestRoadsOverlay => _showForestRoadsOverlay;
+  bool get showHikingTrailsOverlay => _showHikingTrailsOverlay;
+  bool get showMainRoadsOverlay => _showMainRoadsOverlay;
+  bool get showHouseNumbersOverlay => _showHouseNumbersOverlay;
+  bool get showFireHazardZonesOverlay => _showFireHazardZonesOverlay;
+  bool get showHistoricalFiresOverlay => _showHistoricalFiresOverlay;
+  bool get showFirebreaksOverlay => _showFirebreaksOverlay;
+  bool get showKrasFireZonesOverlay => _showKrasFireZonesOverlay;
+  bool get showPlaceNamesOverlay => _showPlaceNamesOverlay;
+  bool get showMunicipalityBordersOverlay => _showMunicipalityBordersOverlay;
+
+  // Contact trail getters
+  bool get showAllContactTrails => _showAllContactTrails;
+
+  // Imported trail getters
+  LocationTrail? get importedTrail => _importedTrail;
+
+  // Download area getters
+  bool get isSelectingDownloadArea => _isSelectingDownloadArea;
+  LatLngBounds? get downloadAreaBounds => _downloadAreaBounds;
+
+  void navigateToLocation({
+    required LatLng location,
+    double zoom = 15.0,
+    bool animate = true,
+  }) {
+    _targetLocation = location;
+    _targetZoom = zoom;
+    _shouldAnimate = animate;
+    notifyListeners();
+  }
+
+  void clearNavigation() {
+    _targetLocation = null;
+    _targetZoom = null;
+    _shouldAnimate = false;
+    // Don't notify listeners to avoid rebuilds
+  }
+
+  /// Navigate to a drawing by its ID
+  void navigateToDrawing(String drawingId, dynamic drawingProvider) {
+    debugPrint('🗺️ [MapProvider] navigateToDrawing called with ID: $drawingId');
+    // Find the drawing in the provider
+    final drawings = drawingProvider.drawings as List;
+    debugPrint('🗺️ [MapProvider] Total drawings in provider: ${drawings.length}');
+    final drawing = drawings.cast<dynamic>().firstWhere(
+      (d) => d.id == drawingId,
+      orElse: () => null,
+    );
+
+    if (drawing == null) {
+      debugPrint('⚠️ [MapProvider] Drawing $drawingId not found');
+      debugPrint('⚠️ [MapProvider] Available drawing IDs: ${drawings.map((d) => d.id).toList()}');
+      return;
+    }
+
+    // Use MapDrawing's built-in getCenter and getBounds methods
+    final center = drawing.getCenter();
+    final bounds = drawing.getBounds();
+
+    // Calculate appropriate zoom level based on bounds
+    // For larger drawings, use lower zoom to fit the whole drawing
+    // For smaller drawings, use higher zoom for better detail
+    final latDiff = (bounds.north - bounds.south).abs();
+    final lonDiff = (bounds.east - bounds.west).abs();
+    final maxDiff = latDiff > lonDiff ? latDiff : lonDiff;
+
+    // Zoom scale: smaller drawings get higher zoom
+    // 0.001 degrees (~100m) -> zoom 17
+    // 0.005 degrees (~500m) -> zoom 16
+    // 0.01 degrees (~1km) -> zoom 15
+    // 0.05 degrees (~5km) -> zoom 13
+    // 0.1 degrees (~10km) -> zoom 12
+    double zoom = 15.0;
+    if (maxDiff < 0.001) {
+      zoom = 17.0;
+    } else if (maxDiff < 0.005) {
+      zoom = 16.0;
+    } else if (maxDiff < 0.01) {
+      zoom = 15.0;
+    } else if (maxDiff < 0.05) {
+      zoom = 13.0;
+    } else if (maxDiff < 0.1) {
+      zoom = 12.0;
+    } else {
+      zoom = 10.0;
+    }
+
+    final typeStr = drawing is LineDrawing ? 'line' : 'rectangle';
+    debugPrint('🗺️ [MapProvider] Navigating to drawing: $typeStr, zoom: $zoom');
+    navigateToLocation(location: center, zoom: zoom, animate: true);
+  }
+
+  void updateZoom(double zoom) {
+    _targetZoom = zoom;
+    notifyListeners();
+  }
+
+  /// Toggle path visibility for a contact
+  void toggleContactPath(String publicKeyHex) {
+    if (_visibleContactPaths.contains(publicKeyHex)) {
+      _visibleContactPaths.remove(publicKeyHex);
+    } else {
+      _visibleContactPaths.add(publicKeyHex);
+    }
+    notifyListeners();
+  }
+
+  /// Check if a contact's path is visible
+  bool isContactPathVisible(String publicKeyHex) {
+    return _visibleContactPaths.contains(publicKeyHex);
+  }
+
+  /// Hide all contact paths
+  void hideAllPaths() {
+    _visibleContactPaths.clear();
+    notifyListeners();
+  }
+
+  /// Show path for specific contact (hide all others)
+  void showOnlyPath(String publicKeyHex) {
+    _visibleContactPaths.clear();
+    _visibleContactPaths.add(publicKeyHex);
+    notifyListeners();
+  }
+
+  /// Start a new location trail
+  void startTrail() {
+    // End current trail if active
+    if (_currentTrail != null && _currentTrail!.isActive) {
+      endTrail();
+    }
+
+    _currentTrail = LocationTrail(
+      id: DateTime.now().millisecondsSinceEpoch.toString(),
+      startTime: DateTime.now(),
+    );
+    _isTrailVisible = true;
+    notifyListeners();
+  }
+
+  /// Add a point to the current trail
+  void addTrailPoint(LatLng position, {double? accuracy, double? speed}) {
+    if (_currentTrail == null || !_currentTrail!.isActive) {
+      startTrail();
+    }
+
+    _currentTrail!.addPoint(TrailPoint(
+      position: position,
+      timestamp: DateTime.now(),
+      accuracy: accuracy,
+      speed: speed,
+    ));
+    notifyListeners();
+  }
+
+  /// End the current trail
+  void endTrail() {
+    if (_currentTrail != null) {
+      _currentTrail!.isActive = false;
+      _currentTrail!.endTime = DateTime.now();
+      if (_currentTrail!.points.isNotEmpty) {
+        _trailHistory.add(_currentTrail!);
+      }
+      _currentTrail = null;
+      notifyListeners();
+    }
+  }
+
+  /// Toggle trail visibility
+  void toggleTrailVisibility() {
+    _isTrailVisible = !_isTrailVisible;
+    notifyListeners();
+  }
+
+  /// Clear the current trail
+  void clearCurrentTrail() {
+    if (_currentTrail != null) {
+      _currentTrail = null;
+      notifyListeners();
+    }
+  }
+
+  /// Clear all trail history
+  void clearAllTrails() {
+    _currentTrail = null;
+    _trailHistory.clear();
+    notifyListeners();
+  }
+
+  /// Get total trail distance in meters
+  double get totalTrailDistance {
+    if (_currentTrail == null) return 0;
+    return _currentTrail!.totalDistance;
+  }
+
+  /// Get trail duration
+  Duration get trailDuration {
+    if (_currentTrail == null) return Duration.zero;
+    return _currentTrail!.duration;
+  }
+
+  /// Toggle cadastral parcels overlay
+  Future<void> toggleCadastralOverlay() async {
+    _showCadastralOverlay = !_showCadastralOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle forest roads overlay
+  Future<void> toggleForestRoadsOverlay() async {
+    _showForestRoadsOverlay = !_showForestRoadsOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle hiking trails overlay
+  Future<void> toggleHikingTrailsOverlay() async {
+    _showHikingTrailsOverlay = !_showHikingTrailsOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle main roads overlay
+  Future<void> toggleMainRoadsOverlay() async {
+    _showMainRoadsOverlay = !_showMainRoadsOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle house numbers overlay
+  Future<void> toggleHouseNumbersOverlay() async {
+    _showHouseNumbersOverlay = !_showHouseNumbersOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle fire hazard zones overlay
+  Future<void> toggleFireHazardZonesOverlay() async {
+    _showFireHazardZonesOverlay = !_showFireHazardZonesOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle historical fires overlay
+  Future<void> toggleHistoricalFiresOverlay() async {
+    _showHistoricalFiresOverlay = !_showHistoricalFiresOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle firebreaks overlay
+  Future<void> toggleFirebreaksOverlay() async {
+    _showFirebreaksOverlay = !_showFirebreaksOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle Kras fire zones overlay
+  Future<void> toggleKrasFireZonesOverlay() async {
+    _showKrasFireZonesOverlay = !_showKrasFireZonesOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle place names overlay
+  Future<void> togglePlaceNamesOverlay() async {
+    _showPlaceNamesOverlay = !_showPlaceNamesOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Toggle municipality borders overlay
+  Future<void> toggleMunicipalityBordersOverlay() async {
+    _showMunicipalityBordersOverlay = !_showMunicipalityBordersOverlay;
+    notifyListeners();
+    await _saveOverlayState();
+  }
+
+  /// Load overlay state from SharedPreferences
+  Future<void> loadOverlayState() async {
+    final prefs = await SharedPreferences.getInstance();
+    _showCadastralOverlay = prefs.getBool('map_show_cadastral_overlay') ?? false;
+    _showForestRoadsOverlay = prefs.getBool('map_show_forest_roads_overlay') ?? false;
+    _showHikingTrailsOverlay = prefs.getBool('map_show_hiking_trails_overlay') ?? false;
+    _showMainRoadsOverlay = prefs.getBool('map_show_main_roads_overlay') ?? false;
+    _showHouseNumbersOverlay = prefs.getBool('map_show_house_numbers_overlay') ?? false;
+    _showFireHazardZonesOverlay = prefs.getBool('map_show_fire_hazard_zones_overlay') ?? false;
+    _showHistoricalFiresOverlay = prefs.getBool('map_show_historical_fires_overlay') ?? false;
+    _showFirebreaksOverlay = prefs.getBool('map_show_firebreaks_overlay') ?? false;
+    _showKrasFireZonesOverlay = prefs.getBool('map_show_kras_fire_zones_overlay') ?? false;
+    _showPlaceNamesOverlay = prefs.getBool('map_show_place_names_overlay') ?? false;
+    _showMunicipalityBordersOverlay = prefs.getBool('map_show_municipality_borders_overlay') ?? false;
+    notifyListeners();
+  }
+
+  /// Save overlay state to SharedPreferences
+  Future<void> _saveOverlayState() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool('map_show_cadastral_overlay', _showCadastralOverlay);
+    await prefs.setBool('map_show_forest_roads_overlay', _showForestRoadsOverlay);
+    await prefs.setBool('map_show_hiking_trails_overlay', _showHikingTrailsOverlay);
+    await prefs.setBool('map_show_main_roads_overlay', _showMainRoadsOverlay);
+    await prefs.setBool('map_show_house_numbers_overlay', _showHouseNumbersOverlay);
+    await prefs.setBool('map_show_fire_hazard_zones_overlay', _showFireHazardZonesOverlay);
+    await prefs.setBool('map_show_historical_fires_overlay', _showHistoricalFiresOverlay);
+    await prefs.setBool('map_show_firebreaks_overlay', _showFirebreaksOverlay);
+    await prefs.setBool('map_show_kras_fire_zones_overlay', _showKrasFireZonesOverlay);
+    await prefs.setBool('map_show_place_names_overlay', _showPlaceNamesOverlay);
+    await prefs.setBool('map_show_municipality_borders_overlay', _showMunicipalityBordersOverlay);
+  }
+
+  /// Toggle all contact trails on/off
+  Future<void> toggleAllContactTrails() async {
+    _showAllContactTrails = !_showAllContactTrails;
+    notifyListeners();
+    await _saveTrailSettings();
+  }
+
+  /// Load trail settings from SharedPreferences
+  Future<void> loadTrailSettings() async {
+    final prefs = await SharedPreferences.getInstance();
+    _showAllContactTrails = prefs.getBool('map_show_all_contact_trails') ?? true; // Default to true (show all)
+    notifyListeners();
+  }
+
+  /// Save trail settings to SharedPreferences
+  Future<void> _saveTrailSettings() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool('map_show_all_contact_trails', _showAllContactTrails);
+  }
+
+  /// Set imported trail (from GPX import)
+  void setImportedTrail(LocationTrail trail) {
+    _importedTrail = trail;
+    notifyListeners();
+  }
+
+  /// Clear imported trail
+  void clearImportedTrail() {
+    _importedTrail = null;
+    notifyListeners();
+  }
+
+  /// Replace current trail with imported trail
+  void replaceCurrentTrailWithImport(LocationTrail importedTrail) {
+    // End current trail if active
+    if (_currentTrail != null && _currentTrail!.isActive) {
+      endTrail();
+    }
+
+    // Set imported trail as current trail
+    _currentTrail = importedTrail;
+    _isTrailVisible = true;
+    notifyListeners();
+  }
+
+  /// Enter download area selection mode with initial bounds
+  void enterDownloadAreaMode(LatLngBounds initialBounds) {
+    _isSelectingDownloadArea = true;
+    _downloadAreaBounds = initialBounds;
+    notifyListeners();
+  }
+
+  /// Exit download area selection mode
+  void exitDownloadAreaMode() {
+    _isSelectingDownloadArea = false;
+    _downloadAreaBounds = null;
+    notifyListeners();
+  }
+
+  /// Update the download area bounds (while dragging/resizing)
+  void updateDownloadAreaBounds(LatLngBounds bounds) {
+    _downloadAreaBounds = bounds;
+    notifyListeners();
+  }
+}