edde746
5f397a99d9
Pausing an episode on one device, finishing it on another and pressing Refresh left the first device showing the old "minutes left". Restarting the app showed the right value. Two independent defects produce that, and either alone reproduces the report. The first is the watch-state overlay. Every local watch event lands in WatchStateStore as a patch, and WatchStateSnapshot.apply overwrites viewOffsetMs unconditionally; isNewerThan only ever orders one patch against another, never against the server row underneath. Nothing expires a patch and nothing clears the map except a profile switch, so the Mac's own paused position kept winning over every subsequent fetch until the process died. A patch exists to bridge the gap between a local action and the next server read of that item, so it should stop applying once that read happens. The store now records the watermark at which a successful authoritative response returned each key, and suppresses an acknowledged session patch at or below it. Only a watermark is stored, never the observed state: WatchStateSnapshot cannot hold a container's leaf counts, and keeping max() per key makes the order two concurrent responses complete irrelevant. Suppression is a read-time predicate, so nothing mutates during build. The barrier covers the parentChain too. patchForItem picks the newest of the item's own entry and its ancestors', so retiring only the item's entry would let an older season mark win and render watched/0 -- worse than either the stale value or the fresh one. An authoritative read of a child already reflects any container mark that preceded it, so the child's observation judges its ancestors as well; a newer container action still wins. Provenance decides what may be suppressed at all. WatchStateEvent now carries serverAcknowledged, defaulting to false so an unclassified emit site degrades to today's behaviour rather than silently becoming retireable. An offline write is owed to the server and a read must never retire it, so it stays until a WatchPatchPromotionNotifier promotion says the queue replayed it. That channel is deliberately not a WatchStateEvent: OfflineWatchSyncService reacts to watched/unwatched by purging queued progress, so replaying one there would delete a newer rewatch. Promotion matches an exact WatchPatchId -- session minted for live crossings, derived from the persisted (profile, row, revision) for queued ones so it still joins after a restart. Report acceptance is not delivery: PlaybackReportSession resolves true for a same-state startup heartbeat it drops, so acknowledgement now keys on onDelivered. A MediaBrowser Started saves play count and last-played date but not the position, so it cannot acknowledge an offset. No report-derived watched crossing is acknowledged on any backend -- Jellyfin hard-codes its threshold and Plex never loads the server pref that would tell it the real one -- so only an awaited explicit markWatched settles one. The second defect is that a failed Refresh reported success. Plex _fetchHubs and the Jellyfin hub legs both degrade a failure to an empty list, and the library prefetch discarded its failures, so a server whose every hub request failed was recorded as succeeded; DiscoverProvider then kept the previous rows, set loaded and surfaced nothing. Worse, the background Continue Watching refresh wiped the row outright on zero success. Hub legs now report what they degraded through a HubFetchDiagnostics sink, which keeps partial rows alongside the failure and leaves every existing caller untouched. Failures ride through the aggregation results, a leg that could not run because discovery failed contributes that failure rather than a successful no-op, and loaded-server ids became succeeded - failed - cancelled so one bad leg no longer caches a server as covered and blocks its retry. The toolbar awaits a DiscoverRefreshOutcome and shows the existing unableToLoad snackbar on failure while the retained rows stay on screen. Rollback after a mid-pass exception is version-guarded, refilters against the current hidden libraries and no longer publishes a system shelf the pass never committed. Observations are staged with the pass and flushed only once the same disposal, generation and exception checks that authorise committing those rows have passed, so a discarded or rolled-back response can never suppress a patch. Also fixes a live data-loss race the promotion work would have built on: upsertProgressAction stamped a millisecond timestamp and updated the row in place, so a rewatch queued during an in-flight replay was deleted by id. Revisions are now strictly monotonic per row, replay deletes and retry updates compare against them, and the upsert resets the retry fields because a new revision is a new logical action. close #1829
89 lines
3.2 KiB
Dart
89 lines
3.2 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
import '../media/ids.dart';
|
|
import '../media/media_item.dart';
|
|
import '../media/media_server_client.dart';
|
|
import '../providers/offline_mode_provider.dart';
|
|
import '../providers/offline_watch_provider.dart';
|
|
import '../utils/provider_extensions.dart';
|
|
import '../utils/watch_state_notifier.dart';
|
|
import 'trackers/tracker_coordinator.dart';
|
|
|
|
enum WatchMarkOutcome {
|
|
/// Queued for later sync (offline). The offline provider emitted the event.
|
|
queuedOffline,
|
|
|
|
/// Marked on the server; event emitted, trackers fired.
|
|
marked,
|
|
|
|
/// Nothing to do (no server id / no bound client).
|
|
skipped,
|
|
}
|
|
|
|
/// Orchestrates watched/unwatched marks: routes offline marks to the offline
|
|
/// queue, online marks to the backend client, emits the single
|
|
/// [WatchStateNotifier] event, and fires trackers. UI surfaces call this
|
|
/// instead of hand-rolling the offline/online + tracker dance; snackbars and
|
|
/// refresh callbacks stay with the caller. Client `markWatched`/`markUnwatched`
|
|
/// are transport-only — they must never be called directly from UI code.
|
|
class WatchActions {
|
|
WatchActions._();
|
|
|
|
/// Marks [item] watched/unwatched. [offline] overrides the
|
|
/// [OfflineModeProvider] read for callers that already know (e.g. screens
|
|
/// rendering downloaded content).
|
|
static Future<WatchMarkOutcome> setWatched(
|
|
BuildContext context,
|
|
MediaItem item, {
|
|
required bool watched,
|
|
bool? offline,
|
|
}) async {
|
|
final isOffline = offline ?? context.read<OfflineModeProvider>().isOffline;
|
|
final serverId = item.serverId;
|
|
|
|
if (isOffline && serverId != null) {
|
|
final offlineWatch = context.read<OfflineWatchProvider>();
|
|
if (watched) {
|
|
await offlineWatch.markAsWatched(serverId: ServerId(serverId), itemId: item.id);
|
|
} else {
|
|
await offlineWatch.markAsUnwatched(serverId: ServerId(serverId), itemId: item.id);
|
|
}
|
|
return WatchMarkOutcome.queuedOffline;
|
|
}
|
|
|
|
if (serverId == null) return WatchMarkOutcome.skipped;
|
|
final client = context.tryGetMediaClientForServer(ServerId(serverId));
|
|
if (client == null) return WatchMarkOutcome.skipped;
|
|
|
|
if (watched) {
|
|
await client.markWatched(item);
|
|
} else {
|
|
await client.markUnwatched(item);
|
|
}
|
|
WatchStateNotifier().notifyWatched(
|
|
item: item,
|
|
isNowWatched: watched,
|
|
cacheServerId: client.cacheServerId,
|
|
serverAcknowledged: true,
|
|
);
|
|
unawaited(
|
|
watched
|
|
? TrackerCoordinator.instance.markWatched(item, client)
|
|
: TrackerCoordinator.instance.markUnwatched(item, client),
|
|
);
|
|
return WatchMarkOutcome.marked;
|
|
}
|
|
|
|
/// Removes [item] from Continue Watching without touching watch state.
|
|
/// Throws when no client is bound for the item's server (mirrors the
|
|
/// pre-existing menu behaviour so callers surface an error snackbar).
|
|
static Future<void> removeFromContinueWatching(BuildContext context, MediaItem item) async {
|
|
final client = context.getMediaClientForServer(ServerId(item.serverId!));
|
|
await client.removeFromContinueWatching(item);
|
|
WatchStateNotifier().notifyRemovedFromContinueWatching(item: item);
|
|
}
|
|
}
|