Add client-side + interface implementation

osu.Game.Tests/Visual/Online/TestSceneMultiplayerQueueList.cs

@@ -0,0 +1,177 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics.Containers;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay;
+using osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual.Multiplayer;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneMultiplayerQueueList : MultiplayerTestScene
+    {
+        private MultiplayerQueueList playlist;
+
+        [Cached(typeof(UserLookupCache))]
+        private readonly TestUserLookupCache userLookupCache = new TestUserLookupCache();
+
+        private BeatmapManager beatmaps;
+        private RulesetStore rulesets;
+        private BeatmapSetInfo importedSet;
+        private BeatmapInfo importedBeatmap;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, AudioManager audio)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
+        }
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddStep("create playlist", () =>
+            {
+                Child = playlist = new MultiplayerQueueList
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(500, 300),
+                    Items = { BindTarget = Client.APIRoom!.Playlist }
+                };
+            });
+
+            AddStep("import beatmap", () =>
+            {
+                beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
+                importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();
+                importedBeatmap = importedSet.Beatmaps.First(b => b.RulesetID == 0);
+            });
+
+            AddStep("change to all players mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+        }
+
+        [Test]
+        public void TestDeleteButtonHiddenWithSingleItem()
+        {
+            AddStep("set all players queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.AllPlayers);
+
+            assertDeleteButtonVisibility(0, false);
+
+            addPlaylistItem(() => API.LocalUser.Value.OnlineID);
+            assertDeleteButtonVisibility(0, true);
+
+            deleteItem(1);
+            assertDeleteButtonVisibility(0, false);
+        }
+
+        [Test]
+        public void TestDeleteButtonHiddenInHostOnlyMode()
+        {
+            AddStep("set all players queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.AllPlayers);
+            addPlaylistItem(() => 1234);
+
+            AddStep("set host-only queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.HostOnly }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.HostOnly);
+
+            assertDeleteButtonVisibility(0, false);
+        }
+
+        [Test]
+        public void TestOnlyItemOwnerHasDeleteButton()
+        {
+            AddStep("set all players queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.AllPlayers);
+
+            addPlaylistItem(() => API.LocalUser.Value.OnlineID);
+            assertDeleteButtonVisibility(0, true);
+            assertDeleteButtonVisibility(1, true);
+
+            addPlaylistItem(() => 1234);
+            assertDeleteButtonVisibility(2, false);
+        }
+
+        [Test]
+        public void TestNonOwnerDoesNotHaveDeleteButton()
+        {
+            AddStep("set all players queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.AllPlayers);
+
+            addPlaylistItem(() => 1234);
+            assertDeleteButtonVisibility(0, true);
+            assertDeleteButtonVisibility(1, false);
+        }
+
+        [Test]
+        public void TestSelectedItemDoesNotHaveDeleteButton()
+        {
+            AddStep("set all players queue mode", () => Client.ChangeSettings(new MultiplayerRoomSettings { QueueMode = QueueMode.AllPlayers }));
+            AddUntilStep("wait for queue mode change", () => Client.APIRoom?.QueueMode.Value == QueueMode.AllPlayers);
+
+            addPlaylistItem(() => API.LocalUser.Value.OnlineID);
+            assertDeleteButtonVisibility(0, true);
+
+            AddStep("set first playlist item as selected", () => playlist.SelectedItem.Value = playlist.Items[0]);
+            assertDeleteButtonVisibility(0, false);
+        }
+
+        private void addPlaylistItem(Func<int> userId)
+        {
+            long itemId = -1;
+
+            AddStep("add playlist item", () =>
+            {
+                MultiplayerPlaylistItem item = new MultiplayerPlaylistItem(new PlaylistItem
+                {
+                    Beatmap = { Value = importedBeatmap },
+                    BeatmapID = importedBeatmap.OnlineID ?? -1,
+                });
+
+                Client.AddUserPlaylistItem(userId(), item);
+
+                itemId = item.ID;
+            });
+
+            AddUntilStep("item arrived in playlist", () => playlist.ChildrenOfType<RearrangeableListItem<PlaylistItem>>().Any(i => i.Model.ID == itemId));
+        }
+
+        private void deleteItem(int index)
+        {
+            OsuRearrangeableListItem<PlaylistItem> item = null;
+
+            AddStep($"move mouse to delete button {index}", () =>
+            {
+                item = playlist.ChildrenOfType<OsuRearrangeableListItem<PlaylistItem>>().ElementAt(index);
+                InputManager.MoveMouseTo(item.ChildrenOfType<DrawableRoomPlaylistItem.PlaylistRemoveButton>().ElementAt(0));
+            });
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddUntilStep("item removed from playlist", () => !playlist.ChildrenOfType<RearrangeableListItem<PlaylistItem>>().Contains(item));
+        }
+
+        private void assertDeleteButtonVisibility(int index, bool visible)
+            => AddUntilStep($"delete button {index} {(visible ? "is" : "is not")} visible",
+                () => (playlist.ChildrenOfType<DrawableRoomPlaylistItem.PlaylistRemoveButton>().ElementAt(index).Alpha > 0) == visible);
+    }
+}

osu.Game/Online/Multiplayer/IMultiplayerRoomServer.cs

@@ -82,5 +82,11 @@ namespace osu.Game.Online.Multiplayer
         /// </summary>
         /// <param name="item">The item to add.</param>
         Task AddPlaylistItem(MultiplayerPlaylistItem item);
+
+        /// <summary>
+        /// Removes an item from the playlist.
+        /// </summary>
+        /// <param name="playlistItemId">The item to remove.</param>
+        Task RemovePlaylistItem(long playlistItemId);
     }
 }

osu.Game/Online/Multiplayer/MultiplayerClient.cs

@@ -335,6 +335,8 @@ namespace osu.Game.Online.Multiplayer
 
         public abstract Task AddPlaylistItem(MultiplayerPlaylistItem item);
 
+        public abstract Task RemovePlaylistItem(long playlistItemId);
+
         Task IMultiplayerClient.RoomStateChanged(MultiplayerRoomState state)
         {
             if (Room == null)

osu.Game/Online/Multiplayer/OnlineMultiplayerClient.cs

@@ -162,6 +162,14 @@ namespace osu.Game.Online.Multiplayer
             return connection.InvokeAsync(nameof(IMultiplayerServer.AddPlaylistItem), item);
         }
 
+        public override Task RemovePlaylistItem(long playlistItemId)
+        {
+            if (!IsConnected.Value)
+                return Task.CompletedTask;
+
+            return connection.InvokeAsync(nameof(IMultiplayerServer.RemovePlaylistItem), playlistItemId);
+        }
+
         protected override Task<APIBeatmap> GetAPIBeatmap(int beatmapId, CancellationToken cancellationToken = default)
         {
             return beatmapLookupCache.GetBeatmapAsync(beatmapId, cancellationToken);

osu.Game/Screens/OnlinePlay/Multiplayer/Match/Playlist/MultiplayerQueueList.cs

@@ -7,6 +7,8 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Online.API;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
 using osuTK;
 
@@ -27,6 +29,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
             Spacing = new Vector2(0, 2)
         };
 
+        protected override DrawableRoomPlaylistItem CreateDrawablePlaylistItem(PlaylistItem item) => new QueuePlaylistItem(item);
+
         private class QueueFillFlowContainer : FillFlowContainer<RearrangeableListItem<PlaylistItem>>
         {
             [Resolved(typeof(Room), nameof(Room.Playlist))]
@@ -40,5 +44,44 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match.Playlist
 
             public override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.OfType<RearrangeableListItem<PlaylistItem>>().OrderBy(item => item.Model.PlaylistOrder);
         }
+
+        private class QueuePlaylistItem : DrawableRoomPlaylistItem
+        {
+            [Resolved]
+            private IAPIProvider api { get; set; }
+
+            [Resolved]
+            private MultiplayerClient multiplayerClient { get; set; }
+
+            [Resolved(typeof(Room), nameof(Room.QueueMode))]
+            private Bindable<QueueMode> queueMode { get; set; }
+
+            [Resolved(typeof(Room), nameof(Room.Playlist))]
+            private BindableList<PlaylistItem> playlist { get; set; }
+
+            public QueuePlaylistItem(PlaylistItem item)
+                : base(item)
+            {
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                RequestDeletion = item => multiplayerClient.RemovePlaylistItem(item.ID);
+
+                playlist.BindCollectionChanged((_, __) => updateDeleteButtonVisibility());
+                queueMode.BindValueChanged(_ => updateDeleteButtonVisibility());
+                SelectedItem.BindValueChanged(_ => updateDeleteButtonVisibility(), true);
+            }
+
+            private void updateDeleteButtonVisibility()
+            {
+                AllowDeletion = queueMode.Value != QueueMode.HostOnly
+                                && playlist.Count > 1
+                                && Item.OwnerID == api.LocalUser.Value.OnlineID
+                                && SelectedItem.Value != Item;
+            }
+        }
     }
 }

osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs

@@ -339,6 +339,36 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         public override Task AddPlaylistItem(MultiplayerPlaylistItem item) => AddUserPlaylistItem(api.LocalUser.Value.OnlineID, item);
 
+        public async Task RemoveUserPlaylistItem(int userId, long playlistItemId)
+        {
+            Debug.Assert(Room != null);
+            Debug.Assert(APIRoom != null);
+
+            if (Room.Settings.QueueMode == QueueMode.HostOnly)
+                throw new InvalidOperationException("Items cannot be removed in host-only mode.");
+
+            if (Room.Playlist.Count == 1)
+                throw new InvalidOperationException("The singular item in the room cannot be removed.");
+
+            var item = serverSidePlaylist.Find(i => i.ID == playlistItemId);
+
+            if (item == null)
+                throw new InvalidOperationException("Item does not exist in the room.");
+
+            if (item == currentItem)
+                throw new InvalidOperationException("The room's current item cannot be removed.");
+
+            if (item.OwnerID != userId)
+                throw new InvalidOperationException("Attempted to remove an item which is not owned by the user.");
+
+            serverSidePlaylist.Remove(item);
+            await ((IMultiplayerClient)this).PlaylistItemRemoved(playlistItemId).ConfigureAwait(false);
+
+            await updateCurrentItem(Room).ConfigureAwait(false);
+        }
+
+        public override Task RemovePlaylistItem(long playlistItemId) => RemoveUserPlaylistItem(api.LocalUser.Value.OnlineID, playlistItemId);
+
         protected override Task<APIBeatmap> GetAPIBeatmap(int beatmapId, CancellationToken cancellationToken = default)
         {
             IBeatmapSetInfo? set = roomManager.ServerSideRooms.SelectMany(r => r.Playlist)