dtourolle/WatchedTogether
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity

Fix watched-state sync so members' Next Up and Continue Watching follow

Browse Source 
Synced rows only ever had the Played flag set. Jellyfin computes Next Up
from LastPlayedDate on the member's own row and Continue Watching from
the resume position, so a member watching through the shared account got
the tick on each episode but their Next Up never advanced. Members are
now written the way BaseItem.MarkPlayed/MarkUnplayed write: date and
position included. Rows the old version ticked without a date are
repaired the next time the item syncs.

PlaybackFinished was also treated as an unwatched toggle. Jellyfin raises
it on every stop, not just completion (and on 10.11 PlaybackStart resets
Played to false first), so a stop halfway through on the shared account
cleared members' own watched state whenever Sync unwatched was on.
Playback-derived reasons (PlaybackFinished, PlaybackProgress,
UpdateUserData) now only ever mirror "watched"; TogglePlayed and Import
remain explicit and mirror either way. PlaybackProgress is acted on so
the tick lands as soon as the completion threshold is crossed, including
for clients that never report a stop.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
dtourolle
2026-09-19 10:36:11 +02:00
co-authored by Claude Opus 5
parent a2ffbb3efe
commit 8ad727d870
3 changed files with 214 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Jellyfin.Plugin.WatchedTogether/Services/WatchedStateSyncService.cs
+73 -11
View File
@@ -70,9 +70,17 @@ public sealed class WatchedStateSyncService : IHostedService, IDisposable
/// Mirrors a shared account's played state onto its members.
/// </summary>
/// <remarks>
/// <para>
/// No loop guard is needed. Writing to a member raises this event again with that member's id,
/// which is not a shared account id, so the handler returns immediately. The
/// <c>Played</c> equality check below suppresses redundant writes on top of that.
/// </para>
/// <para>
/// A member is written the same way Jellyfin's own <c>BaseItem.MarkPlayed</c> and
/// <c>MarkUnplayed</c> write, not just the <c>Played</c> flag. Next Up is driven entirely by
/// <c>LastPlayedDate</c> on the member's own row, so a tick without a date leaves the member's
/// Next Up stuck; and a stale resume position would keep the item in Continue Watching.
/// </para>
/// </remarks>
private void OnUserDataSaved(object? sender, UserDataSaveEventArgs e)
{
@@ -81,11 +89,8 @@ public sealed class WatchedStateSyncService : IHostedService, IDisposable
return;
}
// UserDataSaved fires constantly during playback (progress ticks); only act on the reasons
// that actually represent a change in watched state.
if (e.SaveReason is not (UserDataSaveReason.PlaybackFinished
or UserDataSaveReason.TogglePlayed
or UserDataSaveReason.Import))
var played = e.UserData.Played;
if (!IsWatchedStateChange(e.SaveReason, played))
{
return;
}
@@ -96,7 +101,6 @@ public sealed class WatchedStateSyncService : IHostedService, IDisposable
return;
}
var played = e.UserData.Played;
if (!played && !group.SyncUnwatched)
{
return;
@@ -107,16 +111,36 @@ public sealed class WatchedStateSyncService : IHostedService, IDisposable
try
{
var data = _userDataManager.GetUserData(member, e.Item);
if (data is null || data.Played == played)
if (data is null)
{
continue;
}
data.Played = played;
if (group.SyncPlayCount && played && data.PlayCount < 1)
// Rows written by earlier versions carry the tick but no date; give those a date
// the next time the item syncs rather than skipping them as already in sync.
if (data.Played == played && (!played || data.LastPlayedDate.HasValue))
{
data.PlayCount = 1;
continue;
}
if (played)
{
data.Played = true;
data.PlaybackPositionTicks = 0;
data.LastPlayedDate = e.UserData.LastPlayedDate ?? DateTime.UtcNow;
if (group.SyncPlayCount && data.PlayCount < 1)
{
data.PlayCount = 1;
}
}
else
{
// Same as Jellyfin's MarkUnplayed, except the play count is left alone: it is
// documented as never decreasing.
data.Played = false;
data.PlaybackPositionTicks = 0;
data.LastPlayedDate = null;
}
_userDataManager.SaveUserData(
@@ -144,4 +168,42 @@ public sealed class WatchedStateSyncService : IHostedService, IDisposable
}
}
}
/// <summary>
/// Decides whether a save represents a change in watched state worth mirroring.
/// </summary>
/// <remarks>
/// <para>
/// <see cref="UserDataSaveReason.TogglePlayed"/> and <see cref="UserDataSaveReason.Import"/>
/// are explicit: someone set the flag, so whatever it says is mirrored, unwatched included.
/// </para>
/// <para>
/// The rest only ever mean "watched" when <paramref name="played"/> is true. Jellyfin raises
/// <see cref="UserDataSaveReason.PlaybackFinished"/> on every stop, not just on completion, so
/// a stop before the completion threshold leaves <c>Played</c> false without anybody having
/// marked anything unwatched - and on 10.11 <c>PlaybackStart</c> resets it to false as well.
/// Mirroring that would clear members' own watched state. Likewise
/// <see cref="UserDataSaveReason.UpdateUserData"/> is a partial update (a favourite toggle
/// arrives with the same reason) where a false flag need not mean a change at all.
/// </para>
/// <para>
/// <see cref="UserDataSaveReason.PlaybackProgress"/> is included so the tick lands as soon as
/// the completion threshold is crossed, and still lands for clients that never report a stop.
/// The equality check in the handler keeps the remaining progress ticks write-free.
/// </para>
/// </remarks>
/// <param name="reason">Why the user data was saved.</param>
/// <param name="played">The played flag on the saved user data.</param>
/// <returns><c>true</c> if the save should be mirrored to members.</returns>
private static bool IsWatchedStateChange(UserDataSaveReason reason, bool played)
{
return reason switch
{
UserDataSaveReason.TogglePlayed or UserDataSaveReason.Import => true,
UserDataSaveReason.PlaybackFinished
or UserDataSaveReason.PlaybackProgress
or UserDataSaveReason.UpdateUserData => played,
_ => false,
};
}
}