open-source-mirrors
/
jellyfin
mirror of https://github.com/jellyfin/jellyfin
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor and other minor changes

Browse Source
pull/2733/head
gion 4 years ago
parent aad5058d25
commit 083d3272d0
10 changed files with 407 additions and 266 deletions
Show Stats Download Patch File Download Diff File

5
Emby.Server.Implementations/HttpServer/WebSocketConnection.cs
Unescape View File

@ -176,10 +176,9 @@ namespace Emby.Server.Implementations.HttpServer
{
SendKeepAliveResponse();
}
if (OnReceive != null)
else
{
OnReceive(info);
OnReceive?.Invoke(info);
}
}
catch (Exception ex)

42
Emby.Server.Implementations/Session/SessionWebSocketListener.cs
Unescape View File

@ -1,3 +1,4 @@
using System.Collections.Generic;
using System;
using System.Collections.Concurrent;
using System.Linq;
@ -25,7 +26,7 @@ namespace Emby.Server.Implementations.Session
public readonly int WebSocketLostTimeout = 60;
/// <summary>
/// The timer factor; controls the frequency of the timer.
/// The keep-alive timer factor; controls how often the timer will check on the status of the WebSockets.
/// </summary>
public readonly double TimerFactor = 0.2;
@ -136,11 +137,10 @@ namespace Emby.Server.Implementations.Session
/// </summary>
/// <param name="sender">The WebSocket.</param>
/// <param name="e">The event arguments.</param>
private void _webSocket_Closed(object sender, EventArgs e)
private void OnWebSocketClosed(object sender, EventArgs e)
{
var webSocket = (IWebSocketConnection) sender;
webSocket.Closed -= _webSocket_Closed;
_webSockets.TryRemove(webSocket, out _);
RemoveWebSocket(webSocket);
}
/// <summary>
@ -149,8 +149,12 @@ namespace Emby.Server.Implementations.Session
/// <param name="webSocket">The WebSocket to monitor.</param>
private async void KeepAliveWebSocket(IWebSocketConnection webSocket)
{
_webSockets.TryAdd(webSocket, 0);
webSocket.Closed += _webSocket_Closed;
if (!_webSockets.TryAdd(webSocket, 0))
{
_logger.LogWarning("Multiple attempts to keep alive single WebSocket {0}", webSocket);
return;
}
webSocket.Closed += OnWebSocketClosed;
webSocket.LastKeepAliveDate = DateTime.UtcNow;
// Notify WebSocket about timeout
@ -160,12 +164,22 @@ namespace Emby.Server.Implementations.Session
}
catch (WebSocketException exception)
{
_logger.LogDebug(exception, "Error sending ForceKeepAlive message to WebSocket.");
_logger.LogWarning(exception, "Error sending ForceKeepAlive message to WebSocket.");
}
StartKeepAliveTimer();
}
/// <summary>
/// Removes a WebSocket from the KeepAlive watchlist.
/// </summary>
/// <param name="webSocket">The WebSocket to remove.</param>
private void RemoveWebSocket(IWebSocketConnection webSocket)
{
webSocket.Closed -= OnWebSocketClosed;
_webSockets.TryRemove(webSocket, out _);
}
/// <summary>
/// Starts the KeepAlive timer.
/// </summary>
@ -195,7 +209,7 @@ namespace Emby.Server.Implementations.Session
foreach (var pair in _webSockets)
{
pair.Key.Closed -= _webSocket_Closed;
pair.Key.Closed -= OnWebSocketClosed;
}
}
@ -214,7 +228,7 @@ namespace Emby.Server.Implementations.Session
if (inactive.Any())
{
_logger.LogDebug("Sending ForceKeepAlive message to {0} WebSockets.", inactive.Count());
_logger.LogDebug("Sending ForceKeepAlive message to {0} inactive WebSockets.", inactive.Count());
}
foreach (var webSocket in inactive)
@ -225,15 +239,19 @@ namespace Emby.Server.Implementations.Session
}
catch (WebSocketException exception)
{
_logger.LogDebug(exception, "Error sending ForceKeepAlive message to WebSocket.");
_logger.LogInformation(exception, "Error sending ForceKeepAlive message to WebSocket.");
lost.Append(webSocket);
}
}
if (lost.Any())
{
// TODO: handle lost webSockets
_logger.LogDebug("Lost {0} WebSockets.", lost.Count());
_logger.LogInformation("Lost {0} WebSockets.", lost.Count());
foreach (var webSocket in lost)
{
// TODO: handle session relative to the lost webSocket
RemoveWebSocket(webSocket);
}
}
if (!_webSockets.Any())

485
Emby.Server.Implementations/Syncplay/SyncplayController.cs
Unescape View File

