< Summary - Jellyfin

Information

Class:	Emby.Server.Implementations.Session.SessionManager
Assembly:	Emby.Server.Implementations
File(s):	/srv/git/jellyfin/Emby.Server.Implementations/Session/SessionManager.cs

Line coverage

25%

Covered lines:	256
Uncovered lines:	742
Coverable lines:	998
Total lines:	2197
Line coverage:	25.6%

Branch coverage

13%

Covered branches:	57
Total branches:	416
Branch coverage:	13.7%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage delta

Metrics

Method	Branch coverage	Crap Score	Cyclomatic complexity	Line coverage
.ctor(...)	100%	1	1	100%
get_Sessions()	100%	1	1	100%
OnDeviceManagerDeviceOptionsUpdated(...)	0%	42	6	0%
CheckDisposed()	100%	1	1	100%
OnSessionStarted(...)	50%	4	4	100%
OnSessionEnded()	100%	1	1	100%
UpdateDeviceName(...)	0%	6	2	0%
LogSessionActivity()	90%	10	10	88.46%
OnSessionControllerConnected(...)	100%	1	1	100%
CloseIfNeededAsync()	66.66%	6	6	85.71%
CloseLiveStreamIfNeededAsync()	0%	110	10	0%
ReportSessionEnded()	0%	6	2	0%
GetMediaSource(...)	100%	2	1	0%
UpdateNowPlayingItem()	0%	702	26	0%
RemoveNowPlayingItem(...)	0%	6	2	0%
GetSessionKey(...)	100%	1	1	100%
GetSessionInfo(...)	56.25%	16	16	94.44%
CreateSessionInfo(...)	50%	14	14	87.5%
GetUsers(...)	0%	20	4	0%
StartCheckTimers()	0%	42	6	0%
StopIdleCheckTimer()	0%	6	2	0%
StopInactiveCheckTimer()	0%	6	2	0%
CheckForIdlePlayback()	0%	110	10	0%
CheckForInactiveSteams()	0%	42	6	0%
GetNowPlayingItem(...)	0%	42	6	0%
GetProgressItem(...)	0%	110	10	0%
OnPlaybackStart()	0%	210	14	0%
OnPlaybackStart(...)	0%	20	4	0%
OnPlaybackProgress(...)	100%	2	1	0%
UpdateLiveStreamActiveSessionMappings(...)	0%	110	10	0%
OnPlaybackProgress()	0%	420	20	0%
OnPlaybackProgress(...)	0%	342	18	0%
UpdatePlaybackSettings(...)	0%	272	16	0%
OnPlaybackStopped()	0%	1190	34	0%
OnPlaybackStopped(...)	0%	72	8	0%
GetSession(...)	100%	2	2	100%
GetSessionToRemoteControl(...)	0%	6	2	0%
ToSessionInfoDto(...)	100%	1	1	100%
SendMessageCommand(...)	0%	6	2	0%
SendGeneralCommand(...)	0%	6	2	0%
SendMessageToSession()	100%	2	2	100%
SendMessageToSessions(...)	100%	1	1	100%
SendPlayCommand()	0%	812	28	0%
SendSyncPlayCommand()	100%	1	1	100%
SendSyncPlayGroupUpdate()	100%	1	1	100%
TranslateItemForPlayback(...)	0%	42	6	0%
TranslateItemForInstantMix(...)	0%	6	2	0%
SendBrowseCommand(...)	100%	2	1	0%
SendPlaystateCommand(...)	0%	20	4	0%
AssertCanControl(...)	100%	2	1	0%
SendRestartRequiredNotification(...)	100%	2	1	0%
AddAdditionalUser(...)	0%	42	6	0%
RemoveAdditionalUser(...)	0%	20	4	0%
AuthenticateNewSession(...)	100%	1	1	100%
AuthenticateDirect(...)	100%	2	1	0%
AuthenticateNewSessionInternal()	68.75%	16	16	88.63%
GetAuthorizationToken()	50%	2	2	70.58%
Logout()	0%	6	2	0%
Logout()	0%	6	2	0%
RevokeUserTokens()	50%	4	4	77.77%
ReportCapabilities(...)	100%	2	1	0%
ReportCapabilities(...)	25%	9	4	30%
GetItemInfo(...)	0%	20	4	0%
GetImageCacheTag(...)	100%	2	1	0%
ReportNowViewingItem(...)	100%	2	1	0%
ReportTranscodingInfo(...)	0%	6	2	0%
ClearTranscodingInfo(...)	100%	2	1	0%
GetSession(...)	100%	2	1	0%
GetSessionByAuthenticationToken(...)	0%	72	8	0%
GetSessionByAuthenticationToken()	0%	6	2	0%
GetSessions(...)	0%	600	24	0%
SendMessageToAdminSessions(...)	0%	20	4	0%
SendMessageToUserSessions(...)	0%	6	2	0%
SendMessageToUserSessions(...)	100%	1	1	100%
SendMessageToUserDeviceSessions(...)	100%	2	1	0%
DisposeAsync()	50%	13	8	57.14%
OnApplicationStopping()	75%	4	4	75%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Session/SessionManager.cs

#	Line	Line coverage
	`1`	`#nullable disable`
	`2`
	`3`	`using System;`
	`4`	`using System.Collections.Concurrent;`
	`5`	`using System.Collections.Generic;`
	`6`	`using System.Globalization;`
	`7`	`using System.Linq;`
	`8`	`using System.Threading;`
	`9`	`using System.Threading.Tasks;`
	`10`	`using Jellyfin.Data;`
	`11`	`using Jellyfin.Data.Enums;`
	`12`	`using Jellyfin.Data.Events;`
	`13`	`using Jellyfin.Data.Queries;`
	`14`	`using Jellyfin.Database.Implementations.Entities;`
	`15`	`using Jellyfin.Database.Implementations.Entities.Security;`
	`16`	`using Jellyfin.Database.Implementations.Enums;`
	`17`	`using Jellyfin.Extensions;`
	`18`	`using MediaBrowser.Common.Events;`
	`19`	`using MediaBrowser.Common.Extensions;`
	`20`	`using MediaBrowser.Controller;`
	`21`	`using MediaBrowser.Controller.Authentication;`
	`22`	`using MediaBrowser.Controller.Configuration;`
	`23`	`using MediaBrowser.Controller.Devices;`
	`24`	`using MediaBrowser.Controller.Drawing;`
	`25`	`using MediaBrowser.Controller.Dto;`
	`26`	`using MediaBrowser.Controller.Entities;`
	`27`	`using MediaBrowser.Controller.Events;`
	`28`	`using MediaBrowser.Controller.Events.Authentication;`
	`29`	`using MediaBrowser.Controller.Events.Session;`
	`30`	`using MediaBrowser.Controller.Library;`
	`31`	`using MediaBrowser.Controller.Net;`
	`32`	`using MediaBrowser.Controller.Session;`
	`33`	`using MediaBrowser.Model.Dto;`
	`34`	`using MediaBrowser.Model.Entities;`
	`35`	`using MediaBrowser.Model.Library;`
	`36`	`using MediaBrowser.Model.Querying;`
	`37`	`using MediaBrowser.Model.Session;`
	`38`	`using MediaBrowser.Model.SyncPlay;`
	`39`	`using Microsoft.EntityFrameworkCore;`
	`40`	`using Microsoft.Extensions.Hosting;`
	`41`	`using Microsoft.Extensions.Logging;`
	`42`	`using Episode = MediaBrowser.Controller.Entities.TV.Episode;`
	`43`
	`44`	`namespace Emby.Server.Implementations.Session`
	`45`	`{`
	`46`	`/// <summary>`
	`47`	`/// Class SessionManager.`
	`48`	`/// </summary>`
	`49`	`public sealed class SessionManager : ISessionManager, IAsyncDisposable`
	`50`	`{`
	`51`	`private readonly IUserDataManager _userDataManager;`
	`52`	`private readonly IServerConfigurationManager _config;`
	`53`	`private readonly ILogger<SessionManager> _logger;`
	`54`	`private readonly IEventManager _eventManager;`
	`55`	`private readonly ILibraryManager _libraryManager;`
	`56`	`private readonly IUserManager _userManager;`
	`57`	`private readonly IMusicManager _musicManager;`
	`58`	`private readonly IDtoService _dtoService;`
	`59`	`private readonly IImageProcessor _imageProcessor;`
	`60`	`private readonly IMediaSourceManager _mediaSourceManager;`
	`61`	`private readonly IServerApplicationHost _appHost;`
	`62`	`private readonly IDeviceManager _deviceManager;`
	`63`	`private readonly CancellationTokenRegistration _shutdownCallback;`
32	`64`	`private readonly ConcurrentDictionary<string, SessionInfo> _activeConnections`
32	`65`	`= new(StringComparer.OrdinalIgnoreCase);`
	`66`
32	`67`	`private readonly ConcurrentDictionary<string, ConcurrentDictionary<string, string>> _activeLiveStreamSessions`
32	`68`	`= new(StringComparer.OrdinalIgnoreCase);`
	`69`
	`70`	`private Timer _idleTimer;`
	`71`	`private Timer _inactiveTimer;`
	`72`
	`73`	`private DtoOptions _itemInfoDtoOptions;`
	`74`	`private bool _disposed;`
	`75`
	`76`	`/// <summary>`
	`77`	`/// Initializes a new instance of the <see cref="SessionManager"/> class.`
	`78`	`/// </summary>`
	`79`	`/// <param name="logger">Instance of <see cref="ILogger{SessionManager}"/> interface.</param>`
	`80`	`/// <param name="eventManager">Instance of <see cref="IEventManager"/> interface.</param>`
	`81`	`/// <param name="userDataManager">Instance of <see cref="IUserDataManager"/> interface.</param>`
	`82`	`/// <param name="serverConfigurationManager">Instance of <see cref="IServerConfigurationManager"/> interface.</p`
	`83`	`/// <param name="libraryManager">Instance of <see cref="ILibraryManager"/> interface.</param>`
	`84`	`/// <param name="userManager">Instance of <see cref="IUserManager"/> interface.</param>`
	`85`	`/// <param name="musicManager">Instance of <see cref="IMusicManager"/> interface.</param>`
	`86`	`/// <param name="dtoService">Instance of <see cref="IDtoService"/> interface.</param>`
	`87`	`/// <param name="imageProcessor">Instance of <see cref="IImageProcessor"/> interface.</param>`
	`88`	`/// <param name="appHost">Instance of <see cref="IServerApplicationHost"/> interface.</param>`
	`89`	`/// <param name="deviceManager">Instance of <see cref="IDeviceManager"/> interface.</param>`
	`90`	`/// <param name="mediaSourceManager">Instance of <see cref="IMediaSourceManager"/> interface.</param>`
	`91`	`/// <param name="hostApplicationLifetime">Instance of <see cref="IHostApplicationLifetime"/> interface.</param>`
	`92`	`public SessionManager(`
	`93`	`ILogger<SessionManager> logger,`
	`94`	`IEventManager eventManager,`
	`95`	`IUserDataManager userDataManager,`
	`96`	`IServerConfigurationManager serverConfigurationManager,`
	`97`	`ILibraryManager libraryManager,`
	`98`	`IUserManager userManager,`
	`99`	`IMusicManager musicManager,`
	`100`	`IDtoService dtoService,`
	`101`	`IImageProcessor imageProcessor,`
	`102`	`IServerApplicationHost appHost,`
	`103`	`IDeviceManager deviceManager,`
	`104`	`IMediaSourceManager mediaSourceManager,`
	`105`	`IHostApplicationLifetime hostApplicationLifetime)`
	`106`	`{`
32	`107`	`_logger = logger;`
32	`108`	`_eventManager = eventManager;`
32	`109`	`_userDataManager = userDataManager;`
32	`110`	`_config = serverConfigurationManager;`
32	`111`	`_libraryManager = libraryManager;`
32	`112`	`_userManager = userManager;`
32	`113`	`_musicManager = musicManager;`
32	`114`	`_dtoService = dtoService;`
32	`115`	`_imageProcessor = imageProcessor;`
32	`116`	`_appHost = appHost;`
32	`117`	`_deviceManager = deviceManager;`
32	`118`	`_mediaSourceManager = mediaSourceManager;`
32	`119`	`_shutdownCallback = hostApplicationLifetime.ApplicationStopping.Register(OnApplicationStopping);`
	`120`
32	`121`	`_deviceManager.DeviceOptionsUpdated += OnDeviceManagerDeviceOptionsUpdated;`
32	`122`	`}`
	`123`
	`124`	`/// <summary>`
	`125`	`/// Occurs when playback has started.`
	`126`	`/// </summary>`
	`127`	`public event EventHandler<PlaybackProgressEventArgs> PlaybackStart;`
	`128`
	`129`	`/// <summary>`
	`130`	`/// Occurs when playback has progressed.`
	`131`	`/// </summary>`
	`132`	`public event EventHandler<PlaybackProgressEventArgs> PlaybackProgress;`
	`133`
	`134`	`/// <summary>`
	`135`	`/// Occurs when playback has stopped.`
	`136`	`/// </summary>`
	`137`	`public event EventHandler<PlaybackStopEventArgs> PlaybackStopped;`
	`138`
	`139`	`/// <inheritdoc />`
	`140`	`public event EventHandler<SessionEventArgs> SessionStarted;`
	`141`
	`142`	`/// <inheritdoc />`
	`143`	`public event EventHandler<SessionEventArgs> CapabilitiesChanged;`
	`144`
	`145`	`/// <inheritdoc />`
	`146`	`public event EventHandler<SessionEventArgs> SessionEnded;`
	`147`
	`148`	`/// <inheritdoc />`
	`149`	`public event EventHandler<SessionEventArgs> SessionActivity;`
	`150`
	`151`	`/// <inheritdoc />`
	`152`	`public event EventHandler<SessionEventArgs> SessionControllerConnected;`
	`153`
	`154`	`/// <summary>`
	`155`	`/// Gets all connections.`
	`156`	`/// </summary>`
	`157`	`/// <value>All connections.</value>`
