< Summary - Jellyfin

Information
Class: Jellyfin.Api.Controllers.PlaystateController
Assembly: Jellyfin.Api
File(s): /srv/git/jellyfin/Jellyfin.Api/Controllers/PlaystateController.cs
Line coverage
56%
Covered lines: 14
Uncovered lines: 11
Coverable lines: 25
Total lines: 535
Line coverage: 56%
Branch coverage
0%
Covered branches: 0
Total branches: 8
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
PingPlaybackSession(...)100%210%
UpdatePlayedStatus(...)0%620%
ValidatePlayMethod(...)0%4260%

File(s)

/srv/git/jellyfin/Jellyfin.Api/Controllers/PlaystateController.cs

#LineLine coverage
 1using System;
 2using System.ComponentModel.DataAnnotations;
 3using System.Diagnostics.CodeAnalysis;
 4using System.Threading.Tasks;
 5using Jellyfin.Api.Extensions;
 6using Jellyfin.Api.Helpers;
 7using Jellyfin.Api.ModelBinders;
 8using Jellyfin.Database.Implementations.Entities;
 9using Jellyfin.Extensions;
 10using MediaBrowser.Controller.Entities;
 11using MediaBrowser.Controller.Library;
 12using MediaBrowser.Controller.MediaEncoding;
 13using MediaBrowser.Controller.Session;
 14using MediaBrowser.Model.Dto;
 15using MediaBrowser.Model.Session;
 16using Microsoft.AspNetCore.Authorization;
 17using Microsoft.AspNetCore.Http;
 18using Microsoft.AspNetCore.Mvc;
 19using Microsoft.Extensions.Logging;
 20
 21namespace Jellyfin.Api.Controllers;
 22
 23/// <summary>
 24/// Playstate controller.
 25/// </summary>
 26[Route("")]
 27[Authorize]
 28public class PlaystateController : BaseJellyfinApiController
 29{
 30    private readonly IUserManager _userManager;
 31    private readonly IUserDataManager _userDataRepository;
 32    private readonly ILibraryManager _libraryManager;
 33    private readonly ISessionManager _sessionManager;
 34    private readonly ILogger<PlaystateController> _logger;
 35    private readonly ITranscodeManager _transcodeManager;
 36
 37    /// <summary>
 38    /// Initializes a new instance of the <see cref="PlaystateController"/> class.
 39    /// </summary>
 40    /// <param name="userManager">Instance of the <see cref="IUserManager"/> interface.</param>
 41    /// <param name="userDataRepository">Instance of the <see cref="IUserDataManager"/> interface.</param>
 42    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
 43    /// <param name="sessionManager">Instance of the <see cref="ISessionManager"/> interface.</param>
 44    /// <param name="loggerFactory">Instance of the <see cref="ILoggerFactory"/> interface.</param>
 45    /// <param name="transcodeManager">Instance of the <see cref="ITranscodeManager"/> interface.</param>
 446    public PlaystateController(
 447        IUserManager userManager,
 448        IUserDataManager userDataRepository,
 449        ILibraryManager libraryManager,
 450        ISessionManager sessionManager,
 451        ILoggerFactory loggerFactory,
 452        ITranscodeManager transcodeManager)
 53    {
 454        _userManager = userManager;
 455        _userDataRepository = userDataRepository;
 456        _libraryManager = libraryManager;
 457        _sessionManager = sessionManager;
 458        _logger = loggerFactory.CreateLogger<PlaystateController>();
 59
 460        _transcodeManager = transcodeManager;
 461    }
 62
 63    /// <summary>
 64    /// Marks an item as played for user.
 65    /// </summary>
 66    /// <param name="userId">User id.</param>
 67    /// <param name="itemId">Item id.</param>
 68    /// <param name="datePlayed">Optional. The date the item was played.</param>
 69    /// <response code="200">Item marked as played.</response>
 70    /// <response code="404">Item not found.</response>
 71    /// <returns>An <see cref="OkResult"/> containing the <see cref="UserItemDataDto"/>, or a <see cref="NotFoundResult"
 72    [HttpPost("UserPlayedItems/{itemId}")]
 73    [ProducesResponseType(StatusCodes.Status200OK)]
 74    [ProducesResponseType(StatusCodes.Status404NotFound)]
 75    public async Task<ActionResult<UserItemDataDto?>> MarkPlayedItem(
 76        [FromQuery] Guid? userId,
 77        [FromRoute, Required] Guid itemId,
 78        [FromQuery, ModelBinder(typeof(LegacyDateTimeModelBinder))] DateTime? datePlayed)
 79    {
 80        userId = RequestHelpers.GetUserId(User, userId);
 81        var user = _userManager.GetUserById(userId.Value);
 82        if (user is null)
 83        {
 84            return NotFound();
 85        }
 86
 87        var item = _libraryManager.GetItemById<BaseItem>(itemId, user);
 88        if (item is null)
 89        {
 90            return NotFound();
 91        }
 92
 93        var session = await RequestHelpers.GetSession(_sessionManager, _userManager, HttpContext, userId).ConfigureAwait
 94
 95        var dto = UpdatePlayedStatus(user, item, true, datePlayed);
 96        foreach (var additionalUserInfo in session.AdditionalUsers)
 97        {
 98            var additionalUser = _userManager.GetUserById(additionalUserInfo.UserId);
 99            if (additionalUser is null)
 100            {
 101                return NotFound();
 102            }
 103
 104            UpdatePlayedStatus(additionalUser, item, true, datePlayed);
 105        }
 106
 107        return dto;
 108    }
 109
 110    /// <summary>
 111    /// Marks an item as played for user.
 112    /// </summary>
 113    /// <param name="userId">User id.</param>
 114    /// <param name="itemId">Item id.</param>
 115    /// <param name="datePlayed">Optional. The date the item was played.</param>
 116    /// <response code="200">Item marked as played.</response>
 117    /// <response code="404">Item not found.</response>
 118    /// <returns>An <see cref="OkResult"/> containing the <see cref="UserItemDataDto"/>, or a <see cref="NotFoundResult"
 119    [HttpPost("Users/{userId}/PlayedItems/{itemId}")]
 120    [ProducesResponseType(StatusCodes.Status200OK)]
 121    [ProducesResponseType(StatusCodes.Status404NotFound)]
 122    [Obsolete("Kept for backwards compatibility")]
 123    [ApiExplorerSettings(IgnoreApi = true)]
 124    public Task<ActionResult<UserItemDataDto?>> MarkPlayedItemLegacy(
 125        [FromRoute, Required] Guid userId,
 126        [FromRoute, Required] Guid itemId,
 127        [FromQuery, ModelBinder(typeof(LegacyDateTimeModelBinder))] DateTime? datePlayed)
 128        => MarkPlayedItem(userId, itemId, datePlayed);
 129
 130    /// <summary>
 131    /// Marks an item as unplayed for user.
 132    /// </summary>
 133    /// <param name="userId">User id.</param>
 134    /// <param name="itemId">Item id.</param>
 135    /// <response code="200">Item marked as unplayed.</response>
 136    /// <response code="404">Item not found.</response>
 137    /// <returns>A <see cref="OkResult"/> containing the <see cref="UserItemDataDto"/>, or a <see cref="NotFoundResult"/
 138    [HttpDelete("UserPlayedItems/{itemId}")]
 139    [ProducesResponseType(StatusCodes.Status200OK)]
 140    [ProducesResponseType(StatusCodes.Status404NotFound)]
 141    public async Task<ActionResult<UserItemDataDto?>> MarkUnplayedItem(
 142        [FromQuery] Guid? userId,
 143        [FromRoute, Required] Guid itemId)
 144    {
 145        userId = RequestHelpers.GetUserId(User, userId);
 146        var user = _userManager.GetUserById(userId.Value);
 147        if (user is null)
 148        {
 149            return NotFound();
 150        }
 151
 152        var item = _libraryManager.GetItemById<BaseItem>(itemId, user);
 153        if (item is null)
 154        {
 155            return NotFound();
 156        }
 157
 158        var session = await RequestHelpers.GetSession(_sessionManager, _userManager, HttpContext, userId).ConfigureAwait
 159
 160        var dto = UpdatePlayedStatus(user, item, false, null);
 161        foreach (var additionalUserInfo in session.AdditionalUsers)
 162        {
 163            var additionalUser = _userManager.GetUserById(additionalUserInfo.UserId);
 164            if (additionalUser is null)
 165            {
 166                return NotFound();
 167            }
 168
 169            UpdatePlayedStatus(additionalUser, item, false, null);
 170        }
 171
 172        return dto;
 173    }
 174
 175    /// <summary>
 176    /// Marks an item as unplayed for user.
 177    /// </summary>
 178    /// <param name="userId">User id.</param>
 179    /// <param name="itemId">Item id.</param>
 180    /// <response code="200">Item marked as unplayed.</response>
 181    /// <response code="404">Item not found.</response>
 182    /// <returns>A <see cref="OkResult"/> containing the <see cref="UserItemDataDto"/>, or a <see cref="NotFoundResult"/
 183    [HttpDelete("Users/{userId}/PlayedItems/{itemId}")]
 184    [ProducesResponseType(StatusCodes.Status200OK)]
 185    [ProducesResponseType(StatusCodes.Status404NotFound)]
 186    [Obsolete("Kept for backwards compatibility")]
 187    [ApiExplorerSettings(IgnoreApi = true)]
 188    public Task<ActionResult<UserItemDataDto?>> MarkUnplayedItemLegacy(
 189        [FromRoute, Required] Guid userId,
 190        [FromRoute, Required] Guid itemId)
 191        => MarkUnplayedItem(userId, itemId);
 192
 193    /// <summary>
 194    /// Reports playback has started within a session.
 195    /// </summary>
 196    /// <param name="playbackStartInfo">The playback start info.</param>
 197    /// <response code="204">Playback start recorded.</response>
 198    /// <returns>A <see cref="NoContentResult"/>.</returns>
 199    [HttpPost("Sessions/Playing")]
 200    [ProducesResponseType(StatusCodes.Status204NoContent)]
 201    public async Task<ActionResult> ReportPlaybackStart([FromBody] PlaybackStartInfo playbackStartInfo)
 202    {
 203        playbackStartInfo.PlayMethod = ValidatePlayMethod(playbackStartInfo.PlayMethod, playbackStartInfo.PlaySessionId)
 204        playbackStartInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Conf
 205        await _sessionManager.OnPlaybackStart(playbackStartInfo).ConfigureAwait(false);
 206        return NoContent();
 207    }
 208
 209    /// <summary>
 210    /// Reports playback progress within a session.
 211    /// </summary>
 212    /// <param name="playbackProgressInfo">The playback progress info.</param>
 213    /// <response code="204">Playback progress recorded.</response>
 214    /// <returns>A <see cref="NoContentResult"/>.</returns>
 215    [HttpPost("Sessions/Playing/Progress")]
 216    [ProducesResponseType(StatusCodes.Status204NoContent)]
 217    public async Task<ActionResult> ReportPlaybackProgress([FromBody] PlaybackProgressInfo playbackProgressInfo)
 218    {
 219        playbackProgressInfo.PlayMethod = ValidatePlayMethod(playbackProgressInfo.PlayMethod, playbackProgressInfo.PlayS
 220        playbackProgressInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).C
 221        await _sessionManager.OnPlaybackProgress(playbackProgressInfo).ConfigureAwait(false);
 222        return NoContent();
 223    }
 224
 225    /// <summary>
 226    /// Pings a playback session.
 227    /// </summary>
 228    /// <param name="playSessionId">Playback session id.</param>
 229    /// <response code="204">Playback session pinged.</response>
 230    /// <returns>A <see cref="NoContentResult"/>.</returns>
 231    [HttpPost("Sessions/Playing/Ping")]
 232    [ProducesResponseType(StatusCodes.Status204NoContent)]
 233    public ActionResult PingPlaybackSession([FromQuery, Required] string playSessionId)
 234    {
 0235        _transcodeManager.PingTranscodingJob(playSessionId, null);
 0236        return NoContent();
 237    }
 238
 239    /// <summary>
 240    /// Reports playback has stopped within a session.
 241    /// </summary>
 242    /// <param name="playbackStopInfo">The playback stop info.</param>
 243    /// <response code="204">Playback stop recorded.</response>
 244    /// <returns>A <see cref="NoContentResult"/>.</returns>
 245    [HttpPost("Sessions/Playing/Stopped")]
 246    [ProducesResponseType(StatusCodes.Status204NoContent)]
 247    public async Task<ActionResult> ReportPlaybackStopped([FromBody] PlaybackStopInfo playbackStopInfo)
 248    {
 249        _logger.LogDebug("ReportPlaybackStopped PlaySessionId: {0}", playbackStopInfo.PlaySessionId ?? string.Empty);
 250        if (!string.IsNullOrWhiteSpace(playbackStopInfo.PlaySessionId))
 251        {
 252            await _transcodeManager.KillTranscodingJobs(User.GetDeviceId()!, playbackStopInfo.PlaySessionId, s => true).
 253        }
 254
 255        playbackStopInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Confi
 256        await _sessionManager.OnPlaybackStopped(playbackStopInfo).ConfigureAwait(false);
 257        return NoContent();
 258    }
 259
 260    /// <summary>
 261    /// Reports that a session has begun playing an item.
 262    /// </summary>
 263    /// <param name="itemId">Item id.</param>
 264    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 265    /// <param name="audioStreamIndex">The audio stream index.</param>
 266    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 267    /// <param name="playMethod">The play method.</param>
 268    /// <param name="liveStreamId">The live stream id.</param>
 269    /// <param name="playSessionId">The play session id.</param>
 270    /// <param name="canSeek">Indicates if the client can seek.</param>
 271    /// <response code="204">Play start recorded.</response>
 272    /// <returns>A <see cref="NoContentResult"/>.</returns>
 273    [HttpPost("PlayingItems/{itemId}")]
 274    [ProducesResponseType(StatusCodes.Status204NoContent)]
 275    [Obsolete("This endpoint is obsolete. Use ReportPlaybackStart instead")]
 276    public async Task<ActionResult> OnPlaybackStart(
 277        [FromRoute, Required] Guid itemId,
 278        [FromQuery] string? mediaSourceId,
 279        [FromQuery] int? audioStreamIndex,
 280        [FromQuery] int? subtitleStreamIndex,
 281        [FromQuery] PlayMethod? playMethod,
 282        [FromQuery] string? liveStreamId,
 283        [FromQuery] string? playSessionId,
 284        [FromQuery] bool canSeek = false)
 285    {
 286        var playbackStartInfo = new PlaybackStartInfo
 287        {
 288            CanSeek = canSeek,
 289            ItemId = itemId,
 290            MediaSourceId = mediaSourceId,
 291            AudioStreamIndex = audioStreamIndex,
 292            SubtitleStreamIndex = subtitleStreamIndex,
 293            PlayMethod = playMethod ?? PlayMethod.Transcode,
 294            PlaySessionId = playSessionId,
 295            LiveStreamId = liveStreamId
 296        };
 297
 298        playbackStartInfo.PlayMethod = ValidatePlayMethod(playbackStartInfo.PlayMethod, playbackStartInfo.PlaySessionId)
 299        playbackStartInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Conf
 300        await _sessionManager.OnPlaybackStart(playbackStartInfo).ConfigureAwait(false);
 301        return NoContent();
 302    }
 303
 304    /// <summary>
 305    /// Reports that a user has begun playing an item.
 306    /// </summary>
 307    /// <param name="userId">User id.</param>
 308    /// <param name="itemId">Item id.</param>
 309    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 310    /// <param name="audioStreamIndex">The audio stream index.</param>
 311    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 312    /// <param name="playMethod">The play method.</param>
 313    /// <param name="liveStreamId">The live stream id.</param>
 314    /// <param name="playSessionId">The play session id.</param>
 315    /// <param name="canSeek">Indicates if the client can seek.</param>
 316    /// <response code="204">Play start recorded.</response>
 317    /// <returns>A <see cref="NoContentResult"/>.</returns>
 318    [HttpPost("Users/{userId}/PlayingItems/{itemId}")]
 319    [ProducesResponseType(StatusCodes.Status204NoContent)]
 320    [Obsolete("Kept for backwards compatibility")]
 321    [ApiExplorerSettings(IgnoreApi = true)]
 322    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 323    public Task<ActionResult> OnPlaybackStartLegacy(
 324        [FromRoute, Required] Guid userId,
 325        [FromRoute, Required] Guid itemId,
 326        [FromQuery] string? mediaSourceId,
 327        [FromQuery] int? audioStreamIndex,
 328        [FromQuery] int? subtitleStreamIndex,
 329        [FromQuery] PlayMethod? playMethod,
 330        [FromQuery] string? liveStreamId,
 331        [FromQuery] string? playSessionId,
 332        [FromQuery] bool canSeek = false)
 333        => OnPlaybackStart(itemId, mediaSourceId, audioStreamIndex, subtitleStreamIndex, playMethod, liveStreamId, playS
 334
 335    /// <summary>
 336    /// Reports a session's playback progress.
 337    /// </summary>
 338    /// <param name="itemId">Item id.</param>
 339    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 340    /// <param name="positionTicks">Optional. The current position, in ticks. 1 tick = 10000 ms.</param>
 341    /// <param name="audioStreamIndex">The audio stream index.</param>
 342    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 343    /// <param name="volumeLevel">Scale of 0-100.</param>
 344    /// <param name="playMethod">The play method.</param>
 345    /// <param name="liveStreamId">The live stream id.</param>
 346    /// <param name="playSessionId">The play session id.</param>
 347    /// <param name="repeatMode">The repeat mode.</param>
 348    /// <param name="isPaused">Indicates if the player is paused.</param>
 349    /// <param name="isMuted">Indicates if the player is muted.</param>
 350    /// <response code="204">Play progress recorded.</response>
 351    /// <returns>A <see cref="NoContentResult"/>.</returns>
 352    [HttpPost("PlayingItems/{itemId}/Progress")]
 353    [ProducesResponseType(StatusCodes.Status204NoContent)]
 354    [Obsolete("This endpoint is obsolete. Use ReportPlaybackProgress instead")]
 355    public async Task<ActionResult> OnPlaybackProgress(
 356        [FromRoute, Required] Guid itemId,
 357        [FromQuery] string? mediaSourceId,
 358        [FromQuery] long? positionTicks,
 359        [FromQuery] int? audioStreamIndex,
 360        [FromQuery] int? subtitleStreamIndex,
 361        [FromQuery] int? volumeLevel,
 362        [FromQuery] PlayMethod? playMethod,
 363        [FromQuery] string? liveStreamId,
 364        [FromQuery] string? playSessionId,
 365        [FromQuery] RepeatMode? repeatMode,
 366        [FromQuery] bool isPaused = false,
 367        [FromQuery] bool isMuted = false)
 368    {
 369        var playbackProgressInfo = new PlaybackProgressInfo
 370        {
 371            ItemId = itemId,
 372            PositionTicks = positionTicks,
 373            IsMuted = isMuted,
 374            IsPaused = isPaused,
 375            MediaSourceId = mediaSourceId,
 376            AudioStreamIndex = audioStreamIndex,
 377            SubtitleStreamIndex = subtitleStreamIndex,
 378            VolumeLevel = volumeLevel,
 379            PlayMethod = playMethod ?? PlayMethod.Transcode,
 380            PlaySessionId = playSessionId,
 381            LiveStreamId = liveStreamId,
 382            RepeatMode = repeatMode ?? RepeatMode.RepeatNone
 383        };
 384
 385        playbackProgressInfo.PlayMethod = ValidatePlayMethod(playbackProgressInfo.PlayMethod, playbackProgressInfo.PlayS
 386        playbackProgressInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).C
 387        await _sessionManager.OnPlaybackProgress(playbackProgressInfo).ConfigureAwait(false);
 388        return NoContent();
 389    }
 390
 391    /// <summary>
 392    /// Reports a user's playback progress.
 393    /// </summary>
 394    /// <param name="userId">User id.</param>
 395    /// <param name="itemId">Item id.</param>
 396    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 397    /// <param name="positionTicks">Optional. The current position, in ticks. 1 tick = 10000 ms.</param>
 398    /// <param name="audioStreamIndex">The audio stream index.</param>
 399    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 400    /// <param name="volumeLevel">Scale of 0-100.</param>
 401    /// <param name="playMethod">The play method.</param>
 402    /// <param name="liveStreamId">The live stream id.</param>
 403    /// <param name="playSessionId">The play session id.</param>
 404    /// <param name="repeatMode">The repeat mode.</param>
 405    /// <param name="isPaused">Indicates if the player is paused.</param>
 406    /// <param name="isMuted">Indicates if the player is muted.</param>
 407    /// <response code="204">Play progress recorded.</response>
 408    /// <returns>A <see cref="NoContentResult"/>.</returns>
 409    [HttpPost("Users/{userId}/PlayingItems/{itemId}/Progress")]
 410    [ProducesResponseType(StatusCodes.Status204NoContent)]
 411    [Obsolete("Kept for backwards compatibility")]
 412    [ApiExplorerSettings(IgnoreApi = true)]
 413    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 414    public Task<ActionResult> OnPlaybackProgressLegacy(
 415        [FromRoute, Required] Guid userId,
 416        [FromRoute, Required] Guid itemId,
 417        [FromQuery] string? mediaSourceId,
 418        [FromQuery] long? positionTicks,
 419        [FromQuery] int? audioStreamIndex,
 420        [FromQuery] int? subtitleStreamIndex,
 421        [FromQuery] int? volumeLevel,
 422        [FromQuery] PlayMethod? playMethod,
 423        [FromQuery] string? liveStreamId,
 424        [FromQuery] string? playSessionId,
 425        [FromQuery] RepeatMode? repeatMode,
 426        [FromQuery] bool isPaused = false,
 427        [FromQuery] bool isMuted = false)
 428        => OnPlaybackProgress(itemId, mediaSourceId, positionTicks, audioStreamIndex, subtitleStreamIndex, volumeLevel, 
 429
 430    /// <summary>
 431    /// Reports that a session has stopped playing an item.
 432    /// </summary>
 433    /// <param name="itemId">Item id.</param>
 434    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 435    /// <param name="nextMediaType">The next media type that will play.</param>
 436    /// <param name="positionTicks">Optional. The position, in ticks, where playback stopped. 1 tick = 10000 ms.</param>
 437    /// <param name="liveStreamId">The live stream id.</param>
 438    /// <param name="playSessionId">The play session id.</param>
 439    /// <response code="204">Playback stop recorded.</response>
 440    /// <returns>A <see cref="NoContentResult"/>.</returns>
 441    [HttpDelete("PlayingItems/{itemId}")]
 442    [ProducesResponseType(StatusCodes.Status204NoContent)]
 443    [Obsolete("This endpoint is obsolete. Use ReportPlaybackStop instead")]
 444    public async Task<ActionResult> OnPlaybackStopped(
 445        [FromRoute, Required] Guid itemId,
 446        [FromQuery] string? mediaSourceId,
 447        [FromQuery] string? nextMediaType,
 448        [FromQuery] long? positionTicks,
 449        [FromQuery] string? liveStreamId,
 450        [FromQuery] string? playSessionId)
 451    {
 452        var playbackStopInfo = new PlaybackStopInfo
 453        {
 454            ItemId = itemId,
 455            PositionTicks = positionTicks,
 456            MediaSourceId = mediaSourceId,
 457            PlaySessionId = playSessionId,
 458            LiveStreamId = liveStreamId,
 459            NextMediaType = nextMediaType
 460        };
 461
 462        _logger.LogDebug("ReportPlaybackStopped PlaySessionId: {0}", playbackStopInfo.PlaySessionId ?? string.Empty);
 463        if (!string.IsNullOrWhiteSpace(playbackStopInfo.PlaySessionId))
 464        {
 465            await _transcodeManager.KillTranscodingJobs(User.GetDeviceId()!, playbackStopInfo.PlaySessionId, s => true).
 466        }
 467
 468        playbackStopInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Confi
 469        await _sessionManager.OnPlaybackStopped(playbackStopInfo).ConfigureAwait(false);
 470        return NoContent();
 471    }
 472
 473    /// <summary>
 474    /// Reports that a user has stopped playing an item.
 475    /// </summary>
 476    /// <param name="userId">User id.</param>
 477    /// <param name="itemId">Item id.</param>
 478    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 479    /// <param name="nextMediaType">The next media type that will play.</param>
 480    /// <param name="positionTicks">Optional. The position, in ticks, where playback stopped. 1 tick = 10000 ms.</param>
 481    /// <param name="liveStreamId">The live stream id.</param>
 482    /// <param name="playSessionId">The play session id.</param>
 483    /// <response code="204">Playback stop recorded.</response>
 484    /// <returns>A <see cref="NoContentResult"/>.</returns>
 485    [HttpDelete("Users/{userId}/PlayingItems/{itemId}")]
 486    [ProducesResponseType(StatusCodes.Status204NoContent)]
 487    [Obsolete("Kept for backwards compatibility")]
 488    [ApiExplorerSettings(IgnoreApi = true)]
 489    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 490    public Task<ActionResult> OnPlaybackStoppedLegacy(
 491        [FromRoute, Required] Guid userId,
 492        [FromRoute, Required] Guid itemId,
 493        [FromQuery] string? mediaSourceId,
 494        [FromQuery] string? nextMediaType,
 495        [FromQuery] long? positionTicks,
 496        [FromQuery] string? liveStreamId,
 497        [FromQuery] string? playSessionId)
 498        => OnPlaybackStopped(itemId, mediaSourceId, nextMediaType, positionTicks, liveStreamId, playSessionId);
 499
 500    /// <summary>
 501    /// Updates the played status.
 502    /// </summary>
 503    /// <param name="user">The user.</param>
 504    /// <param name="item">The item.</param>
 505    /// <param name="wasPlayed">if set to <c>true</c> [was played].</param>
 506    /// <param name="datePlayed">The date played.</param>
 507    /// <returns>Task.</returns>
 508    private UserItemDataDto? UpdatePlayedStatus(User user, BaseItem item, bool wasPlayed, DateTime? datePlayed)
 509    {
 0510        if (wasPlayed)
 511        {
 0512            item.MarkPlayed(user, datePlayed, true);
 513        }
 514        else
 515        {
 0516            item.MarkUnplayed(user);
 517        }
 518
 0519        return _userDataRepository.GetUserDataDto(item, user);
 520    }
 521
 522    private PlayMethod ValidatePlayMethod(PlayMethod method, string? playSessionId)
 523    {
 0524        if (method == PlayMethod.Transcode)
 525        {
 0526            var job = string.IsNullOrWhiteSpace(playSessionId) ? null : _transcodeManager.GetTranscodingJob(playSessionI
 0527            if (job is null)
 528            {
 0529                return PlayMethod.DirectPlay;
 530            }
 531        }
 532
 0533        return method;
 534    }
 535}
Generated by: ReportGenerator 5.4.7.0
5/17/2025 - 12:09:39 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(MediaBrowser.Controller.Library.IUserManager,MediaBrowser.Controller.Library.IUserDataManager,MediaBrowser.Controller.Library.ILibraryManager,MediaBrowser.Controller.Session.ISessionManager,Microsoft.Extensions.Logging.ILoggerFactory,MediaBrowser.Controller.MediaEncoding.ITranscodeManager)
PingPlaybackSession(System.String)
UpdatePlayedStatus(Jellyfin.Database.Implementations.Entities.User,MediaBrowser.Controller.Entities.BaseItem,System.Boolean,System.Nullable`1<System.DateTime>)
ValidatePlayMethod(MediaBrowser.Model.Session.PlayMethod,System.String)