Offline Mode

Speed: Instant access (microseconds)
Duration: App session
Storage: RAM

The fastest cache layer keeps frequently accessed data in memory for instant retrieval. Perfect for lists, media entries, and user profiles that are accessed multiple times during an app session.

// lib/core/cache/memory_cache.dart

class MemoryCache {
  final Map<String, CacheEntry> _cache = {};
  final Duration defaultTtl;

  MemoryCache({this.defaultTtl = const Duration(hours: 1)});

  void set(String key, dynamic value, {Duration? ttl}) {
    _cache[key] = CacheEntry(
      value: value,
      expiry: DateTime.now().add(ttl ?? defaultTtl),
    );
  }

  T? get<T>(String key) {
    final entry = _cache[key];
    if (entry == null) return null;
    
    if (entry.isExpired) {
      _cache.remove(key);
      return null;
    }
    
    return entry.value as T?;
  }

  void clear() => _cache.clear();
}

class CacheEntry {
  final dynamic value;
  final DateTime expiry;

  CacheEntry({required this.value, required this.expiry});

  bool get isExpired => DateTime.now().isAfter(expiry);
}

Speed: Fast (milliseconds)
Duration: Permanent
Storage: SQLite/Hive

Persistent storage using SQLite or Hive keeps your data available across app restarts. This is your primary offline data source that survives app updates and device restarts.

// lib/core/cache/local_database.dart

import 'package:hive_flutter/hive_flutter.dart';

class LocalDatabase {
  late Box<MediaEntry> _mediaBox;
  late Box<UserProfile> _userBox;

  Future<void> init() async {
    await Hive.initFlutter();
    
    // Register adapters
    Hive.registerAdapter(MediaEntryAdapter());
    Hive.registerAdapter(UserProfileAdapter());
    
    // Open boxes
    _mediaBox = await Hive.openBox<MediaEntry>('media');
    _userBox = await Hive.openBox<UserProfile>('user');
  }

  // Save media entry
  Future<void> saveMedia(MediaEntry entry) async {
    await _mediaBox.put(entry.id.toString(), entry);
  }

  // Get media entry
  MediaEntry? getMedia(int id) {
    return _mediaBox.get(id.toString());
  }

  // Save user list
  Future<void> saveUserList(List<MediaEntry> entries) async {
    final map = Map.fromEntries(
      entries.map((e) => MapEntry(e.id.toString(), e)),
    );
    await _mediaBox.putAll(map);
  }

  // Get all media
  List<MediaEntry> getAllMedia() {
    return _mediaBox.values.toList();
  }
}

Speed: Fast (milliseconds)
Duration: Configurable (default 7 days)
Storage: File system

Images are cached on disk using cached_network_image for offline viewing. Covers and banners remain accessible even without internet.

// lib/core/widgets/cached_image.dart

import 'package:cached_network_image/cached_network_image.dart';

class CachedImage extends StatelessWidget {
  final String imageUrl;
  final double? width;
  final double? height;
  final BoxFit fit;

  const CachedImage({
    required this.imageUrl,
    this.width,
    this.height,
    this.fit = BoxFit.cover,
  });

  @override
  Widget build(BuildContext context) {
    return CachedNetworkImage(
      imageUrl: imageUrl,
      width: width,
      height: height,
      fit: fit,
      placeholder: (context, url) => Container(
        color: Colors.grey[800],
        child: Center(child: CircularProgressIndicator()),
      ),
      errorWidget: (context, url, error) => Container(
        color: Colors.grey[800],
        child: Icon(Icons.broken_image, color: Colors.grey),
      ),
      cacheManager: CacheManager(
        Config(
          'customCacheKey',
          stalePeriod: Duration(days: 7),
          maxNrOfCacheObjects: 500,
        ),
      ),
    );
  }
}