43	`158`	`public IEnumerable<SessionInfo> Sessions => _activeConnections.Values.OrderByDescending(c => c.LastActivityDate)`
	`159`
	`160`	`private void OnDeviceManagerDeviceOptionsUpdated(object sender, GenericEventArgs<Tuple<string, DeviceOptions>> e`
	`161`	`{`
0	`162`	`foreach (var session in Sessions)`
	`163`	`{`
0	`164`	`if (string.Equals(session.DeviceId, e.Argument.Item1, StringComparison.Ordinal))`
	`165`	`{`
0	`166`	`if (!string.IsNullOrWhiteSpace(e.Argument.Item2.CustomName))`
	`167`	`{`
0	`168`	`session.HasCustomDeviceName = true;`
0	`169`	`session.DeviceName = e.Argument.Item2.CustomName;`
	`170`	`}`
	`171`	`else`
	`172`	`{`
0	`173`	`session.HasCustomDeviceName = false;`
	`174`	`}`
	`175`	`}`
	`176`	`}`
0	`177`	`}`
	`178`
	`179`	`private void CheckDisposed()`
	`180`	`{`
111	`181`	`ObjectDisposedException.ThrowIf(_disposed, this);`
111	`182`	`}`
	`183`
	`184`	`private void OnSessionStarted(SessionInfo info)`
	`185`	`{`
17	`186`	`if (!string.IsNullOrEmpty(info.DeviceId))`
	`187`	`{`
17	`188`	`var capabilities = _deviceManager.GetCapabilities(info.DeviceId);`
	`189`
17	`190`	`if (capabilities is not null)`
	`191`	`{`
17	`192`	`ReportCapabilities(info, capabilities, false);`
	`193`	`}`
	`194`	`}`
	`195`
17	`196`	`_eventManager.Publish(new SessionStartedEventArgs(info));`
	`197`
17	`198`	`EventHelper.QueueEventIfNotNull(`
17	`199`	`SessionStarted,`
17	`200`	`this,`
17	`201`	`new SessionEventArgs`
17	`202`	`{`
17	`203`	`SessionInfo = info`
17	`204`	`},`
17	`205`	`_logger);`
17	`206`	`}`
	`207`
	`208`	`private async ValueTask OnSessionEnded(SessionInfo info)`
	`209`	`{`
1	`210`	`EventHelper.QueueEventIfNotNull(`
1	`211`	`SessionEnded,`
1	`212`	`this,`
1	`213`	`new SessionEventArgs`
1	`214`	`{`
1	`215`	`SessionInfo = info`
1	`216`	`},`
1	`217`	`_logger);`
	`218`
1	`219`	`_eventManager.Publish(new SessionEndedEventArgs(info));`
	`220`
1	`221`	`await info.DisposeAsync().ConfigureAwait(false);`
1	`222`	`}`
	`223`
	`224`	`/// <inheritdoc />`
	`225`	`public void UpdateDeviceName(string sessionId, string reportedDeviceName)`
	`226`	`{`
0	`227`	`var session = GetSession(sessionId);`
0	`228`	`if (session is not null)`
	`229`	`{`
0	`230`	`session.DeviceName = reportedDeviceName;`
	`231`	`}`
0	`232`	`}`
	`233`
	`234`	`/// <summary>`
	`235`	`/// Logs the user activity.`
	`236`	`/// </summary>`
	`237`	`/// <param name="appName">Type of the client.</param>`
	`238`	`/// <param name="appVersion">The app version.</param>`
	`239`	`/// <param name="deviceId">The device id.</param>`
	`240`	`/// <param name="deviceName">Name of the device.</param>`
	`241`	`/// <param name="remoteEndPoint">The remote end point.</param>`
	`242`	`/// <param name="user">The user.</param>`
	`243`	`/// <returns>SessionInfo.</returns>`
	`244`	`public async Task<SessionInfo> LogSessionActivity(`
	`245`	`string appName,`
	`246`	`string appVersion,`
	`247`	`string deviceId,`
	`248`	`string deviceName,`
	`249`	`string remoteEndPoint,`
	`250`	`User user)`
	`251`	`{`
40	`252`	`CheckDisposed();`
	`253`
40	`254`	`ArgumentException.ThrowIfNullOrEmpty(appName);`
40	`255`	`ArgumentException.ThrowIfNullOrEmpty(appVersion);`
40	`256`	`ArgumentException.ThrowIfNullOrEmpty(deviceId);`
	`257`
40	`258`	`var activityDate = DateTime.UtcNow;`
40	`259`	`var session = GetSessionInfo(appName, appVersion, deviceId, deviceName, remoteEndPoint, user);`
40	`260`	`var lastActivityDate = session.LastActivityDate;`
40	`261`	`session.LastActivityDate = activityDate;`
	`262`
40	`263`	`if (user is not null)`
	`264`	`{`
40	`265`	`var userLastActivityDate = user.LastActivityDate ?? DateTime.MinValue;`
	`266`
40	`267`	`if ((activityDate - userLastActivityDate).TotalSeconds > 60)`
	`268`	`{`
	`269`	`try`
	`270`	`{`
16	`271`	`user.LastActivityDate = activityDate;`
16	`272`	`await _userManager.UpdateUserAsync(user).ConfigureAwait(false);`
16	`273`	`}`
0	`274`	`catch (DbUpdateConcurrencyException)`
	`275`	`{`
0	`276`	`_logger.LogDebug("Error updating user's last activity date due to concurrency conflict. This is`
0	`277`	`}`
	`278`	`}`
	`279`	`}`
	`280`
40	`281`	`if ((activityDate - lastActivityDate).TotalSeconds > 10)`
	`282`	`{`
17	`283`	`SessionActivity?.Invoke(`
17	`284`	`this,`
17	`285`	`new SessionEventArgs`
17	`286`	`{`
17	`287`	`SessionInfo = session`
17	`288`	`});`
	`289`	`}`
	`290`
40	`291`	`return session;`
40	`292`	`}`
	`293`
	`294`	`/// <inheritdoc />`
	`295`	`public void OnSessionControllerConnected(SessionInfo session)`
	`296`	`{`
1	`297`	`EventHelper.QueueEventIfNotNull(`
1	`298`	`SessionControllerConnected,`
1	`299`	`this,`
1	`300`	`new SessionEventArgs`
1	`301`	`{`
1	`302`	`SessionInfo = session`
1	`303`	`},`
1	`304`	`_logger);`
1	`305`	`}`
	`306`
	`307`	`/// <inheritdoc />`
	`308`	`public async Task CloseIfNeededAsync(SessionInfo session)`
	`309`	`{`
1	`310`	`if (!session.SessionControllers.Any(i => i.IsSessionActive))`
	`311`	`{`
1	`312`	`var key = GetSessionKey(session.Client, session.DeviceId);`
	`313`
1	`314`	`_activeConnections.TryRemove(key, out _);`
1	`315`	`if (!string.IsNullOrEmpty(session.PlayState?.LiveStreamId))`
	`316`	`{`
0	`317`	`await CloseLiveStreamIfNeededAsync(session.PlayState.LiveStreamId, session.Id).ConfigureAwait(false)`
	`318`	`}`
	`319`
1	`320`	`await OnSessionEnded(session).ConfigureAwait(false);`
	`321`	`}`
1	`322`	`}`
	`323`
	`324`	`/// <inheritdoc />`
	`325`	`public async Task CloseLiveStreamIfNeededAsync(string liveStreamId, string sessionIdOrPlaySessionId)`
	`326`	`{`
0	`327`	`bool liveStreamNeedsToBeClosed = false;`
	`328`
0	`329`	`if (_activeLiveStreamSessions.TryGetValue(liveStreamId, out var activeSessionMappings))`
	`330`	`{`
0	`331`	`if (activeSessionMappings.TryRemove(sessionIdOrPlaySessionId, out var correspondingId))`
	`332`	`{`
0	`333`	`if (!string.IsNullOrEmpty(correspondingId))`
	`334`	`{`
0	`335`	`activeSessionMappings.TryRemove(correspondingId, out _);`
	`336`	`}`
	`337`
0	`338`	`liveStreamNeedsToBeClosed = true;`
	`339`	`}`
	`340`
0	`341`	`if (activeSessionMappings.IsEmpty)`
	`342`	`{`
0	`343`	`_activeLiveStreamSessions.TryRemove(liveStreamId, out _);`
	`344`	`}`
	`345`	`}`
	`346`	`else`
	`347`	`{`
0	`348`	`liveStreamNeedsToBeClosed = true;`
	`349`	`}`
	`350`
0	`351`	`if (liveStreamNeedsToBeClosed)`
	`352`	`{`
	`353`	`try`
	`354`	`{`
0	`355`	`await _mediaSourceManager.CloseLiveStream(liveStreamId).ConfigureAwait(false);`
0	`356`	`}`
0	`357`	`catch (Exception ex)`
	`358`	`{`
0	`359`	`_logger.LogError(ex, "Error closing live stream");`
0	`360`	`}`
	`361`	`}`
0	`362`	`}`
	`363`
	`364`	`/// <inheritdoc />`
	`365`	`public async ValueTask ReportSessionEnded(string sessionId)`
	`366`	`{`
0	`367`	`CheckDisposed();`
0	`368`	`var session = GetSession(sessionId, false);`
	`369`
0	`370`	`if (session is not null)`
	`371`	`{`
0	`372`	`var key = GetSessionKey(session.Client, session.DeviceId);`
	`373`
0	`374`	`_activeConnections.TryRemove(key, out _);`
	`375`
0	`376`	`await OnSessionEnded(session).ConfigureAwait(false);`
	`377`	`}`
0	`378`	`}`
	`379`
	`380`	`private Task<MediaSourceInfo> GetMediaSource(BaseItem item, string mediaSourceId, string liveStreamId)`
	`381`	`{`
0	`382`	`return _mediaSourceManager.GetMediaSource(item, mediaSourceId, liveStreamId, false, CancellationToken.None);`
	`383`	`}`
	`384`
	`385`	`/// <summary>`
	`386`	`/// Updates the now playing item id.`
	`387`	`/// </summary>`
	`388`	`/// <returns>Task.</returns>`
	`389`	`private async Task UpdateNowPlayingItem(SessionInfo session, PlaybackProgressInfo info, BaseItem libraryItem, bo`
	`390`	`{`
0	`391`	`if (session is null)`
	`392`	`{`
0	`393`	`return;`
	`394`	`}`
	`395`
0	`396`	`if (string.IsNullOrEmpty(info.MediaSourceId))`
	`397`	`{`
0	`398`	`info.MediaSourceId = info.ItemId.ToString("N", CultureInfo.InvariantCulture);`
	`399`	`}`
	`400`
0	`401`	`if (!info.ItemId.IsEmpty() && info.Item is null && libraryItem is not null)`
	`402`	`{`
0	`403`	`var current = session.NowPlayingItem;`
	`404`
0	`405`	`if (current is null \|\| !info.ItemId.Equals(current.Id))`
	`406`	`{`
0	`407`	`var runtimeTicks = libraryItem.RunTimeTicks;`
	`408`
0	`409`	`MediaSourceInfo mediaSource = null;`
0	`410`	`if (libraryItem is IHasMediaSources)`
	`411`	`{`
0	`412`	`mediaSource = await GetMediaSource(libraryItem, info.MediaSourceId, info.LiveStreamId).Configure`
	`413`
0	`414`	`if (mediaSource is not null)`
	`415`	`{`
0	`416`	`runtimeTicks = mediaSource.RunTimeTicks;`
	`417`	`}`
	`418`	`}`
	`419`
0	`420`	`info.Item = GetItemInfo(libraryItem, mediaSource);`
	`421`
0	`422`	`info.Item.RunTimeTicks = runtimeTicks;`
	`423`	`}`
	`424`	`else`
	`425`	`{`
0	`426`	`info.Item = current;`
	`427`	`}`
	`428`	`}`
	`429`
0	`430`	`session.NowPlayingItem = info.Item;`
0	`431`	`session.LastActivityDate = DateTime.UtcNow;`
	`432`
0	`433`	`if (updateLastCheckInTime)`
	`434`	`{`
0	`435`	`session.LastPlaybackCheckIn = DateTime.UtcNow;`
	`436`	`}`
	`437`
0	`438`	`if (info.IsPaused && session.LastPausedDate is null)`
	`439`	`{`
0	`440`	`session.LastPausedDate = DateTime.UtcNow;`
	`441`	`}`
0	`442`	`else if (!info.IsPaused)`
	`443`	`{`
0	`444`	`session.LastPausedDate = null;`
	`445`	`}`
	`446`
0	`447`	`session.PlayState.IsPaused = info.IsPaused;`
0	`448`	`session.PlayState.PositionTicks = info.PositionTicks;`
0	`449`	`session.PlayState.MediaSourceId = info.MediaSourceId;`
0	`450`	`session.PlayState.LiveStreamId = info.LiveStreamId;`
0	`451`	`session.PlayState.CanSeek = info.CanSeek;`
0	`452`	`session.PlayState.IsMuted = info.IsMuted;`
0	`453`	`session.PlayState.VolumeLevel = info.VolumeLevel;`
0	`454`	`session.PlayState.AudioStreamIndex = info.AudioStreamIndex;`
0	`455`	`session.PlayState.SubtitleStreamIndex = info.SubtitleStreamIndex;`
0	`456`	`session.PlayState.PlayMethod = info.PlayMethod;`
0	`457`	`session.PlayState.RepeatMode = info.RepeatMode;`
0	`458`	`session.PlayState.PlaybackOrder = info.PlaybackOrder;`
0	`459`	`session.PlaylistItemId = info.PlaylistItemId;`
0	`460`	`}`
	`461`
	`462`	`/// <summary>`
	`463`	`/// Removes the now playing item id.`
	`464`	`/// </summary>`
	`465`	`/// <param name="session">The session.</param>`
	`466`	`private void RemoveNowPlayingItem(SessionInfo session)`
	`467`	`{`
