Implement syncplay backend

4 files changed, 687 insertions, 0 deletions

diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index 4d906a1bf..8419014c2 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -47,6 +47,7 @@ using Emby.Server.Implementations.Session;
 using Emby.Server.Implementations.SocketSharp;
 using Emby.Server.Implementations.TV;
 using Emby.Server.Implementations.Updates;
+using Emby.Server.Implementations.Syncplay;
 using MediaBrowser.Api;
 using MediaBrowser.Common;
 using MediaBrowser.Common.Configuration;
@@ -80,6 +81,7 @@ using MediaBrowser.Controller.Session;
 using MediaBrowser.Controller.Sorting;
 using MediaBrowser.Controller.Subtitles;
 using MediaBrowser.Controller.TV;
+using MediaBrowser.Controller.Syncplay;
 using MediaBrowser.LocalMetadata.Savers;
 using MediaBrowser.MediaEncoding.BdInfo;
 using MediaBrowser.Model.Activity;
@@ -643,6 +645,8 @@ namespace Emby.Server.Implementations
 
             serviceCollection.AddSingleton<IPlaylistManager, PlaylistManager>();
 
+            serviceCollection.AddSingleton<ISyncplayManager, SyncplayManager>();
+
             serviceCollection.AddSingleton<LiveTvDtoService>();
             serviceCollection.AddSingleton<ILiveTvManager, LiveTvManager>();
 
diff --git a/Emby.Server.Implementations/Session/SessionManager.cs b/Emby.Server.Implementations/Session/SessionManager.cs
index c93c02c48..b1519b572 100644
--- a/Emby.Server.Implementations/Session/SessionManager.cs
+++ b/Emby.Server.Implementations/Session/SessionManager.cs
@@ -25,6 +25,7 @@ using MediaBrowser.Model.Events;
 using MediaBrowser.Model.Library;
 using MediaBrowser.Model.Querying;
 using MediaBrowser.Model.Session;
+using MediaBrowser.Model.Syncplay;
 using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Session
@@ -1154,6 +1155,22 @@ namespace Emby.Server.Implementations.Session
             await SendMessageToSession(session, "Play", command, cancellationToken).ConfigureAwait(false);
         }
 