@ -16,11 +16,26 @@ namespace Emby.Server.Implementations.Syncplay
/// </summary>
public class SyncplayController : ISyncplayController, IDisposable
{
/// <summary>
/// Used to filter the sessions of a group.
/// </summary>
private enum BroadcastType
{
/// <summary>
/// All sessions will receive the message.
/// </summary>
AllGroup = 0,
SingleSession = 1,
AllExceptSession = 2,
/// <summary>
/// Only the specified session will receive the message.
/// </summary>
CurrentSession = 1,
/// <summary>
/// All sessions, except the current one, will receive the message.
/// </summary>
AllExceptCurrentSession = 2,
/// <summary>
/// Only sessions that are not buffering will receive the message.
/// </summary>
AllReady = 3
}
@ -95,40 +110,46 @@ namespace Emby.Server.Implementations.Syncplay
}
}
/// <summary>
/// Filters sessions of this group.
/// </summary>
/// <param name="from">The current session.</param>
/// <param name="type">The filtering type.</param>
/// <value>The array of sessions matching the filter.</value>
private SessionInfo[] FilterSessions(SessionInfo from, BroadcastType type)
{
if (type == BroadcastType.SingleSession)
{
return new SessionInfo[] { from };
}
else if (type == BroadcastType.AllGroup)
{
return _group.Partecipants.Values.Select(
session => session.Session
).ToArray();
}
else if (type == BroadcastType.AllExceptSession)
{
return _group.Partecipants.Values.Select(
session => session.Session
).Where(
session => !session.Id.Equals(from.Id)
).ToArray();
}
else if (type == BroadcastType.AllReady)
switch (type)
{
return _group.Partecipants.Values.Where(
session => !session.IsBuffering
).Select(
session => session.Session
).ToArray();
}
else
{
return new SessionInfo[] {};
case BroadcastType.CurrentSession:
return new SessionInfo[] { from };
case BroadcastType.AllGroup:
return _group.Participants.Values.Select(
session => session.Session
).ToArray();
case BroadcastType.AllExceptCurrentSession:
return _group.Participants.Values.Select(
session => session.Session
).Where(
session => !session.Id.Equals(from.Id)
).ToArray();
case BroadcastType.AllReady:
return _group.Participants.Values.Where(
session => !session.IsBuffering
).Select(
session => session.Session
).ToArray();
default:
return new SessionInfo[] { };
}
}
/// <summary>
/// Sends a GroupUpdate message to the interested sessions.
/// </summary>
/// <param name="from">The current session.</param>
/// <param name="type">The filtering type.</param>
/// <param name="message">The message to send.</param>
/// <value>The task.</value>
private Task SendGroupUpdate<T>(SessionInfo from, BroadcastType type, GroupUpdate<T> message)
{
IEnumerable<Task> GetTasks()
@ -143,6 +164,13 @@ namespace Emby.Server.Implementations.Syncplay
return Task.WhenAll(GetTasks());
}
/// <summary>
/// Sends a playback command to the interested sessions.
/// </summary>
/// <param name="from">The current session.</param>
/// <param name="type">The filtering type.</param>
/// <param name="message">The message to send.</param>
/// <value>The task.</value>
private Task SendCommand(SessionInfo from, BroadcastType type, SendCommand message)
{
IEnumerable<Task> GetTasks()
@ -157,31 +185,44 @@ namespace Emby.Server.Implementations.Syncplay
return Task.WhenAll(GetTasks());
}
/// <summary>
/// Builds a new playback command with some default values.
/// </summary>
/// <param name="type">The command type.</param>
/// <value>The SendCommand.</value>
private SendCommand NewSyncplayCommand(SendCommandType type)
{
var command = new SendCommand();
command.GroupId = _group.GroupId.ToString();
command.Command = type;
command.PositionTicks = _group.PositionTicks;
command.When = _group.LastActivity.ToUniversalTime().ToString("o");
command.EmittedAt = DateTime.UtcNow.ToUniversalTime().ToString("o");
return command;
return new SendCommand()
{
GroupId = _group.GroupId.ToString(),
Command = type,
PositionTicks = _group.PositionTicks,
When = _group.LastActivity.ToUniversalTime().ToString("o"),
EmittedAt = DateTime.UtcNow.ToUniversalTime().ToString("o")
};
}
/// <summary>
/// Builds a new group update message.
/// </summary>
/// <param name="type">The update type.</param>
/// <param name="data">The data to send.</param>
/// <value>The GroupUpdate.</value>
private GroupUpdate<T> NewSyncplayGroupUpdate<T>(GroupUpdateType type, T data)
{
var command = new GroupUpdate<T>();
command.GroupId = _group.GroupId.ToString();
command.Type = type;
command.Data = data;
return command;
return new GroupUpdate<T>()
{
GroupId = _group.GroupId.ToString(),
Type = type,
Data = data
};
}
/// <inheritdoc />
public void InitGroup(SessionInfo session)
{
_group.AddSession(session);
_syncplayManager.MapSessionToGroup(session, this);
_syncplayManager.AddSessionToGroup(session, this);
_group.PlayingItem = session.FullNowPlayingItem;
_group.IsPaused = true;
@ -189,37 +230,35 @@ namespace Emby.Server.Implementations.Syncplay
_group.LastActivity = DateTime.UtcNow;
var updateSession = NewSyncplayGroupUpdate(GroupUpdateType.GroupJoined, DateTime.UtcNow.ToUniversalTime().ToString("o"));
SendGroupUpdate(session, BroadcastType.SingleSession, updateSession);
SendGroupUpdate(session, BroadcastType.CurrentSession, updateSession);
var pauseCommand = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.SingleSession, pauseCommand);
SendCommand(session, BroadcastType.CurrentSession, pauseCommand);
}
/// <inheritdoc />
public void SessionJoin(SessionInfo session, JoinGroupRequest request)
{
if (session.NowPlayingItem != null &&
session.NowPlayingItem.Id.Equals(_group.PlayingItem.Id) &&
request.PlayingItemId.Equals(_group.PlayingItem.Id))
if (session.NowPlayingItem?.Id == _group.PlayingItem.Id && request.PlayingItemId == _group.PlayingItem.Id)
{
_group.AddSession(session);
_syncplayManager.MapSessionToGroup(session, this);
_syncplayManager.AddSessionToGroup(session, this);
var updateSession = NewSyncplayGroupUpdate(GroupUpdateType.GroupJoined, DateTime.UtcNow.ToUniversalTime().ToString("o"));
SendGroupUpdate(session, BroadcastType.SingleSession, updateSession);
SendGroupUpdate(session, BroadcastType.CurrentSession, updateSession);
var updateOthers = NewSyncplayGroupUpdate(GroupUpdateType.UserJoined, session.UserName);
SendGroupUpdate(session, BroadcastType.AllExceptSession, updateOthers);
SendGroupUpdate(session, BroadcastType.AllExceptCurrentSession, updateOthers);
// Client join and play, syncing will happen client side
if (!_group.IsPaused)
{
var playCommand = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.SingleSession, playCommand);
SendCommand(session, BroadcastType.CurrentSession, playCommand);
}
else
{
var pauseCommand = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.SingleSession, pauseCommand);
SendCommand(session, BroadcastType.CurrentSession, pauseCommand);
}
}
else
@ -228,7 +267,7 @@ namespace Emby.Server.Implementations.Syncplay
playRequest.ItemIds = new Guid[] { _group.PlayingItem.Id };
playRequest.StartPositionTicks = _group.PositionTicks;
var update = NewSyncplayGroupUpdate(GroupUpdateType.PrepareSession, playRequest);
SendGroupUpdate(session, BroadcastType.SingleSession, update);
SendGroupUpdate(session, BroadcastType.CurrentSession, update);
}
}
@ -236,182 +275,250 @@ namespace Emby.Server.Implementations.Syncplay
public void SessionLeave(SessionInfo session)
{
_group.RemoveSession(session);
_syncplayManager.UnmapSessionFromGroup(session, this);
_syncplayManager.RemoveSessionFromGroup(session, this);
var updateSession = NewSyncplayGroupUpdate(GroupUpdateType.GroupLeft, _group.PositionTicks);
SendGroupUpdate(session, BroadcastType.SingleSession, updateSession);
SendGroupUpdate(session, BroadcastType.CurrentSession, updateSession);
var updateOthers = NewSyncplayGroupUpdate(GroupUpdateType.UserLeft, session.UserName);
SendGroupUpdate(session, BroadcastType.AllExceptSession, updateOthers);
SendGroupUpdate(session, BroadcastType.AllExceptCurrentSession, updateOthers);
}
/// <inheritdoc />
public void HandleRequest(SessionInfo session, PlaybackRequest request)
{
if (request.Type.Equals(PlaybackRequestType.Play))
// The server's job is to mantain a consistent state to which clients refer to,
// as also to 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.
switch (request.Type)
{
if (_group.IsPaused)
{
var delay = _group.GetHighestPing() * 2;
delay = delay < _group.DefaulPing ? _group.DefaulPing : delay;
_group.IsPaused = false;
_group.LastActivity = DateTime.UtcNow.AddMilliseconds(
delay
);
case PlaybackRequestType.Play:
HandlePlayRequest(session, request);
break;
case PlaybackRequestType.Pause:
HandlePauseRequest(session, request);
break;
case PlaybackRequestType.Seek:
HandleSeekRequest(session, request);
break;
case PlaybackRequestType.Buffering:
HandleBufferingRequest(session, request);
break;
case PlaybackRequestType.BufferingDone:
HandleBufferingDoneRequest(session, request);
break;
case PlaybackRequestType.UpdatePing:
HandlePingUpdateRequest(session, request);
break;
}
}
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.AllGroup, command);
}
else
{
// Client got lost
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.SingleSession, command);
}
/// <summary>
/// Handles a play action requested by a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The play action.</param>
private void HandlePlayRequest(SessionInfo session, PlaybackRequest request)
{
if (_group.IsPaused)
{
// Pick a suitable time that accounts for latency
var delay = _group.GetHighestPing() * 2;
delay = delay < _group.DefaulPing ? _group.DefaulPing : delay;
// 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
_group.IsPaused = false;
_group.LastActivity = DateTime.UtcNow.AddMilliseconds(
delay
);
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.AllGroup, command);
}
else if (request.Type.Equals(PlaybackRequestType.Pause))
else
{
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;
// Client got lost, sending current state
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.CurrentSession, command);
}
}
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.AllGroup, command);
}
else
{
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.SingleSession, command);
}
/// <summary>
/// Handles a pause action requested by a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The pause action.</param>
private void HandlePauseRequest(SessionInfo session, PlaybackRequest request)
{
if (!_group.IsPaused)
{
// Pause group and compute the media playback position
_group.IsPaused = true;
var currentTime = DateTime.UtcNow;
var elapsedTime = currentTime - _group.LastActivity;
_group.LastActivity = currentTime;
// Seek only if playback actually started
// (a pause request may be issued during the delay added to account for latency)
_group.PositionTicks += elapsedTime.Ticks > 0 ? elapsedTime.Ticks : 0;
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.AllGroup, command);
}
else if (request.Type.Equals(PlaybackRequestType.Seek))
else
{
// 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;
}
// Client got lost, sending current state
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.CurrentSession, command);
}
}
/// <summary>
/// Handles a seek action requested by a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The seek action.</param>
private void HandleSeekRequest(SessionInfo session, PlaybackRequest request)
{
// 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;
}
// Pause and seek
_group.IsPaused = true;
_group.PositionTicks = ticks;
_group.LastActivity = DateTime.UtcNow;
var command = NewSyncplayCommand(SendCommandType.Seek);
SendCommand(session, BroadcastType.AllGroup, command);
}
/// <summary>
/// Handles a buffering action requested by a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The buffering action.</param>
private void HandleBufferingRequest(SessionInfo session, PlaybackRequest request)
{
if (!_group.IsPaused)
{
// Pause group and compute the media playback position
_group.IsPaused = true;
_group.PositionTicks = ticks;
_group.LastActivity = DateTime.UtcNow;
var currentTime = DateTime.UtcNow;
var elapsedTime = currentTime - _group.LastActivity;
_group.LastActivity = currentTime;
_group.PositionTicks += elapsedTime.Ticks > 0 ? elapsedTime.Ticks : 0;
var command = NewSyncplayCommand(SendCommandType.Seek);
SendCommand(session, BroadcastType.AllGroup, command);
_group.SetBuffering(session, true);
// Send pause command to all non-buffering sessions
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.AllReady, command);
var updateOthers = NewSyncplayGroupUpdate(GroupUpdateType.GroupWait, session.UserName);
SendGroupUpdate(session, BroadcastType.AllExceptCurrentSession, updateOthers);
}
// TODO: client does not implement this yet
else if (request.Type.Equals(PlaybackRequestType.Buffering))
else
{
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;
// Client got lost, sending current state
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.CurrentSession, command);
}
}
_group.SetBuffering(session, true);
/// <summary>
/// Handles a buffering-done action requested by a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The buffering-done action.</param>
private void HandleBufferingDoneRequest(SessionInfo session, PlaybackRequest request)
{
if (_group.IsPaused)
{
_group.SetBuffering(session, false);
// Send pause command to all non-buffering sessions
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.AllReady, command);
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 updateOthers = NewSyncplayGroupUpdate(GroupUpdateType.GroupWait, session.UserName);
SendGroupUpdate(session, BroadcastType.AllExceptSession, updateOthers);
}
else
if (_group.IsBuffering())
{
// Others are buffering, tell this client to pause when ready
var command = NewSyncplayCommand(SendCommandType.Pause);
SendCommand(session, BroadcastType.SingleSession, command);
command.When = currentTime.AddMilliseconds(
delay
).ToUniversalTime().ToString("o");
SendCommand(session, BroadcastType.CurrentSession, command);
}
}
// TODO: client does not implement this yet
else if (request.Type.Equals(PlaybackRequestType.BufferingComplete))
{
if (_group.IsPaused)
else
{
_group.SetBuffering(session, 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(SendCommandType.Pause);
command.When = currentTime.AddMilliseconds(
// Let other clients resume as soon as the buffering client catches up
_group.IsPaused = false;
if (delay > _group.GetHighestPing() * 2)
{
// Client that was buffering is recovering, notifying others to resume
_group.LastActivity = currentTime.AddMilliseconds(
delay
).ToUniversalTime().ToString("o");
SendCommand(session, BroadcastType.SingleSession, command);
);
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.AllExceptCurrentSession, 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(SendCommandType.Play);
SendCommand(session, BroadcastType.AllExceptSession, 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(SendCommandType.Play);
SendCommand(session, BroadcastType.AllGroup, command);
}
}
}
else
{
// Make sure client has latest group state
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.SingleSession, command);
// 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(SendCommandType.Play);
SendCommand(session, BroadcastType.AllGroup, command);
}
}
}
else if (request.Type.Equals(PlaybackRequestType.UpdatePing))
else
{
_group.UpdatePing(session, request.Ping ??= _group.DefaulPing);
// Group was not waiting, make sure client has latest state
var command = NewSyncplayCommand(SendCommandType.Play);
SendCommand(session, BroadcastType.CurrentSession, command);
}
}
/// <summary>
/// Updates ping of a session.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="request">The update.</param>
private void HandlePingUpdateRequest(SessionInfo session, PlaybackRequest request)
{
// Collected pings are used to account for network latency when unpausing playback
_group.UpdatePing(session, request.Ping ??= _group.DefaulPing);
}
/// <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(session => session.Session.UserName).ToArray();
return info;
return new GroupInfoView()
{
GroupId = GetGroupId().ToString(),
PlayingItemName = _group.PlayingItem.Name,
PlayingItemId = _group.PlayingItem.Id.ToString(),
PositionTicks = _group.PositionTicks,
Participants = _group.Participants.Values.Select(session => session.Session.UserName).ToArray()
};
}
}
}