0	`468`	`session.NowPlayingItem = null;`
0	`469`	`session.FullNowPlayingItem = null;`
0	`470`	`session.PlayState = new PlayerStateInfo();`
	`471`
0	`472`	`if (!string.IsNullOrEmpty(session.DeviceId))`
	`473`	`{`
0	`474`	`ClearTranscodingInfo(session.DeviceId);`
	`475`	`}`
0	`476`	`}`
	`477`
	`478`	`private static string GetSessionKey(string appName, string deviceId)`
41	`479`	`=> appName + deviceId;`
	`480`
	`481`	`/// <summary>`
	`482`	`/// Gets the connection.`
	`483`	`/// </summary>`
	`484`	`/// <param name="appName">Type of the client.</param>`
	`485`	`/// <param name="appVersion">The app version.</param>`
	`486`	`/// <param name="deviceId">The device id.</param>`
	`487`	`/// <param name="deviceName">Name of the device.</param>`
	`488`	`/// <param name="remoteEndPoint">The remote end point.</param>`
	`489`	`/// <param name="user">The user.</param>`
	`490`	`/// <returns>SessionInfo.</returns>`
	`491`	`private SessionInfo GetSessionInfo(`
	`492`	`string appName,`
	`493`	`string appVersion,`
	`494`	`string deviceId,`
	`495`	`string deviceName,`
	`496`	`string remoteEndPoint,`
	`497`	`User user)`
	`498`	`{`
40	`499`	`CheckDisposed();`
	`500`
40	`501`	`ArgumentException.ThrowIfNullOrEmpty(deviceId);`
	`502`
40	`503`	`var key = GetSessionKey(appName, deviceId);`
40	`504`	`SessionInfo newSession = CreateSessionInfo(key, appName, appVersion, deviceId, deviceName, remoteEndPoint, u`
40	`505`	`SessionInfo sessionInfo = _activeConnections.GetOrAdd(key, newSession);`
40	`506`	`if (ReferenceEquals(newSession, sessionInfo))`
	`507`	`{`
17	`508`	`OnSessionStarted(newSession);`
	`509`	`}`
	`510`
40	`511`	`sessionInfo.UserId = user?.Id ?? Guid.Empty;`
40	`512`	`sessionInfo.UserName = user?.Username;`
40	`513`	`sessionInfo.UserPrimaryImageTag = user?.ProfileImage is null ? null : GetImageCacheTag(user);`
40	`514`	`sessionInfo.RemoteEndPoint = remoteEndPoint;`
40	`515`	`sessionInfo.Client = appName;`
	`516`
40	`517`	`if (!sessionInfo.HasCustomDeviceName \|\| string.IsNullOrEmpty(sessionInfo.DeviceName))`
	`518`	`{`
40	`519`	`sessionInfo.DeviceName = deviceName;`
	`520`	`}`
	`521`
40	`522`	`sessionInfo.ApplicationVersion = appVersion;`
	`523`
40	`524`	`if (user is null)`
	`525`	`{`
0	`526`	`sessionInfo.AdditionalUsers = Array.Empty<SessionUserInfo>();`
	`527`	`}`
	`528`
40	`529`	`return sessionInfo;`
	`530`	`}`
	`531`
	`532`	`private SessionInfo CreateSessionInfo(`
	`533`	`string key,`
	`534`	`string appName,`
	`535`	`string appVersion,`
	`536`	`string deviceId,`
	`537`	`string deviceName,`
	`538`	`string remoteEndPoint,`
	`539`	`User user)`
	`540`	`{`
40	`541`	`var sessionInfo = new SessionInfo(this, _logger)`
40	`542`	`{`
40	`543`	`Client = appName,`
40	`544`	`DeviceId = deviceId,`
40	`545`	`ApplicationVersion = appVersion,`
40	`546`	`Id = key.GetMD5().ToString("N", CultureInfo.InvariantCulture),`
40	`547`	`ServerId = _appHost.SystemId`
40	`548`	`};`
	`549`
40	`550`	`var username = user?.Username;`
	`551`
40	`552`	`sessionInfo.UserId = user?.Id ?? Guid.Empty;`
40	`553`	`sessionInfo.UserName = username;`
40	`554`	`sessionInfo.UserPrimaryImageTag = user?.ProfileImage is null ? null : GetImageCacheTag(user);`
40	`555`	`sessionInfo.RemoteEndPoint = remoteEndPoint;`
	`556`
40	`557`	`if (string.IsNullOrEmpty(deviceName))`
	`558`	`{`
0	`559`	`deviceName = "Network Device";`
	`560`	`}`
	`561`
40	`562`	`var deviceOptions = _deviceManager.GetDeviceOptions(deviceId) ?? new()`
40	`563`	`{`
40	`564`	`DeviceId = deviceId`
40	`565`	`};`
40	`566`	`if (string.IsNullOrEmpty(deviceOptions.CustomName))`
	`567`	`{`
40	`568`	`sessionInfo.DeviceName = deviceName;`
	`569`	`}`
	`570`	`else`
	`571`	`{`
0	`572`	`sessionInfo.DeviceName = deviceOptions.CustomName;`
0	`573`	`sessionInfo.HasCustomDeviceName = true;`
	`574`	`}`
	`575`
40	`576`	`return sessionInfo;`
	`577`	`}`
	`578`
	`579`	`private List<User> GetUsers(SessionInfo session)`
	`580`	`{`
0	`581`	`var users = new List<User>();`
	`582`
0	`583`	`if (session.UserId.IsEmpty())`
	`584`	`{`
0	`585`	`return users;`
	`586`	`}`
	`587`
0	`588`	`var user = _userManager.GetUserById(session.UserId);`
	`589`
0	`590`	`if (user is null)`
	`591`	`{`
0	`592`	`throw new InvalidOperationException("User not found");`
	`593`	`}`
	`594`
0	`595`	`users.Add(user);`
	`596`
0	`597`	`users.AddRange(session.AdditionalUsers`
0	`598`	`.Select(i => _userManager.GetUserById(i.UserId))`
0	`599`	`.Where(i => i is not null));`
	`600`
0	`601`	`return users;`
	`602`	`}`
	`603`
	`604`	`private void StartCheckTimers()`
	`605`	`{`
0	`606`	`_idleTimer ??= new Timer(CheckForIdlePlayback, null, TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));`
	`607`
0	`608`	`if (_config.Configuration.InactiveSessionThreshold > 0)`
	`609`	`{`
0	`610`	`_inactiveTimer ??= new Timer(CheckForInactiveSteams, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes`
	`611`	`}`
	`612`	`else`
	`613`	`{`
0	`614`	`StopInactiveCheckTimer();`
	`615`	`}`
0	`616`	`}`
	`617`
	`618`	`private void StopIdleCheckTimer()`
	`619`	`{`
0	`620`	`if (_idleTimer is not null)`
	`621`	`{`
0	`622`	`_idleTimer.Dispose();`
0	`623`	`_idleTimer = null;`
	`624`	`}`
0	`625`	`}`
	`626`
	`627`	`private void StopInactiveCheckTimer()`
	`628`	`{`
0	`629`	`if (_inactiveTimer is not null)`
	`630`	`{`
0	`631`	`_inactiveTimer.Dispose();`
0	`632`	`_inactiveTimer = null;`
	`633`	`}`
0	`634`	`}`
	`635`
	`636`	`private async void CheckForIdlePlayback(object state)`
	`637`	`{`
0	`638`	`var playingSessions = Sessions.Where(i => i.NowPlayingItem is not null)`
0	`639`	`.ToList();`
	`640`
0	`641`	`if (playingSessions.Count > 0)`
	`642`	`{`
0	`643`	`var idle = playingSessions`
0	`644`	`.Where(i => (DateTime.UtcNow - i.LastPlaybackCheckIn).TotalMinutes > 5)`
0	`645`	`.ToList();`
	`646`
0	`647`	`foreach (var session in idle)`
	`648`	`{`
0	`649`	`_logger.LogDebug("Session {0} has gone idle while playing", session.Id);`
	`650`
	`651`	`try`
	`652`	`{`
0	`653`	`await OnPlaybackStopped(new PlaybackStopInfo`
0	`654`	`{`
0	`655`	`Item = session.NowPlayingItem,`
0	`656`	`ItemId = session.NowPlayingItem is null ? Guid.Empty : session.NowPlayingItem.Id,`
0	`657`	`SessionId = session.Id,`
0	`658`	`MediaSourceId = session.PlayState?.MediaSourceId,`
0	`659`	`PositionTicks = session.PlayState?.PositionTicks`
0	`660`	`}).ConfigureAwait(false);`
0	`661`	`}`
0	`662`	`catch (Exception ex)`
	`663`	`{`
0	`664`	`_logger.LogDebug(ex, "Error calling OnPlaybackStopped");`
0	`665`	`}`
	`666`	`}`
	`667`	`}`
	`668`	`else`
	`669`	`{`
0	`670`	`StopIdleCheckTimer();`
	`671`	`}`
0	`672`	`}`
	`673`
	`674`	`private async void CheckForInactiveSteams(object state)`
	`675`	`{`
0	`676`	`var inactiveSessions = Sessions.Where(i =>`
0	`677`	`i.NowPlayingItem is not null`
0	`678`	`&& i.PlayState.IsPaused`
0	`679`	`&& (DateTime.UtcNow - i.LastPausedDate).Value.TotalMinutes > _config.Configuration.InactiveSessionTh`
	`680`
0	`681`	`foreach (var session in inactiveSessions)`
	`682`	`{`
0	`683`	`_logger.LogDebug("Session {Session} has been inactive for {InactiveTime} minutes. Stopping it.", session`
	`684`
	`685`	`try`
	`686`	`{`
0	`687`	`await SendPlaystateCommand(`
0	`688`	`session.Id,`
0	`689`	`session.Id,`
0	`690`	`new PlaystateRequest()`
0	`691`	`{`
0	`692`	`Command = PlaystateCommand.Stop,`
0	`693`	`ControllingUserId = session.UserId.ToString(),`
0	`694`	`SeekPositionTicks = session.PlayState?.PositionTicks`
0	`695`	`},`
0	`696`	`CancellationToken.None).ConfigureAwait(true);`
0	`697`	`}`
0	`698`	`catch (Exception ex)`
	`699`	`{`
0	`700`	`_logger.LogDebug(ex, "Error calling SendPlaystateCommand for stopping inactive session {Session}.",`
0	`701`	`}`
0	`702`	`}`
	`703`
0	`704`	`bool playingSessions = Sessions.Any(i => i.NowPlayingItem is not null);`
	`705`
0	`706`	`if (!playingSessions)`
	`707`	`{`
0	`708`	`StopInactiveCheckTimer();`
	`709`	`}`
0	`710`	`}`
	`711`
	`712`	`private BaseItem GetNowPlayingItem(SessionInfo session, Guid itemId)`
	`713`	`{`
0	`714`	`if (session is null)`
	`715`	`{`
0	`716`	`return null;`
	`717`	`}`
	`718`
0	`719`	`var item = session.FullNowPlayingItem;`
0	`720`	`if (item is not null && item.Id.Equals(itemId))`
	`721`	`{`
0	`722`	`return item;`
	`723`	`}`
	`724`
0	`725`	`item = _libraryManager.GetItemById(itemId);`
	`726`
0	`727`	`session.FullNowPlayingItem = item;`
	`728`
0	`729`	`return item;`
	`730`	`}`
	`731`
	`732`	`/// <summary>`
	`733`	`/// Resolves the item whose user data (playback position, played status) should be updated`
	`734`	`/// for a playback report. When an alternate version is played the client reports the displayed`
	`735`	`/// item as <c>ItemId</c> and the played version as <c>MediaSourceId</c>.`
	`736`	`/// </summary>`
	`737`	`/// <param name="libraryItem">The now playing (displayed) item.</param>`
	`738`	`/// <param name="mediaSourceId">The reported media source id.</param>`
	`739`	`/// <returns>The item to track progress against.</returns>`
	`740`	`private BaseItem GetProgressItem(BaseItem libraryItem, string mediaSourceId)`
	`741`	`{`
0	`742`	`if (libraryItem is Video libraryVideo`
0	`743`	`&& !string.IsNullOrEmpty(mediaSourceId)`
0	`744`	`&& Guid.TryParse(mediaSourceId, out var mediaSourceItemId)`
0	`745`	`&& !mediaSourceItemId.Equals(libraryVideo.Id))`
	`746`	`{`
0	`747`	`var versionItem = libraryVideo.GetAlternateVersion(mediaSourceItemId);`
0	`748`	`if (versionItem is not null)`
	`749`	`{`
0	`750`	`return versionItem;`
	`751`	`}`
	`752`	`}`
	`753`
0	`754`	`return libraryItem;`
	`755`	`}`
	`756`
	`757`	`/// <summary>`
	`758`	`/// Used to report that playback has started for an item.`
	`759`	`/// </summary>`
	`760`	`/// <param name="info">The info.</param>`
	`761`	`/// <returns>Task.</returns>`
	`762`	`/// <exception cref="ArgumentNullException"><c>info</c> is <c>null</c>.</exception>`
	`763`	`public async Task OnPlaybackStart(PlaybackStartInfo info)`
	`764`	`{`
