wjones
af1152b001
Refactored all C# test files to use explicit namespace declarations and moved all using directives inside the namespace block for consistency. Updated assembly info and cache files to reflect the new build. Adjusted MvcTestingAppManifest.json to use fully qualified assembly names. No functional changes; all updates are related to code style, organization, and project metadata.
684 lines
24 KiB
C#
684 lines
24 KiB
C#
// <copyright file="Group.cs" company="PlaceholderCompany">
|
|
// Copyright (c) PlaceholderCompany. All rights reserved.
|
|
// </copyright>
|
|
|
|
namespace Emby.Server.Implementations.SyncPlay
|
|
{
|
|
#nullable disable
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Jellyfin.Database.Implementations.Entities;
|
|
using Jellyfin.Extensions;
|
|
using MediaBrowser.Controller.Library;
|
|
using MediaBrowser.Controller.Session;
|
|
using MediaBrowser.Controller.SyncPlay;
|
|
using MediaBrowser.Controller.SyncPlay.GroupStates;
|
|
using MediaBrowser.Controller.SyncPlay.Queue;
|
|
using MediaBrowser.Controller.SyncPlay.Requests;
|
|
using MediaBrowser.Model.SyncPlay;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
/// <summary>
|
|
/// Class Group.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Class is not thread-safe, external locking is required when accessing methods.
|
|
/// </remarks>
|
|
public class Group : IGroupStateContext
|
|
{
|
|
/// <summary>
|
|
/// The logger.
|
|
/// </summary>
|
|
private readonly ILogger<Group> _logger;
|
|
|
|
/// <summary>
|
|
/// The logger factory.
|
|
/// </summary>
|
|
private readonly ILoggerFactory _loggerFactory;
|
|
|
|
/// <summary>
|
|
/// The user manager.
|
|
/// </summary>
|
|
private readonly IUserManager _userManager;
|
|
|
|
/// <summary>
|
|
/// The session manager.
|
|
/// </summary>
|
|
private readonly ISessionManager _sessionManager;
|
|
|
|
/// <summary>
|
|
/// The library manager.
|
|
/// </summary>
|
|
private readonly ILibraryManager _libraryManager;
|
|
|
|
/// <summary>
|
|
/// The participants, or members of the group.
|
|
/// </summary>
|
|
private readonly Dictionary<string, GroupMember> _participants =
|
|
new Dictionary<string, GroupMember>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
/// <summary>
|
|
/// The internal group state.
|
|
/// </summary>
|
|
private IGroupState _state;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="Group" /> class.
|
|
/// </summary>
|
|
/// <param name="loggerFactory">The logger factory.</param>
|
|
/// <param name="userManager">The user manager.</param>
|
|
/// <param name="sessionManager">The session manager.</param>
|
|
/// <param name="libraryManager">The library manager.</param>
|
|
public Group(
|
|
ILoggerFactory loggerFactory,
|
|
IUserManager userManager,
|
|
ISessionManager sessionManager,
|
|
ILibraryManager libraryManager)
|
|
{
|
|
_loggerFactory = loggerFactory;
|
|
_userManager = userManager;
|
|
_sessionManager = sessionManager;
|
|
_libraryManager = libraryManager;
|
|
_logger = loggerFactory.CreateLogger<Group>();
|
|
|
|
_state = new IdleGroupState(loggerFactory);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the default ping value used for sessions.
|
|
/// </summary>
|
|
/// <value>The default ping.</value>
|
|
public long DefaultPing { get; } = 500;
|
|
|
|
/// <summary>
|
|
/// Gets the maximum time offset error accepted for dates reported by clients, in milliseconds.
|
|
/// </summary>
|
|
/// <value>The maximum time offset error.</value>
|
|
public long TimeSyncOffset { get; } = 2000;
|
|
|
|
/// <summary>
|
|
/// Gets the maximum offset error accepted for position reported by clients, in milliseconds.
|
|
/// </summary>
|
|
/// <value>The maximum offset error.</value>
|
|
public long MaxPlaybackOffset { get; } = 500;
|
|
|
|
/// <summary>
|
|
/// Gets the group identifier.
|
|
/// </summary>
|
|
/// <value>The group identifier.</value>
|
|
public Guid GroupId { get; } = Guid.NewGuid();
|
|
|
|
/// <summary>
|
|
/// Gets the group name.
|
|
/// </summary>
|
|
/// <value>The group name.</value>
|
|
public string GroupName { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the group identifier.
|
|
/// </summary>
|
|
/// <value>The group identifier.</value>
|
|
public PlayQueueManager PlayQueue { get; } = new PlayQueueManager();
|
|
|
|
/// <summary>
|
|
/// Gets the runtime ticks of current playing item.
|
|
/// </summary>
|
|
/// <value>The runtime ticks of current playing item.</value>
|
|
public long RunTimeTicks { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the position ticks.
|
|
/// </summary>
|
|
/// <value>The position ticks.</value>
|
|
public long PositionTicks { get; set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the last activity.
|
|
/// </summary>
|
|
/// <value>The last activity.</value>
|
|
public DateTime LastActivity { get; set; }
|
|
|
|
/// <summary>
|
|
/// Adds the session to the group.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
private void AddSession(SessionInfo session)
|
|
{
|
|
_participants.TryAdd(
|
|
session.Id,
|
|
new GroupMember(session)
|
|
{
|
|
Ping = DefaultPing,
|
|
IsBuffering = false
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the session from the group.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
private void RemoveSession(SessionInfo session)
|
|
{
|
|
_participants.Remove(session.Id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Filters sessions of this group.
|
|
/// </summary>
|
|
/// <param name="fromId">The current session identifier.</param>
|
|
/// <param name="type">The filtering type.</param>
|
|
/// <returns>The list of sessions matching the filter.</returns>
|
|
private IEnumerable<string> FilterSessions(string fromId, SyncPlayBroadcastType type)
|
|
{
|
|
return type switch
|
|
{
|
|
SyncPlayBroadcastType.CurrentSession => new string[] { fromId },
|
|
SyncPlayBroadcastType.AllGroup => _participants
|
|
.Values
|
|
.Select(member => member.SessionId),
|
|
SyncPlayBroadcastType.AllExceptCurrentSession => _participants
|
|
.Values
|
|
.Select(member => member.SessionId)
|
|
.Where(sessionId => !sessionId.Equals(fromId, StringComparison.OrdinalIgnoreCase)),
|
|
SyncPlayBroadcastType.AllReady => _participants
|
|
.Values
|
|
.Where(member => !member.IsBuffering)
|
|
.Select(member => member.SessionId),
|
|
_ => Enumerable.Empty<string>()
|
|
};
|
|
}
|
|
|
|
/// <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, IReadOnlyList<Guid> queue)
|
|
{
|
|
// Check if queue is empty.
|
|
if (queue is null || queue.Count == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
foreach (var itemId in queue)
|
|
{
|
|
var item = _libraryManager.GetItemById(itemId);
|
|
if (!item.IsVisibleStandalone(user))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool AllUsersHaveAccessToQueue(IReadOnlyList<Guid> queue)
|
|
{
|
|
// Check if queue is empty.
|
|
if (queue is null || queue.Count == 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Get list of users.
|
|
var users = _participants
|
|
.Values
|
|
.Select(participant => _userManager.GetUserById(participant.UserId));
|
|
|
|
// Find problematic users.
|
|
var usersWithNoAccess = users.Where(user => !HasAccessToQueue(user, queue));
|
|
|
|
// All users must be able to access the queue.
|
|
return !usersWithNoAccess.Any();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the group is empty.
|
|
/// </summary>
|
|
/// <returns><c>true</c> if the group is empty, <c>false</c> otherwise.</returns>
|
|
public bool IsGroupEmpty() => _participants.Count == 0;
|
|
|
|
/// <summary>
|
|
/// Initializes the group with the session's info.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="request">The request.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
public void CreateGroup(SessionInfo session, NewGroupRequest request, CancellationToken cancellationToken)
|
|
{
|
|
GroupName = request.GroupName;
|
|
AddSession(session);
|
|
|
|
var sessionIsPlayingAnItem = session.FullNowPlayingItem is not null;
|
|
|
|
RestartCurrentItem();
|
|
|
|
if (sessionIsPlayingAnItem)
|
|
{
|
|
var playlist = session.NowPlayingQueue.Select(item => item.Id).ToList();
|
|
PlayQueue.Reset();
|
|
PlayQueue.SetPlaylist(playlist);
|
|
PlayQueue.SetPlayingItemById(session.FullNowPlayingItem.Id);
|
|
RunTimeTicks = session.FullNowPlayingItem.RunTimeTicks ?? 0;
|
|
PositionTicks = session.PlayState.PositionTicks ?? 0;
|
|
|
|
// Maintain playstate.
|
|
var waitingState = new WaitingGroupState(_loggerFactory)
|
|
{
|
|
ResumePlaying = !session.PlayState.IsPaused
|
|
};
|
|
SetState(waitingState);
|
|
}
|
|
|
|
var updateSession = new SyncPlayGroupJoinedUpdate(GroupId, GetInfo());
|
|
SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, updateSession, cancellationToken);
|
|
|
|
_state.SessionJoined(this, _state.Type, session, cancellationToken);
|
|
|
|
_logger.LogInformation("Session {SessionId} created group {GroupId}.", session.Id, GroupId.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the session to the group.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="request">The request.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
public void SessionJoin(SessionInfo session, JoinGroupRequest request, CancellationToken cancellationToken)
|
|
{
|
|
AddSession(session);
|
|
|
|
var updateSession = new SyncPlayGroupJoinedUpdate(GroupId, GetInfo());
|
|
SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, updateSession, cancellationToken);
|
|
|
|
var updateOthers = new SyncPlayUserJoinedUpdate(GroupId, session.UserName);
|
|
SendGroupUpdate(session, SyncPlayBroadcastType.AllExceptCurrentSession, updateOthers, cancellationToken);
|
|
|
|
_state.SessionJoined(this, _state.Type, session, cancellationToken);
|
|
|
|
_logger.LogInformation("Session {SessionId} joined group {GroupId}.", session.Id, GroupId.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes the session from the group.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="request">The request.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
public void SessionLeave(SessionInfo session, LeaveGroupRequest request, CancellationToken cancellationToken)
|
|
{
|
|
_state.SessionLeaving(this, _state.Type, session, cancellationToken);
|
|
|
|
RemoveSession(session);
|
|
|
|
var updateSession = new SyncPlayGroupLeftUpdate(GroupId, GroupId.ToString());
|
|
SendGroupUpdate(session, SyncPlayBroadcastType.CurrentSession, updateSession, cancellationToken);
|
|
|
|
var updateOthers = new SyncPlayUserLeftUpdate(GroupId, session.UserName);
|
|
SendGroupUpdate(session, SyncPlayBroadcastType.AllExceptCurrentSession, updateOthers, cancellationToken);
|
|
|
|
_logger.LogInformation("Session {SessionId} left group {GroupId}.", session.Id, GroupId.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles the requested action by the session.
|
|
/// </summary>
|
|
/// <param name="session">The session.</param>
|
|
/// <param name="request">The requested action.</param>
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
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("Session {SessionId} requested {RequestType} in group {GroupId} that is {StateType}.", session.Id, request.Action, GroupId.ToString(), _state.Type);
|
|
|
|
// Apply requested changes to this group given its current state.
|
|
// Every request has a slightly different outcome depending on the group's state.
|
|
// There are currently four different group states that accomplish different goals:
|
|
// - Idle: in this state no media is playing and clients should be idle (playback is stopped).
|
|
// - Waiting: in this state the group is waiting for all the clients to be ready to start the playback,
|
|
// that is, they've either finished loading the media for the first time or they've finished buffering.
|
|
// Once all clients report to be ready the group's state can change to Playing or Paused.
|
|
// - Playing: clients have some media loaded and playback is unpaused.
|
|
// - Paused: clients have some media loaded but playback is currently paused.
|
|
request.Apply(this, _state, session, cancellationToken);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the info about the group for the clients.
|
|
/// </summary>
|
|
/// <returns>The group info for the clients.</returns>
|
|
public GroupInfoDto GetInfo()
|
|
{
|
|
var participants = _participants.Values.Select(session => session.UserName).Distinct().ToList();
|
|
return new GroupInfoDto(GroupId, GroupName, _state.Type, participants, DateTime.UtcNow);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if a user has access to all content in the play queue.
|
|
/// </summary>
|
|
/// <param name="user">The user.</param>
|
|
/// <returns><c>true</c> if the user can access the play queue; <c>false</c> otherwise.</returns>
|
|
public bool HasAccessToPlayQueue(User user)
|
|
{
|
|
var items = PlayQueue.GetPlaylist().Select(item => item.ItemId).ToList();
|
|
return HasAccessToQueue(user, items);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetIgnoreGroupWait(SessionInfo session, bool ignoreGroupWait)
|
|
{
|
|
if (_participants.TryGetValue(session.Id, out GroupMember value))
|
|
{
|
|
value.IgnoreGroupWait = ignoreGroupWait;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetState(IGroupState state)
|
|
{
|
|
_logger.LogInformation("Group {GroupId} switching from {FromStateType} to {ToStateType}.", GroupId.ToString(), _state.Type, state.Type);
|
|
this._state = state;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task SendGroupUpdate<T>(SessionInfo from, SyncPlayBroadcastType type, GroupUpdate<T> message, CancellationToken cancellationToken)
|
|
{
|
|
IEnumerable<Task> GetTasks()
|
|
{
|
|
foreach (var sessionId in FilterSessions(from.Id, type))
|
|
{
|
|
yield return _sessionManager.SendSyncPlayGroupUpdate(sessionId, message, cancellationToken);
|
|
}
|
|
}
|
|
|
|
return Task.WhenAll(GetTasks());
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task SendCommand(SessionInfo from, SyncPlayBroadcastType type, SendCommand message, CancellationToken cancellationToken)
|
|
{
|
|
IEnumerable<Task> GetTasks()
|
|
{
|
|
foreach (var sessionId in FilterSessions(from.Id, type))
|
|
{
|
|
yield return _sessionManager.SendSyncPlayCommand(sessionId, message, cancellationToken);
|
|
}
|
|
}
|
|
|
|
return Task.WhenAll(GetTasks());
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public SendCommand NewSyncPlayCommand(SendCommandType type)
|
|
{
|
|
return new SendCommand(
|
|
GroupId,
|
|
PlayQueue.GetPlayingItemPlaylistId(),
|
|
LastActivity,
|
|
type,
|
|
PositionTicks,
|
|
DateTime.UtcNow);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public long SanitizePositionTicks(long? positionTicks)
|
|
{
|
|
var ticks = positionTicks ?? 0;
|
|
return Math.Clamp(ticks, 0, RunTimeTicks);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void UpdatePing(SessionInfo session, long ping)
|
|
{
|
|
if (_participants.TryGetValue(session.Id, out GroupMember value))
|
|
{
|
|
value.Ping = ping;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public long GetHighestPing()
|
|
{
|
|
long max = long.MinValue;
|
|
foreach (var session in _participants.Values)
|
|
{
|
|
max = Math.Max(max, session.Ping);
|
|
}
|
|
|
|
return max;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetBuffering(SessionInfo session, bool isBuffering)
|
|
{
|
|
if (_participants.TryGetValue(session.Id, out GroupMember value))
|
|
{
|
|
value.IsBuffering = isBuffering;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetAllBuffering(bool isBuffering)
|
|
{
|
|
foreach (var session in _participants.Values)
|
|
{
|
|
session.IsBuffering = isBuffering;
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool IsBuffering()
|
|
{
|
|
foreach (var session in _participants.Values)
|
|
{
|
|
if (session.IsBuffering && !session.IgnoreGroupWait)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool SetPlayQueue(IReadOnlyList<Guid> playQueue, int playingItemPosition, long startPositionTicks)
|
|
{
|
|
// Ignore on empty queue or invalid item position.
|
|
if (playQueue.Count == 0 || playingItemPosition >= playQueue.Count || playingItemPosition < 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check if participants can access the new playing queue.
|
|
if (!AllUsersHaveAccessToQueue(playQueue))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
PlayQueue.Reset();
|
|
PlayQueue.SetPlaylist(playQueue);
|
|
PlayQueue.SetPlayingItemByIndex(playingItemPosition);
|
|
var item = _libraryManager.GetItemById(PlayQueue.GetPlayingItemId());
|
|
RunTimeTicks = item.RunTimeTicks ?? 0;
|
|
PositionTicks = startPositionTicks;
|
|
LastActivity = DateTime.UtcNow;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool SetPlayingItem(Guid playlistItemId)
|
|
{
|
|
var itemFound = PlayQueue.SetPlayingItemByPlaylistId(playlistItemId);
|
|
|
|
if (itemFound)
|
|
{
|
|
var item = _libraryManager.GetItemById(PlayQueue.GetPlayingItemId());
|
|
RunTimeTicks = item.RunTimeTicks ?? 0;
|
|
}
|
|
else
|
|
{
|
|
RunTimeTicks = 0;
|
|
}
|
|
|
|
RestartCurrentItem();
|
|
|
|
return itemFound;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void ClearPlayQueue(bool clearPlayingItem)
|
|
{
|
|
PlayQueue.ClearPlaylist(clearPlayingItem);
|
|
if (clearPlayingItem)
|
|
{
|
|
RestartCurrentItem();
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool RemoveFromPlayQueue(IReadOnlyList<Guid> playlistItemIds)
|
|
{
|
|
var playingItemRemoved = PlayQueue.RemoveFromPlaylist(playlistItemIds);
|
|
if (playingItemRemoved)
|
|
{
|
|
var itemId = PlayQueue.GetPlayingItemId();
|
|
if (!itemId.IsEmpty())
|
|
{
|
|
var item = _libraryManager.GetItemById(itemId);
|
|
RunTimeTicks = item.RunTimeTicks ?? 0;
|
|
}
|
|
else
|
|
{
|
|
RunTimeTicks = 0;
|
|
}
|
|
|
|
RestartCurrentItem();
|
|
}
|
|
|
|
return playingItemRemoved;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool MoveItemInPlayQueue(Guid playlistItemId, int newIndex)
|
|
{
|
|
return PlayQueue.MovePlaylistItem(playlistItemId, newIndex);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool AddToPlayQueue(IReadOnlyList<Guid> newItems, GroupQueueMode mode)
|
|
{
|
|
// Ignore on empty list.
|
|
if (newItems.Count == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Check if participants can access the new playing queue.
|
|
if (!AllUsersHaveAccessToQueue(newItems))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (mode.Equals(GroupQueueMode.QueueNext))
|
|
{
|
|
PlayQueue.QueueNext(newItems);
|
|
}
|
|
else
|
|
{
|
|
PlayQueue.Queue(newItems);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void RestartCurrentItem()
|
|
{
|
|
PositionTicks = 0;
|
|
LastActivity = DateTime.UtcNow;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool NextItemInQueue()
|
|
{
|
|
var update = PlayQueue.Next();
|
|
if (update)
|
|
{
|
|
var item = _libraryManager.GetItemById(PlayQueue.GetPlayingItemId());
|
|
RunTimeTicks = item.RunTimeTicks ?? 0;
|
|
RestartCurrentItem();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool PreviousItemInQueue()
|
|
{
|
|
var update = PlayQueue.Previous();
|
|
if (update)
|
|
{
|
|
var item = _libraryManager.GetItemById(PlayQueue.GetPlayingItemId());
|
|
RunTimeTicks = item.RunTimeTicks ?? 0;
|
|
RestartCurrentItem();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetRepeatMode(GroupRepeatMode mode)
|
|
{
|
|
PlayQueue.SetRepeatMode(mode);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void SetShuffleMode(GroupShuffleMode mode)
|
|
{
|
|
PlayQueue.SetShuffleMode(mode);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public PlayQueueUpdate GetPlayQueueUpdate(PlayQueueUpdateReason reason)
|
|
{
|
|
var startPositionTicks = PositionTicks;
|
|
var isPlaying = _state.Type.Equals(GroupStateType.Playing);
|
|
|
|
if (isPlaying)
|
|
{
|
|
var currentTime = DateTime.UtcNow;
|
|
var elapsedTime = currentTime - LastActivity;
|
|
// 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.
|
|
// Adjust ticks only if playback actually started.
|
|
startPositionTicks += Math.Max(elapsedTime.Ticks, 0);
|
|
}
|
|
|
|
return new PlayQueueUpdate(
|
|
reason,
|
|
PlayQueue.LastChange,
|
|
PlayQueue.GetPlaylist(),
|
|
PlayQueue.PlayingItemIndex,
|
|
startPositionTicks,
|
|
isPlaying,
|
|
PlayQueue.ShuffleMode,
|
|
PlayQueue.RepeatMode);
|
|
}
|
|
}
|
|
}
|