lib/services/offline_cache_service.dartDart
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';
class CachedJson {
const CachedJson({
required this.data,
required this.savedAt,
});
final Map<String, dynamic> data;
final DateTime savedAt;
}
class OfflineCacheService {
OfflineCacheService._();
static const _prefix = 'mw_api_cache_v1_';
static const _maxPersistentEntries = 24;
static const _maxEntryBytes = 350 * 1024;
static const _maxPersistentBytes = 2 * 1024 * 1024;
// Web uses a bounded in-memory cache; native platforms may persist entries.
static final Map<String, CachedJson> _webMemory = <String, CachedJson>{};
static const _maxWebMemoryEntries = 20;
static String _encodedKey(String key) =>
_prefix + base64Url.encode(utf8.encode(key));
static Future<void> writeJson(
String key,
Map<String, dynamic> data,
) async {
final now = DateTime.now().toUtc();
if (kIsWeb) {
_webMemory[key] = CachedJson(data: data, savedAt: now);
while (_webMemory.length > _maxWebMemoryEntries) {
_webMemory.remove(_webMemory.keys.first);
}
return;
}
final raw = jsonEncode({
'saved_at': now.toIso8601String(),
'data': data,
});
if (utf8.encode(raw).length > _maxEntryBytes) return;
try {
final prefs = await SharedPreferences.getInstance();
await _prunePersistentCache(prefs,
incomingBytes: utf8.encode(raw).length);
await prefs.setString(_encodedKey(key), raw);
} catch (error) {
// Cache failures are non-fatal.
if (kDebugMode) debugPrint('[MeinWeimar cache] write skipped: $error');
}
}
static Future<CachedJson?> readJson(
String key, {
Duration maxAge = const Duration(days: 30),
}) async {
if (kIsWeb) {
final cached = _webMemory[key];
if (cached == null) return null;
if (DateTime.now().toUtc().difference(cached.savedAt) > maxAge) {
_webMemory.remove(key);
return null;
}
return cached;
}
try {
final prefs = await SharedPreferences.getInstance();
final encodedKey = _encodedKey(key);
final raw = prefs.getString(encodedKey);
if (raw == null || raw.isEmpty) return null;
final decoded = jsonDecode(raw);
if (decoded is! Map<String, dynamic>) return null;
final savedAt = DateTime.tryParse(decoded['saved_at']?.toString() ?? '');
final data = decoded['data'];
if (savedAt == null || data is! Map<String, dynamic>) return null;
if (DateTime.now().toUtc().difference(savedAt) > maxAge) {
try {
await prefs.remove(encodedKey);
} catch (_) {}
return null;
}
return CachedJson(data: data, savedAt: savedAt);
} catch (_) {
return null;
}
}
static Future<int> entryCount() async {
if (kIsWeb) return _webMemory.length;
try {
final prefs = await SharedPreferences.getInstance();
return prefs.getKeys().where((key) => key.startsWith(_prefix)).length;
} catch (_) {
return 0;
}
}
static Future<void> clear() async {
_webMemory.clear();
try {
final prefs = await SharedPreferences.getInstance();
final keys =
prefs.getKeys().where((key) => key.startsWith(_prefix)).toList();
for (final key in keys) {
try {
await prefs.remove(key);
} catch (_) {}
}
} catch (_) {}
}
static Future<void> _prunePersistentCache(
SharedPreferences prefs, {
required int incomingBytes,
}) async {
final entries = <({String key, DateTime savedAt, int bytes})>[];
var totalBytes = 0;
for (final key in prefs.getKeys().where((k) => k.startsWith(_prefix))) {
final raw = prefs.getString(key);
if (raw == null) continue;
final bytes = utf8.encode(raw).length;
totalBytes += bytes;
DateTime savedAt = DateTime.fromMillisecondsSinceEpoch(0, isUtc: true);
try {
final decoded = jsonDecode(raw);
if (decoded is Map<String, dynamic>) {
savedAt = DateTime.tryParse(decoded['saved_at']?.toString() ?? '') ??
savedAt;
}
} catch (_) {}
entries.add((key: key, savedAt: savedAt, bytes: bytes));
}
entries.sort((a, b) => a.savedAt.compareTo(b.savedAt));
while (entries.isNotEmpty &&
(entries.length >= _maxPersistentEntries ||
totalBytes + incomingBytes > _maxPersistentBytes)) {
final oldest = entries.removeAt(0);
try {
await prefs.remove(oldest.key);
} catch (_) {}
totalBytes -= oldest.bytes;
}
}
}