0	`765`	`CheckDisposed();`
	`766`
0	`767`	`ArgumentNullException.ThrowIfNull(info);`
	`768`
0	`769`	`var session = GetSession(info.SessionId);`
	`770`
0	`771`	`var libraryItem = info.ItemId.IsEmpty()`
0	`772`	`? null`
0	`773`	`: GetNowPlayingItem(session, info.ItemId);`
	`774`
0	`775`	`await UpdateNowPlayingItem(session, info, libraryItem, true).ConfigureAwait(false);`
	`776`
0	`777`	`if (!string.IsNullOrEmpty(session.DeviceId) && info.PlayMethod != PlayMethod.Transcode)`
	`778`	`{`
0	`779`	`ClearTranscodingInfo(session.DeviceId);`
	`780`	`}`
	`781`
0	`782`	`session.StartAutomaticProgress(info);`
	`783`
0	`784`	`var users = GetUsers(session);`
	`785`
0	`786`	`if (libraryItem is not null)`
	`787`	`{`
0	`788`	`var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);`
0	`789`	`foreach (var user in users)`
	`790`	`{`
0	`791`	`OnPlaybackStart(user, progressItem);`
	`792`	`}`
	`793`	`}`
	`794`
0	`795`	`if (!string.IsNullOrEmpty(info.LiveStreamId))`
	`796`	`{`
0	`797`	`UpdateLiveStreamActiveSessionMappings(info.LiveStreamId, info.SessionId, info.PlaySessionId);`
	`798`	`}`
	`799`
0	`800`	`var eventArgs = new PlaybackStartEventArgs`
0	`801`	`{`
0	`802`	`Item = libraryItem,`
0	`803`	`Users = users,`
0	`804`	`MediaSourceId = info.MediaSourceId,`
0	`805`	`MediaInfo = info.Item,`
0	`806`	`DeviceName = session.DeviceName,`
0	`807`	`ClientName = session.Client,`
0	`808`	`DeviceId = session.DeviceId,`
0	`809`	`Session = session,`
0	`810`	`PlaybackPositionTicks = info.PositionTicks,`
0	`811`	`PlaySessionId = info.PlaySessionId`
0	`812`	`};`
	`813`
0	`814`	`if (info.Item is not null)`
	`815`	`{`
0	`816`	`_logger.LogInformation(`
0	`817`	`"User {0} started playback of '{1}' ({2} {3})",`
0	`818`	`session.UserName,`
0	`819`	`info.Item.Name,`
0	`820`	`session.Client,`
0	`821`	`session.ApplicationVersion);`
	`822`	`}`
	`823`
0	`824`	`await _eventManager.PublishAsync(eventArgs).ConfigureAwait(false);`
	`825`
	`826`	`// Nothing to save here`
	`827`	`// Fire events to inform plugins`
0	`828`	`EventHelper.QueueEventIfNotNull(`
0	`829`	`PlaybackStart,`
0	`830`	`this,`
0	`831`	`eventArgs,`
0	`832`	`_logger);`
	`833`
0	`834`	`StartCheckTimers();`
0	`835`	`}`
	`836`
	`837`	`/// <summary>`
	`838`	`/// Called when [playback start].`
	`839`	`/// </summary>`
	`840`	`/// <param name="user">The user object.</param>`
	`841`	`/// <param name="item">The item.</param>`
	`842`	`private void OnPlaybackStart(User user, BaseItem item)`
	`843`	`{`
0	`844`	`var data = _userDataManager.GetUserData(user, item);`
	`845`
0	`846`	`data.PlayCount++;`
0	`847`	`data.LastPlayedDate = DateTime.UtcNow;`
	`848`
0	`849`	`if (item.SupportsPlayedStatus && !item.SupportsPositionTicksResume)`
	`850`	`{`
0	`851`	`data.Played = true;`
	`852`	`}`
	`853`
0	`854`	`_userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackStart, CancellationToken.None);`
0	`855`	`}`
	`856`
	`857`	`/// <inheritdoc />`
	`858`	`public Task OnPlaybackProgress(PlaybackProgressInfo info)`
	`859`	`{`
0	`860`	`return OnPlaybackProgress(info, false);`
	`861`	`}`
	`862`
	`863`	`private void UpdateLiveStreamActiveSessionMappings(string liveStreamId, string sessionId, string playSessionId)`
	`864`	`{`
0	`865`	`var activeSessionMappings = _activeLiveStreamSessions.GetOrAdd(liveStreamId, _ => new ConcurrentDictionary<s`
	`866`
0	`867`	`if (!string.IsNullOrEmpty(playSessionId))`
	`868`	`{`
0	`869`	`if (!activeSessionMappings.TryGetValue(sessionId, out var currentPlaySessionId) \|\| currentPlaySessionId`
	`870`	`{`
0	`871`	`if (!string.IsNullOrEmpty(currentPlaySessionId))`
	`872`	`{`
0	`873`	`activeSessionMappings.TryRemove(currentPlaySessionId, out _);`
	`874`	`}`
	`875`
0	`876`	`activeSessionMappings[sessionId] = playSessionId;`
0	`877`	`activeSessionMappings[playSessionId] = sessionId;`
	`878`	`}`
	`879`	`}`
	`880`	`else`
	`881`	`{`
0	`882`	`if (!activeSessionMappings.TryGetValue(sessionId, out _))`
	`883`	`{`
0	`884`	`activeSessionMappings[sessionId] = string.Empty;`
	`885`	`}`
	`886`	`}`
0	`887`	`}`
	`888`
	`889`	`/// <summary>`
	`890`	`/// Used to report playback progress for an item.`
	`891`	`/// </summary>`
	`892`	`/// <param name="info">The playback progress info.</param>`
	`893`	`/// <param name="isAutomated">Whether this is an automated update.</param>`
	`894`	`/// <returns>Task.</returns>`
	`895`	`public async Task OnPlaybackProgress(PlaybackProgressInfo info, bool isAutomated)`
	`896`	`{`
0	`897`	`CheckDisposed();`
	`898`
0	`899`	`ArgumentNullException.ThrowIfNull(info);`
	`900`
0	`901`	`var session = GetSession(info.SessionId, false);`
0	`902`	`if (session is null)`
	`903`	`{`
0	`904`	`return;`
	`905`	`}`
	`906`
0	`907`	`var libraryItem = info.ItemId.IsEmpty()`
0	`908`	`? null`
0	`909`	`: GetNowPlayingItem(session, info.ItemId);`
	`910`
0	`911`	`await UpdateNowPlayingItem(session, info, libraryItem, !isAutomated).ConfigureAwait(false);`
	`912`
0	`913`	`if (!string.IsNullOrEmpty(session.DeviceId) && info.PlayMethod != PlayMethod.Transcode)`
	`914`	`{`
0	`915`	`ClearTranscodingInfo(session.DeviceId);`
	`916`	`}`
	`917`
0	`918`	`var users = GetUsers(session);`
	`919`
	`920`	`// only update saved user data on actual check-ins, not automated ones`
0	`921`	`if (libraryItem is not null && !isAutomated)`
	`922`	`{`
0	`923`	`var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);`
0	`924`	`foreach (var user in users)`
	`925`	`{`
0	`926`	`OnPlaybackProgress(user, progressItem, info);`
	`927`	`}`
	`928`	`}`
	`929`
0	`930`	`if (!string.IsNullOrEmpty(info.LiveStreamId))`
	`931`	`{`
0	`932`	`UpdateLiveStreamActiveSessionMappings(info.LiveStreamId, info.SessionId, info.PlaySessionId);`
	`933`	`}`
	`934`
0	`935`	`var eventArgs = new PlaybackProgressEventArgs`
0	`936`	`{`
0	`937`	`Item = libraryItem,`
0	`938`	`Users = users,`
0	`939`	`PlaybackPositionTicks = session.PlayState.PositionTicks,`
0	`940`	`MediaSourceId = session.PlayState.MediaSourceId,`
0	`941`	`MediaInfo = info.Item,`
0	`942`	`DeviceName = session.DeviceName,`
0	`943`	`ClientName = session.Client,`
0	`944`	`DeviceId = session.DeviceId,`
0	`945`	`IsPaused = info.IsPaused,`
0	`946`	`PlaySessionId = info.PlaySessionId,`
0	`947`	`IsAutomated = isAutomated,`
0	`948`	`Session = session`
0	`949`	`};`
	`950`
0	`951`	`await _eventManager.PublishAsync(eventArgs).ConfigureAwait(false);`
	`952`
0	`953`	`PlaybackProgress?.Invoke(this, eventArgs);`
	`954`
0	`955`	`if (!isAutomated)`
	`956`	`{`
0	`957`	`session.StartAutomaticProgress(info);`
	`958`	`}`
	`959`
0	`960`	`StartCheckTimers();`
0	`961`	`}`
	`962`
	`963`	`private void OnPlaybackProgress(User user, BaseItem item, PlaybackProgressInfo info)`
	`964`	`{`
0	`965`	`var data = _userDataManager.GetUserData(user, item);`
	`966`
0	`967`	`var positionTicks = info.PositionTicks;`
	`968`
0	`969`	`var changed = false;`
	`970`
0	`971`	`if (positionTicks.HasValue)`
	`972`	`{`
0	`973`	`_userDataManager.UpdatePlayState(item, data, positionTicks.Value);`
0	`974`	`changed = true;`
	`975`	`}`
	`976`
0	`977`	`var tracksChanged = UpdatePlaybackSettings(user, info, data);`
0	`978`	`if (tracksChanged)`
	`979`	`{`
0	`980`	`changed = true;`
	`981`	`}`
	`982`
0	`983`	`if (changed)`
	`984`	`{`
0	`985`	`_userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackProgress, CancellationToken.N`
	`986`
	`987`	`// A completed version marks every alternate version played and clears their resume points, so the`
	`988`	`// whole movie leaves Continue Watching and reads as watched everywhere. (Per-version resume positions`
	`989`	`// only persist while nothing has been completed yet.)`
0	`990`	`if (data.Played == true && item is Video playedVideo)`
	`991`	`{`
0	`992`	`playedVideo.PropagatePlayedState(user, true);`
	`993`	`}`
	`994`	`}`
	`995`
0	`996`	`if ((!user.RememberAudioSelections && info.AudioStreamIndex.HasValue)`
0	`997`	`\|\| (!user.RememberSubtitleSelections && info.SubtitleStreamIndex.HasValue))`
	`998`	`{`
0	`999`	`_userDataManager.ResetPlaybackStreamSelections(user, item);`
	`1000`	`}`
0	`1001`	`}`
	`1002`
	`1003`	`private static bool UpdatePlaybackSettings(User user, PlaybackProgressInfo info, UserItemData data)`
	`1004`	`{`
0	`1005`	`var changed = false;`
	`1006`
0	`1007`	`if (user.RememberAudioSelections)`
	`1008`	`{`
0	`1009`	`if (info.AudioStreamIndex.HasValue && data.AudioStreamIndex != info.AudioStreamIndex)`
	`1010`	`{`
0	`1011`	`data.AudioStreamIndex = info.AudioStreamIndex;`
0	`1012`	`changed = true;`
	`1013`	`}`
	`1014`	`}`
	`1015`	`else`
	`1016`	`{`
0	`1017`	`if (data.AudioStreamIndex.HasValue)`
	`1018`	`{`
0	`1019`	`data.AudioStreamIndex = null;`
0	`1020`	`changed = true;`
	`1021`	`}`
	`1022`	`}`
	`1023`
0	`1024`	`if (user.RememberSubtitleSelections)`
	`1025`	`{`
0	`1026`	`if (info.SubtitleStreamIndex.HasValue && data.SubtitleStreamIndex != info.SubtitleStreamIndex)`
	`1027`	`{`
0	`1028`	`data.SubtitleStreamIndex = info.SubtitleStreamIndex;`
0	`1029`	`changed = true;`
	`1030`	`}`
	`1031`	`}`
	`1032`	`else`
	`1033`	`{`
0	`1034`	`if (data.SubtitleStreamIndex.HasValue)`
	`1035`	`{`
0	`1036`	`data.SubtitleStreamIndex = null;`
0	`1037`	`changed = true;`
	`1038`	`}`
	`1039`	`}`
	`1040`
0	`1041`	`return changed;`
	`1042`	`}`
	`1043`
	`1044`	`/// <summary>`
	`1045`	`/// Used to report that playback has ended for an item.`
	`1046`	`/// </summary>`
	`1047`	`/// <param name="info">The info.</param>`
	`1048`	`/// <returns>Task.</returns>`
	`1049`	`/// <exception cref="ArgumentNullException"><c>info</c> is <c>null</c>.</exception>`
	`1050`	`/// <exception cref="ArgumentOutOfRangeException"><c>info.PositionTicks</c> is <c>null</c> or negative.</excepti`
	`1051`	`public async Task OnPlaybackStopped(PlaybackStopInfo info)`
	`1052`	`{`
0	`1053`	`CheckDisposed();`
	`1054`
0	`1055`	`ArgumentNullException.ThrowIfNull(info);`
	`1056`
0	`1057`	`var session = GetSession(info.SessionId);`
	`1058`
0	`1059`	`session.StopAutomaticProgress();`
	`1060`
0	`1061`	`if (info.PositionTicks.HasValue && info.PositionTicks.Value < 0)`
	`1062`	`{`
	`1063`	`// Ensure live stream is cleaned up before throwing, to prevent tuner`
	`1064`	`// resource leaks when stalled clients report a negative PositionTicks.`
0	`1065`	`if (!string.IsNullOrEmpty(info.LiveStreamId))`
	`1066`	`{`
