Address requested changes and fix some warnings

7 files changed, 136 insertions, 1492 deletions

diff --git a/Emby.Server.Implementations/SyncPlay/GroupController.cs b/Emby.Server.Implementations/SyncPlay/GroupController.cs
index ffd65d7f8..5a3c707db 100644
--- a/Emby.Server.Implementations/SyncPlay/GroupController.cs
+++ b/Emby.Server.Implementations/SyncPlay/GroupController.cs
@@ -16,29 +16,14 @@ using Microsoft.Extensions.Logging;
 namespace Emby.Server.Implementations.SyncPlay
 {
     /// <summary>
-    /// Class SyncPlayGroupController.
+    /// Class GroupController.
     /// </summary>
     /// <remarks>
     /// Class is not thread-safe, external locking is required when accessing methods.
     /// </remarks>
-    public class SyncPlayGroupController : ISyncPlayGroupController, ISyncPlayStateContext
+    public class GroupController : IGroupController, IGroupStateContext
     {
         /// <summary>
-        /// Gets the default ping value used for sessions.
-        /// </summary>
-        public long DefaultPing { get; } = 500;
-
-        /// <summary>
-        /// Gets the maximum time offset error accepted for dates reported by clients, in milliseconds.
-        /// </summary>
-        public long TimeSyncOffset { get; } = 2000;
-
-        /// <summary>
-        /// Gets the maximum offset error accepted for position reported by clients, in milliseconds.
-        /// </summary>
-        public long MaxPlaybackOffset { get; } = 500;
-
-        /// <summary>
         /// The logger.
         /// </summary>
         private readonly ILogger _logger;
@@ -67,7 +52,46 @@ namespace Emby.Server.Implementations.SyncPlay
         /// Internal group state.
         /// </summary>
         /// <value>The group's state.</value>
-        private ISyncPlayState State;
+        private IGroupState _state;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GroupController" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="userManager">The user manager.</param>
+        /// <param name="sessionManager">The session manager.</param>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="syncPlayManager">The SyncPlay manager.</param>
+        public GroupController(
+            ILogger logger,
+            IUserManager userManager,
+            ISessionManager sessionManager,
+            ILibraryManager libraryManager,
+            ISyncPlayManager syncPlayManager)
+        {
+            _logger = logger;
+            _userManager = userManager;
+            _sessionManager = sessionManager;
+            _libraryManager = libraryManager;
+            _syncPlayManager = syncPlayManager;
+
+            _state = new IdleGroupState(_logger);
+        }
+
+        /// <summary>
+        /// Gets the default ping value used for sessions.
+        /// </summary>
+        public long DefaultPing { get; } = 500;
+
+        /// <summary>
+        /// Gets the maximum time offset error accepted for dates reported by clients, in milliseconds.
+        /// </summary>
+        public long TimeSyncOffset { get; } = 2000;
+
+        /// <summary>
+        /// Gets the maximum offset error accepted for position reported by clients, in milliseconds.
+        /// </summary>
+        public long MaxPlaybackOffset { get; } = 500;
 
         /// <summary>
         /// Gets the group identifier.
@@ -88,7 +112,7 @@ namespace Emby.Server.Implementations.SyncPlay
         public PlayQueueManager PlayQueue { get; } = new PlayQueueManager();
 
         /// <summary>
-        /// Gets or sets the runtime ticks of current playing item.
+        /// Gets the runtime ticks of current playing item.
         /// </summary>
         /// <value>The runtime ticks of current playing item.</value>
         public long RunTimeTicks { get; private set; }
@@ -113,30 +137,6 @@ namespace Emby.Server.Implementations.SyncPlay
             new Dictionary<string, GroupMember>(StringComparer.OrdinalIgnoreCase);
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="SyncPlayGroupController" /> class.
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="userManager">The user manager.</param>
-        /// <param name="sessionManager">The session manager.</param>
-        /// <param name="libraryManager">The library manager.</param>
-        /// <param name="syncPlayManager">The SyncPlay manager.</param>
-        public SyncPlayGroupController(
-            ILogger logger,
-            IUserManager userManager,
-            ISessionManager sessionManager,
-            ILibraryManager libraryManager,
-            ISyncPlayManager syncPlayManager)
-        {
-            _logger = logger;
-            _userManager = userManager;
-            _sessionManager = sessionManager;
-            _libraryManager = libraryManager;
-            _syncPlayManager = syncPlayManager;
-
-            State = new IdleGroupState(_logger);
-        }
-
-        /// <summary>
         /// Adds the session to the group.
         /// </summary>
         /// <param name="session">The session.</param>
@@ -167,34 +167,32 @@ namespace Emby.Server.Implementations.SyncPlay
         /// <param name="from">The current session.</param>
         /// <param name="type">The filtering type.</param>
         /// <returns>The array of sessions matching the filter.</returns>
-        private SessionInfo[] FilterSessions(SessionInfo from, SyncPlayBroadcastType type)
-        {
-            switch (type)
-            {
-                case SyncPlayBroadcastType.CurrentSession:
-                    return new SessionInfo[] { from };
-                case SyncPlayBroadcastType.AllGroup:
-                    return Participants
-                        .Values
-                        .Select(session => session.Session)
-                        .ToArray();
-                case SyncPlayBroadcastType.AllExceptCurrentSession:
-                    return Participants
-                        .Values
-                        .Select(session => session.Session)
-                        .Where(session => !session.Id.Equals(from.Id))
-                        .ToArray();
-                case SyncPlayBroadcastType.AllReady:
-                    return Participants
-                        .Values
-                        .Where(session => !session.IsBuffering)
-                        .Select(session => session.Session)
-                        .ToArray();
-                default:
-                    return Array.Empty<SessionInfo>();
-            }
+        private IEnumerable<SessionInfo> FilterSessions(SessionInfo from, SyncPlayBroadcastType type)
+        {
+            return type switch
+            {
+                SyncPlayBroadcastType.CurrentSession => new SessionInfo[] { from },
+                SyncPlayBroadcastType.AllGroup => Participants
+                    .Values
+                    .Select(session => session.Session),
+                SyncPlayBroadcastType.AllExceptCurrentSession => Participants
+                    .Values
+                    .Select(session => session.Session)
+                    .Where(session => !session.Id.Equals(from.Id, StringComparison.OrdinalIgnoreCase)),
+                SyncPlayBroadcastType.AllReady => Participants
+                    .Values
+                    .Where(session => !session.IsBuffering)
+                    .Select(session => session.Session),
+                _ => Enumerable.Empty<SessionInfo>()
+            };
         }
 
+        /// <summary>
+        /// Checks if a given user can access a given item, that is, the user has access to a folder where the item is stored.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="item">The item.</param>
+        /// <returns><c>true</c> if the user can access the item, <c>false</c> otherwise.</returns>
         private bool HasAccessToItem(User user, BaseItem item)
         {
             var collections = _libraryManager.GetCollectionFolders(item)
@@ -202,41 +200,42 @@ namespace Emby.Server.Implementations.SyncPlay
             return collections.Intersect(user.GetPreference(PreferenceKind.EnabledFolders)).Any();
         }
 
-        private bool HasAccessToQueue(User user, Guid[] queue)
+        /// <summary>
+        /// Checks if a given user can access all items of a given queue, that is,
+        /// the user has the required minimum parental access and has access to all required folders.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="queue">The queue.</param>
+        /// <returns><c>true</c> if the user can access all the items in the queue, <c>false</c> otherwise.</returns>
+        private bool HasAccessToQueue(User user, IEnumerable<Guid> queue)
         {
-            if (queue == null || queue.Length == 0)
+            // Check if queue is empty.
+            if (!queue?.Any() ?? true)
             {
                 return true;
             }
 
-            var items = queue.ToList()
-                .Select(item => _libraryManager.GetItemById(item));
-
-            // Find the highest rating value, which becomes the required minimum for the user.
-            var MinParentalRatingAccessRequired = items
-                .Select(item => item.InheritedParentalRatingValue)
-                .Min();
-
-            // Check ParentalRating access, user must have the minimum required access level.
-            var hasParentalRatingAccess = !user.MaxParentalAgeRating.HasValue
-                || MinParentalRatingAccessRequired <= user.MaxParentalAgeRating;
-
-            // Check that user has access to all required folders.
-            if (!user.HasPermission(PermissionKind.EnableAllFolders) && hasParentalRatingAccess)
+            foreach (var itemId in queue)
             {
-                // Get list of items that are not accessible.
-                var blockedItems = items.Where(item => !HasAccessToItem(user, item));
+                var item = _libraryManager.GetItemById(itemId);
+                if (user.MaxParentalAgeRating.HasValue && item.InheritedParentalRatingValue > user.MaxParentalAgeRating)
+                {
+                    return false;
+                }
 
-                // We need the user to be able to access all items.
-                return !blockedItems.Any();
+                if (!user.HasPermission(PermissionKind.EnableAllFolders) && !HasAccessToItem(user, item))
+                {
+                    return false;
+                }
             }
 
-            return hasParentalRatingAccess;
+            return true;
         }
 
-        private bool AllUsersHaveAccessToQueue(Guid[] queue)
+        private bool AllUsersHaveAccessToQueue(IEnumerable<Guid> queue)
         {
-            if (queue == null || queue.Length == 0)
+            // Check if queue is empty.
+            if (!queue?.Any() ?? true)
             {
                 return true;
             }
@@ -269,7 +268,7 @@ namespace Emby.Server.Implementations.SyncPlay
 
             if (sessionIsPlayingAnItem)
             {
-                var playlist = session.NowPlayingQueue.Select(item => item.Id).ToArray();
+                var playlist = session.NowPlayingQueue.Select(item => item.Id);
                 PlayQueue.Reset();
                 PlayQueue.SetPlaylist(playlist);
                 PlayQueue.SetPlayingItemById(session.FullNowPlayingItem.Id);
@@ -277,17 +276,19 @@ namespace Emby.Server.Implementations.SyncPlay
                 PositionTicks = session.PlayState.PositionTicks ?? 0;
 
                 // Mantain playstate.
-                var waitingState = new WaitingGroupState(_logger);
-                waitingState.ResumePlaying = !session.PlayState.IsPaused;
+                var waitingState = new WaitingGroupState(_logger)
+                {
+                    ResumePlaying = !session.PlayState.IsPaused
+                };
                 SetState(waitingState);
             }
 
             var updateSession = NewSyncPlayGroupUpdate(GroupUpdateType.GroupJoined, GetInfo());
             SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, updateSession, cancellationToken);
 
-            State.SessionJoined(this, State.GetGroupState(), session, cancellationToken);
+            _state.SessionJoined(this, _state.Type, session, cancellationToken);
 
-            _logger.LogInformation("InitGroup: {0} created group {1}.", session.Id.ToString(), GroupId.ToString());
+            _logger.LogInformation("InitGroup: {0} created group {1}.", session.Id, GroupId.ToString());
         }
 
         /// <inheritdoc />
@@ -302,9 +303,9 @@ namespace Emby.Server.Implementations.SyncPlay
             var updateOthers = NewSyncPlayGroupUpdate(GroupUpdateType.UserJoined, session.UserName);
             SendGroupUpdate(session, SyncPlayBroadcastType.AllExceptCurrentSession, updateOthers, cancellationToken);
 
-            State.SessionJoined(this, State.GetGroupState(), session, cancellationToken);
+            _state.SessionJoined(this, _state.Type, session, cancellationToken);
 
-            _logger.LogInformation("SessionJoin: {0} joined group {1}.", session.Id.ToString(), GroupId.ToString());
+            _logger.LogInformation("SessionJoin: {0} joined group {1}.", session.Id, GroupId.ToString());
         }
 
         /// <inheritdoc />
@@ -316,15 +317,15 @@ namespace Emby.Server.Implementations.SyncPlay
             var updateOthers = NewSyncPlayGroupUpdate(GroupUpdateType.UserJoined, session.UserName);
             SendGroupUpdate(session, SyncPlayBroadcastType.AllExceptCurrentSession, updateOthers, cancellationToken);
 
-            State.SessionJoined(this, State.GetGroupState(), session, cancellationToken);
+            _state.SessionJoined(this, _state.Type, session, cancellationToken);
 
-            _logger.LogInformation("SessionRestore: {0} re-joined group {1}.", session.Id.ToString(), GroupId.ToString());
+            _logger.LogInformation("SessionRestore: {0} re-joined group {1}.", session.Id, GroupId.ToString());
         }
 
         /// <inheritdoc />
         public void SessionLeave(SessionInfo session, CancellationToken cancellationToken)
         {
-            State.SessionLeaving(this, State.GetGroupState(), session, cancellationToken);
+            _state.SessionLeaving(this, _state.Type, session, cancellationToken);
 
             RemoveSession(session);
             _syncPlayManager.RemoveSessionFromGroup(session, this);
@@ -335,18 +336,17 @@ namespace Emby.Server.Implementations.SyncPlay
             var updateOthers = NewSyncPlayGroupUpdate(GroupUpdateType.UserLeft, session.UserName);
             SendGroupUpdate(session, SyncPlayBroadcastType.AllExceptCurrentSession, updateOthers, cancellationToken);
 
-            _logger.LogInformation("SessionLeave: {0} left group {1}.", session.Id.ToString(), GroupId.ToString());
+            _logger.LogInformation("SessionLeave: {0} left group {1}.", session.Id, GroupId.ToString());
         }
 
         /// <inheritdoc />