+        /// <inheritdoc />
+        public async Task SendSyncplayCommand(string sessionId, SyncplayCommand command, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            var session = GetSessionToRemoteControl(sessionId);
+            await SendMessageToSession(session, "SyncplayCommand", command, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc />
+        public async Task SendSyncplayGroupUpdate<T>(string sessionId, SyncplayGroupUpdate<T> command, CancellationToken cancellationToken)
+        {
+            CheckDisposed();
+            var session = GetSessionToRemoteControl(sessionId);
+            await SendMessageToSession(session, "SyncplayGroupUpdate", command, cancellationToken).ConfigureAwait(false);
+        }
+
         private IEnumerable<BaseItem> TranslateItemForPlayback(Guid id, User user)
         {
             var item = _libraryManager.GetItemById(id);
diff --git a/Emby.Server.Implementations/Syncplay/SyncplayController.cs b/Emby.Server.Implementations/Syncplay/SyncplayController.cs
new file mode 100644
index 000000000..4a20ceba0
--- /dev/null
+++ b/Emby.Server.Implementations/Syncplay/SyncplayController.cs
@@ -0,0 +1,418 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Controller.Syncplay;
+using MediaBrowser.Model.Session;
+using MediaBrowser.Model.Syncplay;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Syncplay
+{
+    /// <summary>
+    /// Class SyncplayController.
+    /// </summary>
+    public class SyncplayController : ISyncplayController, IDisposable
+    {
+        private enum BroadcastType
+        {
+            AllGroup = 0,
+            SingleUser = 1,
+            AllExceptUser = 2,
+            AllReady = 3
+        }
+
+        /// <summary>
+        /// The logger.
+        /// </summary>
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// The session manager.
+        /// </summary>
+        private readonly ISessionManager _sessionManager;
+
+        /// <summary>
+        /// The syncplay manager.
+        /// </summary>
+        private readonly ISyncplayManager _syncplayManager;
+
+        /// <summary>
+        /// The group to manage.
+        /// </summary>
+        private readonly GroupInfo _group = new GroupInfo();
+
+        /// <inheritdoc />
+        public Guid GetGroupId() => _group.GroupId;
+
+        /// <inheritdoc />
+        public Guid GetPlayingItemId() => _group.PlayingItem.Id;
+
+        /// <inheritdoc />
+        public bool IsGroupEmpty() => _group.IsEmpty();
+
+        private bool _disposed = false;
+
+        public SyncplayController(
+            ILogger logger,
+            ISessionManager sessionManager,
+            ISyncplayManager syncplayManager)
+        {
+            _logger = logger;
+            _sessionManager = sessionManager;
+            _syncplayManager = syncplayManager;
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and optionally managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+        }
+
+        // TODO: use this somewhere
+        private void CheckDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name);
+            }
+        }
+
+        private SessionInfo[] FilterUsers(SessionInfo from, BroadcastType type)
+        {
+            if (type == BroadcastType.SingleUser)
+            {
+                return new SessionInfo[] { from };
+            }
+            else if (type == BroadcastType.AllGroup)
+            {
+                return _group.Partecipants.Values.Select(
+                    user => user.Session
+                ).ToArray();
+            }
+            else if (type == BroadcastType.AllExceptUser)
+            {
+                return _group.Partecipants.Values.Select(
+                    user => user.Session
+                ).Where(
+                    user => !user.Id.Equals(from.Id)
+                ).ToArray();
+            }
+            else if (type == BroadcastType.AllReady)
+            {
+                return _group.Partecipants.Values.Where(
+                    user => !user.IsBuffering
+                ).Select(
+                    user => user.Session
+                ).ToArray();
+            }
+            else
+            {
+                return new SessionInfo[] {};
+            }
+        }
+
+        private Task SendGroupUpdate<T>(SessionInfo from, BroadcastType type, SyncplayGroupUpdate<T> message)
+        {
+            IEnumerable<Task> GetTasks()
+            {
+                SessionInfo[] users = FilterUsers(from, type);
+                foreach (var user in users)
+                {
+                    yield return _sessionManager.SendSyncplayGroupUpdate(user.Id.ToString(), message, CancellationToken.None);
+                }
+            }
+
+            return Task.WhenAll(GetTasks());
+        }
+
+        private Task SendCommand(SessionInfo from, BroadcastType type, SyncplayCommand message)
+        {
+            IEnumerable<Task> GetTasks()
+            {
+                SessionInfo[] users = FilterUsers(from, type);
+                foreach (var user in users)
+                {
+                    yield return _sessionManager.SendSyncplayCommand(user.Id.ToString(), message, CancellationToken.None);
+                }
+            }
+
+            return Task.WhenAll(GetTasks());
+        }
+
+        private SyncplayCommand NewSyncplayCommand(SyncplayCommandType type) {
+            var command = new SyncplayCommand();
+            command.GroupId = _group.GroupId.ToString();
+            command.Command = type;
+            command.PositionTicks = _group.PositionTicks;
+            command.When = _group.LastActivity.ToUniversalTime().ToString("o");
+            return command;
+        }
+
+        private SyncplayGroupUpdate<T> NewSyncplayGroupUpdate<T>(SyncplayGroupUpdateType type, T data)
+        {
+            var command = new SyncplayGroupUpdate<T>();
+            command.GroupId = _group.GroupId.ToString();
+            command.Type = type;
+            command.Data = data;
+            return command;
+        }
+
+        /// <inheritdoc />
+        public void InitGroup(SessionInfo user)
+        {
+            _group.AddUser(user);
+            _syncplayManager.MapUserToGroup(user, this);
+
+            _group.PlayingItem = user.FullNowPlayingItem;
+            _group.IsPaused = true;
+            _group.PositionTicks = user.PlayState.PositionTicks ??= 0;
+            _group.LastActivity = DateTime.UtcNow;
+
+            var updateUser = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.GroupJoined, DateTime.UtcNow.ToUniversalTime().ToString("o"));
+            SendGroupUpdate(user, BroadcastType.SingleUser, updateUser);
+            var pauseCommand = NewSyncplayCommand(SyncplayCommandType.Pause);
+            SendCommand(user, BroadcastType.SingleUser, pauseCommand);
+        }
+
+        /// <inheritdoc />
+        public void UserJoin(SessionInfo user)
+        {
+            if (user.NowPlayingItem != null && user.NowPlayingItem.Id.Equals(_group.PlayingItem.Id))
+            {
+                _group.AddUser(user);
+                _syncplayManager.MapUserToGroup(user, this);
+
+                var updateUser = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.GroupJoined, _group.PositionTicks);
+                SendGroupUpdate(user, BroadcastType.SingleUser, updateUser);
+
+                var updateOthers = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.UserJoined, user.UserName);
+                SendGroupUpdate(user, BroadcastType.AllExceptUser, updateOthers);
+
+                // Client join and play, syncing will happen client side
+                if (!_group.IsPaused)
+                {
+                    var playCommand = NewSyncplayCommand(SyncplayCommandType.Play);
+                    SendCommand(user, BroadcastType.SingleUser, playCommand);
+                }
+                else
+                {
+                    var pauseCommand = NewSyncplayCommand(SyncplayCommandType.Pause);
+                    SendCommand(user, BroadcastType.SingleUser, pauseCommand);
+                }
+            }
+            else
+            {
+                var playRequest = new PlayRequest();
+                playRequest.ItemIds = new Guid[] { _group.PlayingItem.Id };
+                playRequest.StartPositionTicks = _group.PositionTicks;
+                var update = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.PrepareSession, playRequest);
+                SendGroupUpdate(user, BroadcastType.SingleUser, update);
+            }
+        }
+
+        /// <inheritdoc />
+        public void UserLeave(SessionInfo user)
+        {
+            _group.RemoveUser(user);
+            _syncplayManager.UnmapUserFromGroup(user, this);
+
+            var updateUser = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.GroupLeft, _group.PositionTicks);
+            SendGroupUpdate(user, BroadcastType.SingleUser, updateUser);
+
+            var updateOthers = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.UserLeft, user.UserName);
+            SendGroupUpdate(user, BroadcastType.AllExceptUser, updateOthers);
+        }
+
+        /// <inheritdoc />
+        public void HandleRequest(SessionInfo user, SyncplayRequestInfo request)
+        {
+            if (request.Type.Equals(SyncplayRequestType.Play))
+            {
+                if (_group.IsPaused)
+                {
+                    var delay = _group.GetHighestPing() * 2;
+                    delay = delay < _group.DefaulPing ? _group.DefaulPing : delay;
+
+                    _group.IsPaused = false;
+                    _group.LastActivity = DateTime.UtcNow.AddMilliseconds(
+                        delay
+                    );
+
+                    var command = NewSyncplayCommand(SyncplayCommandType.Play);
+                    SendCommand(user, BroadcastType.AllGroup, command);
+                }
+                else
+                {
+                    // Client got lost
+                    var command = NewSyncplayCommand(SyncplayCommandType.Play);
+                    SendCommand(user, BroadcastType.SingleUser, command);
+                }
+            }
+            else if (request.Type.Equals(SyncplayRequestType.Pause))
+            {
+                if (!_group.IsPaused)
+                {
+                    _group.IsPaused = true;
+                    var currentTime = DateTime.UtcNow;
+                    var elapsedTime = currentTime - _group.LastActivity;
+                    _group.LastActivity = currentTime;
+                    _group.PositionTicks += elapsedTime.Ticks > 0 ? elapsedTime.Ticks : 0;
+
+                    var command = NewSyncplayCommand(SyncplayCommandType.Pause);
+                    SendCommand(user, BroadcastType.AllGroup, command);
+                }
+                else
+                {
+                    var command = NewSyncplayCommand(SyncplayCommandType.Pause);
+                    SendCommand(user, BroadcastType.SingleUser, command);
+                }
+            }
+            else if (request.Type.Equals(SyncplayRequestType.Seek))
+            {
+                // Sanitize PositionTicks
+                var ticks = request.PositionTicks ??= 0;
+                ticks = ticks >= 0 ? ticks : 0;
+                if (_group.PlayingItem.RunTimeTicks != null)
+                {
+                    var runTimeTicks = _group.PlayingItem.RunTimeTicks ??= 0;
+                    ticks = ticks > runTimeTicks ? runTimeTicks : ticks;
+                }
+
+                _group.IsPaused = true;
+                _group.PositionTicks = ticks;
+                _group.LastActivity = DateTime.UtcNow;
+
+                var command = NewSyncplayCommand(SyncplayCommandType.Seek);
+                SendCommand(user, BroadcastType.AllGroup, command);
+            }
+            // TODO: client does not implement this yet
+            else if (request.Type.Equals(SyncplayRequestType.Buffering))
+            {
+                if (!_group.IsPaused)
+                {
+                    _group.IsPaused = true;
+                    var currentTime = DateTime.UtcNow;
+                    var elapsedTime = currentTime - _group.LastActivity;
+                    _group.LastActivity = currentTime;
+                    _group.PositionTicks += elapsedTime.Ticks > 0 ? elapsedTime.Ticks : 0;
+
+                    _group.SetBuffering(user, true);
+
+                    // Send pause command to all non-buffering users
+                    var command = NewSyncplayCommand(SyncplayCommandType.Pause);
+                    SendCommand(user, BroadcastType.AllReady, command);
+
+                    var updateOthers = NewSyncplayGroupUpdate(SyncplayGroupUpdateType.GroupWait, user.UserName);
+                    SendGroupUpdate(user, BroadcastType.AllExceptUser, updateOthers);
+                }
+                else
+                {
+                    var command = NewSyncplayCommand(SyncplayCommandType.Pause);
+                    SendCommand(user, BroadcastType.SingleUser, command);
+                }
+            }
+            // TODO: client does not implement this yet
+            else if (request.Type.Equals(SyncplayRequestType.BufferingComplete))
+            {
+                if (_group.IsPaused)
+                {
+                    _group.SetBuffering(user, false);
+
+                    if (_group.IsBuffering()) {
+                        // Others are buffering, tell this client to pause when ready
+                        var when = request.When ??= DateTime.UtcNow;
+                        var currentTime = DateTime.UtcNow;
+                        var elapsedTime = currentTime - when;
+                        var clientPosition = TimeSpan.FromTicks(request.PositionTicks ??= 0) + elapsedTime;
+                        var delay = _group.PositionTicks - clientPosition.Ticks;
+
+                        var command = NewSyncplayCommand(SyncplayCommandType.Pause);
+                        command.When = currentTime.AddMilliseconds(
+                            delay
+                        ).ToUniversalTime().ToString("o");
+                        SendCommand(user, BroadcastType.SingleUser, command);
+                    }
+                    else
+                    {
+                        // Let other clients resume as soon as the buffering client catches up
+                        var when = request.When ??= DateTime.UtcNow;
+                        var currentTime = DateTime.UtcNow;
+                        var elapsedTime = currentTime - when;
+                        var clientPosition = TimeSpan.FromTicks(request.PositionTicks ??= 0) + elapsedTime;
+                        var delay = _group.PositionTicks - clientPosition.Ticks;
+
+                        _group.IsPaused = false;
+
+                        if (delay > _group.GetHighestPing() * 2)
+                        {
+                            // Client that was buffering is recovering, notifying others to resume
+                            _group.LastActivity = currentTime.AddMilliseconds(
+                                delay
+                            );
+                            var command = NewSyncplayCommand(SyncplayCommandType.Play);
+                            SendCommand(user, BroadcastType.AllExceptUser, command);
+                        }
+                        else
+                        {
+                            // Client, that was buffering, resumed playback but did not update others in time
+                            delay = _group.GetHighestPing() * 2;
+                            delay = delay < _group.DefaulPing ? _group.DefaulPing : delay;
+
+                            _group.LastActivity = currentTime.AddMilliseconds(
+                                delay
+                            );
+
+                            var command = NewSyncplayCommand(SyncplayCommandType.Play);
+                            SendCommand(user, BroadcastType.AllGroup, command);
+                        }
+                    }                    
+                }
+                else
+                {
+                    // Make sure client has latest group state
+                    var command = NewSyncplayCommand(SyncplayCommandType.Play);
+                    SendCommand(user, BroadcastType.SingleUser, command);
+                }
+            }
+            else if (request.Type.Equals(SyncplayRequestType.KeepAlive))
+            {
+                _group.UpdatePing(user, request.Ping ??= _group.DefaulPing);
+
+                var keepAlive = new SyncplayGroupUpdate<string>();
+                keepAlive.GroupId = _group.GroupId.ToString();
+                keepAlive.Type = SyncplayGroupUpdateType.KeepAlive;
+                SendGroupUpdate(user, BroadcastType.SingleUser, keepAlive);
+            }
+        }
+
+        /// <inheritdoc />
+        public GroupInfoView GetInfo()
+        {
+            var info = new GroupInfoView();
+            info.GroupId = GetGroupId().ToString();
+            info.PlayingItemName = _group.PlayingItem.Name;
+            info.PlayingItemId = _group.PlayingItem.Id.ToString();
+            info.PositionTicks = _group.PositionTicks;
+            info.Partecipants = _group.Partecipants.Values.Select(user => user.Session.UserName).ToArray();
+            return info;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Syncplay/SyncplayManager.cs b/Emby.Server.Implementations/Syncplay/SyncplayManager.cs
new file mode 100644
index 000000000..6bfd6aa9b
--- /dev/null
+++ b/Emby.Server.Implementations/Syncplay/SyncplayManager.cs
@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Controller.Syncplay;
+using MediaBrowser.Model.Syncplay;
+
+namespace Emby.Server.Implementations.Syncplay
+{
+    /// <summary>
+    /// Class SyncplayManager.
+    /// </summary>
+    public class SyncplayManager : ISyncplayManager, IDisposable
+    {
+        /// <summary>
+        /// The logger.
+        /// </summary>
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// The session manager.
+        /// </summary>
+        private readonly ISessionManager _sessionManager;
+
+        /// <summary>
+        /// The map between users and groups.
+        /// </summary>
+        private readonly ConcurrentDictionary<string, ISyncplayController> _userToGroupMap =
+            new ConcurrentDictionary<string, ISyncplayController>(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// The groups.
+        /// </summary>
+        private readonly ConcurrentDictionary<string, ISyncplayController> _groups =
+        new ConcurrentDictionary<string, ISyncplayController>(StringComparer.OrdinalIgnoreCase);
+
+        private bool _disposed = false;
+
+        public SyncplayManager(
+            ILogger<SyncplayManager> logger,
+            ISessionManager sessionManager)
+        {
+            _logger = logger;
+            _sessionManager = sessionManager;
+
+            _sessionManager.SessionEnded += _sessionManager_SessionEnded;
+            _sessionManager.PlaybackStopped += _sessionManager_PlaybackStopped;
+        }
+
+        /// <summary>
+        /// Gets all groups.
+        /// </summary>
+        /// <value>All groups.</value>
+        public IEnumerable<ISyncplayController> Groups => _groups.Values;
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and optionally managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _sessionManager.SessionEnded -= _sessionManager_SessionEnded;
+            _sessionManager.PlaybackStopped -= _sessionManager_PlaybackStopped;
+
+            _disposed = true;
+        }
+
+        private void CheckDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name);
+            }
+        }
+
+        void _sessionManager_SessionEnded(object sender, SessionEventArgs e)
+        {
+            LeaveGroup(e.SessionInfo);
+        }
+
+        void _sessionManager_PlaybackStopped(object sender, PlaybackStopEventArgs e)
+        {
+            LeaveGroup(e.Session);
+        }
+
+        private bool IsUserInGroup(SessionInfo user)
+        {
+            return _userToGroupMap.ContainsKey(user.Id);
+        }
+
+        private Guid? GetUserGroup(SessionInfo user)
+        {
+            ISyncplayController group;
+            _userToGroupMap.TryGetValue(user.Id, out group);
+            if (group != null)
+            {
+                return group.GetGroupId();
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        /// <inheritdoc />
+        public void NewGroup(SessionInfo user)
+        {
+            if (IsUserInGroup(user))
+            {
+                LeaveGroup(user);
+            }
+
+            var group = new SyncplayController(_logger, _sessionManager, this);
+            _groups[group.GetGroupId().ToString()] = group;
+
+            group.InitGroup(user);
+        }
+
+        /// <inheritdoc />
+        public void JoinGroup(SessionInfo user, string groupId)
+        {
+            if (IsUserInGroup(user))
+            {
+                if (GetUserGroup(user).Equals(groupId)) return;
+                LeaveGroup(user);
+            }
+
+            ISyncplayController group;
+            _groups.TryGetValue(groupId, out group);
+
+            if (group == null)
+            {
+                _logger.LogError("Syncplaymanager JoinGroup: " + groupId + " does not exist.");
+
+                var update = new SyncplayGroupUpdate<string>();
+                update.Type = SyncplayGroupUpdateType.NotInGroup;
+                _sessionManager.SendSyncplayGroupUpdate(user.Id.ToString(), update, CancellationToken.None);
+                return;
+            }
+            group.UserJoin(user);
+        }
+
+        /// <inheritdoc />
+        public void LeaveGroup(SessionInfo user)
+        {
+            ISyncplayController group;
+            _userToGroupMap.TryGetValue(user.Id, out group);
+
+            if (group == null)
+            {
+                _logger.LogWarning("Syncplaymanager HandleRequest: " + user.Id + " not in group.");
+
+                var update = new SyncplayGroupUpdate<string>();
+                update.Type = SyncplayGroupUpdateType.NotInGroup;
+                _sessionManager.SendSyncplayGroupUpdate(user.Id.ToString(), update, CancellationToken.None);
+                return;
+            }
+            group.UserLeave(user);
+
+            if (group.IsGroupEmpty())
+            {
+                _groups.Remove(group.GetGroupId().ToString(), out _);
+            }
+        }
+
+        /// <inheritdoc />
+        public List<GroupInfoView> ListGroups(SessionInfo user)
+        {
+            // Filter by playing item if the user is viewing something already
+            if (user.NowPlayingItem != null)
+            {
+                return _groups.Values.Where(
+                    group => group.GetPlayingItemId().Equals(user.FullNowPlayingItem.Id)
+                ).Select(
+                    group => group.GetInfo()
+                ).ToList();
+            }
+            // Otherwise show all available groups
+            else
+            {
+                return _groups.Values.Select(
+                    group => group.GetInfo()
+                ).ToList();
+            }
+        }
+
+        /// <inheritdoc />
+        public void HandleRequest(SessionInfo user, SyncplayRequestInfo request)
+        {
+            ISyncplayController group;
+            _userToGroupMap.TryGetValue(user.Id, out group);
+
+            if (group == null)
+            {
+                _logger.LogWarning("Syncplaymanager HandleRequest: " + user.Id + " not in group.");
+
+                var update = new SyncplayGroupUpdate<string>();
+                update.Type = SyncplayGroupUpdateType.NotInGroup;
+                _sessionManager.SendSyncplayGroupUpdate(user.Id.ToString(), update, CancellationToken.None);
+                return;
+            }
+            group.HandleRequest(user, request);
+        }
+        
+        /// <inheritdoc />
+        public void MapUserToGroup(SessionInfo user, ISyncplayController group)
+        {
+            if (IsUserInGroup(user))
+            {
+                throw new InvalidOperationException("User in other group already!");
+            }
+            _userToGroupMap[user.Id] = group;
+        }
+
+        /// <inheritdoc />
+        public void UnmapUserFromGroup(SessionInfo user, ISyncplayController group)
+        {
+            if (!IsUserInGroup(user))
+            {
+                throw new InvalidOperationException("User not in any group!");
+            }
+
+            ISyncplayController tempGroup;
+            _userToGroupMap.Remove(user.Id, out tempGroup);
+
+            if (!tempGroup.GetGroupId().Equals(group.GetGroupId()))
+            {
+                throw new InvalidOperationException("User was in wrong group!");
+            }
+        }
+    }
+}