0	`1067`	`await CloseLiveStreamIfNeededAsync(info.LiveStreamId, session.Id).ConfigureAwait(false);`
	`1068`	`}`
	`1069`
0	`1070`	`throw new ArgumentOutOfRangeException(nameof(info), "The PlaybackStopInfo's PositionTicks was negative."`
	`1071`	`}`
	`1072`
0	`1073`	`var libraryItem = info.ItemId.IsEmpty()`
0	`1074`	`? null`
0	`1075`	`: GetNowPlayingItem(session, info.ItemId);`
	`1076`
	`1077`	`// Normalize`
0	`1078`	`if (string.IsNullOrEmpty(info.MediaSourceId))`
	`1079`	`{`
0	`1080`	`info.MediaSourceId = info.ItemId.ToString("N", CultureInfo.InvariantCulture);`
	`1081`	`}`
	`1082`
0	`1083`	`if (!info.ItemId.IsEmpty() && info.Item is null && libraryItem is not null)`
	`1084`	`{`
0	`1085`	`var current = session.NowPlayingItem;`
	`1086`
0	`1087`	`if (current is null \|\| !info.ItemId.Equals(current.Id))`
	`1088`	`{`
0	`1089`	`MediaSourceInfo mediaSource = null;`
	`1090`
0	`1091`	`if (libraryItem is IHasMediaSources)`
	`1092`	`{`
0	`1093`	`mediaSource = await GetMediaSource(libraryItem, info.MediaSourceId, info.LiveStreamId).Configure`
	`1094`	`}`
	`1095`
0	`1096`	`info.Item = GetItemInfo(libraryItem, mediaSource);`
	`1097`	`}`
	`1098`	`else`
	`1099`	`{`
0	`1100`	`info.Item = current;`
	`1101`	`}`
	`1102`	`}`
	`1103`
0	`1104`	`if (info.Item is not null)`
	`1105`	`{`
0	`1106`	`var msString = info.PositionTicks.HasValue ? (info.PositionTicks.Value / 10000).ToString(CultureInfo.Inv`
	`1107`
0	`1108`	`_logger.LogInformation(`
0	`1109`	`"User {0} stopped playback of '{1}' at {2}ms ({3} {4})",`
0	`1110`	`session.UserName,`
0	`1111`	`info.Item.Name,`
0	`1112`	`msString,`
0	`1113`	`session.Client,`
0	`1114`	`session.ApplicationVersion);`
	`1115`	`}`
	`1116`
0	`1117`	`if (info.NowPlayingQueue is not null)`
	`1118`	`{`
0	`1119`	`session.NowPlayingQueue = info.NowPlayingQueue;`
	`1120`	`}`
	`1121`
0	`1122`	`session.PlaylistItemId = info.PlaylistItemId;`
	`1123`
0	`1124`	`RemoveNowPlayingItem(session);`
	`1125`
0	`1126`	`var users = GetUsers(session);`
0	`1127`	`var playedToCompletion = false;`
	`1128`
0	`1129`	`if (libraryItem is not null)`
	`1130`	`{`
0	`1131`	`var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);`
0	`1132`	`foreach (var user in users)`
	`1133`	`{`
0	`1134`	`playedToCompletion = OnPlaybackStopped(user, progressItem, info.PositionTicks, info.Failed);`
	`1135`	`}`
	`1136`	`}`
	`1137`
0	`1138`	`if (!string.IsNullOrEmpty(info.LiveStreamId))`
	`1139`	`{`
0	`1140`	`await CloseLiveStreamIfNeededAsync(info.LiveStreamId, session.Id).ConfigureAwait(false);`
	`1141`	`}`
	`1142`
0	`1143`	`var eventArgs = new PlaybackStopEventArgs`
0	`1144`	`{`
0	`1145`	`Item = libraryItem,`
0	`1146`	`Users = users,`
0	`1147`	`PlaybackPositionTicks = info.PositionTicks,`
0	`1148`	`PlayedToCompletion = playedToCompletion,`
0	`1149`	`MediaSourceId = info.MediaSourceId,`
0	`1150`	`MediaInfo = info.Item,`
0	`1151`	`DeviceName = session.DeviceName,`
0	`1152`	`ClientName = session.Client,`
0	`1153`	`DeviceId = session.DeviceId,`
0	`1154`	`Session = session,`
0	`1155`	`PlaySessionId = info.PlaySessionId`
0	`1156`	`};`
	`1157`
0	`1158`	`await _eventManager.PublishAsync(eventArgs).ConfigureAwait(false);`
	`1159`
0	`1160`	`EventHelper.QueueEventIfNotNull(PlaybackStopped, this, eventArgs, _logger);`
0	`1161`	`}`
	`1162`
	`1163`	`private bool OnPlaybackStopped(User user, BaseItem item, long? positionTicks, bool playbackFailed)`
	`1164`	`{`
0	`1165`	`if (playbackFailed)`
	`1166`	`{`
0	`1167`	`return false;`
	`1168`	`}`
	`1169`
0	`1170`	`var data = _userDataManager.GetUserData(user, item);`
	`1171`	`bool playedToCompletion;`
0	`1172`	`if (positionTicks.HasValue)`
	`1173`	`{`
0	`1174`	`playedToCompletion = _userDataManager.UpdatePlayState(item, data, positionTicks.Value);`
	`1175`	`}`
	`1176`	`else`
	`1177`	`{`
	`1178`	`// If the client isn't able to report this, then we'll just have to make an assumption`
0	`1179`	`data.PlayCount++;`
0	`1180`	`data.Played = item.SupportsPlayedStatus;`
0	`1181`	`data.PlaybackPositionTicks = 0;`
0	`1182`	`playedToCompletion = true;`
	`1183`	`}`
	`1184`
0	`1185`	`_userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackFinished, CancellationToken.None)`
	`1186`
	`1187`	`// A completed version marks every alternate version played and clears their resume points, so the`
	`1188`	`// whole movie leaves Continue Watching and reads as watched everywhere. (Per-version resume positions`
	`1189`	`// only persist while nothing has been completed yet.)`
0	`1190`	`if (data.Played == true && item is Video playedVideo)`
	`1191`	`{`
0	`1192`	`playedVideo.PropagatePlayedState(user, true);`
	`1193`	`}`
	`1194`
0	`1195`	`return playedToCompletion;`
	`1196`	`}`
	`1197`
	`1198`	`/// <summary>`
	`1199`	`/// Gets the session.`
	`1200`	`/// </summary>`
	`1201`	`/// <param name="sessionId">The session identifier.</param>`
	`1202`	`/// <param name="throwOnMissing">if set to <c>true</c> [throw on missing].</param>`
	`1203`	`/// <returns>SessionInfo.</returns>`
	`1204`	`/// <exception cref="ResourceNotFoundException">`
	`1205`	`/// No session with an Id equal to <c>sessionId</c> was found`
	`1206`	`/// and <c>throwOnMissing</c> is <c>true</c>.`
	`1207`	`/// </exception>`
	`1208`	`private SessionInfo GetSession(string sessionId, bool throwOnMissing = true)`
	`1209`	`{`
3	`1210`	`var session = Sessions.FirstOrDefault(i => string.Equals(i.Id, sessionId, StringComparison.Ordinal));`
3	`1211`	`if (session is null && throwOnMissing)`
	`1212`	`{`
1	`1213`	`throw new ResourceNotFoundException(`
1	`1214`	`string.Format(CultureInfo.InvariantCulture, "Session {0} not found.", sessionId));`
	`1215`	`}`
	`1216`
2	`1217`	`return session;`
	`1218`	`}`
	`1219`
	`1220`	`private SessionInfo GetSessionToRemoteControl(string sessionId)`
	`1221`	`{`
	`1222`	`// Accept either device id or session id`
0	`1223`	`var session = Sessions.FirstOrDefault(i => string.Equals(i.Id, sessionId, StringComparison.Ordinal));`
	`1224`
0	`1225`	`if (session is null)`
	`1226`	`{`
0	`1227`	`throw new ResourceNotFoundException(`
0	`1228`	`string.Format(CultureInfo.InvariantCulture, "Session {0} not found.", sessionId));`
	`1229`	`}`
	`1230`
0	`1231`	`return session;`
	`1232`	`}`
	`1233`
	`1234`	`/// <inheritdoc />`
	`1235`	`public SessionInfoDto ToSessionInfoDto(SessionInfo sessionInfo)`
	`1236`	`{`
16	`1237`	`return new SessionInfoDto`
16	`1238`	`{`
16	`1239`	`PlayState = sessionInfo.PlayState,`
16	`1240`	`AdditionalUsers = sessionInfo.AdditionalUsers,`
16	`1241`	`Capabilities = _deviceManager.ToClientCapabilitiesDto(sessionInfo.Capabilities),`
16	`1242`	`RemoteEndPoint = sessionInfo.RemoteEndPoint,`
16	`1243`	`PlayableMediaTypes = sessionInfo.PlayableMediaTypes,`
16	`1244`	`Id = sessionInfo.Id,`
16	`1245`	`UserId = sessionInfo.UserId,`
16	`1246`	`UserName = sessionInfo.UserName,`
16	`1247`	`Client = sessionInfo.Client,`
16	`1248`	`LastActivityDate = sessionInfo.LastActivityDate,`
16	`1249`	`LastPlaybackCheckIn = sessionInfo.LastPlaybackCheckIn,`
16	`1250`	`LastPausedDate = sessionInfo.LastPausedDate,`
16	`1251`	`DeviceName = sessionInfo.DeviceName,`
16	`1252`	`DeviceType = sessionInfo.DeviceType,`
16	`1253`	`NowPlayingItem = sessionInfo.NowPlayingItem,`
16	`1254`	`NowViewingItem = sessionInfo.NowViewingItem,`
16	`1255`	`DeviceId = sessionInfo.DeviceId,`
16	`1256`	`ApplicationVersion = sessionInfo.ApplicationVersion,`
16	`1257`	`TranscodingInfo = sessionInfo.TranscodingInfo,`
16	`1258`	`IsActive = sessionInfo.IsActive,`
16	`1259`	`SupportsMediaControl = sessionInfo.SupportsMediaControl,`
16	`1260`	`SupportsRemoteControl = sessionInfo.SupportsRemoteControl,`
16	`1261`	`NowPlayingQueue = sessionInfo.NowPlayingQueue,`
16	`1262`	`HasCustomDeviceName = sessionInfo.HasCustomDeviceName,`
16	`1263`	`PlaylistItemId = sessionInfo.PlaylistItemId,`
16	`1264`	`ServerId = sessionInfo.ServerId,`
16	`1265`	`UserPrimaryImageTag = sessionInfo.UserPrimaryImageTag,`
16	`1266`	`SupportedCommands = sessionInfo.SupportedCommands`
16	`1267`	`};`
	`1268`	`}`
	`1269`
	`1270`	`/// <inheritdoc />`
	`1271`	`public Task SendMessageCommand(string controllingSessionId, string sessionId, MessageCommand command, Cancellati`
	`1272`	`{`
0	`1273`	`CheckDisposed();`
	`1274`
0	`1275`	`var generalCommand = new GeneralCommand`
0	`1276`	`{`
0	`1277`	`Name = GeneralCommandType.DisplayMessage`
0	`1278`	`};`
	`1279`
0	`1280`	`generalCommand.Arguments["Header"] = command.Header;`
0	`1281`	`generalCommand.Arguments["Text"] = command.Text;`
	`1282`
0	`1283`	`if (command.TimeoutMs.HasValue)`
	`1284`	`{`
0	`1285`	`generalCommand.Arguments["TimeoutMs"] = command.TimeoutMs.Value.ToString(CultureInfo.InvariantCulture);`
	`1286`	`}`
	`1287`
0	`1288`	`return SendGeneralCommand(controllingSessionId, sessionId, generalCommand, cancellationToken);`
	`1289`	`}`
	`1290`
	`1291`	`/// <inheritdoc />`
	`1292`	`public Task SendGeneralCommand(string controllingSessionId, string sessionId, GeneralCommand command, Cancellati`
	`1293`	`{`
0	`1294`	`CheckDisposed();`
	`1295`
0	`1296`	`var session = GetSessionToRemoteControl(sessionId);`
	`1297`
0	`1298`	`if (!string.IsNullOrEmpty(controllingSessionId))`
	`1299`	`{`
0	`1300`	`var controllingSession = GetSession(controllingSessionId);`
0	`1301`	`AssertCanControl(session, controllingSession);`
	`1302`	`}`
	`1303`
0	`1304`	`return SendMessageToSession(session, SessionMessageType.GeneralCommand, command, cancellationToken);`
	`1305`	`}`
	`1306`
	`1307`	`private static async Task SendMessageToSession<T>(SessionInfo session, SessionMessageType name, T data, Cancella`
	`1308`	`{`
2	`1309`	`var controllers = session.SessionControllers;`
2	`1310`	`var messageId = Guid.NewGuid();`
	`1311`
8	`1312`	`foreach (var controller in controllers)`
	`1313`	`{`
2	`1314`	`await controller.SendMessage(name, messageId, data, cancellationToken).ConfigureAwait(false);`
	`1315`	`}`
2	`1316`	`}`
	`1317`
	`1318`	`private static Task SendMessageToSessions<T>(IEnumerable<SessionInfo> sessions, SessionMessageType name, T data,`
	`1319`	`{`
	`1320`	`IEnumerable<Task> GetTasks()`
	`1321`	`{`
	`1322`	`var messageId = Guid.NewGuid();`
	`1323`	`foreach (var session in sessions)`
	`1324`	`{`
	`1325`	`var controllers = session.SessionControllers;`
	`1326`	`foreach (var controller in controllers)`
	`1327`	`{`
	`1328`	`yield return controller.SendMessage(name, messageId, data, cancellationToken);`
	`1329`	`}`
	`1330`	`}`
	`1331`	`}`
	`1332`
