Get rid of double cache layer, remove tiles from network status indicator, fix status callbacks from split fetches, use tileprovider instead of http catching.

2026-08-16 16:10:20 +02:00 · 2025-11-24 18:28:36 -06:00
parent 2b2349dd16
commit 45f1635e10
20 changed files with 445 additions and 194 deletions
@@ -0,0 +1,127 @@
+import 'package:flutter_map/flutter_map.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/widgets.dart';
+import 'dart:async';
+import 'dart:typed_data';
+import 'dart:ui';
+
+import '../app_state.dart';
+import '../models/tile_provider.dart' as models;
+import 'map_data_provider.dart';
+
+/// Custom tile provider that integrates with DeFlock's offline/online architecture.
+/// 
+/// This replaces the complex HTTP interception approach with a clean TileProvider 
+/// implementation that directly interfaces with our MapDataProvider system.
+class DeflockTileProvider extends TileProvider {
+  final MapDataProvider _mapDataProvider = MapDataProvider();
+  
+  @override
+  ImageProvider getImage(TileCoordinates coordinates, TileLayer options) {
+    // Get current provider info to include in cache key
+    final appState = AppState.instance;
+    final providerId = appState.selectedTileProvider?.id ?? 'unknown';
+    final tileTypeId = appState.selectedTileType?.id ?? 'unknown';
+    
+    return DeflockTileImageProvider(
+      coordinates: coordinates,
+      options: options,
+      mapDataProvider: _mapDataProvider,
+      providerId: providerId,
+      tileTypeId: tileTypeId,
+    );
+  }
+}
+
+/// Image provider that fetches tiles through our MapDataProvider.
+/// 
+/// This handles the actual tile fetching using our existing offline/online
+/// routing logic without any HTTP interception complexity.
+class DeflockTileImageProvider extends ImageProvider<DeflockTileImageProvider> {
+  final TileCoordinates coordinates;
+  final TileLayer options;
+  final MapDataProvider mapDataProvider;
+  final String providerId;
+  final String tileTypeId;
+  
+  const DeflockTileImageProvider({
+    required this.coordinates,
+    required this.options,
+    required this.mapDataProvider,
+    required this.providerId,
+    required this.tileTypeId,
+  });
+  
+  @override
+  Future<DeflockTileImageProvider> obtainKey(ImageConfiguration configuration) {
+    return SynchronousFuture<DeflockTileImageProvider>(this);
+  }
+  
+  @override
+  ImageStreamCompleter loadImage(DeflockTileImageProvider key, ImageDecoderCallback decode) {
+    final chunkEvents = StreamController<ImageChunkEvent>();
+    
+    return MultiFrameImageStreamCompleter(
+      codec: _loadAsync(key, decode, chunkEvents),
+      chunkEvents: chunkEvents.stream,
+      scale: 1.0,
+    );
+  }
+  
+  Future<Codec> _loadAsync(
+    DeflockTileImageProvider key,
+    ImageDecoderCallback decode,
+    StreamController<ImageChunkEvent> chunkEvents,
+  ) async {
+    try {
+      // Get current tile provider and type from app state
+      final appState = AppState.instance;
+      final selectedProvider = appState.selectedTileProvider;
+      final selectedTileType = appState.selectedTileType;
+      
+      if (selectedProvider == null || selectedTileType == null) {
+        throw Exception('No tile provider configured');
+      }
+      
+      // Fetch tile through our existing MapDataProvider system
+      // This automatically handles offline/online routing, caching, etc.
+      final tileBytes = await mapDataProvider.getTile(
+        z: coordinates.z, 
+        x: coordinates.x, 
+        y: coordinates.y,
+        source: MapSource.auto, // Use auto routing (offline first, then online)
+      );
+      
+      // Decode the image bytes
+      final buffer = await ImmutableBuffer.fromUint8List(Uint8List.fromList(tileBytes));
+      return await decode(buffer);
+      
+    } catch (e) {
+      // Log error for debugging but don't spam network status
+      debugPrint('[DeflockTileProvider] Failed to load tile ${coordinates.z}/${coordinates.x}/${coordinates.y}: $e');
+      
+      // Return a transparent 1x1 pixel tile for missing tiles
+      // This is more graceful than throwing and prevents cascade failures
+      final transparentPixel = Uint8List.fromList([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 
+        0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 
+        0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4, 0x89, 0x00, 0x00, 0x00, 0x0B, 0x49, 0x44, 0x41, 
+        0x54, 0x78, 0x9C, 0x63, 0x00, 0x01, 0x00, 0x00, 0x05, 0x00, 0x01, 0x0D, 0x0A, 0x2D, 0xB4, 0x00, 
+        0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82]);
+      
+      final buffer = await ImmutableBuffer.fromUint8List(transparentPixel);
+      return await decode(buffer);
+    }
+  }
+  
+  @override
+  bool operator ==(Object other) {
+    if (other.runtimeType != runtimeType) return false;
+    return other is DeflockTileImageProvider &&
+           other.coordinates == coordinates &&
+           other.providerId == providerId &&
+           other.tileTypeId == tileTypeId;
+  }
+  
+  @override
+  int get hashCode => Object.hash(coordinates, providerId, tileTypeId);
+}
@@ -20,6 +20,45 @@ Future<List<OsmNode>> fetchOsmApiNodes({
 }) async {
  if (profiles.isEmpty) return [];
  
+  // Check if this is a user-initiated fetch (indicated by loading state)
+  final wasUserInitiated = NetworkStatus.instance.currentStatus == NetworkStatusType.waiting;
+  
+  try {
+    final nodes = await _fetchFromOsmApi(
+      bounds: bounds,
+      profiles: profiles,
+      uploadMode: uploadMode,
+      maxResults: maxResults,
+    );
+    
+    // Only report success at the top level if this was user-initiated
+    if (wasUserInitiated) {
+      NetworkStatus.instance.setSuccess();
+    }
+    
+    return nodes;
+  } catch (e) {
+    // Only report errors at the top level if this was user-initiated
+    if (wasUserInitiated) {
+      if (e.toString().contains('timeout') || e.toString().contains('timed out')) {
+        NetworkStatus.instance.setTimeoutError();
+      } else {
+        NetworkStatus.instance.setNetworkError();
+      }
+    }
+    
+    debugPrint('[fetchOsmApiNodes] OSM API operation failed: $e');
+    return [];
+  }
+}
+
+/// Internal method that performs the actual OSM API fetch.
+Future<List<OsmNode>> _fetchFromOsmApi({
+  required LatLngBounds bounds,
+  required List<NodeProfile> profiles,
+  UploadMode uploadMode = UploadMode.production,
+  required int maxResults,
+}) async {
  // Choose API endpoint based on upload mode
  final String apiHost = uploadMode == UploadMode.sandbox 
      ? 'api06.dev.openstreetmap.org'
@@ -41,8 +80,7 @@ Future<List<OsmNode>> fetchOsmApiNodes({
    
    if (response.statusCode != 200) {
      debugPrint('[fetchOsmApiNodes] OSM API error: ${response.statusCode} - ${response.body}');
-      NetworkStatus.instance.reportOverpassIssue(); // Reuse same status tracking
-      return [];
+      throw Exception('OSM API error: ${response.statusCode} - ${response.body}');
    }
    
    // Parse XML response
@@ -53,20 +91,14 @@ Future<List<OsmNode>> fetchOsmApiNodes({
      debugPrint('[fetchOsmApiNodes] Retrieved ${nodes.length} matching surveillance nodes');
    }
    
-    NetworkStatus.instance.reportOverpassSuccess(); // Reuse same status tracking
+    // Don't report success here - let the top level handle it
    return nodes;
    
  } catch (e) {
    debugPrint('[fetchOsmApiNodes] Exception: $e');
    
-    // Report network issues for connection errors
-    if (e.toString().contains('Connection refused') || 
-        e.toString().contains('Connection timed out') ||
-        e.toString().contains('Connection reset')) {
-      NetworkStatus.instance.reportOverpassIssue();
-    }
-    
-    return [];
+    // Don't report status here - let the top level handle it
+    throw e; // Re-throw to let caller handle
  }
 }

@@ -23,14 +23,35 @@ Future<List<OsmNode>> fetchOverpassNodes({
  // Check if this is a user-initiated fetch (indicated by loading state)
  final wasUserInitiated = NetworkStatus.instance.currentStatus == NetworkStatusType.waiting;
  
-  return _fetchOverpassNodesWithSplitting(
-    bounds: bounds,
-    profiles: profiles,
-    uploadMode: uploadMode,
-    maxResults: maxResults,
-    splitDepth: 0,
-    wasUserInitiated: wasUserInitiated,
-  );
+  try {
+    final nodes = await _fetchOverpassNodesWithSplitting(
+      bounds: bounds,
+      profiles: profiles,
+      uploadMode: uploadMode,
+      maxResults: maxResults,
+      splitDepth: 0,
+      reportStatus: wasUserInitiated, // Only top level reports status
+    );
+    
+    // Only report success at the top level if this was user-initiated
+    if (wasUserInitiated) {
+      NetworkStatus.instance.setSuccess();
+    }
+    
+    return nodes;
+  } catch (e) {
+    // Only report errors at the top level if this was user-initiated
+    if (wasUserInitiated) {
+      if (e.toString().contains('timeout') || e.toString().contains('timed out')) {
+        NetworkStatus.instance.setTimeoutError();
+      } else {
+        NetworkStatus.instance.setNetworkError();
+      }
+    }
+    
+    debugPrint('[fetchOverpassNodes] Top-level operation failed: $e');
+    return [];
+  }
 }

 /// Internal method that handles splitting when node limit is exceeded.
@@ -40,7 +61,7 @@ Future<List<OsmNode>> _fetchOverpassNodesWithSplitting({
  UploadMode uploadMode = UploadMode.production,
  required int maxResults,
  required int splitDepth,
-  required bool wasUserInitiated,
+  required bool reportStatus, // Only true for top level
 }) async {
  if (profiles.isEmpty) return [];
  
@@ -51,28 +72,20 @@ Future<List<OsmNode>> _fetchOverpassNodesWithSplitting({
      bounds: bounds,
      profiles: profiles,
      maxResults: maxResults,
+      reportStatus: reportStatus,
    );
  } on OverpassRateLimitException catch (e) {
    // Rate limits should NOT be split - just fail with extended backoff
    debugPrint('[fetchOverpassNodes] Rate limited - using extended backoff, not splitting');
    
-    // Report error if user was waiting
-    if (wasUserInitiated) {
-      NetworkStatus.instance.setNetworkError();
-    }
-    
    // Wait longer for rate limits before giving up entirely  
    await Future.delayed(const Duration(seconds: 30));
-    return []; // Return empty rather than rethrowing
+    return []; // Return empty rather than rethrowing - let caller handle error reporting
  } on OverpassNodeLimitException {
    // If we've hit max split depth, give up to avoid infinite recursion
    if (splitDepth >= maxSplitDepth) {
      debugPrint('[fetchOverpassNodes] Max split depth reached, giving up on area: $bounds');
-      // Report timeout if this was user-initiated (can't split further)
-      if (wasUserInitiated) {
-        NetworkStatus.instance.setTimeoutError();
-      }
-      return [];
+      return []; // Return empty - let caller handle error reporting
    }
    
    // Split the bounds into 4 quadrants and try each separately
@@ -87,7 +100,7 @@ Future<List<OsmNode>> _fetchOverpassNodesWithSplitting({
        uploadMode: uploadMode,
        maxResults: 0, // No limit on individual quadrants to avoid double-limiting
        splitDepth: splitDepth + 1,
-        wasUserInitiated: wasUserInitiated,
+        reportStatus: false, // Sub-requests don't report status
      );
      allNodes.addAll(nodes);
    }
@@ -102,6 +115,7 @@ Future<List<OsmNode>> _fetchSingleOverpassQuery({
  required LatLngBounds bounds,
  required List<NodeProfile> profiles,
  required int maxResults,
+  required bool reportStatus,
 }) async {
  const String overpassEndpoint = 'https://overpass-api.de/api/interpreter';
  
@@ -146,8 +160,8 @@ Future<List<OsmNode>> _fetchSingleOverpassQuery({
        throw OverpassRateLimitException('Rate limited by server', serverResponse: errorBody);
      }
      
-      NetworkStatus.instance.reportOverpassIssue();
-      return [];
+      // Don't report status here - let the top level handle it
+      throw Exception('Overpass API error: $errorBody');
    }
    
    final data = await compute(jsonDecode, response.body) as Map<String, dynamic>;
@@ -157,7 +171,7 @@ Future<List<OsmNode>> _fetchSingleOverpassQuery({
      debugPrint('[fetchOverpassNodes] Retrieved ${elements.length} elements (nodes + ways/relations)');
    }
    
-    NetworkStatus.instance.reportOverpassSuccess();
+    // Don't report success here - let the top level handle it
    
    // Parse response to determine which nodes are constrained
    final nodes = _parseOverpassResponseWithConstraints(elements);
@@ -173,14 +187,8 @@ Future<List<OsmNode>> _fetchSingleOverpassQuery({
    
    debugPrint('[fetchOverpassNodes] Exception: $e');
    
-    // Report network issues for connection errors
-    if (e.toString().contains('Connection refused') || 
-        e.toString().contains('Connection timed out') ||
-        e.toString().contains('Connection reset')) {
-      NetworkStatus.instance.reportOverpassIssue();
-    }
-    
-    return [];
+    // Don't report status here - let the top level handle it
+    throw e; // Re-throw to let caller handle
  }
 }

@@ -6,7 +6,6 @@ import 'package:flutter/foundation.dart';
 import 'package:latlong2/latlong.dart';
 import 'package:flutter_map/flutter_map.dart';
 import 'package:deflockapp/dev_config.dart';
-import '../network_status.dart';

 /// Global semaphore to limit simultaneous tile fetches
 final _tileFetchSemaphore = _SimpleSemaphore(kTileFetchConcurrentThreads);
@@ -121,21 +120,12 @@ Future<List<int>> fetchRemoteTile({
        if (attempt > 1) {
          debugPrint('[fetchRemoteTile] SUCCESS $z/$x/$y from $hostInfo after $attempt attempts');
        }
-        NetworkStatus.instance.reportOsmTileSuccess();
        return resp.bodyBytes;
      } else {
        debugPrint('[fetchRemoteTile] FAIL $z/$x/$y from $hostInfo: code=${resp.statusCode}, bytes=${resp.bodyBytes.length}');
-        NetworkStatus.instance.reportOsmTileIssue();
        throw HttpException('Failed to fetch tile $z/$x/$y from $hostInfo: status ${resp.statusCode}');
      }
    } catch (e) {
-      // Report network issues on connection errors
-      if (e.toString().contains('Connection refused') || 
-          e.toString().contains('Connection timed out') ||
-          e.toString().contains('Connection reset')) {
-        NetworkStatus.instance.reportOsmTileIssue();
-      }
-      
      // Calculate delay and retry (no attempt limit - keep trying forever)
      final delay = _calculateRetryDelay(attempt, random);
      if (attempt == 1) {
@@ -3,7 +3,7 @@ import 'dart:async';

 import '../app_state.dart';

-enum NetworkIssueType { osmTiles, overpassApi, both }
+enum NetworkIssueType { overpassApi }
 enum NetworkStatusType { waiting, issues, timedOut, noData, ready, success, nodeLimitReached }


@@ -12,14 +12,12 @@ class NetworkStatus extends ChangeNotifier {
  static final NetworkStatus instance = NetworkStatus._();
  NetworkStatus._();

-  bool _osmTilesHaveIssues = false;
  bool _overpassHasIssues = false;
  bool _isWaitingForData = false;
  bool _isTimedOut = false;
  bool _hasNoData = false;
  bool _hasSuccess = false;
  int _recentOfflineMisses = 0;
-  Timer? _osmRecoveryTimer;
  Timer? _overpassRecoveryTimer;
  Timer? _waitingTimer;
  Timer? _noDataResetTimer;
@@ -28,8 +26,7 @@ class NetworkStatus extends ChangeNotifier {
  Timer? _nodeLimitResetTimer;

  // Getters
-  bool get hasAnyIssues => _osmTilesHaveIssues || _overpassHasIssues;
-  bool get osmTilesHaveIssues => _osmTilesHaveIssues;
+  bool get hasAnyIssues => _overpassHasIssues;
  bool get overpassHasIssues => _overpassHasIssues;
  bool get isWaitingForData => _isWaitingForData;
  bool get isTimedOut => _isTimedOut;
@@ -49,29 +46,10 @@ class NetworkStatus extends ChangeNotifier {
  }

  NetworkIssueType? get currentIssueType {
-    if (_osmTilesHaveIssues && _overpassHasIssues) return NetworkIssueType.both;
-    if (_osmTilesHaveIssues) return NetworkIssueType.osmTiles;
    if (_overpassHasIssues) return NetworkIssueType.overpassApi;
    return null;
  }

-  /// Report tile server issues (for any provider)
-  void reportOsmTileIssue() {
-    if (!_osmTilesHaveIssues) {
-      _osmTilesHaveIssues = true;
-      notifyListeners();
-      debugPrint('[NetworkStatus] Tile server issues detected');
-    }
-    
-    // Reset recovery timer - if we keep getting errors, keep showing indicator
-    _osmRecoveryTimer?.cancel();
-    _osmRecoveryTimer = Timer(const Duration(minutes: 2), () {
-      _osmTilesHaveIssues = false;
-      notifyListeners();
-      debugPrint('[NetworkStatus] Tile server issues cleared');
-    });
-  }
-
  /// Report Overpass API issues
  void reportOverpassIssue() {
    if (!_overpassHasIssues) {
@@ -90,16 +68,6 @@ class NetworkStatus extends ChangeNotifier {
  }

  /// Report successful operations to potentially clear issues faster
-  void reportOsmTileSuccess() {
-    // Clear issues immediately on success (they were likely temporary)
-    if (_osmTilesHaveIssues) {
-      // Quietly clear - don't log routine success
-      _osmTilesHaveIssues = false;
-      _osmRecoveryTimer?.cancel();
-      notifyListeners();
-    }
-  }
-
  void reportOverpassSuccess() {
    if (_overpassHasIssues) {
      // Quietly clear - don't log routine success
@@ -271,7 +239,6 @@ class NetworkStatus extends ChangeNotifier {

  @override
  void dispose() {
-    _osmRecoveryTimer?.cancel();
    _overpassRecoveryTimer?.cancel();
    _waitingTimer?.cancel();
    _noDataResetTimer?.cancel();
@@ -139,20 +139,15 @@ class PrefetchAreaService {
      _preFetchedUploadMode = uploadMode;
      _lastFetchTime = DateTime.now();
      
-      // Report completion to network status (only if user was waiting)
-      NetworkStatus.instance.setSuccess();
+      // The overpass module already reported success/failure during fetching
+      // We just need to handle the successful result here
      
      // Notify UI that cache has been updated with fresh data
      CameraProviderWithCache.instance.refreshDisplay();
      
    } catch (e) {
      debugPrint('[PrefetchAreaService] Pre-fetch failed: $e');
-      // Report failure to network status (only if user was waiting)
-      if (e.toString().contains('timeout') || e.toString().contains('timed out')) {
-        NetworkStatus.instance.setTimeoutError();
-      } else {
-        NetworkStatus.instance.setNetworkError();
-      }
+      // The overpass module already reported the error status
      // Don't update pre-fetched area info on failure
    } finally {
      _preFetchInProgress = false;