50
Emby.Server.Implementations/Syncplay/SyncplayManager.cs
Unescape View File

@ -49,7 +49,7 @@ namespace Emby.Server.Implementations.Syncplay
/// The groups.
/// </summary>
private readonly ConcurrentDictionary<string, ISyncplayController> _groups =
new ConcurrentDictionary<string, ISyncplayController>(StringComparer.OrdinalIgnoreCase);
new ConcurrentDictionary<string, ISyncplayController>(StringComparer.OrdinalIgnoreCase);
private bool _disposed = false;
@ -64,8 +64,8 @@ namespace Emby.Server.Implementations.Syncplay
_sessionManager = sessionManager;
_libraryManager = libraryManager;
_sessionManager.SessionEnded += _sessionManager_SessionEnded;
_sessionManager.PlaybackStopped += _sessionManager_PlaybackStopped;
_sessionManager.SessionEnded += OnSessionManagerSessionEnded;
_sessionManager.PlaybackStopped += OnSessionManagerPlaybackStopped;
}
/// <summary>
@ -92,8 +92,8 @@ namespace Emby.Server.Implementations.Syncplay
return;
}
_sessionManager.SessionEnded -= _sessionManager_SessionEnded;
_sessionManager.PlaybackStopped -= _sessionManager_PlaybackStopped;
_sessionManager.SessionEnded -= OnSessionManagerSessionEnded;
_sessionManager.PlaybackStopped -= OnSessionManagerPlaybackStopped;
_disposed = true;
}
@ -106,14 +106,14 @@ namespace Emby.Server.Implementations.Syncplay
}
}
void _sessionManager_SessionEnded(object sender, SessionEventArgs e)
private void OnSessionManagerSessionEnded(object sender, SessionEventArgs e)
{
var session = e.SessionInfo;
if (!IsSessionInGroup(session)) return;
LeaveGroup(session);
}
void _sessionManager_PlaybackStopped(object sender, PlaybackStopEventArgs e)
private void OnSessionManagerPlaybackStopped(object sender, PlaybackStopEventArgs e)
{
var session = e.Session;
if (!IsSessionInGroup(session)) return;
@ -130,13 +130,13 @@ namespace Emby.Server.Implementations.Syncplay
var item = _libraryManager.GetItemById(itemId);
var hasParentalRatingAccess = user.Policy.MaxParentalRating.HasValue ? item.InheritedParentalRatingValue <= user.Policy.MaxParentalRating : true;
if (!user.Policy.EnableAllFolders)
if (!user.Policy.EnableAllFolders && hasParentalRatingAccess)
{
var collections = _libraryManager.GetCollectionFolders(item).Select(
folder => folder.Id.ToString("N", CultureInfo.InvariantCulture)
);
var intersect = collections.Intersect(user.Policy.EnabledFolders);
return intersect.Count() > 0 && hasParentalRatingAccess;
return intersect.Count() > 0;
}
else
{
@ -165,7 +165,7 @@ namespace Emby.Server.Implementations.Syncplay
if (user.Policy.SyncplayAccess != SyncplayAccess.CreateAndJoinGroups)
{
// TODO: shall an error message be sent back to the client?
// TODO: report the error to the client
throw new ArgumentException("User does not have permission to create groups");
}
@ -187,22 +187,16 @@ namespace Emby.Server.Implementations.Syncplay
if (user.Policy.SyncplayAccess == SyncplayAccess.None)
{
// TODO: shall an error message be sent back to the client?
// TODO: report the error to the client
throw new ArgumentException("User does not have access to syncplay");
}
if (IsSessionInGroup(session))
{
if (GetSessionGroup(session).Equals(groupId)) return;
LeaveGroup(session);
}
ISyncplayController group;
_groups.TryGetValue(groupId, out group);
if (group == null)
{
_logger.LogError("Syncplaymanager JoinGroup: " + groupId + " does not exist.");
_logger.LogWarning("Syncplaymanager JoinGroup: {0} does not exist.", groupId);
var update = new GroupUpdate<string>();
update.Type = GroupUpdateType.NotInGroup;
@ -215,20 +209,26 @@ namespace Emby.Server.Implementations.Syncplay
throw new ArgumentException("User does not have access to playing item");
}
if (IsSessionInGroup(session))
{
if (GetSessionGroup(session).Equals(groupId)) return;
LeaveGroup(session);
}
group.SessionJoin(session, request);
}
/// <inheritdoc />
public void LeaveGroup(SessionInfo session)
{
// TODO: what happens to users that are in a group and get their permissions revoked?
// TODO: determine what happens to users that are in a group and get their permissions revoked
ISyncplayController group;
_sessionToGroupMap.TryGetValue(session.Id, out group);
if (group == null)
{
_logger.LogWarning("Syncplaymanager HandleRequest: " + session.Id + " not in group.");
_logger.LogWarning("Syncplaymanager LeaveGroup: {0} does not belong to any group.", session.Id);
var update = new GroupUpdate<string>();
update.Type = GroupUpdateType.NotInGroup;
@ -257,9 +257,7 @@ namespace Emby.Server.Implementations.Syncplay
if (session.NowPlayingItem != null)
{
return _groups.Values.Where(
group => HasAccessToItem(user, group.GetPlayingItemId())
).Where(
group => group.GetPlayingItemId().Equals(session.FullNowPlayingItem.Id)
group => group.GetPlayingItemId().Equals(session.FullNowPlayingItem.Id) && HasAccessToItem(user, group.GetPlayingItemId())
).Select(
group => group.GetInfo()
).ToList();
@ -291,7 +289,7 @@ namespace Emby.Server.Implementations.Syncplay
if (group == null)
{
_logger.LogWarning("Syncplaymanager HandleRequest: " + session.Id + " not in group.");
_logger.LogWarning("Syncplaymanager HandleRequest: {0} not in a group.", session.Id);
var update = new GroupUpdate<string>();
update.Type = GroupUpdateType.NotInGroup;
@ -302,7 +300,7 @@ namespace Emby.Server.Implementations.Syncplay
}
/// <inheritdoc />
public void MapSessionToGroup(SessionInfo session, ISyncplayController group)
public void AddSessionToGroup(SessionInfo session, ISyncplayController group)
{
if (IsSessionInGroup(session))
{
@ -312,7 +310,7 @@ namespace Emby.Server.Implementations.Syncplay
}
/// <inheritdoc />
public void UnmapSessionFromGroup(SessionInfo session, ISyncplayController group)
public void RemoveSessionFromGroup(SessionInfo session, ISyncplayController group)
{
if (!IsSessionInGroup(session))
{

52
MediaBrowser.Api/Syncplay/SyncplayService.cs
Unescape View File

@ -90,12 +90,20 @@ namespace MediaBrowser.Api.Syncplay
[ApiMember(Name = "SessionId", IsRequired = true, DataType = "string", ParameterType = "path", Verb = "POST")]
public string SessionId { get; set; }
/// <summary>
/// Gets or sets the date used to pin PositionTicks in time.
/// </summary>
/// <value>The date related to PositionTicks.</value>
[ApiMember(Name = "When", IsRequired = true, DataType = "string", ParameterType = "query", Verb = "POST")]
public string When { get; set; }
[ApiMember(Name = "PositionTicks", IsRequired = true, DataType = "long", ParameterType = "query", Verb = "POST")]
public long PositionTicks { get; set; }
/// <summary>
/// Gets or sets whether this is a buffering or a buffering-done request.
/// </summary>
/// <value><c>true</c> if buffering is complete; <c>false</c> otherwise.</value>
[ApiMember(Name = "Resume", IsRequired = true, DataType = "bool", ParameterType = "query", Verb = "POST")]
public bool Resume { get; set; }
}
@ -162,8 +170,10 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplayJoinGroup request)
{
var currentSession = GetSession(_sessionContext);
var joinRequest = new JoinGroupRequest();
joinRequest.GroupId = Guid.Parse(request.GroupId);
var joinRequest = new JoinGroupRequest()
{
GroupId = Guid.Parse(request.GroupId)
};
try
{
joinRequest.PlayingItemId = Guid.Parse(request.PlayingItemId);
@ -207,8 +217,10 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplayPlayRequest request)
{
var currentSession = GetSession(_sessionContext);
var syncplayRequest = new PlaybackRequest();
syncplayRequest.Type = PlaybackRequestType.Play;
var syncplayRequest = new PlaybackRequest()
{
Type = PlaybackRequestType.Play
};
_syncplayManager.HandleRequest(currentSession, syncplayRequest);
}
@ -219,8 +231,10 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplayPauseRequest request)
{
var currentSession = GetSession(_sessionContext);
var syncplayRequest = new PlaybackRequest();
syncplayRequest.Type = PlaybackRequestType.Pause;
var syncplayRequest = new PlaybackRequest()
{
Type = PlaybackRequestType.Pause
};
_syncplayManager.HandleRequest(currentSession, syncplayRequest);
}
@ -231,9 +245,11 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplaySeekRequest request)
{
var currentSession = GetSession(_sessionContext);
var syncplayRequest = new PlaybackRequest();
syncplayRequest.Type = PlaybackRequestType.Seek;
syncplayRequest.PositionTicks = request.PositionTicks;
var syncplayRequest = new PlaybackRequest()
{
Type = PlaybackRequestType.Seek,
PositionTicks = request.PositionTicks
};
_syncplayManager.HandleRequest(currentSession, syncplayRequest);
}
@ -244,10 +260,12 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplayBufferingRequest request)
{
var currentSession = GetSession(_sessionContext);
var syncplayRequest = new PlaybackRequest();
syncplayRequest.Type = request.Resume ? PlaybackRequestType.BufferingComplete : PlaybackRequestType.Buffering;
syncplayRequest.When = DateTime.Parse(request.When);
syncplayRequest.PositionTicks = request.PositionTicks;
var syncplayRequest = new PlaybackRequest()
{
Type = request.Resume ? PlaybackRequestType.BufferingDone : PlaybackRequestType.Buffering,
When = DateTime.Parse(request.When),
PositionTicks = request.PositionTicks
};
_syncplayManager.HandleRequest(currentSession, syncplayRequest);
}
@ -258,9 +276,11 @@ namespace MediaBrowser.Api.Syncplay
public void Post(SyncplayUpdatePing request)
{
var currentSession = GetSession(_sessionContext);
var syncplayRequest = new PlaybackRequest();
syncplayRequest.Type = PlaybackRequestType.UpdatePing;
syncplayRequest.Ping = Convert.ToInt64(request.Ping);
var syncplayRequest = new PlaybackRequest()
{
Type = PlaybackRequestType.UpdatePing,
Ping = Convert.ToInt64(request.Ping)
};
_syncplayManager.HandleRequest(currentSession, syncplayRequest);
}
}

1
MediaBrowser.Api/Syncplay/TimeSyncService.cs
Unescape View File

@ -54,7 +54,6 @@ namespace MediaBrowser.Api.Syncplay
var response = new UtcTimeResponse();
response.RequestReceptionTime = requestReceptionTime;
var currentSession = GetSession(_sessionContext);
// Important to keep the following two lines at the end
var responseTransmissionTime = DateTime.UtcNow.ToUniversalTime().ToString("o");

24
MediaBrowser.Controller/Syncplay/GroupInfo.cs
Unescape View File

@ -46,11 +46,11 @@ namespace MediaBrowser.Controller.Syncplay
public DateTime LastActivity { get; set; }
/// <summary>
/// Gets the partecipants.
/// Gets the participants.
/// </summary>
/// <value>The partecipants.</value>
public readonly ConcurrentDictionary<string, GroupMember> Partecipants =
new ConcurrentDictionary<string, GroupMember>(StringComparer.OrdinalIgnoreCase);
/// <value>The participants, or members of the group.</value>
public readonly ConcurrentDictionary<string, GroupMember> Participants =
new ConcurrentDictionary<string, GroupMember>(StringComparer.OrdinalIgnoreCase);
/// <summary>
/// Checks if a session is in this group.
@ -58,7 +58,7 @@ namespace MediaBrowser.Controller.Syncplay
/// <value><c>true</c> if the session is in this group; <c>false</c> otherwise.</value>
public bool ContainsSession(string sessionId)
{
return Partecipants.ContainsKey(sessionId);
return Participants.ContainsKey(sessionId);
}
/// <summary>
@ -72,7 +72,7 @@ namespace MediaBrowser.Controller.Syncplay
member.Session = session;
member.Ping = DefaulPing;
member.IsBuffering = false;
Partecipants[session.Id.ToString()] = member;
Participants[session.Id.ToString()] = member;
}
/// <summary>
@ -84,7 +84,7 @@ namespace MediaBrowser.Controller.Syncplay
{
if (!ContainsSession(session.Id.ToString())) return;
GroupMember member;
Partecipants.Remove(session.Id.ToString(), out member);
Participants.Remove(session.Id.ToString(), out member);
}
/// <summary>
@ -95,7 +95,7 @@ namespace MediaBrowser.Controller.Syncplay
public void UpdatePing(SessionInfo session, long ping)
{
if (!ContainsSession(session.Id.ToString())) return;
Partecipants[session.Id.ToString()].Ping = ping;
Participants[session.Id.ToString()].Ping = ping;
}
/// <summary>
@ -105,7 +105,7 @@ namespace MediaBrowser.Controller.Syncplay
public long GetHighestPing()
{
long max = Int64.MinValue;
foreach (var session in Partecipants.Values)
foreach (var session in Participants.Values)
{
max = Math.Max(max, session.Ping);
}
@ -120,7 +120,7 @@ namespace MediaBrowser.Controller.Syncplay
public void SetBuffering(SessionInfo session, bool isBuffering)
{
if (!ContainsSession(session.Id.ToString())) return;
Partecipants[session.Id.ToString()].IsBuffering = isBuffering;
Participants[session.Id.ToString()].IsBuffering = isBuffering;
}
/// <summary>
@ -129,7 +129,7 @@ namespace MediaBrowser.Controller.Syncplay
/// <value><c>true</c> if there is a session buffering in the group; <c>false</c> otherwise.</value>
public bool IsBuffering()
{
foreach (var session in Partecipants.Values)
foreach (var session in Participants.Values)
{
if (session.IsBuffering) return true;
}
@ -142,7 +142,7 @@ namespace MediaBrowser.Controller.Syncplay
/// <value><c>true</c> if the group is empty; <c>false</c> otherwise.</value>
public bool IsEmpty()
{
return Partecipants.Count == 0;
return Participants.Count == 0;
}
}
}

4
MediaBrowser.Controller/Syncplay/ISyncplayManager.cs
Unescape View File

@ -50,7 +50,7 @@ namespace MediaBrowser.Controller.Syncplay
/// <param name="session">The session.</param>
/// <param name="group">The group.</param>
/// <exception cref="InvalidOperationException"></exception>
void MapSessionToGroup(SessionInfo session, ISyncplayController group);
void AddSessionToGroup(SessionInfo session, ISyncplayController group);
/// <summary>
/// Unmaps a session from a group.
@ -58,6 +58,6 @@ namespace MediaBrowser.Controller.Syncplay
/// <param name="session">The session.</param>
/// <param name="group">The group.</param>
/// <exception cref="InvalidOperationException"></exception>
void UnmapSessionFromGroup(SessionInfo session, ISyncplayController group);
void RemoveSessionFromGroup(SessionInfo session, ISyncplayController group);
}
}

8
MediaBrowser.Model/Syncplay/GroupInfoModel.cs → MediaBrowser.Model/Syncplay/GroupInfoView.cs
Unescape View File

@ -1,7 +1,7 @@
namespace MediaBrowser.Model.Syncplay
{
/// <summary>
/// Class GroupInfoModel.
/// Class GroupInfoView.
/// </summary>
public class GroupInfoView
{
@ -30,9 +30,9 @@ namespace MediaBrowser.Model.Syncplay
public long PositionTicks { get; set; }
/// <summary>
/// Gets or sets the partecipants.
/// Gets or sets the participants.
/// </summary>
/// <value>The partecipants.</value>
public string[] Partecipants { get; set; }
/// <value>The participants.</value>
public string[] Participants { get; set; }
}
}

2
MediaBrowser.Model/Syncplay/PlaybackRequestType.cs
Unescape View File

@ -24,7 +24,7 @@ namespace MediaBrowser.Model.Syncplay
/// <summary>
/// A user is signaling that playback resumed.
/// </summary>
BufferingComplete = 4,
BufferingDone = 4,
/// <summary>
/// A user is reporting its ping.
/// </summary>

Write Preview
Loading…
Cancel
Save