24	`1333`	`return Task.WhenAll(GetTasks());`
	`1334`	`}`
	`1335`
	`1336`	`/// <inheritdoc />`
	`1337`	`public async Task SendPlayCommand(string controllingSessionId, string sessionId, PlayRequest command, Cancellati`
	`1338`	`{`
0	`1339`	`CheckDisposed();`
	`1340`
0	`1341`	`var session = GetSessionToRemoteControl(sessionId);`
	`1342`
0	`1343`	`var user = session.UserId.IsEmpty() ? null : _userManager.GetUserById(session.UserId);`
	`1344`
	`1345`	`List<BaseItem> items;`
	`1346`
0	`1347`	`if (command.PlayCommand == PlayCommand.PlayInstantMix)`
	`1348`	`{`
0	`1349`	`items = command.ItemIds.SelectMany(i => TranslateItemForInstantMix(i, user))`
0	`1350`	`.ToList();`
	`1351`
0	`1352`	`command.PlayCommand = PlayCommand.PlayNow;`
	`1353`	`}`
	`1354`	`else`
	`1355`	`{`
0	`1356`	`var list = new List<BaseItem>();`
0	`1357`	`foreach (var itemId in command.ItemIds)`
	`1358`	`{`
0	`1359`	`var subItems = TranslateItemForPlayback(itemId, user);`
0	`1360`	`list.AddRange(subItems);`
	`1361`	`}`
	`1362`
0	`1363`	`items = list;`
	`1364`	`}`
	`1365`
0	`1366`	`if (command.PlayCommand == PlayCommand.PlayShuffle)`
	`1367`	`{`
0	`1368`	`items.Shuffle();`
0	`1369`	`command.PlayCommand = PlayCommand.PlayNow;`
	`1370`	`}`
	`1371`
0	`1372`	`command.ItemIds = items.Select(i => i.Id).ToArray();`
	`1373`
0	`1374`	`if (user is not null)`
	`1375`	`{`
0	`1376`	`if (items.Any(i => i.GetPlayAccess(user) != PlayAccess.Full))`
	`1377`	`{`
0	`1378`	`throw new ArgumentException(`
0	`1379`	`string.Format(CultureInfo.InvariantCulture, "{0} is not allowed to play media.", user.Username))`
	`1380`	`}`
	`1381`	`}`
	`1382`
0	`1383`	`if (user is not null`
0	`1384`	`&& command.ItemIds.Length == 1`
0	`1385`	`&& user.EnableNextEpisodeAutoPlay`
0	`1386`	`&& _libraryManager.GetItemById(command.ItemIds[0]) is Episode episode)`
	`1387`	`{`
0	`1388`	`var series = episode.Series;`
0	`1389`	`if (series is not null)`
	`1390`	`{`
0	`1391`	`var episodes = series.GetEpisodes(`
0	`1392`	`user,`
0	`1393`	`new DtoOptions(false)`
0	`1394`	`{`
0	`1395`	`EnableImages = false`
0	`1396`	`},`
0	`1397`	`user.DisplayMissingEpisodes)`
0	`1398`	`.Where(i => !i.IsVirtualItem)`
0	`1399`	`.SkipWhile(i => !i.Id.Equals(episode.Id))`
0	`1400`	`.ToList();`
	`1401`
0	`1402`	`if (episodes.Count > 0)`
	`1403`	`{`
0	`1404`	`command.ItemIds = episodes.Select(i => i.Id).ToArray();`
	`1405`	`}`
	`1406`	`}`
	`1407`	`}`
	`1408`
0	`1409`	`if (!string.IsNullOrEmpty(controllingSessionId))`
	`1410`	`{`
0	`1411`	`var controllingSession = GetSession(controllingSessionId);`
0	`1412`	`AssertCanControl(session, controllingSession);`
0	`1413`	`if (!controllingSession.UserId.IsEmpty())`
	`1414`	`{`
0	`1415`	`command.ControllingUserId = controllingSession.UserId;`
	`1416`	`}`
	`1417`	`}`
	`1418`
0	`1419`	`await SendMessageToSession(session, SessionMessageType.Play, command, cancellationToken).ConfigureAwait(fals`
0	`1420`	`}`
	`1421`
	`1422`	`/// <inheritdoc />`
	`1423`	`public async Task SendSyncPlayCommand(string sessionId, SendCommand command, CancellationToken cancellationToken`
	`1424`	`{`
1	`1425`	`CheckDisposed();`
1	`1426`	`var session = GetSession(sessionId);`
1	`1427`	`await SendMessageToSession(session, SessionMessageType.SyncPlayCommand, command, cancellationToken).Configur`
1	`1428`	`}`
	`1429`
	`1430`	`/// <inheritdoc />`
	`1431`	`public async Task SendSyncPlayGroupUpdate<T>(string sessionId, GroupUpdate<T> command, CancellationToken cancell`
	`1432`	`{`
2	`1433`	`CheckDisposed();`
2	`1434`	`var session = GetSession(sessionId);`
1	`1435`	`await SendMessageToSession(session, SessionMessageType.SyncPlayGroupUpdate, command, cancellationToken).Conf`
1	`1436`	`}`
	`1437`
	`1438`	`private IEnumerable<BaseItem> TranslateItemForPlayback(Guid id, User user)`
	`1439`	`{`
0	`1440`	`var item = _libraryManager.GetItemById(id);`
	`1441`
0	`1442`	`if (item is null)`
	`1443`	`{`
0	`1444`	`_logger.LogError("A nonexistent item Id {0} was passed into TranslateItemForPlayback", id);`
0	`1445`	`return Array.Empty<BaseItem>();`
	`1446`	`}`
	`1447`
0	`1448`	`if (item is IItemByName byName)`
	`1449`	`{`
0	`1450`	`return byName.GetTaggedItems(new InternalItemsQuery(user)`
0	`1451`	`{`
0	`1452`	`IsFolder = false,`
0	`1453`	`Recursive = true,`
0	`1454`	`DtoOptions = new DtoOptions(false)`
0	`1455`	`{`
0	`1456`	`EnableImages = false,`
0	`1457`	`Fields = new[]`
0	`1458`	`{`
0	`1459`	`ItemFields.SortName`
0	`1460`	`}`
0	`1461`	`},`
0	`1462`	`IsVirtualItem = false,`
0	`1463`	`OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) }`
0	`1464`	`});`
	`1465`	`}`
	`1466`
0	`1467`	`if (item.IsFolder)`
	`1468`	`{`
0	`1469`	`var folder = (Folder)item;`
	`1470`
0	`1471`	`return folder.GetItemList(new InternalItemsQuery(user)`
0	`1472`	`{`
0	`1473`	`Recursive = true,`
0	`1474`	`IsFolder = false,`
0	`1475`	`DtoOptions = new DtoOptions(false)`
0	`1476`	`{`
0	`1477`	`EnableImages = false,`
0	`1478`	`Fields = new ItemFields[]`
0	`1479`	`{`
0	`1480`	`ItemFields.SortName`
0	`1481`	`}`
0	`1482`	`},`
0	`1483`	`IsVirtualItem = false,`
0	`1484`	`OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) }`
0	`1485`	`});`
	`1486`	`}`
	`1487`
0	`1488`	`return new[] { item };`
	`1489`	`}`
	`1490`
	`1491`	`private List<BaseItem> TranslateItemForInstantMix(Guid id, User user)`
	`1492`	`{`
0	`1493`	`var item = _libraryManager.GetItemById(id);`
	`1494`
0	`1495`	`if (item is null)`
	`1496`	`{`
0	`1497`	`_logger.LogError("A nonexistent item Id {0} was passed into TranslateItemForInstantMix", id);`
0	`1498`	`return new List<BaseItem>();`
	`1499`	`}`
	`1500`
0	`1501`	`return _musicManager.GetInstantMixFromItem(item, user, new DtoOptions(false) { EnableImages = false }).ToLis`
	`1502`	`}`
	`1503`
	`1504`	`/// <inheritdoc />`
	`1505`	`public Task SendBrowseCommand(string controllingSessionId, string sessionId, BrowseRequest command, Cancellation`
	`1506`	`{`
0	`1507`	`var generalCommand = new GeneralCommand`
0	`1508`	`{`
0	`1509`	`Name = GeneralCommandType.DisplayContent,`
0	`1510`	`Arguments =`
0	`1511`	`{`
0	`1512`	`["ItemId"] = command.ItemId,`
0	`1513`	`["ItemName"] = command.ItemName,`
0	`1514`	`["ItemType"] = command.ItemType.ToString()`
0	`1515`	`}`
0	`1516`	`};`
	`1517`
0	`1518`	`return SendGeneralCommand(controllingSessionId, sessionId, generalCommand, cancellationToken);`
	`1519`	`}`
	`1520`
	`1521`	`/// <inheritdoc />`
	`1522`	`public Task SendPlaystateCommand(string controllingSessionId, string sessionId, PlaystateRequest command, Cancel`
	`1523`	`{`
0	`1524`	`CheckDisposed();`
	`1525`
0	`1526`	`var session = GetSessionToRemoteControl(sessionId);`
	`1527`
0	`1528`	`if (!string.IsNullOrEmpty(controllingSessionId))`
	`1529`	`{`
0	`1530`	`var controllingSession = GetSession(controllingSessionId);`
0	`1531`	`AssertCanControl(session, controllingSession);`
0	`1532`	`if (!controllingSession.UserId.IsEmpty())`
	`1533`	`{`
0	`1534`	`command.ControllingUserId = controllingSession.UserId.ToString("N", CultureInfo.InvariantCulture);`
	`1535`	`}`
	`1536`	`}`
	`1537`
0	`1538`	`return SendMessageToSession(session, SessionMessageType.Playstate, command, cancellationToken);`
	`1539`	`}`
	`1540`
	`1541`	`private static void AssertCanControl(SessionInfo session, SessionInfo controllingSession)`
	`1542`	`{`
0	`1543`	`ArgumentNullException.ThrowIfNull(session);`
	`1544`
0	`1545`	`ArgumentNullException.ThrowIfNull(controllingSession);`
0	`1546`	`}`
	`1547`
	`1548`	`/// <summary>`
	`1549`	`/// Sends the restart required message.`
	`1550`	`/// </summary>`
	`1551`	`/// <param name="cancellationToken">The cancellation token.</param>`
	`1552`	`/// <returns>Task.</returns>`
	`1553`	`public Task SendRestartRequiredNotification(CancellationToken cancellationToken)`
	`1554`	`{`
0	`1555`	`CheckDisposed();`
	`1556`
0	`1557`	`return SendMessageToSessions(Sessions, SessionMessageType.RestartRequired, string.Empty, cancellationToken);`
	`1558`	`}`
	`1559`
	`1560`	`/// <summary>`
	`1561`	`/// Adds the additional user.`
	`1562`	`/// </summary>`
	`1563`	`/// <param name="sessionId">The session identifier.</param>`
	`1564`	`/// <param name="userId">The user identifier.</param>`
	`1565`	`/// <exception cref="UnauthorizedAccessException">Cannot modify additional users without authenticating first.</`
	`1566`	`/// <exception cref="ArgumentException">The requested user is already the primary user of the session.</exceptio`
	`1567`	`public void AddAdditionalUser(string sessionId, Guid userId)`
	`1568`	`{`
0	`1569`	`CheckDisposed();`
	`1570`
0	`1571`	`var session = GetSession(sessionId);`
	`1572`
0	`1573`	`if (session.UserId.Equals(userId))`
	`1574`	`{`
0	`1575`	`throw new ArgumentException("The requested user is already the primary user of the session.");`
	`1576`	`}`
	`1577`
0	`1578`	`if (session.AdditionalUsers.All(i => !i.UserId.Equals(userId)))`
	`1579`	`{`
0	`1580`	`var user = _userManager.GetUserById(userId);`
0	`1581`	`var newUser = new SessionUserInfo`
0	`1582`	`{`
0	`1583`	`UserId = userId,`
0	`1584`	`UserName = user.Username`
0	`1585`	`};`
	`1586`
0	`1587`	`session.AdditionalUsers = [.. session.AdditionalUsers, newUser];`
	`1588`	`}`
0	`1589`	`}`
	`1590`
	`1591`	`/// <summary>`
	`1592`	`/// Removes the additional user.`
	`1593`	`/// </summary>`
	`1594`	`/// <param name="sessionId">The session identifier.</param>`
	`1595`	`/// <param name="userId">The user identifier.</param>`
	`1596`	`/// <exception cref="UnauthorizedAccessException">Cannot modify additional users without authenticating first.</`
	`1597`	`/// <exception cref="ArgumentException">The requested user is already the primary user of the session.</exceptio`
	`1598`	`public void RemoveAdditionalUser(string sessionId, Guid userId)`
	`1599`	`{`
0	`1600`	`CheckDisposed();`
	`1601`
0	`1602`	`var session = GetSession(sessionId);`
	`1603`
0	`1604`	`if (session.UserId.Equals(userId))`
	`1605`	`{`
0	`1606`	`throw new ArgumentException("The requested user is already the primary user of the session.");`
	`1607`	`}`
	`1608`
0	`1609`	`var user = session.AdditionalUsers.FirstOrDefault(i => i.UserId.Equals(userId));`
	`1610`
0	`1611`	`if (user is not null)`
	`1612`	`{`
0	`1613`	`var list = session.AdditionalUsers.ToList();`
0	`1614`	`list.Remove(user);`
	`1615`
0	`1616`	`session.AdditionalUsers = list.ToArray();`
	`1617`	`}`