-        public void HandleRequest(SessionInfo session, IPlaybackGroupRequest request, CancellationToken cancellationToken)
+        public void HandleRequest(SessionInfo session, IGroupPlaybackRequest request, CancellationToken cancellationToken)
         {
             // The server's job is to maintain a consistent state for clients to reference
             // and notify clients of state changes. The actual syncing of media playback
             // happens client side. Clients are aware of the server's time and use it to sync.
-            _logger.LogInformation("HandleRequest: {0} requested {1}, group {2} in {3} state.",
-                session.Id.ToString(), request.GetRequestType(), GroupId.ToString(), State.GetGroupState());
-            request.Apply(this, State, session, cancellationToken);
+            _logger.LogInformation("HandleRequest: {0} requested {1}, group {2} in {3} state.", session.Id, request.Type, GroupId.ToString(), _state.Type);
+            request.Apply(this, _state, session, cancellationToken);
         }
 
         /// <inheritdoc />
@@ -356,7 +356,7 @@ namespace Emby.Server.Implementations.SyncPlay
             {
                 GroupId = GroupId.ToString(),
                 GroupName = GroupName,
-                State = State.GetGroupState(),
+                State = _state.Type,
                 Participants = Participants.Values.Select(session => session.Session.UserName).Distinct().ToList(),
                 LastUpdatedAt = DateToUTCString(DateTime.UtcNow)
             };
