feat: jellyfin
This commit is contained in:
edde746
@@ -0,0 +1,234 @@
|
||||
import 'dart:convert';
|
||||
|
||||
import 'package:drift/drift.dart';
|
||||
|
||||
import '../database/app_database.dart';
|
||||
import '../media/media_backend.dart';
|
||||
import '../media/media_item.dart';
|
||||
import '../utils/isolate_helper.dart';
|
||||
|
||||
/// Backend-agnostic key-value cache for API responses.
|
||||
///
|
||||
/// Stores raw JSON keyed by `serverId:endpoint` in the shared `ApiCache`
|
||||
/// Drift table. `serverId` values are globally unique across connected
|
||||
/// backends, so Plex and Jellyfin entries never collide despite sharing
|
||||
/// the same table.
|
||||
///
|
||||
/// Plex- and Jellyfin-specific helpers (item-id pinning, metadata parsing)
|
||||
/// live on subclasses [PlexApiCache] / [JellyfinApiCache], which also
|
||||
/// implement the abstract [getMetadata] / [pinForOffline] / [deleteForItem]
|
||||
/// methods so callers can dispatch via [forBackend] instead of switching on
|
||||
/// the backend type at every call site.
|
||||
abstract class ApiCache {
|
||||
static ApiCache? _instance;
|
||||
|
||||
/// Returns the most recently registered cache instance — used by callers
|
||||
/// that don't care which backend's helpers they're hitting (e.g. plain
|
||||
/// `get`/`put` from `JellyfinClient`). Backend-specific operations should
|
||||
/// route through [forBackend] instead.
|
||||
static ApiCache get instance {
|
||||
if (_instance == null) {
|
||||
throw StateError('ApiCache not initialized. Call initialize() on a backend cache first.');
|
||||
}
|
||||
return _instance!;
|
||||
}
|
||||
|
||||
static final Map<MediaBackend, ApiCache> _byBackend = {};
|
||||
|
||||
/// Subclasses call this from their own `initialize` to register themselves
|
||||
/// for backend dispatch. Also seeds [instance] so the legacy singleton
|
||||
/// surface keeps working.
|
||||
static void registerInstance(MediaBackend backend, ApiCache cache) {
|
||||
_byBackend[backend] = cache;
|
||||
_instance = cache;
|
||||
}
|
||||
|
||||
/// Pick the cache for [backend]. Plex is the legacy default — covers items
|
||||
/// predating the Connections table where the backend can't be resolved.
|
||||
static ApiCache forBackend(MediaBackend? backend) {
|
||||
final picked = _byBackend[backend ?? MediaBackend.plex] ?? _byBackend[MediaBackend.plex];
|
||||
if (picked == null) {
|
||||
throw StateError('No ApiCache registered for backend $backend');
|
||||
}
|
||||
return picked;
|
||||
}
|
||||
|
||||
final AppDatabase _db;
|
||||
|
||||
ApiCache(this._db);
|
||||
|
||||
/// Direct database access for services that need to query the cache table
|
||||
/// outside the standard get/put surface (e.g. playback initialisation that
|
||||
/// joins on adjacent tables).
|
||||
AppDatabase get database => _db;
|
||||
|
||||
String _buildKey(String serverId, String endpoint) {
|
||||
return '$serverId:$endpoint';
|
||||
}
|
||||
|
||||
/// Get cached response for an endpoint.
|
||||
Future<Map<String, dynamic>?> get(String serverId, String endpoint) async {
|
||||
final key = _buildKey(serverId, endpoint);
|
||||
final result = await (_db.select(_db.apiCache)..where((t) => t.cacheKey.equals(key))).getSingleOrNull();
|
||||
if (result != null) {
|
||||
return await tryIsolateRun(() => jsonDecode(result.data) as Map<String, dynamic>);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Cache a response for an endpoint.
|
||||
Future<void> put(String serverId, String endpoint, Map<String, dynamic> data) async {
|
||||
final key = _buildKey(serverId, endpoint);
|
||||
final encoded = await tryIsolateRun(() => jsonEncode(data));
|
||||
await _db
|
||||
.into(_db.apiCache)
|
||||
.insertOnConflictUpdate(
|
||||
ApiCacheCompanion(cacheKey: Value(key), data: Value(encoded), cachedAt: Value(DateTime.now())),
|
||||
);
|
||||
}
|
||||
|
||||
/// Delete all cached data for a server.
|
||||
Future<void> deleteForServer(String serverId) async {
|
||||
await (_db.delete(_db.apiCache)..where((t) => t.cacheKey.like('$serverId:%'))).go();
|
||||
}
|
||||
|
||||
/// Pin an endpoint's response so the row survives cache eviction.
|
||||
Future<void> pin(String serverId, String endpoint) async {
|
||||
final key = _buildKey(serverId, endpoint);
|
||||
await (_db.update(
|
||||
_db.apiCache,
|
||||
)..where((t) => t.cacheKey.equals(key))).write(const ApiCacheCompanion(pinned: Value(true)));
|
||||
}
|
||||
|
||||
/// Unpin a previously pinned endpoint.
|
||||
Future<void> unpin(String serverId, String endpoint) async {
|
||||
final key = _buildKey(serverId, endpoint);
|
||||
await (_db.update(
|
||||
_db.apiCache,
|
||||
)..where((t) => t.cacheKey.equals(key))).write(const ApiCacheCompanion(pinned: Value(false)));
|
||||
}
|
||||
|
||||
/// Whether the endpoint is pinned for offline.
|
||||
Future<bool> isPinned(String serverId, String endpoint) async {
|
||||
final key = _buildKey(serverId, endpoint);
|
||||
final result = await (_db.select(_db.apiCache)..where((t) => t.cacheKey.equals(key))).getSingleOrNull();
|
||||
return result?.pinned ?? false;
|
||||
}
|
||||
|
||||
/// Clear every cached row (debugging / sign-out).
|
||||
Future<void> clearAll() async {
|
||||
await _db.delete(_db.apiCache).go();
|
||||
}
|
||||
|
||||
/// Clear volatile cached rows while preserving pinned offline metadata.
|
||||
Future<void> clearVolatile() async {
|
||||
await (_db.delete(_db.apiCache)..where((t) => t.pinned.equals(false))).go();
|
||||
}
|
||||
|
||||
/// Pin every row whose `cacheKey` matches the SQL `LIKE` [pattern]. Used by
|
||||
/// backend subclasses that pin by item-shape rather than a single endpoint
|
||||
/// (e.g. Jellyfin's per-user item rows where the user segment is a
|
||||
/// wildcard).
|
||||
Future<void> pinByKeyPattern(String pattern) async {
|
||||
await (_db.update(
|
||||
_db.apiCache,
|
||||
)..where((t) => t.cacheKey.like(pattern))).write(const ApiCacheCompanion(pinned: Value(true)));
|
||||
}
|
||||
|
||||
/// Inverse of [pinByKeyPattern].
|
||||
Future<void> unpinByKeyPattern(String pattern) async {
|
||||
await (_db.update(
|
||||
_db.apiCache,
|
||||
)..where((t) => t.cacheKey.like(pattern))).write(const ApiCacheCompanion(pinned: Value(false)));
|
||||
}
|
||||
|
||||
/// True when at least one pinned row matches [pattern].
|
||||
Future<bool> hasPinnedMatching(String pattern) async {
|
||||
final rows = await (_db.select(_db.apiCache)..where((t) => t.cacheKey.like(pattern) & t.pinned.equals(true))).get();
|
||||
return rows.isNotEmpty;
|
||||
}
|
||||
|
||||
/// Pull pinned rows for [serverId] and extract the first capture group of
|
||||
/// [keyPattern] from each `cacheKey`. Returns the unique set of captured
|
||||
/// ids — backend subclasses use this to enumerate their pinned items
|
||||
/// (Plex ratingKeys, Jellyfin item ids).
|
||||
Future<Set<String>> extractPinnedIds(String serverId, RegExp keyPattern) async {
|
||||
final rows = await (_db.select(
|
||||
_db.apiCache,
|
||||
)..where((t) => t.cacheKey.like('$serverId:%') & t.pinned.equals(true))).get();
|
||||
final ids = <String>{};
|
||||
for (final row in rows) {
|
||||
final match = keyPattern.firstMatch(row.cacheKey);
|
||||
if (match != null) ids.add(match.group(1)!);
|
||||
}
|
||||
return ids;
|
||||
}
|
||||
|
||||
/// Walk every pinned row, extract `(serverId, capturedId, rawData)` tuples
|
||||
/// from rows whose `cacheKey` matches [keyPattern]. The serverId is parsed
|
||||
/// from the prefix before the first colon. Backend subclasses use this to
|
||||
/// batch-load all pinned metadata into their own model type without
|
||||
/// re-implementing the row walker.
|
||||
Future<List<({String serverId, String id, String data})>> listPinnedRowsByPattern(RegExp keyPattern) async {
|
||||
final rows = await (_db.select(_db.apiCache)..where((t) => t.pinned.equals(true))).get();
|
||||
final out = <({String serverId, String id, String data})>[];
|
||||
for (final row in rows) {
|
||||
final colon = row.cacheKey.indexOf(':');
|
||||
if (colon < 0) continue;
|
||||
final match = keyPattern.firstMatch(row.cacheKey);
|
||||
if (match == null) continue;
|
||||
out.add((serverId: row.cacheKey.substring(0, colon), id: match.group(1)!, data: row.data));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// ── Backend-shape operations ──────────────────────────────────────
|
||||
// These are implemented by the per-backend subclasses so callers can
|
||||
// dispatch via [forBackend(backend).getMetadata(...)] without an outer
|
||||
// `switch (backend)` at every call site.
|
||||
|
||||
/// Fetch and parse cached [MediaItem] for [itemId] on [serverId]. Returns
|
||||
/// `null` when the item isn't cached.
|
||||
Future<MediaItem?> getMetadata(String serverId, String itemId);
|
||||
|
||||
/// Pin the cached metadata row(s) for [itemId] so they survive cache
|
||||
/// eviction (used by the offline-download pipeline).
|
||||
Future<void> pinForOffline(String serverId, String itemId);
|
||||
|
||||
/// Delete cached metadata for [itemId] (used when removing a download).
|
||||
Future<void> deleteForItem(String serverId, String itemId);
|
||||
|
||||
/// Persist a watched/unwatched flip into the cached metadata JSON for
|
||||
/// [itemId] so reloads (`getMetadata` / `getAllPinnedMetadata`) reflect the
|
||||
/// state without having to refetch from the server. No-op when the row
|
||||
/// isn't cached. Backend subclasses know which JSON fields to mutate
|
||||
/// (Plex `viewCount`, Jellyfin `UserData.PlayCount` / `Played`).
|
||||
///
|
||||
/// Optional positional progress fields ([viewOffsetMs], [lastViewedAt],
|
||||
/// [viewedLeafCount]) let the offline-watch-sync service mirror richer
|
||||
/// snapshots from the server's episode-list response without having to
|
||||
/// fall back to a per-backend mutation. When omitted, the watched flip
|
||||
/// uses the same defaults as before (zero-out `viewOffset`, stamp
|
||||
/// `lastViewedAt` only when transitioning to watched).
|
||||
///
|
||||
/// **Drift discipline:** the inputs are backend-neutral but the JSON
|
||||
/// shape + units are not. Adding a new watch-state input here means
|
||||
/// updating *both* concrete impls ([PlexApiCache.applyWatchState],
|
||||
/// [JellyfinApiCache.applyWatchState]) — Plex stores epoch-seconds and
|
||||
/// flat fields, Jellyfin stores ISO-8601 + ticks under `UserData`.
|
||||
/// The mutations are too short (~3 lines per backend) for a shared
|
||||
/// adapter to be a net win, so they live duplicated by design.
|
||||
Future<void> applyWatchState({
|
||||
required String serverId,
|
||||
required String itemId,
|
||||
required bool isWatched,
|
||||
int? viewOffsetMs,
|
||||
int? lastViewedAt,
|
||||
int? viewedLeafCount,
|
||||
});
|
||||
|
||||
/// Bulk-load every pinned metadata row into a [MediaItem] map keyed by
|
||||
/// `buildGlobalKey(serverId, itemId)`. Used by [DownloadManagerService] on
|
||||
/// cold start to hydrate offline state in a single query per backend.
|
||||
Future<Map<String, MediaItem>> getAllPinnedMetadata();
|
||||
}
|
||||
Reference in New Issue
Block a user