0	`1618`	`}`
	`1619`
	`1620`	`/// <summary>`
	`1621`	`/// Authenticates the new session.`
	`1622`	`/// </summary>`
	`1623`	`/// <param name="request">The authenticationrequest.</param>`
	`1624`	`/// <returns>The authentication result.</returns>`
	`1625`	`public Task<AuthenticationResult> AuthenticateNewSession(AuthenticationRequest request)`
	`1626`	`{`
16	`1627`	`return AuthenticateNewSessionInternal(request, true);`
	`1628`	`}`
	`1629`
	`1630`	`/// <summary>`
	`1631`	`/// Directly authenticates the session without enforcing password.`
	`1632`	`/// </summary>`
	`1633`	`/// <param name="request">The authentication request.</param>`
	`1634`	`/// <returns>The authentication result.</returns>`
	`1635`	`public Task<AuthenticationResult> AuthenticateDirect(AuthenticationRequest request)`
	`1636`	`{`
0	`1637`	`return AuthenticateNewSessionInternal(request, false);`
	`1638`	`}`
	`1639`
	`1640`	`internal async Task<AuthenticationResult> AuthenticateNewSessionInternal(AuthenticationRequest request, bool enf`
	`1641`	`{`
24	`1642`	`CheckDisposed();`
	`1643`
24	`1644`	`ArgumentException.ThrowIfNullOrEmpty(request.App);`
22	`1645`	`ArgumentException.ThrowIfNullOrEmpty(request.DeviceId);`
20	`1646`	`ArgumentException.ThrowIfNullOrEmpty(request.DeviceName);`
18	`1647`	`ArgumentException.ThrowIfNullOrEmpty(request.AppVersion);`
	`1648`
16	`1649`	`User user = null;`
16	`1650`	`if (!request.UserId.IsEmpty())`
	`1651`	`{`
0	`1652`	`user = _userManager.GetUserById(request.UserId);`
	`1653`	`}`
	`1654`
16	`1655`	`user ??= _userManager.GetUserByName(request.Username);`
	`1656`
16	`1657`	`if (enforcePassword)`
	`1658`	`{`
16	`1659`	`user = await _userManager.AuthenticateUser(`
16	`1660`	`request.Username,`
16	`1661`	`request.Password,`
16	`1662`	`request.RemoteEndPoint,`
16	`1663`	`true).ConfigureAwait(false);`
	`1664`	`}`
	`1665`
16	`1666`	`if (user is null)`
	`1667`	`{`
0	`1668`	`await _eventManager.PublishAsync(new AuthenticationRequestEventArgs(request)).ConfigureAwait(false);`
0	`1669`	`throw new AuthenticationException("Invalid username or password entered.");`
	`1670`	`}`
	`1671`
16	`1672`	`if (!string.IsNullOrEmpty(request.DeviceId)`
16	`1673`	`&& !_deviceManager.CanAccessDevice(user, request.DeviceId))`
	`1674`	`{`
0	`1675`	`throw new SecurityException("User is not allowed access from this device.");`
	`1676`	`}`
	`1677`
16	`1678`	`int sessionsCount = Sessions.Count(i => i.UserId.Equals(user.Id));`
16	`1679`	`int maxActiveSessions = user.MaxActiveSessions;`
16	`1680`	`_logger.LogInformation("Current/Max sessions for user {User}: {Sessions}/{Max}", user.Username, sessionsCoun`
16	`1681`	`if (maxActiveSessions >= 1 && sessionsCount >= maxActiveSessions)`
	`1682`	`{`
0	`1683`	`throw new SecurityException("User is at their maximum number of sessions.");`
	`1684`	`}`
	`1685`
16	`1686`	`var token = await GetAuthorizationToken(user, request.DeviceId, request.App, request.AppVersion, request.Dev`
	`1687`
16	`1688`	`var session = await LogSessionActivity(`
16	`1689`	`request.App,`
16	`1690`	`request.AppVersion,`
16	`1691`	`request.DeviceId,`
16	`1692`	`request.DeviceName,`
16	`1693`	`request.RemoteEndPoint,`
16	`1694`	`user).ConfigureAwait(false);`
	`1695`
16	`1696`	`var returnResult = new AuthenticationResult`
16	`1697`	`{`
16	`1698`	`User = _userManager.GetUserDto(user, request.RemoteEndPoint),`
16	`1699`	`SessionInfo = ToSessionInfoDto(session),`
16	`1700`	`AccessToken = token,`
16	`1701`	`ServerId = _appHost.SystemId`
16	`1702`	`};`
	`1703`
16	`1704`	`await _eventManager.PublishAsync(new AuthenticationResultEventArgs(returnResult)).ConfigureAwait(false);`
16	`1705`	`return returnResult;`
16	`1706`	`}`
	`1707`
	`1708`	`internal async Task<string> GetAuthorizationToken(User user, string deviceId, string app, string appVersion, str`
	`1709`	`{`
	`1710`	`// This should be validated above, but if it isn't don't delete all tokens.`
18	`1711`	`ArgumentException.ThrowIfNullOrEmpty(deviceId);`
	`1712`
16	`1713`	`var existing = _deviceManager.GetDevices(`
16	`1714`	`new DeviceQuery`
16	`1715`	`{`
16	`1716`	`DeviceId = deviceId,`
16	`1717`	`UserId = user.Id`
16	`1718`	`}).Items;`
	`1719`
32	`1720`	`foreach (var auth in existing)`
	`1721`	`{`
	`1722`	`try`
	`1723`	`{`
	`1724`	`// Logout any existing sessions for the user on this device`
0	`1725`	`await Logout(auth).ConfigureAwait(false);`
0	`1726`	`}`
0	`1727`	`catch (Exception ex)`
	`1728`	`{`
0	`1729`	`_logger.LogError(ex, "Error while logging out existing session.");`
0	`1730`	`}`
	`1731`	`}`
	`1732`
16	`1733`	`_logger.LogInformation("Creating new access token for user {0}", user.Id);`
16	`1734`	`var device = await _deviceManager.CreateDevice(new Device(user.Id, app, appVersion, deviceName, deviceId)).C`
	`1735`
16	`1736`	`return device.AccessToken;`
16	`1737`	`}`
	`1738`
	`1739`	`/// <inheritdoc />`
	`1740`	`public async Task Logout(string accessToken)`
	`1741`	`{`
0	`1742`	`CheckDisposed();`
	`1743`
0	`1744`	`ArgumentException.ThrowIfNullOrEmpty(accessToken);`
	`1745`
0	`1746`	`var existing = _deviceManager.GetDevices(`
0	`1747`	`new DeviceQuery`
0	`1748`	`{`
0	`1749`	`Limit = 1,`
0	`1750`	`AccessToken = accessToken`
0	`1751`	`}).Items;`
	`1752`
0	`1753`	`if (existing.Count > 0)`
	`1754`	`{`
0	`1755`	`await Logout(existing[0]).ConfigureAwait(false);`
	`1756`	`}`
0	`1757`	`}`
	`1758`
	`1759`	`/// <inheritdoc />`
	`1760`	`public async Task Logout(Device device)`
	`1761`	`{`
0	`1762`	`CheckDisposed();`
	`1763`
0	`1764`	`_logger.LogInformation("Logging out access token {0}", device.AccessToken);`
	`1765`
0	`1766`	`await _deviceManager.DeleteDevice(device).ConfigureAwait(false);`
	`1767`
0	`1768`	`var sessions = Sessions`
0	`1769`	`.Where(i => string.Equals(i.DeviceId, device.DeviceId, StringComparison.OrdinalIgnoreCase))`
0	`1770`	`.ToList();`
	`1771`
0	`1772`	`foreach (var session in sessions)`
	`1773`	`{`
	`1774`	`try`
	`1775`	`{`
0	`1776`	`await ReportSessionEnded(session.Id).ConfigureAwait(false);`
0	`1777`	`}`
0	`1778`	`catch (Exception ex)`
	`1779`	`{`
0	`1780`	`_logger.LogError(ex, "Error reporting session ended");`
0	`1781`	`}`
	`1782`	`}`
0	`1783`	`}`
	`1784`
	`1785`	`/// <inheritdoc />`
	`1786`	`public async Task RevokeUserTokens(Guid userId, string currentAccessToken)`
	`1787`	`{`
2	`1788`	`CheckDisposed();`
	`1789`
2	`1790`	`var existing = _deviceManager.GetDevices(new DeviceQuery`
2	`1791`	`{`
2	`1792`	`UserId = userId`
2	`1793`	`});`
	`1794`
4	`1795`	`foreach (var info in existing.Items)`
	`1796`	`{`
0	`1797`	`if (!string.Equals(currentAccessToken, info.AccessToken, StringComparison.OrdinalIgnoreCase))`
	`1798`	`{`
0	`1799`	`await Logout(info).ConfigureAwait(false);`
	`1800`	`}`
	`1801`	`}`
2	`1802`	`}`
	`1803`
	`1804`	`/// <summary>`
	`1805`	`/// Reports the capabilities.`
	`1806`	`/// </summary>`
	`1807`	`/// <param name="sessionId">The session identifier.</param>`
	`1808`	`/// <param name="capabilities">The capabilities.</param>`
	`1809`	`public void ReportCapabilities(string sessionId, ClientCapabilities capabilities)`
	`1810`	`{`
0	`1811`	`CheckDisposed();`
	`1812`
0	`1813`	`var session = GetSession(sessionId);`
	`1814`
0	`1815`	`ReportCapabilities(session, capabilities, true);`
0	`1816`	`}`
	`1817`
	`1818`	`private void ReportCapabilities(`
	`1819`	`SessionInfo session,`
	`1820`	`ClientCapabilities capabilities,`
	`1821`	`bool saveCapabilities)`
	`1822`	`{`
17	`1823`	`session.Capabilities = capabilities;`
	`1824`
17	`1825`	`if (saveCapabilities)`
	`1826`	`{`
0	`1827`	`CapabilitiesChanged?.Invoke(`
0	`1828`	`this,`
0	`1829`	`new SessionEventArgs`
0	`1830`	`{`
0	`1831`	`SessionInfo = session`
0	`1832`	`});`
	`1833`
0	`1834`	`_deviceManager.SaveCapabilities(session.DeviceId, capabilities);`
	`1835`	`}`
17	`1836`	`}`
	`1837`
	`1838`	`/// <summary>`
	`1839`	`/// Converts a BaseItem to a BaseItemInfo.`
	`1840`	`/// </summary>`
	`1841`	`private BaseItemDto GetItemInfo(BaseItem item, MediaSourceInfo mediaSource)`
	`1842`	`{`
0	`1843`	`ArgumentNullException.ThrowIfNull(item);`
	`1844`
0	`1845`	`var dtoOptions = _itemInfoDtoOptions;`
	`1846`
0	`1847`	`if (_itemInfoDtoOptions is null)`
	`1848`	`{`
0	`1849`	`dtoOptions = new DtoOptions`
0	`1850`	`{`
0	`1851`	`AddProgramRecordingInfo = false`
0	`1852`	`};`
	`1853`
0	`1854`	`var fields = dtoOptions.Fields.ToList();`
	`1855`
0	`1856`	`fields.Remove(ItemFields.CanDelete);`
0	`1857`	`fields.Remove(ItemFields.CanDownload);`
0	`1858`	`fields.Remove(ItemFields.ChildCount);`
0	`1859`	`fields.Remove(ItemFields.CustomRating);`
0	`1860`	`fields.Remove(ItemFields.DateLastMediaAdded);`
0	`1861`	`fields.Remove(ItemFields.DateLastRefreshed);`
0	`1862`	`fields.Remove(ItemFields.DateLastSaved);`
0	`1863`	`fields.Remove(ItemFields.DisplayPreferencesId);`
0	`1864`	`fields.Remove(ItemFields.Etag);`
0	`1865`	`fields.Remove(ItemFields.ItemCounts);`
0	`1866`	`fields.Remove(ItemFields.MediaSourceCount);`
0	`1867`	`fields.Remove(ItemFields.MediaStreams);`
0	`1868`	`fields.Remove(ItemFields.MediaSources);`
0	`1869`	`fields.Remove(ItemFields.People);`
0	`1870`	`fields.Remove(ItemFields.PlayAccess);`
0	`1871`	`fields.Remove(ItemFields.People);`
0	`1872`	`fields.Remove(ItemFields.ProductionLocations);`
0	`1873`	`fields.Remove(ItemFields.RecursiveItemCount);`
0	`1874`	`fields.Remove(ItemFields.RemoteTrailers);`
0	`1875`	`fields.Remove(ItemFields.SeasonUserData);`
0	`1876`	`fields.Remove(ItemFields.Settings);`
0	`1877`	`fields.Remove(ItemFields.SortName);`
0	`1878`	`fields.Remove(ItemFields.Tags);`
	`1879`
0	`1880`	`dtoOptions.Fields = fields.ToArray();`
	`1881`
0	`1882`	`_itemInfoDtoOptions = dtoOptions;`
	`1883`	`}`
	`1884`
0	`1885`	`var info = _dtoService.GetBaseItemDto(item, dtoOptions);`
	`1886`
0	`1887`	`if (mediaSource is not null)`
	`1888`	`{`
0	`1889`	`info.MediaStreams = mediaSource.MediaStreams.ToArray();`
	`1890`	`}`
	`1891`
0	`1892`	`return info;`
	`1893`	`}`
	`1894`
	`1895`	`private string GetImageCacheTag(User user)`
	`1896`	`{`
	`1897`	`try`
	`1898`	`{`
0	`1899`	`return _imageProcessor.GetImageCacheTag(user);`
	`1900`	`}`
0	`1901`	`catch (Exception e)`
	`1902`	`{`
0	`1903`	`_logger.LogError(e, "Error getting image information for profile image");`
0	`1904`	`return null;`
	`1905`	`}`
