add in-memory tile cache, tile fade transitions, and performance HUD to map page

lib/pages/map/tiles/hive_tile_cache.dart

@@ -1,3 +1,4 @@
+import 'dart:collection';
 import 'dart:typed_data';
 
 import 'package:hive/hive.dart';
@@ -8,9 +9,14 @@ class HiveTileCache {
 
   static const String _boxName = 'map_tile_cache_v1';
   static const int _maxEntries = 6000;
+  static const int _maxMemoryEntries = 1024;
   static const Duration _staleAfter = Duration(days: 14);
+  static const Duration _prefetchCooldown = Duration(seconds: 25);
   static final Map<String, Future<Uint8List?>> _inFlight =
       <String, Future<Uint8List?>>{};
+  static final LinkedHashMap<String, Uint8List> _memoryCache =
+      LinkedHashMap<String, Uint8List>();
+  static final Map<String, int> _recentPrefetches = <String, int>{};
 
   static Future<void> init() async {
     if (!Hive.isBoxOpen(_boxName)) {
@@ -27,30 +33,68 @@ class HiveTileCache {
     }
   }
 
-  static Future<Uint8List?> getOrFetch(String url) async {
-    final now = DateTime.now().millisecondsSinceEpoch;
-    final box = _boxOrNull;
-    if (box == null) return _fetchWithoutCache(url);
-    final cached = _freshCachedBytes(box, url, now);
-    if (cached != null) return cached;
+  static Uint8List? peek(String url) {
+    final inMemory = _memoryCache.remove(url);
+    if (inMemory != null) {
+      _memoryCache[url] = inMemory;
+      return inMemory;
+    }
 
-    return _fetchAndStore(box, url, now);
+    final box = _boxOrNull;
+    if (box == null) return null;
+    final now = DateTime.now().millisecondsSinceEpoch;
+    final cached = _freshCachedBytes(box, url, now);
+    if (cached == null || cached.isEmpty) return null;
+    _rememberInMemory(url, cached);
+    return cached;
   }
 
-  static void prefetchUrls(
-    Iterable<String> urls, {
-    int maxCount = 96,
-  }) {
+  static Future<Uint8List?> getOrFetch(String url) async {
+    final immediate = peek(url);
+    if (immediate != null) return immediate;
+
+    final now = DateTime.now().millisecondsSinceEpoch;
+    final box = _boxOrNull;
+    if (box == null) {
+      final bytes = await _fetchWithoutCache(url);
+      if (bytes != null && bytes.isNotEmpty) {
+        _rememberInMemory(url, bytes);
+      }
+      return bytes;
+    }
+
+    final bytes = await _fetchAndStore(box, url, now);
+    if (bytes != null && bytes.isNotEmpty) {
+      _rememberInMemory(url, bytes);
+    }
+    return bytes;
+  }
+
+  static void prefetchUrls(Iterable<String> urls, {int maxCount = 48}) {
     final box = _boxOrNull;
     if (box == null) return;
     final now = DateTime.now().millisecondsSinceEpoch;
+    _recentPrefetches.removeWhere(
+      (_, ts) => now - ts > _prefetchCooldown.inMilliseconds,
+    );
     var queued = 0;
     for (final url in urls) {
       if (queued >= maxCount) break;
-      if (_freshCachedBytes(box, url, now) != null) continue;
+      if (_memoryCache.containsKey(url)) continue;
+      if (box.containsKey(url)) continue;
+      final lastPrefetchTs = _recentPrefetches[url];
+      if (lastPrefetchTs != null &&
+          now - lastPrefetchTs < _prefetchCooldown.inMilliseconds) {
+        continue;
+      }
       if (_inFlight.containsKey(url)) continue;
+      _recentPrefetches[url] = now;
       queued += 1;
-      _fetchAndStore(box, url, now);
+      _fetchAndStore(box, url, now).then((bytes) {
+        if (bytes != null && bytes.isNotEmpty) {
+          _rememberInMemory(url, bytes);
+        }
+      });
     }
   }
 
@@ -89,6 +133,7 @@ class HiveTileCache {
       if (response.statusCode != 200) return null;
       final bytes = response.bodyBytes;
       await box.put(url, <String, dynamic>{'ts': now, 'bytes': bytes});
+      _rememberInMemory(url, bytes);
       await _pruneIfNeeded(box);
       return bytes;
     } catch (_) {
@@ -116,13 +161,30 @@ class HiveTileCache {
     }
 
     entries.sort((a, b) {
-      final ats = (a.value is Map && a.value['ts'] is int) ? a.value['ts'] as int : 0;
-      final bts = (b.value is Map && b.value['ts'] is int) ? b.value['ts'] as int : 0;
+      final ats = (a.value is Map && a.value['ts'] is int)
+          ? a.value['ts'] as int
+          : 0;
+      final bts = (b.value is Map && b.value['ts'] is int)
+          ? b.value['ts'] as int
+          : 0;
       return ats.compareTo(bts);
     });
 
     for (var i = 0; i < overflow; i++) {
-      await box.delete(entries[i].key);
+      final key = entries[i].key;
+      await box.delete(key);
+      if (key is String) {
+        _memoryCache.remove(key);
+      }
+    }
+  }
+
+  static void _rememberInMemory(String url, Uint8List bytes) {
+    if (bytes.isEmpty) return;
+    _memoryCache.remove(url);
+    _memoryCache[url] = bytes;
+    while (_memoryCache.length > _maxMemoryEntries) {
+      _memoryCache.remove(_memoryCache.keys.first);
     }
   }
 }