@@ -365,7 +365,7 @@ namespace Emby.Server.Implementations.SyncPlay
         /// <inheritdoc />
         public bool HasAccessToPlayQueue(User user)
         {
-            var items = PlayQueue.GetPlaylist().Select(item => item.ItemId).ToArray();
+            var items = PlayQueue.GetPlaylist().Select(item => item.ItemId);
             return HasAccessToQueue(user, items);
         }
 
@@ -381,10 +381,10 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public void SetState(ISyncPlayState state)
+        public void SetState(IGroupState state)
         {
-            _logger.LogInformation("SetState: {0} switching from {1} to {2}.", GroupId.ToString(), State.GetGroupState(), state.GetGroupState());
-            this.State = state;
+            _logger.LogInformation("SetState: {0} switching from {1} to {2}.", GroupId.ToString(), _state.Type, state.Type);
+            this._state = state;
         }
 
         /// <inheritdoc />
@@ -443,16 +443,14 @@ namespace Emby.Server.Implementations.SyncPlay
         /// <inheritdoc />
         public string DateToUTCString(DateTime dateTime)
         {
-            return dateTime.ToUniversalTime().ToString("o");
+            return dateTime.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture);
         }
 
         /// <inheritdoc />
         public long SanitizePositionTicks(long? positionTicks)
         {
             var ticks = positionTicks ?? 0;
-            ticks = Math.Max(ticks, 0);
-            ticks = Math.Min(ticks, RunTimeTicks);
-            return ticks;
+            return Math.Clamp(ticks, 0, RunTimeTicks);
         }
 
         /// <inheritdoc />