0	`1906`	`}`
	`1907`
	`1908`	`/// <inheritdoc />`
	`1909`	`public void ReportNowViewingItem(string sessionId, string itemId)`
	`1910`	`{`
0	`1911`	`ArgumentException.ThrowIfNullOrEmpty(itemId);`
	`1912`
0	`1913`	`var item = _libraryManager.GetItemById(new Guid(itemId));`
0	`1914`	`var session = GetSession(sessionId);`
	`1915`
0	`1916`	`session.NowViewingItem = GetItemInfo(item, null);`
0	`1917`	`}`
	`1918`
	`1919`	`/// <inheritdoc />`
	`1920`	`public void ReportTranscodingInfo(string deviceId, TranscodingInfo info)`
	`1921`	`{`
0	`1922`	`var session = Sessions.FirstOrDefault(i =>`
0	`1923`	`string.Equals(i.DeviceId, deviceId, StringComparison.OrdinalIgnoreCase));`
	`1924`
0	`1925`	`if (session is not null)`
	`1926`	`{`
0	`1927`	`session.TranscodingInfo = info;`
	`1928`	`}`
0	`1929`	`}`
	`1930`
	`1931`	`/// <inheritdoc />`
	`1932`	`public void ClearTranscodingInfo(string deviceId)`
	`1933`	`{`
0	`1934`	`ReportTranscodingInfo(deviceId, null);`
0	`1935`	`}`
	`1936`
	`1937`	`/// <inheritdoc />`
	`1938`	`public SessionInfo GetSession(string deviceId, string client, string version)`
	`1939`	`{`
0	`1940`	`return Sessions.FirstOrDefault(i =>`
0	`1941`	`string.Equals(i.DeviceId, deviceId, StringComparison.OrdinalIgnoreCase)`
0	`1942`	`&& string.Equals(i.Client, client, StringComparison.OrdinalIgnoreCase));`
	`1943`	`}`
	`1944`
	`1945`	`/// <inheritdoc />`
	`1946`	`public Task<SessionInfo> GetSessionByAuthenticationToken(Device info, string deviceId, string remoteEndpoint, st`
	`1947`	`{`
0	`1948`	`ArgumentNullException.ThrowIfNull(info);`
	`1949`
0	`1950`	`var user = info.UserId.IsEmpty()`
0	`1951`	`? null`
0	`1952`	`: _userManager.GetUserById(info.UserId);`
	`1953`
0	`1954`	`appVersion = string.IsNullOrEmpty(appVersion)`
0	`1955`	`? info.AppVersion`
0	`1956`	`: appVersion;`
	`1957`
0	`1958`	`var deviceName = info.DeviceName;`
0	`1959`	`var appName = info.AppName;`
	`1960`
0	`1961`	`if (string.IsNullOrEmpty(deviceId))`
	`1962`	`{`
0	`1963`	`deviceId = info.DeviceId;`
	`1964`	`}`
	`1965`
	`1966`	`// Prevent argument exception`
0	`1967`	`if (string.IsNullOrEmpty(appVersion))`
	`1968`	`{`
0	`1969`	`appVersion = "1";`
	`1970`	`}`
	`1971`
0	`1972`	`return LogSessionActivity(appName, appVersion, deviceId, deviceName, remoteEndpoint, user);`
	`1973`	`}`
	`1974`
	`1975`	`/// <inheritdoc />`
	`1976`	`public async Task<SessionInfo> GetSessionByAuthenticationToken(string token, string deviceId, string remoteEndpo`
	`1977`	`{`
0	`1978`	`var items = _deviceManager.GetDevices(new DeviceQuery`
0	`1979`	`{`
0	`1980`	`AccessToken = token,`
0	`1981`	`Limit = 1`
0	`1982`	`}).Items;`
	`1983`
0	`1984`	`if (items.Count == 0)`
	`1985`	`{`
0	`1986`	`return null;`
	`1987`	`}`
	`1988`
0	`1989`	`return await GetSessionByAuthenticationToken(items[0], deviceId, remoteEndpoint, null).ConfigureAwait(false)`
0	`1990`	`}`
	`1991`
	`1992`	`/// <inheritdoc/>`
	`1993`	`public IReadOnlyList<SessionInfoDto> GetSessions(`
	`1994`	`Guid userId,`
	`1995`	`string deviceId,`
	`1996`	`int? activeWithinSeconds,`
	`1997`	`Guid? controllableUserToCheck,`
	`1998`	`bool isApiKey)`
	`1999`	`{`
0	`2000`	`var result = Sessions;`
0	`2001`	`if (!string.IsNullOrEmpty(deviceId))`
	`2002`	`{`
0	`2003`	`result = result.Where(i => string.Equals(i.DeviceId, deviceId, StringComparison.OrdinalIgnoreCase));`
	`2004`	`}`
	`2005`
0	`2006`	`var userCanControlOthers = false;`
0	`2007`	`var userIsAdmin = false;`
0	`2008`	`User user = null;`
	`2009`
0	`2010`	`if (isApiKey)`
	`2011`	`{`
0	`2012`	`userCanControlOthers = true;`
0	`2013`	`userIsAdmin = true;`
	`2014`	`}`
0	`2015`	`else if (!userId.IsEmpty())`
	`2016`	`{`
0	`2017`	`user = _userManager.GetUserById(userId);`
0	`2018`	`if (user is not null)`
	`2019`	`{`
0	`2020`	`userCanControlOthers = user.HasPermission(PermissionKind.EnableRemoteControlOfOtherUsers);`
0	`2021`	`userIsAdmin = user.HasPermission(PermissionKind.IsAdministrator);`
	`2022`	`}`
	`2023`	`else`
	`2024`	`{`
0	`2025`	`return [];`
	`2026`	`}`
	`2027`	`}`
	`2028`
0	`2029`	`if (!controllableUserToCheck.IsNullOrEmpty())`
	`2030`	`{`
0	`2031`	`result = result.Where(i => i.SupportsRemoteControl);`
	`2032`
0	`2033`	`var controlledUser = _userManager.GetUserById(controllableUserToCheck.Value);`
0	`2034`	`if (controlledUser is null)`
	`2035`	`{`
0	`2036`	`return [];`
	`2037`	`}`
	`2038`
0	`2039`	`if (!controlledUser.HasPermission(PermissionKind.EnableSharedDeviceControl))`
	`2040`	`{`
	`2041`	`// Controlled user has device sharing disabled`
0	`2042`	`result = result.Where(i => !i.UserId.IsEmpty());`
	`2043`	`}`
	`2044`
0	`2045`	`if (!userCanControlOthers)`
	`2046`	`{`
	`2047`	`// User cannot control other user's sessions, validate user id.`
0	`2048`	`result = result.Where(i => i.UserId.IsEmpty() \|\| i.ContainsUser(userId));`
	`2049`	`}`
	`2050`
0	`2051`	`result = result.Where(i =>`
0	`2052`	`{`
0	`2053`	`if (isApiKey)`
0	`2054`	`{`
0	`2055`	`return true;`
0	`2056`	`}`
0	`2057`
0	`2058`	`if (user is null)`
0	`2059`	`{`
0	`2060`	`return false;`
0	`2061`	`}`
0	`2062`
0	`2063`	`return string.IsNullOrWhiteSpace(i.DeviceId) \|\| _deviceManager.CanAccessDevice(user, i.DeviceId);`
0	`2064`	`});`
	`2065`	`}`
0	`2066`	`else if (!userIsAdmin)`
	`2067`	`{`
	`2068`	`// Request isn't from administrator, limit to "own" sessions.`
0	`2069`	`result = result.Where(i => i.UserId.IsEmpty() \|\| i.ContainsUser(userId));`
	`2070`	`}`
	`2071`
0	`2072`	`if (!userIsAdmin)`
	`2073`	`{`
	`2074`	`// Don't report acceleration type for non-admin users.`
0	`2075`	`result = result.Select(r =>`
0	`2076`	`{`
0	`2077`	`if (r.TranscodingInfo is not null)`
0	`2078`	`{`
0	`2079`	`r.TranscodingInfo.HardwareAccelerationType = HardwareAccelerationType.none;`
0	`2080`	`}`
0	`2081`
0	`2082`	`return r;`
0	`2083`	`});`
	`2084`	`}`
	`2085`
0	`2086`	`if (activeWithinSeconds.HasValue && activeWithinSeconds.Value > 0)`
	`2087`	`{`
0	`2088`	`var minActiveDate = DateTime.UtcNow.AddSeconds(0 - activeWithinSeconds.Value);`
0	`2089`	`result = result.Where(i => i.LastActivityDate >= minActiveDate);`
	`2090`	`}`
	`2091`
0	`2092`	`return result.Select(ToSessionInfoDto).ToList();`
	`2093`	`}`
	`2094`
	`2095`	`/// <inheritdoc />`
	`2096`	`public Task SendMessageToAdminSessions<T>(SessionMessageType name, T data, CancellationToken cancellationToken)`
	`2097`	`{`
0	`2098`	`CheckDisposed();`
	`2099`
0	`2100`	`var adminUserIds = _userManager.GetUsers()`
0	`2101`	`.Where(i => i.HasPermission(PermissionKind.IsAdministrator))`
0	`2102`	`.Select(i => i.Id)`
0	`2103`	`.ToList();`
	`2104`
0	`2105`	`return SendMessageToUserSessions(adminUserIds, name, data, cancellationToken);`
	`2106`	`}`
	`2107`
	`2108`	`/// <inheritdoc />`
	`2109`	`public Task SendMessageToUserSessions<T>(List<Guid> userIds, SessionMessageType name, Func<T> dataFn, Cancellati`
	`2110`	`{`
0	`2111`	`CheckDisposed();`
	`2112`
0	`2113`	`var sessions = Sessions.Where(i => userIds.Any(i.ContainsUser)).ToList();`
	`2114`
0	`2115`	`if (sessions.Count == 0)`
	`2116`	`{`
0	`2117`	`return Task.CompletedTask;`
	`2118`	`}`
	`2119`
0	`2120`	`return SendMessageToSessions(sessions, name, dataFn(), cancellationToken);`
	`2121`	`}`
	`2122`
	`2123`	`/// <inheritdoc />`
	`2124`	`public Task SendMessageToUserSessions<T>(List<Guid> userIds, SessionMessageType name, T data, CancellationToken`
	`2125`	`{`
2	`2126`	`CheckDisposed();`
	`2127`
2	`2128`	`var sessions = Sessions.Where(i => userIds.Any(i.ContainsUser));`
2	`2129`	`return SendMessageToSessions(sessions, name, data, cancellationToken);`
	`2130`	`}`
	`2131`
	`2132`	`/// <inheritdoc />`
	`2133`	`public Task SendMessageToUserDeviceSessions<T>(string deviceId, SessionMessageType name, T data, CancellationTok`
	`2134`	`{`
0	`2135`	`CheckDisposed();`
	`2136`
0	`2137`	`var sessions = Sessions.Where(i => string.Equals(i.DeviceId, deviceId, StringComparison.OrdinalIgnoreCase));`
	`2138`
0	`2139`	`return SendMessageToSessions(sessions, name, data, cancellationToken);`
	`2140`	`}`
	`2141`
	`2142`	`/// <inheritdoc />`
	`2143`	`public async ValueTask DisposeAsync()`
	`2144`	`{`
32	`2145`	`if (_disposed)`
	`2146`	`{`
0	`2147`	`return;`
	`2148`	`}`
	`2149`
64	`2150`	`foreach (var session in _activeConnections.Values)`
	`2151`	`{`
0	`2152`	`await session.DisposeAsync().ConfigureAwait(false);`
	`2153`	`}`
	`2154`
32	`2155`	`if (_idleTimer is not null)`
	`2156`	`{`
0	`2157`	`await _idleTimer.DisposeAsync().ConfigureAwait(false);`
0	`2158`	`_idleTimer = null;`
	`2159`	`}`
	`2160`
32	`2161`	`if (_inactiveTimer is not null)`
	`2162`	`{`
0	`2163`	`await _inactiveTimer.DisposeAsync().ConfigureAwait(false);`
0	`2164`	`_inactiveTimer = null;`
	`2165`	`}`
	`2166`
32	`2167`	`await _shutdownCallback.DisposeAsync().ConfigureAwait(false);`
	`2168`
32	`2169`	`_deviceManager.DeviceOptionsUpdated -= OnDeviceManagerDeviceOptionsUpdated;`
32	`2170`	`_disposed = true;`
32	`2171`	`}`
	`2172`
	`2173`	`private async void OnApplicationStopping()`
	`2174`	`{`
22	`2175`	`_logger.LogInformation("Sending shutdown notifications");`
	`2176`	`try`
	`2177`	`{`
22	`2178`	`var messageType = _appHost.ShouldRestart ? SessionMessageType.ServerRestarting : SessionMessageType.Serv`
	`2179`
22	`2180`	`await SendMessageToSessions(Sessions, messageType, string.Empty, CancellationToken.None).ConfigureAwait(`
22	`2181`	`}`
0	`2182`	`catch (Exception ex)`
	`2183`	`{`
0	`2184`	`_logger.LogError(ex, "Error sending server shutdown notifications");`
0	`2185`	`}`
	`2186`
	`2187`	`// Close open websockets to allow Kestrel to shut down cleanly`
76	`2188`	`foreach (var session in _activeConnections.Values)`
	`2189`	`{`
16	`2190`	`await session.DisposeAsync().ConfigureAwait(false);`
	`2191`	`}`
	`2192`
22	`2193`	`_activeConnections.Clear();`
22	`2194`	`_activeLiveStreamSessions.Clear();`
22	`2195`	`}`
	`2196`	`}`
	`2197`	`}`

Methods/Properties