< 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

22%

Covered lines:	113
Uncovered lines:	391
Coverable lines:	504
Total lines:	2144
Line coverage:	22.4%

Branch coverage

12%

Covered branches:	23
Total branches:	178
Branch coverage:	12.9%

Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

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(...)	100%	4	4	100%
UpdateDeviceName(...)	0%	6	2	0%
OnSessionControllerConnected(...)	100%	2	1	0%
GetMediaSource(...)	100%	2	1	0%
RemoveNowPlayingItem(...)	0%	6	2	0%
GetSessionKey(...)	100%	1	1	100%
GetSessionInfo(...)	62.5%	16	16	94.44%
CreateSession(...)	57.14%	14	14	88%
GetUsers(...)	0%	20	4	0%
StartCheckTimers()	0%	42	6	0%
StopIdleCheckTimer()	0%	6	2	0%
StopInactiveCheckTimer()	0%	6	2	0%
GetNowPlayingItem(...)	0%	42	6	0%
OnPlaybackStart(...)	0%	20	4	0%
OnPlaybackProgress(...)	100%	2	1	0%
UpdateLiveStreamActiveSessionMappings(...)	0%	110	10	0%
OnPlaybackProgress(...)	0%	42	6	0%
UpdatePlaybackSettings(...)	0%	156	12	0%
OnPlaybackStopped(...)	0%	20	4	0%
GetSession(...)	0%	6	2	0%
GetSessionToRemoteControl(...)	0%	6	2	0%
ToSessionInfoDto(...)	100%	1	1	100%
SendMessageCommand(...)	0%	6	2	0%
SendGeneralCommand(...)	0%	6	2	0%
SendMessageToSessions(...)	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%
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%
GetSessions(...)	0%	600	24	0%
SendMessageToAdminSessions(...)	0%	20	4	0%
SendMessageToUserSessions(...)	0%	6	2	0%
SendMessageToUserSessions(...)	100%	2	1	0%
SendMessageToUserDeviceSessions(...)	100%	2	1	0%

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

Methods/Properties