@@ -509,10 +507,10 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public bool SetPlayQueue(Guid[] playQueue, int playingItemPosition, long startPositionTicks)
+        public bool SetPlayQueue(IEnumerable<Guid> playQueue, int playingItemPosition, long startPositionTicks)
         {
             // Ignore on empty queue or invalid item position.
-            if (playQueue.Length < 1 || playingItemPosition >= playQueue.Length || playingItemPosition < 0)
+            if (!playQueue.Any() || playingItemPosition >= playQueue.Count() || playingItemPosition < 0)
             {
                 return false;
             }
@@ -555,7 +553,7 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public bool RemoveFromPlayQueue(string[] playlistItemIds)
+        public bool RemoveFromPlayQueue(IEnumerable<string> playlistItemIds)
         {
             var playingItemRemoved = PlayQueue.RemoveFromPlaylist(playlistItemIds);
             if (playingItemRemoved)
@@ -584,10 +582,10 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public bool AddToPlayQueue(Guid[] newItems, string mode)
+        public bool AddToPlayQueue(IEnumerable<Guid> newItems, string mode)
         {
             // Ignore on empty list.
-            if (newItems.Length < 1)
+            if (!newItems.Any())
             {
                 return false;
             }
@@ -598,7 +596,7 @@ namespace Emby.Server.Implementations.SyncPlay
                 return false;
             }
 
-            if (mode.Equals("next"))
+            if (mode.Equals("next", StringComparison.OrdinalIgnoreCase))
             {
                 PlayQueue.QueueNext(newItems);
             }
@@ -652,7 +650,8 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public void SetRepeatMode(string mode) {
+        public void SetRepeatMode(string mode)
+        {
             switch (mode)
             {
                 case "RepeatOne":
@@ -669,7 +668,8 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public void SetShuffleMode(string mode) {
+        public void SetShuffleMode(string mode)
+        {
             switch (mode)
             {
                 case "Shuffle":
@@ -687,7 +687,7 @@ namespace Emby.Server.Implementations.SyncPlay
         {
             var startPositionTicks = PositionTicks;
 
-            if (State.GetGroupState().Equals(GroupState.Playing))
+            if (_state.Type.Equals(GroupStateType.Playing))
             {
                 var currentTime = DateTime.UtcNow;
                 var elapsedTime = currentTime - LastActivity;
@@ -711,6 +711,5 @@ namespace Emby.Server.Implementations.SyncPlay
                 RepeatMode = PlayQueue.RepeatMode
             };
         }
-
     }
 }
diff --git a/Emby.Server.Implementations/SyncPlay/GroupStates/AbstractGroupState.cs b/Emby.Server.Implementations/SyncPlay/GroupStates/AbstractGroupState.cs
deleted file mode 100644
index 26cd51b8d..000000000
--- a/Emby.Server.Implementations/SyncPlay/GroupStates/AbstractGroupState.cs
+++ /dev/null
@@ -1,218 +0,0 @@
-using System.Threading;
-using MediaBrowser.Controller.Session;
-using MediaBrowser.Model.SyncPlay;
-using Microsoft.Extensions.Logging;
-
-namespace MediaBrowser.Controller.SyncPlay
-{
-    /// <summary>
-    /// Class AbstractGroupState.
-    /// </summary>
-    /// <remarks>
-    /// Class is not thread-safe, external locking is required when accessing methods.
-    /// </remarks>
-    public abstract class AbstractGroupState : ISyncPlayState
-    {
-        /// <summary>
-        /// The logger.
-        /// </summary>
-        protected readonly ILogger _logger;
-
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        public AbstractGroupState(ILogger logger)
-        {
-            _logger = logger;
-        }
-
-        /// <summary>
-        /// Sends a group state update to all group.
-        /// </summary>
-        /// <param name="context">The context of the state.</param>
-        /// <param name="reason">The reason of the state change.</param>
-        /// <param name="session">The session.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        protected void SendGroupStateUpdate(ISyncPlayStateContext context, IPlaybackGroupRequest reason, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Notify relevant state change event.
-            var stateUpdate = new GroupStateUpdate()
-            {
-                State = GetGroupState(),
-                Reason = reason.GetRequestType()
-            };
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.StateUpdate, stateUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public abstract GroupState GetGroupState();
-
-        /// <inheritdoc />
-        public abstract void SessionJoined(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken);
-
-        /// <inheritdoc />
-        public abstract void SessionLeaving(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken);
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, IPlaybackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PlayGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SetPlaylistItemGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, RemoveFromPlaylistGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            var playingItemRemoved = context.RemoveFromPlayQueue(request.PlaylistItemIds);
-
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.RemoveItems);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-            if (playingItemRemoved)
-            {
-                var PlayingItemIndex = context.PlayQueue.PlayingItemIndex;
-                if (context.PlayQueue.PlayingItemIndex == -1)
-                {
-                    _logger.LogDebug("HandleRequest: {0} in group {1}, play queue is empty.", request.GetRequestType(), context.GroupId.ToString());
-
-                    ISyncPlayState idleState = new IdleGroupState(_logger);
-                    context.SetState(idleState);
-                    var stopRequest = new StopGroupRequest();
-                    idleState.HandleRequest(context, GetGroupState(), stopRequest, session, cancellationToken);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, MovePlaylistItemGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            var result = context.MoveItemInPlayQueue(request.PlaylistItemId, request.NewIndex);
-
-            if (!result)
-            {
-                _logger.LogError("HandleRequest: {0} in group {1}, unable to move item in play queue.", request.GetRequestType(), context.GroupId.ToString());
-                return;
-            }
-
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.MoveItem);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, QueueGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            var result = context.AddToPlayQueue(request.ItemIds, request.Mode);
-
-            if (!result)
-            {
-                _logger.LogError("HandleRequest: {0} in group {1}, unable to add items to play queue.", request.GetRequestType(), context.GroupId.ToString());
-                return;
-            }
-
-            var reason = request.Mode.Equals("next") ? PlayQueueUpdateReason.QueueNext : PlayQueueUpdateReason.Queue;
-            var playQueueUpdate = context.GetPlayQueueUpdate(reason);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, UnpauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, StopGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SeekGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, BufferGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, ReadyGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, NextTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PreviousTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            UnhandledRequest(request);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SetRepeatModeGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            context.SetRepeatMode(request.Mode);
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.RepeatMode);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SetShuffleModeGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            context.SetShuffleMode(request.Mode);
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.ShuffleMode);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PingGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Collected pings are used to account for network latency when unpausing playback.
-            context.UpdatePing(session, request.Ping);
-        }
-
-        /// <inheritdoc />
-        public virtual void HandleRequest(ISyncPlayStateContext context, GroupState prevState, IgnoreWaitGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            context.SetIgnoreGroupWait(session, request.IgnoreWait);
-        }
-
-        private void UnhandledRequest(IPlaybackGroupRequest request)
-        {
-            _logger.LogWarning("HandleRequest: unhandled {0} request for {1} state.", request.GetRequestType(), GetGroupState());
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/SyncPlay/GroupStates/IdleGroupState.cs b/Emby.Server.Implementations/SyncPlay/GroupStates/IdleGroupState.cs
deleted file mode 100644
index 70fe3e006..000000000
--- a/Emby.Server.Implementations/SyncPlay/GroupStates/IdleGroupState.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-using System.Threading;
-using MediaBrowser.Controller.Session;
-using MediaBrowser.Model.SyncPlay;
-using Microsoft.Extensions.Logging;
-
-namespace MediaBrowser.Controller.SyncPlay
-{
-    /// <summary>
-    /// Class IdleGroupState.
-    /// </summary>
-    /// <remarks>
-    /// Class is not thread-safe, external locking is required when accessing methods.
-    /// </remarks>
-    public class IdleGroupState : AbstractGroupState
-    {
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        public IdleGroupState(ILogger logger)
-            : base(logger)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override GroupState GetGroupState()
-        {
-            return GroupState.Idle;
-        }
-
-        /// <inheritdoc />
-        public override void SessionJoined(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, GetGroupState(), session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void SessionLeaving(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PlayGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, UnpauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, prevState, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, StopGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, prevState, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SeekGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, prevState, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, BufferGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, prevState, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, ReadyGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            SendStopCommand(context, prevState, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, NextTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PreviousTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        private void SendStopCommand(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            var command = context.NewSyncPlayCommand(SendCommandType.Stop);
-            if (!prevState.Equals(GetGroupState()))
-            {
-                context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-            }
-            else
-            {
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/SyncPlay/GroupStates/PausedGroupState.cs b/Emby.Server.Implementations/SyncPlay/GroupStates/PausedGroupState.cs
deleted file mode 100644
index ca2cb0988..000000000
--- a/Emby.Server.Implementations/SyncPlay/GroupStates/PausedGroupState.cs
+++ /dev/null
@@ -1,161 +0,0 @@
-using System;
-using System.Threading;
-using MediaBrowser.Controller.Session;
-using MediaBrowser.Model.SyncPlay;
-using Microsoft.Extensions.Logging;
-
-namespace MediaBrowser.Controller.SyncPlay
-{
-    /// <summary>
-    /// Class PausedGroupState.
-    /// </summary>
-    /// <remarks>
-    /// Class is not thread-safe, external locking is required when accessing methods.
-    /// </remarks>
-    public class PausedGroupState : AbstractGroupState
-    {
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        public PausedGroupState(ILogger logger)
-            : base(logger)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override GroupState GetGroupState()
-        {
-            return GroupState.Paused;
-        }
-
-        /// <inheritdoc />
-        public override void SessionJoined(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Wait for session to be ready.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.SessionJoined(context, GetGroupState(), session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void SessionLeaving(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PlayGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, UnpauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var playingState = new PlayingGroupState(_logger);
-            context.SetState(playingState);
-            playingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            if (!prevState.Equals(GetGroupState()))
-            {
-                // Pause group and compute the media playback position.
-                var currentTime = DateTime.UtcNow;
-                var elapsedTime = currentTime - context.LastActivity;
-                context.LastActivity = currentTime;
-                // Elapsed time is negative if event happens
-                // during the delay added to account for latency.
-                // In this phase clients haven't started the playback yet.
-                // In other words, LastActivity is in the future,
-                // when playback unpause is supposed to happen.
-                // Seek only if playback actually started.
-                context.PositionTicks += Math.Max(elapsedTime.Ticks, 0);
-
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-
-                // Notify relevant state change event.
-                SendGroupStateUpdate(context, request, session, cancellationToken);
-            }
-            else
-            {
-                // Client got lost, sending current state.
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, StopGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var idleState = new IdleGroupState(_logger);
-            context.SetState(idleState);
-            idleState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SeekGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, BufferGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, ReadyGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            if (prevState.Equals(GetGroupState()))
-            {
-                // Client got lost, sending current state.
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-            else if (prevState.Equals(GroupState.Waiting))
-            {
-                // Sending current state to all clients.
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-
-                // Notify relevant state change event.
-                SendGroupStateUpdate(context, request, session, cancellationToken);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, NextTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PreviousTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/SyncPlay/GroupStates/PlayingGroupState.cs b/Emby.Server.Implementations/SyncPlay/GroupStates/PlayingGroupState.cs
deleted file mode 100644
index 85119669d..000000000
--- a/Emby.Server.Implementations/SyncPlay/GroupStates/PlayingGroupState.cs
+++ /dev/null
@@ -1,166 +0,0 @@
-using System;
-using System.Threading;
-using MediaBrowser.Controller.Session;
-using MediaBrowser.Model.SyncPlay;
-using Microsoft.Extensions.Logging;
-
-namespace MediaBrowser.Controller.SyncPlay
-{
-    /// <summary>
-    /// Class PlayingGroupState.
-    /// </summary>
-    /// <remarks>
-    /// Class is not thread-safe, external locking is required when accessing methods.
-    /// </remarks>
-    public class PlayingGroupState : AbstractGroupState
-    {
-        /// <summary>
-        /// Ignore requests for buffering.
-        /// </summary>
-        public bool IgnoreBuffering { get; set; }
-
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        public PlayingGroupState(ILogger logger)
-            : base(logger)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override GroupState GetGroupState()
-        {
-            return GroupState.Playing;
-        }
-
-        /// <inheritdoc />
-        public override void SessionJoined(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Wait for session to be ready.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.SessionJoined(context, GetGroupState(), session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void SessionLeaving(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PlayGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, UnpauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            if (!prevState.Equals(GetGroupState()))
-            {
-                // Pick a suitable time that accounts for latency.
-                var delayMillis = Math.Max(context.GetHighestPing() * 2, context.DefaultPing);
-
-                // Unpause group and set starting point in future.
-                // Clients will start playback at LastActivity (datetime) from PositionTicks (playback position).
-                // The added delay does not guarantee, of course, that the command will be received in time.
-                // Playback synchronization will mainly happen client side.
-                context.LastActivity = DateTime.UtcNow.AddMilliseconds(
-                    delayMillis
-                );
-
-                var command = context.NewSyncPlayCommand(SendCommandType.Unpause);
-                context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-
-                // Notify relevant state change event.
-                SendGroupStateUpdate(context, request, session, cancellationToken);
-            }
-            else
-            {
-                // Client got lost, sending current state.
-                var command = context.NewSyncPlayCommand(SendCommandType.Unpause);
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var pausedState = new PausedGroupState(_logger);
-            context.SetState(pausedState);
-            pausedState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, StopGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var idleState = new IdleGroupState(_logger);
-            context.SetState(idleState);
-            idleState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SeekGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, BufferGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            if (IgnoreBuffering)
-            {
-                return;
-            }
-
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, ReadyGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            if (prevState.Equals(GetGroupState()))
-            {
-                // Group was not waiting, make sure client has latest state.
-                var command = context.NewSyncPlayCommand(SendCommandType.Unpause);
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-            else if (prevState.Equals(GroupState.Waiting))
-            {
-                // Notify relevant state change event.
-                SendGroupStateUpdate(context, request, session, cancellationToken);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, NextTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PreviousTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Change state.
-            var waitingState = new WaitingGroupState(_logger);
-            context.SetState(waitingState);
-            waitingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/SyncPlay/GroupStates/WaitingGroupState.cs b/Emby.Server.Implementations/SyncPlay/GroupStates/WaitingGroupState.cs
deleted file mode 100644
index bc3cc4918..000000000
--- a/Emby.Server.Implementations/SyncPlay/GroupStates/WaitingGroupState.cs
+++ /dev/null
@@ -1,683 +0,0 @@
-using System;
-using System.Threading;
-using MediaBrowser.Controller.Session;
-using MediaBrowser.Model.SyncPlay;
-using Microsoft.Extensions.Logging;
-
-namespace MediaBrowser.Controller.SyncPlay
-{
-    /// <summary>
-    /// Class WaitingGroupState.
-    /// </summary>
-    /// <remarks>
-    /// Class is not thread-safe, external locking is required when accessing methods.
-    /// </remarks>
-    public class WaitingGroupState : AbstractGroupState
-    {
-        /// <summary>
-        /// Tells the state to switch to after buffering is done.
-        /// </summary>
-        public bool ResumePlaying { get; set; } = false;
-
-        /// <summary>
-        /// Whether the initial state has been set.
-        /// </summary>
-        private bool InitialStateSet { get; set; } = false;
-
-        /// <summary>
-        /// The group state before the first ever event.
-        /// </summary>
-        private GroupState InitialState { get; set; }
-
-        /// <summary>
-        /// Default constructor.
-        /// </summary>
-        public WaitingGroupState(ILogger logger)
-            : base(logger)
-        {
-            // Do nothing.
-        }
-
-        /// <inheritdoc />
-        public override GroupState GetGroupState()
-        {
-            return GroupState.Waiting;
-        }
-
-        /// <inheritdoc />
-        public override void SessionJoined(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            if (prevState.Equals(GroupState.Playing)) {
-                ResumePlaying = true;
-                // Pause group and compute the media playback position.
-                var currentTime = DateTime.UtcNow;
-                var elapsedTime = currentTime - context.LastActivity;
-                context.LastActivity = currentTime;
-                // Elapsed time is negative if event happens
-                // during the delay added to account for latency.
-                // In this phase clients haven't started the playback yet.
-                // In other words, LastActivity is in the future,
-                // when playback unpause is supposed to happen.
-                // Seek only if playback actually started.
-                context.PositionTicks += Math.Max(elapsedTime.Ticks, 0);
-            }
-
-            // Prepare new session.
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.NewPlaylist);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, update, cancellationToken);
-
-            context.SetBuffering(session, true);
-
-            // Send pause command to all non-buffering sessions.
-            var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-            context.SendCommand(session, SyncPlayBroadcastType.AllReady, command, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void SessionLeaving(ISyncPlayStateContext context, GroupState prevState, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            context.SetBuffering(session, false);
-
-            if (!context.IsBuffering())
-            {
-                if (ResumePlaying)
-                {
-                    // Client, that was buffering, left the group.
-                    var playingState = new PlayingGroupState(_logger);
-                    context.SetState(playingState);
-                    var unpauseRequest = new UnpauseGroupRequest();
-                    playingState.HandleRequest(context, GetGroupState(), unpauseRequest, session, cancellationToken);
-
-                    _logger.LogDebug("SessionLeaving: {0} left the group {1}, notifying others to resume.", session.Id.ToString(), context.GroupId.ToString());
-                }
-                else
-                {
-                    // Group is ready, returning to previous state.
-                    var pausedState = new PausedGroupState(_logger);
-                    context.SetState(pausedState);
-
-                    _logger.LogDebug("SessionLeaving: {0} left the group {1}, returning to previous state.", session.Id.ToString(), context.GroupId.ToString());
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PlayGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            ResumePlaying = true;
-
-            var setQueueStatus = context.SetPlayQueue(request.PlayingQueue, request.PlayingItemPosition, request.StartPositionTicks);
-            if (!setQueueStatus)
-            {
-                _logger.LogError("HandleRequest: {0} in group {1}, unable to set playing queue.", request.GetRequestType(), context.GroupId.ToString());
-
-                // Ignore request and return to previous state.
-                ISyncPlayState newState;
-                switch (prevState)
-                {
-                    case GroupState.Playing:
-                        newState = new PlayingGroupState(_logger);
-                        break;
-                    case GroupState.Paused:
-                        newState = new PausedGroupState(_logger);
-                        break;
-                    default:
-                        newState = new IdleGroupState(_logger);
-                        break;
-                }
-
-                context.SetState(newState);
-                return;
-            }
-
-            var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.NewPlaylist);
-            var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-            context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-            // Reset status of sessions and await for all Ready events.
-            context.SetAllBuffering(true);
-
-            _logger.LogDebug("HandleRequest: {0} in group {1}, {2} set a new play queue.", request.GetRequestType(), context.GroupId.ToString(), session.Id.ToString());
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SetPlaylistItemGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            ResumePlaying = true;
-
-            var result = context.SetPlayingItem(request.PlaylistItemId);
-            if (result)
-            {
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.SetCurrentItem);
-                var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-                // Reset status of sessions and await for all Ready events.
-                context.SetAllBuffering(true);
-            }
-            else
-            {
-                // Return to old state.
-                ISyncPlayState newState;
-                switch (prevState)
-                {
-                    case GroupState.Playing:
-                        newState = new PlayingGroupState(_logger);
-                        break;
-                    case GroupState.Paused:
-                        newState = new PausedGroupState(_logger);
-                        break;
-                    default:
-                        newState = new IdleGroupState(_logger);
-                        break;
-                }
-
-                context.SetState(newState);
-
-                _logger.LogDebug("HandleRequest: {0} in group {1}, unable to change current playing item.", request.GetRequestType(), context.GroupId.ToString());
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, UnpauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            if (prevState.Equals(GroupState.Idle))
-            {
-                ResumePlaying = true;
-                context.RestartCurrentItem();
-
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.NewPlaylist);
-                var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-                // Reset status of sessions and await for all Ready events.
-                context.SetAllBuffering(true);
-
-                _logger.LogDebug("HandleRequest: {0} in group {1}, waiting for all ready events.", request.GetRequestType(), context.GroupId.ToString());
-            }
-            else
-            {
-                if (ResumePlaying)
-                {
-                    _logger.LogDebug("HandleRequest: {0} in group {1}, ignoring sessions that are not ready and forcing the playback to start.", request.GetRequestType(), context.GroupId.ToString());
-
-                    // An Unpause request is forcing the playback to start, ignoring sessions that are not ready.
-                    context.SetAllBuffering(false);
-
-                    // Change state.
-                    var playingState = new PlayingGroupState(_logger);
-                    playingState.IgnoreBuffering = true;
-                    context.SetState(playingState);
-                    playingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-                }
-                else
-                {
-                    // Group would have gone to paused state, now will go to playing state when ready.
-                    ResumePlaying = true;
-
-                    // Notify relevant state change event.
-                    SendGroupStateUpdate(context, request, session, cancellationToken);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PauseGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            // Wait for sessions to be ready, then switch to paused state.
-            ResumePlaying = false;
-
-            // Notify relevant state change event.
-            SendGroupStateUpdate(context, request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, StopGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            // Change state.
-            var idleState = new IdleGroupState(_logger);
-            context.SetState(idleState);
-            idleState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, SeekGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            if (prevState.Equals(GroupState.Playing))
-            {
-                ResumePlaying = true;
-            }
-            else if(prevState.Equals(GroupState.Paused))
-            {
-                ResumePlaying = false;
-            }
-
-            // Sanitize PositionTicks.
-            var ticks = context.SanitizePositionTicks(request.PositionTicks);
-
-            // Seek.
-            context.PositionTicks = ticks;
-            context.LastActivity = DateTime.UtcNow;
-
-            var command = context.NewSyncPlayCommand(SendCommandType.Seek);
-            context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-
-            // Reset status of sessions and await for all Ready events.
-            context.SetAllBuffering(true);
-
-            // Notify relevant state change event.
-            SendGroupStateUpdate(context, request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, BufferGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            // Make sure the client is playing the correct item.
-            if (!request.PlaylistItemId.Equals(context.PlayQueue.GetPlayingItemPlaylistId()))
-            {
-                _logger.LogDebug("HandleRequest: {0} in group {1}, {2} has wrong playlist item.", request.GetRequestType(), context.GroupId.ToString(), session.Id.ToString());
-
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.SetCurrentItem);
-                var updateSession = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, updateSession, cancellationToken);
-                context.SetBuffering(session, true);
-
-                return;
-            }
-
-            if (prevState.Equals(GroupState.Playing))
-            {
-                // Resume playback when all ready.
-                ResumePlaying = true;
-
-                context.SetBuffering(session, true);
-
-                // Pause group and compute the media playback position.
-                var currentTime = DateTime.UtcNow;
-                var elapsedTime = currentTime - context.LastActivity;
-                context.LastActivity = currentTime;
-                // Elapsed time is negative if event happens
-                // during the delay added to account for latency.
-                // In this phase clients haven't started the playback yet.
-                // In other words, LastActivity is in the future,
-                // when playback unpause is supposed to happen.
-                // Seek only if playback actually started.
-                context.PositionTicks += Math.Max(elapsedTime.Ticks, 0);
-
-                // Send pause command to all non-buffering sessions.
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.AllReady, command, cancellationToken);
-            }
-            else if (prevState.Equals(GroupState.Paused))
-            {
-                // Don't resume playback when all ready.
-                ResumePlaying = false;
-
-                context.SetBuffering(session, true);
-
-                // Send pause command to buffering session.
-                var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-            }
-            else if (prevState.Equals(GroupState.Waiting))
-            {
-                // Another session is now buffering.
-                context.SetBuffering(session, true);
-
-                if (!ResumePlaying)
-                {
-                    // Force update for this session that should be paused.
-                    var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                    context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-                }
-            }
-
-            // Notify relevant state change event.
-            SendGroupStateUpdate(context, request, session, cancellationToken);
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, ReadyGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            // Make sure the client is playing the correct item.
-            if (!request.PlaylistItemId.Equals(context.PlayQueue.GetPlayingItemPlaylistId()))
-            {
-                _logger.LogDebug("HandleRequest: {0} in group {1}, {2} has wrong playlist item.", request.GetRequestType(), context.GroupId.ToString(), session.Id.ToString());
-
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.SetCurrentItem);
-                var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, update, cancellationToken);
-                context.SetBuffering(session, true);
-
-                return;
-            }
-
-            // Compute elapsed time between the client reported time and now.
-            // Elapsed time is used to estimate the client position when playback is unpaused.
-            // Ideally, the request is received and handled without major delays.
-            // However, to avoid waiting indefinitely when a client is not reporting a correct time,
-            // the elapsed time is ignored after a certain threshold.
-            var currentTime = DateTime.UtcNow;
-            var elapsedTime = currentTime.Subtract(request.When);
-            var timeSyncThresholdTicks = TimeSpan.FromMilliseconds(context.TimeSyncOffset).Ticks;
-            if (Math.Abs(elapsedTime.Ticks) > timeSyncThresholdTicks)
-            {
-                _logger.LogWarning("HandleRequest: {0} in group {1}, {2} is not time syncing properly. Ignoring elapsed time.",
-                    request.GetRequestType(), context.GroupId.ToString(), session.Id);
-
-                elapsedTime = TimeSpan.Zero;
-            }
-
-            // Ignore elapsed time if client is paused.
-            if (!request.IsPlaying)
-            {
-                elapsedTime = TimeSpan.Zero;
-            }
-
-            var requestTicks = context.SanitizePositionTicks(request.PositionTicks);
-            var clientPosition = TimeSpan.FromTicks(requestTicks) + elapsedTime;
-            var delayTicks = context.PositionTicks - clientPosition.Ticks;
-            var maxPlaybackOffsetTicks = TimeSpan.FromMilliseconds(context.MaxPlaybackOffset).Ticks;
-
-            _logger.LogDebug("HandleRequest: {0} in group {1}, {2} at {3} (delay of {4} seconds).",
-                request.GetRequestType(), context.GroupId.ToString(), session.Id, clientPosition, TimeSpan.FromTicks(delayTicks).TotalSeconds);
-
-            if (ResumePlaying)
-            {
-                // Handle case where session reported as ready but in reality
-                // it has no clue of the real position nor the playback state.
-                if (!request.IsPlaying && Math.Abs(delayTicks) > maxPlaybackOffsetTicks)
-                {
-                    // Session not ready at all.
-                    context.SetBuffering(session, true);
-
-                    // Correcting session's position.
-                    var command = context.NewSyncPlayCommand(SendCommandType.Seek);
-                    context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-
-                    // Notify relevant state change event.
-                    SendGroupStateUpdate(context, request, session, cancellationToken);
-
-                    _logger.LogWarning("HandleRequest: {0} in group {1}, {2} got lost in time, correcting.",
-                        request.GetRequestType(), context.GroupId.ToString(), session.Id);
-                    return;
-                }
-
-                // Session is ready.
-                context.SetBuffering(session, false);
-
-                if (context.IsBuffering())
-                {
-                    // Others are still buffering, tell this client to pause when ready.
-                    var command = context.NewSyncPlayCommand(SendCommandType.Pause);
-                    var pauseAtTime = currentTime.AddTicks(delayTicks);
-                    command.When = context.DateToUTCString(pauseAtTime);
-                    context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-
-                    _logger.LogInformation("HandleRequest: {0} in group {1}, others still buffering, {2} will pause when ready in {3} seconds.",
-                        request.GetRequestType(), context.GroupId.ToString(), session.Id, TimeSpan.FromTicks(delayTicks).TotalSeconds);
-                }
-                else
-                {
-                    // If all ready, then start playback.
-                    // Let other clients resume as soon as the buffering client catches up.
-                    if (delayTicks > context.GetHighestPing() * 2 * TimeSpan.TicksPerMillisecond)
-                    {
-                        // Client that was buffering is recovering, notifying others to resume.
-                        context.LastActivity = currentTime.AddTicks(delayTicks);
-                        var command = context.NewSyncPlayCommand(SendCommandType.Unpause);
-                        var filter = SyncPlayBroadcastType.AllExceptCurrentSession;
-                        if (!request.IsPlaying)
-                        {
-                            filter = SyncPlayBroadcastType.AllGroup;
-                        }
-
-                        context.SendCommand(session, filter, command, cancellationToken);
-
-                        _logger.LogInformation("HandleRequest: {0} in group {1}, {2} is recovering, notifying others to resume in {3} seconds.",
-                            request.GetRequestType(), context.GroupId.ToString(), session.Id, TimeSpan.FromTicks(delayTicks).TotalSeconds);
-                    }
-                    else
-                    {
-                        // Client, that was buffering, resumed playback but did not update others in time.
-                        delayTicks = context.GetHighestPing() * 2 * TimeSpan.TicksPerMillisecond;
-                        delayTicks = Math.Max(delayTicks, context.DefaultPing);
-
-                        context.LastActivity = currentTime.AddTicks(delayTicks);
-
-                        var command = context.NewSyncPlayCommand(SendCommandType.Unpause);
-                        context.SendCommand(session, SyncPlayBroadcastType.AllGroup, command, cancellationToken);
-
-                        _logger.LogWarning("HandleRequest: {0} in group {1}, {2} resumed playback but did not update others in time. {3} seconds to recover.",
-                            request.GetRequestType(), context.GroupId.ToString(), session.Id, TimeSpan.FromTicks(delayTicks).TotalSeconds);
-                    }
-
-                    // Change state.
-                    var playingState = new PlayingGroupState(_logger);
-                    context.SetState(playingState);
-                    playingState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-                }
-            }
-            else
-            {
-                // Check that session is really ready, tollerate player imperfections under a certain threshold.
-                if (Math.Abs(context.PositionTicks - requestTicks) > maxPlaybackOffsetTicks)
-                {
-                    // Session still not ready.
-                    context.SetBuffering(session, true);
-                    // Session is seeking to wrong position, correcting.
-                    var command = context.NewSyncPlayCommand(SendCommandType.Seek);
-                    context.SendCommand(session, SyncPlayBroadcastType.CurrentSession, command, cancellationToken);
-
-                    // Notify relevant state change event.
-                    SendGroupStateUpdate(context, request, session, cancellationToken);
-
-                    _logger.LogWarning("HandleRequest: {0} in group {1}, {2} was seeking to wrong position, correcting.",
-                        request.GetRequestType(), context.GroupId.ToString(), session.Id);
-                    return;
-                } else {
-                    // Session is ready.
-                    context.SetBuffering(session, false);
-                }
-
-                if (!context.IsBuffering())
-                {
-                    // Group is ready, returning to previous state.
-                    var pausedState = new PausedGroupState(_logger);
-                    context.SetState(pausedState);
-
-                    if (InitialState.Equals(GroupState.Playing))
-                    {
-                        // Group went from playing to waiting state and a pause request occured while waiting.
-                        var pauserequest = new PauseGroupRequest();
-                        pausedState.HandleRequest(context, GetGroupState(), pauserequest, session, cancellationToken);
-                    }
-                    else if (InitialState.Equals(GroupState.Paused))
-                    {
-                        pausedState.HandleRequest(context, GetGroupState(), request, session, cancellationToken);
-                    }
-
-                    _logger.LogDebug("HandleRequest: {0} in group {1}, {2} is ready, returning to previous state.",
-                        request.GetRequestType(), context.GroupId.ToString(), session.Id);
-                }
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, NextTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            ResumePlaying = true;
-
-            // Make sure the client knows the playing item, to avoid duplicate requests.
-            if (!request.PlaylistItemId.Equals(context.PlayQueue.GetPlayingItemPlaylistId()))
-            {
-                _logger.LogDebug("HandleRequest: {0} in group {1}, client provided the wrong playlist identifier.", request.GetRequestType(), context.GroupId.ToString());
-                return;
-            }
-
-            var newItem = context.NextItemInQueue();
-            if (newItem)
-            {
-                // Send playing-queue update.
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.NextTrack);
-                var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-                // Reset status of sessions and await for all Ready events.
-                context.SetAllBuffering(true);
-            }
-            else
-            {
-                // Return to old state.
-                ISyncPlayState newState;
-                switch (prevState)
-                {
-                    case GroupState.Playing:
-                        newState = new PlayingGroupState(_logger);
-                        break;
-                    case GroupState.Paused:
-                        newState = new PausedGroupState(_logger);
-                        break;
-                    default:
-                        newState = new IdleGroupState(_logger);
-                        break;
-                }
-
-                context.SetState(newState);
-
-                _logger.LogDebug("HandleRequest: {0} in group {1}, no next track available.", request.GetRequestType(), context.GroupId.ToString());
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleRequest(ISyncPlayStateContext context, GroupState prevState, PreviousTrackGroupRequest request, SessionInfo session, CancellationToken cancellationToken)
-        {
-            // Save state if first event.
-            if (!InitialStateSet)
-            {
-                InitialState = prevState;
-                InitialStateSet = true;
-            }
-
-            ResumePlaying = true;
-
-            // Make sure the client knows the playing item, to avoid duplicate requests.
-            if (!request.PlaylistItemId.Equals(context.PlayQueue.GetPlayingItemPlaylistId()))
-            {
-                _logger.LogDebug("HandleRequest: {0} in group {1}, client provided the wrong playlist identifier.", request.GetRequestType(), context.GroupId.ToString());
-                return;
-            }
-
-            var newItem = context.PreviousItemInQueue();
-            if (newItem)
-            {
-                // Send playing-queue update.
-                var playQueueUpdate = context.GetPlayQueueUpdate(PlayQueueUpdateReason.PreviousTrack);
-                var update = context.NewSyncPlayGroupUpdate(GroupUpdateType.PlayQueue, playQueueUpdate);
-                context.SendGroupUpdate(session, SyncPlayBroadcastType.AllGroup, update, cancellationToken);
-
-                // Reset status of sessions and await for all Ready events.
-                context.SetAllBuffering(true);
-            }
-            else
-            {
-                // Return to old state.
-                ISyncPlayState newState;
-                switch (prevState)
-                {
-                    case GroupState.Playing:
-                        newState = new PlayingGroupState(_logger);
-                        break;
-                    case GroupState.Paused:
-                        newState = new PausedGroupState(_logger);
-                        break;
-                    default:
-                        newState = new IdleGroupState(_logger);
-                        break;
-                }
-
-                context.SetState(newState);
-
-                _logger.LogDebug("HandleRequest: {0} in group {1}, no previous track available.", request.GetRequestType(), context.GroupId.ToString());
-            }
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/SyncPlay/SyncPlayManager.cs b/Emby.Server.Implementations/SyncPlay/SyncPlayManager.cs
index ab9be145f..178536631 100644
--- a/Emby.Server.Implementations/SyncPlay/SyncPlayManager.cs
+++ b/Emby.Server.Implementations/SyncPlay/SyncPlayManager.cs
@@ -39,14 +39,14 @@ namespace Emby.Server.Implementations.SyncPlay
         /// <summary>
         /// The map between sessions and groups.
         /// </summary>
-        private readonly Dictionary<string, ISyncPlayGroupController> _sessionToGroupMap =
-            new Dictionary<string, ISyncPlayGroupController>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, IGroupController> _sessionToGroupMap =
+            new Dictionary<string, IGroupController>(StringComparer.OrdinalIgnoreCase);
 
         /// <summary>
         /// The groups.
         /// </summary>
-        private readonly Dictionary<Guid, ISyncPlayGroupController> _groups =
-            new Dictionary<Guid, ISyncPlayGroupController>();
+        private readonly Dictionary<Guid, IGroupController> _groups =
+            new Dictionary<Guid, IGroupController>();
 
         /// <summary>
         /// Lock used for accesing any group.
@@ -83,7 +83,7 @@ namespace Emby.Server.Implementations.SyncPlay
         /// Gets all groups.
         /// </summary>
         /// <value>All groups.</value>
-        public IEnumerable<ISyncPlayGroupController> Groups => _groups.Values;
+        public IEnumerable<IGroupController> Groups => _groups.Values;
 
         /// <inheritdoc />
         public void Dispose()
@@ -229,7 +229,7 @@ namespace Emby.Server.Implementations.SyncPlay
                     LeaveGroup(session, cancellationToken);
                 }
 
-                var group = new SyncPlayGroupController(_logger, _userManager, _sessionManager, _libraryManager, this);
+                var group = new GroupController(_logger, _userManager, _sessionManager, _libraryManager, this);
                 _groups[group.GroupId] = group;
 
                 group.CreateGroup(session, request, cancellationToken);
@@ -249,7 +249,7 @@ namespace Emby.Server.Implementations.SyncPlay
 
             lock (_groupsLock)
             {
-                _groups.TryGetValue(groupId, out ISyncPlayGroupController group);
+                _groups.TryGetValue(groupId, out IGroupController group);
 
                 if (group == null)
                 {
@@ -346,7 +346,7 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public void HandleRequest(SessionInfo session, IPlaybackGroupRequest request, CancellationToken cancellationToken)
+        public void HandleRequest(SessionInfo session, IGroupPlaybackRequest request, CancellationToken cancellationToken)
         {
             // TODO: create abstract class for GroupRequests to avoid explicit request type here.
             if (!IsRequestValid(session, GroupRequestType.Playback, request))
@@ -375,28 +375,23 @@ namespace Emby.Server.Implementations.SyncPlay
         }
 
         /// <inheritdoc />
-        public void AddSessionToGroup(SessionInfo session, ISyncPlayGroupController group)
+        public void AddSessionToGroup(SessionInfo session, IGroupController group)
         {
             if (session == null)
             {
                 throw new InvalidOperationException("Session is null!");
             }
 
-            if (group == null)
-            {
-                throw new InvalidOperationException("Group is null!");
-            }
-
             if (IsSessionInGroup(session))
             {
                 throw new InvalidOperationException("Session in other group already!");
             }
 
-            _sessionToGroupMap[session.Id] = group;
+            _sessionToGroupMap[session.Id] = group ?? throw new InvalidOperationException("Group is null!");
         }
 
         /// <inheritdoc />
-        public void RemoveSessionFromGroup(SessionInfo session, ISyncPlayGroupController group)
+        public void RemoveSessionFromGroup(SessionInfo session, IGroupController group)
         {
             if (session == null)
             {