< 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: 532
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    public async Task<ActionResult> OnPlaybackStart(
 276        [FromRoute, Required] Guid itemId,
 277        [FromQuery] string? mediaSourceId,
 278        [FromQuery] int? audioStreamIndex,
 279        [FromQuery] int? subtitleStreamIndex,
 280        [FromQuery] PlayMethod? playMethod,
 281        [FromQuery] string? liveStreamId,
 282        [FromQuery] string? playSessionId,
 283        [FromQuery] bool canSeek = false)
 284    {
 285        var playbackStartInfo = new PlaybackStartInfo
 286        {
 287            CanSeek = canSeek,
 288            ItemId = itemId,
 289            MediaSourceId = mediaSourceId,
 290            AudioStreamIndex = audioStreamIndex,
 291            SubtitleStreamIndex = subtitleStreamIndex,
 292            PlayMethod = playMethod ?? PlayMethod.Transcode,
 293            PlaySessionId = playSessionId,
 294            LiveStreamId = liveStreamId
 295        };
 296
 297        playbackStartInfo.PlayMethod = ValidatePlayMethod(playbackStartInfo.PlayMethod, playbackStartInfo.PlaySessionId)
 298        playbackStartInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Conf
 299        await _sessionManager.OnPlaybackStart(playbackStartInfo).ConfigureAwait(false);
 300        return NoContent();
 301    }
 302
 303    /// <summary>
 304    /// Reports that a user has begun playing an item.
 305    /// </summary>
 306    /// <param name="userId">User id.</param>
 307    /// <param name="itemId">Item id.</param>
 308    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 309    /// <param name="audioStreamIndex">The audio stream index.</param>
 310    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 311    /// <param name="playMethod">The play method.</param>
 312    /// <param name="liveStreamId">The live stream id.</param>
 313    /// <param name="playSessionId">The play session id.</param>
 314    /// <param name="canSeek">Indicates if the client can seek.</param>
 315    /// <response code="204">Play start recorded.</response>
 316    /// <returns>A <see cref="NoContentResult"/>.</returns>
 317    [HttpPost("Users/{userId}/PlayingItems/{itemId}")]
 318    [ProducesResponseType(StatusCodes.Status204NoContent)]
 319    [Obsolete("Kept for backwards compatibility")]
 320    [ApiExplorerSettings(IgnoreApi = true)]
 321    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 322    public Task<ActionResult> OnPlaybackStartLegacy(
 323        [FromRoute, Required] Guid userId,
 324        [FromRoute, Required] Guid itemId,
 325        [FromQuery] string? mediaSourceId,
 326        [FromQuery] int? audioStreamIndex,
 327        [FromQuery] int? subtitleStreamIndex,
 328        [FromQuery] PlayMethod? playMethod,
 329        [FromQuery] string? liveStreamId,
 330        [FromQuery] string? playSessionId,
 331        [FromQuery] bool canSeek = false)
 332        => OnPlaybackStart(itemId, mediaSourceId, audioStreamIndex, subtitleStreamIndex, playMethod, liveStreamId, playS
 333
 334    /// <summary>
 335    /// Reports a session's playback progress.
 336    /// </summary>
 337    /// <param name="itemId">Item id.</param>
 338    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 339    /// <param name="positionTicks">Optional. The current position, in ticks. 1 tick = 10000 ms.</param>
 340    /// <param name="audioStreamIndex">The audio stream index.</param>
 341    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 342    /// <param name="volumeLevel">Scale of 0-100.</param>
 343    /// <param name="playMethod">The play method.</param>
 344    /// <param name="liveStreamId">The live stream id.</param>
 345    /// <param name="playSessionId">The play session id.</param>
 346    /// <param name="repeatMode">The repeat mode.</param>
 347    /// <param name="isPaused">Indicates if the player is paused.</param>
 348    /// <param name="isMuted">Indicates if the player is muted.</param>
 349    /// <response code="204">Play progress recorded.</response>
 350    /// <returns>A <see cref="NoContentResult"/>.</returns>
 351    [HttpPost("PlayingItems/{itemId}/Progress")]
 352    [ProducesResponseType(StatusCodes.Status204NoContent)]
 353    public async Task<ActionResult> OnPlaybackProgress(
 354        [FromRoute, Required] Guid itemId,
 355        [FromQuery] string? mediaSourceId,
 356        [FromQuery] long? positionTicks,
 357        [FromQuery] int? audioStreamIndex,
 358        [FromQuery] int? subtitleStreamIndex,
 359        [FromQuery] int? volumeLevel,
 360        [FromQuery] PlayMethod? playMethod,
 361        [FromQuery] string? liveStreamId,
 362        [FromQuery] string? playSessionId,
 363        [FromQuery] RepeatMode? repeatMode,
 364        [FromQuery] bool isPaused = false,
 365        [FromQuery] bool isMuted = false)
 366    {
 367        var playbackProgressInfo = new PlaybackProgressInfo
 368        {
 369            ItemId = itemId,
 370            PositionTicks = positionTicks,
 371            IsMuted = isMuted,
 372            IsPaused = isPaused,
 373            MediaSourceId = mediaSourceId,
 374            AudioStreamIndex = audioStreamIndex,
 375            SubtitleStreamIndex = subtitleStreamIndex,
 376            VolumeLevel = volumeLevel,
 377            PlayMethod = playMethod ?? PlayMethod.Transcode,
 378            PlaySessionId = playSessionId,
 379            LiveStreamId = liveStreamId,
 380            RepeatMode = repeatMode ?? RepeatMode.RepeatNone
 381        };
 382
 383        playbackProgressInfo.PlayMethod = ValidatePlayMethod(playbackProgressInfo.PlayMethod, playbackProgressInfo.PlayS
 384        playbackProgressInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).C
 385        await _sessionManager.OnPlaybackProgress(playbackProgressInfo).ConfigureAwait(false);
 386        return NoContent();
 387    }
 388
 389    /// <summary>
 390    /// Reports a user's playback progress.
 391    /// </summary>
 392    /// <param name="userId">User id.</param>
 393    /// <param name="itemId">Item id.</param>
 394    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 395    /// <param name="positionTicks">Optional. The current position, in ticks. 1 tick = 10000 ms.</param>
 396    /// <param name="audioStreamIndex">The audio stream index.</param>
 397    /// <param name="subtitleStreamIndex">The subtitle stream index.</param>
 398    /// <param name="volumeLevel">Scale of 0-100.</param>
 399    /// <param name="playMethod">The play method.</param>
 400    /// <param name="liveStreamId">The live stream id.</param>
 401    /// <param name="playSessionId">The play session id.</param>
 402    /// <param name="repeatMode">The repeat mode.</param>
 403    /// <param name="isPaused">Indicates if the player is paused.</param>
 404    /// <param name="isMuted">Indicates if the player is muted.</param>
 405    /// <response code="204">Play progress recorded.</response>
 406    /// <returns>A <see cref="NoContentResult"/>.</returns>
 407    [HttpPost("Users/{userId}/PlayingItems/{itemId}/Progress")]
 408    [ProducesResponseType(StatusCodes.Status204NoContent)]
 409    [Obsolete("Kept for backwards compatibility")]
 410    [ApiExplorerSettings(IgnoreApi = true)]
 411    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 412    public Task<ActionResult> OnPlaybackProgressLegacy(
 413        [FromRoute, Required] Guid userId,
 414        [FromRoute, Required] Guid itemId,
 415        [FromQuery] string? mediaSourceId,
 416        [FromQuery] long? positionTicks,
 417        [FromQuery] int? audioStreamIndex,
 418        [FromQuery] int? subtitleStreamIndex,
 419        [FromQuery] int? volumeLevel,
 420        [FromQuery] PlayMethod? playMethod,
 421        [FromQuery] string? liveStreamId,
 422        [FromQuery] string? playSessionId,
 423        [FromQuery] RepeatMode? repeatMode,
 424        [FromQuery] bool isPaused = false,
 425        [FromQuery] bool isMuted = false)
 426        => OnPlaybackProgress(itemId, mediaSourceId, positionTicks, audioStreamIndex, subtitleStreamIndex, volumeLevel, 
 427
 428    /// <summary>
 429    /// Reports that a session has stopped playing an item.
 430    /// </summary>
 431    /// <param name="itemId">Item id.</param>
 432    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 433    /// <param name="nextMediaType">The next media type that will play.</param>
 434    /// <param name="positionTicks">Optional. The position, in ticks, where playback stopped. 1 tick = 10000 ms.</param>
 435    /// <param name="liveStreamId">The live stream id.</param>
 436    /// <param name="playSessionId">The play session id.</param>
 437    /// <response code="204">Playback stop recorded.</response>
 438    /// <returns>A <see cref="NoContentResult"/>.</returns>
 439    [HttpDelete("PlayingItems/{itemId}")]
 440    [ProducesResponseType(StatusCodes.Status204NoContent)]
 441    public async Task<ActionResult> OnPlaybackStopped(
 442        [FromRoute, Required] Guid itemId,
 443        [FromQuery] string? mediaSourceId,
 444        [FromQuery] string? nextMediaType,
 445        [FromQuery] long? positionTicks,
 446        [FromQuery] string? liveStreamId,
 447        [FromQuery] string? playSessionId)
 448    {
 449        var playbackStopInfo = new PlaybackStopInfo
 450        {
 451            ItemId = itemId,
 452            PositionTicks = positionTicks,
 453            MediaSourceId = mediaSourceId,
 454            PlaySessionId = playSessionId,
 455            LiveStreamId = liveStreamId,
 456            NextMediaType = nextMediaType
 457        };
 458
 459        _logger.LogDebug("ReportPlaybackStopped PlaySessionId: {0}", playbackStopInfo.PlaySessionId ?? string.Empty);
 460        if (!string.IsNullOrWhiteSpace(playbackStopInfo.PlaySessionId))
 461        {
 462            await _transcodeManager.KillTranscodingJobs(User.GetDeviceId()!, playbackStopInfo.PlaySessionId, s => true).
 463        }
 464
 465        playbackStopInfo.SessionId = await RequestHelpers.GetSessionId(_sessionManager, _userManager, HttpContext).Confi
 466        await _sessionManager.OnPlaybackStopped(playbackStopInfo).ConfigureAwait(false);
 467        return NoContent();
 468    }
 469
 470    /// <summary>
 471    /// Reports that a user has stopped playing an item.
 472    /// </summary>
 473    /// <param name="userId">User id.</param>
 474    /// <param name="itemId">Item id.</param>
 475    /// <param name="mediaSourceId">The id of the MediaSource.</param>
 476    /// <param name="nextMediaType">The next media type that will play.</param>
 477    /// <param name="positionTicks">Optional. The position, in ticks, where playback stopped. 1 tick = 10000 ms.</param>
 478    /// <param name="liveStreamId">The live stream id.</param>
 479    /// <param name="playSessionId">The play session id.</param>
 480    /// <response code="204">Playback stop recorded.</response>
 481    /// <returns>A <see cref="NoContentResult"/>.</returns>
 482    [HttpDelete("Users/{userId}/PlayingItems/{itemId}")]
 483    [ProducesResponseType(StatusCodes.Status204NoContent)]
 484    [Obsolete("Kept for backwards compatibility")]
 485    [ApiExplorerSettings(IgnoreApi = true)]
 486    [SuppressMessage("Microsoft.Performance", "CA1801:ReviewUnusedParameters", MessageId = "userId", Justification = "Re
 487    public Task<ActionResult> OnPlaybackStoppedLegacy(
 488        [FromRoute, Required] Guid userId,
 489        [FromRoute, Required] Guid itemId,
 490        [FromQuery] string? mediaSourceId,
 491        [FromQuery] string? nextMediaType,
 492        [FromQuery] long? positionTicks,
 493        [FromQuery] string? liveStreamId,
 494        [FromQuery] string? playSessionId)
 495        => OnPlaybackStopped(itemId, mediaSourceId, nextMediaType, positionTicks, liveStreamId, playSessionId);
 496
 497    /// <summary>
 498    /// Updates the played status.
 499    /// </summary>
 500    /// <param name="user">The user.</param>
 501    /// <param name="item">The item.</param>
 502    /// <param name="wasPlayed">if set to <c>true</c> [was played].</param>
 503    /// <param name="datePlayed">The date played.</param>
 504    /// <returns>Task.</returns>
 505    private UserItemDataDto? UpdatePlayedStatus(User user, BaseItem item, bool wasPlayed, DateTime? datePlayed)
 506    {
 0507        if (wasPlayed)
 508        {
 0509            item.MarkPlayed(user, datePlayed, true);
 510        }
 511        else
 512        {
 0513            item.MarkUnplayed(user);
 514        }
 515
 0516        return _userDataRepository.GetUserDataDto(item, user);
 517    }
 518
 519    private PlayMethod ValidatePlayMethod(PlayMethod method, string? playSessionId)
 520    {
 0521        if (method == PlayMethod.Transcode)
 522        {
 0523            var job = string.IsNullOrWhiteSpace(playSessionId) ? null : _transcodeManager.GetTranscodingJob(playSessionI
 0524            if (job is null)
 525            {
 0526                return PlayMethod.DirectPlay;
 527            }
 528        }
 529
 0530        return method;
 531    }
 532}
Generated by: ReportGenerator 5.4.5.0
4/3/2025 - 12:11:21 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)