Hook up all required interfaces to new BeatmapManager

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -158,18 +158,34 @@ namespace osu.Game.Tests.Online
 
             public Task<BeatmapSetInfo> CurrentImportTask { get; private set; }
 
-            protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
+            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host)
-                => new TestDownloadRequest(set);
+            {
+                return new TestBeatmapModelManager(this, storage, contextFactory, rulesets, api, host);
+            }
 
             public TestBeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null, WorkingBeatmap defaultBeatmap = null)
                 : base(storage, contextFactory, rulesets, api, audioManager, resources, host, defaultBeatmap)
             {
             }
 
+            internal class TestBeatmapModelManager : BeatmapModelManager
+            {
+                private readonly TestBeatmapManager testBeatmapManager;
+
+                public TestBeatmapModelManager(TestBeatmapManager testBeatmapManager, Storage storage, IDatabaseContextFactory databaseContextFactory, RulesetStore rulesetStore, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(storage, databaseContextFactory, rulesetStore, apiProvider, gameHost)
+                {
+                    this.testBeatmapManager = testBeatmapManager;
+                }
+
+                protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
+                    => new TestDownloadRequest(set);
+
                 public override async Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
                 {
-                await AllowImport.Task.ConfigureAwait(false);
+                    await testBeatmapManager.AllowImport.Task.ConfigureAwait(false);
-                return await (CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken)).ConfigureAwait(false);
+                    return await (testBeatmapManager.CurrentImportTask = base.Import(item, archive, lowPriority, cancellationToken)).ConfigureAwait(false);
+                }
             }
         }
 

osu.Game/Beatmaps/BeatmapManager.cs

@@ -1,7 +1,27 @@
 // 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.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.IO.Stores;
+using osu.Framework.Platform;
 using osu.Framework.Testing;
+using osu.Game.Database;
+using osu.Game.IO;
+using osu.Game.IO.Archives;
+using osu.Game.Online.API;
+using osu.Game.Overlays.Notifications;
+using osu.Game.Rulesets;
+using osu.Game.Skinning;
+using osu.Game.Users;
 
 namespace osu.Game.Beatmaps
 {
@@ -9,13 +29,282 @@ namespace osu.Game.Beatmaps
     /// Handles general operations related to global beatmap management.
     /// </summary>
     [ExcludeFromDynamicCompile]
-    public class BeatmapManager
+    public class BeatmapManager : IModelDownloader<BeatmapSetInfo>, IModelFileManager<BeatmapSetInfo, BeatmapSetFileInfo>, ICanAcceptFiles, IWorkingBeatmapCache
     {
-        public BeatmapManager()
+        private readonly BeatmapModelManager beatmapModelManager;
+        private readonly WorkingBeatmapCache workingBeatmapCache;
+
+        public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null,
+                              WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
         {
-            beatmapModelManager = new BeatmapModelManager()
+            beatmapModelManager = CreateBeatmapModelManager(storage, contextFactory, rulesets, api, host);
+            workingBeatmapCache = CreateWorkingBeatmapCache(audioManager, resources, new FileStore(contextFactory, storage).Store, defaultBeatmap, host);
+
+            workingBeatmapCache.BeatmapManager = beatmapModelManager;
+
+            var onlineBeatmapLookupCache = new BeatmapOnlineLookupQueue(api, storage);
+
+            beatmapModelManager.PopulateOnlineInformation = onlineBeatmapLookupCache.UpdateAsync;
         }
 
+        protected virtual WorkingBeatmapCache CreateWorkingBeatmapCache(AudioManager audioManager, IResourceStore<byte[]> resources, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost host) =>
+            new WorkingBeatmapCache(audioManager, resources, storage, defaultBeatmap, host);
+
+        protected virtual BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host) =>
+            new BeatmapModelManager(storage, contextFactory, rulesets, api, host);
+
+        /// <summary>
+        /// Create a new <see cref="WorkingBeatmap"/>.
+        /// </summary>
+        public WorkingBeatmap CreateNew(RulesetInfo ruleset, User user)
+        {
+            var metadata = new BeatmapMetadata
+            {
+                Author = user,
+            };
+
+            var set = new BeatmapSetInfo
+            {
+                Metadata = metadata,
+                Beatmaps = new List<BeatmapInfo>
+                {
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                        Ruleset = ruleset,
+                        Metadata = metadata,
+                        WidescreenStoryboard = true,
+                        SamplesMatchPlaybackRate = true,
+                    }
+                }
+            };
+
+            var working = beatmapModelManager.Import(set).Result;
+            return GetWorkingBeatmap(working.Beatmaps.First());
         }
 
+        #region Delegation to BeatmapModelManager (methods which previously existed locally).
+
+        /// <summary>
+        /// Fired when a single difficulty has been hidden.
+        /// </summary>
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapHidden => beatmapModelManager.BeatmapHidden;
+
+        /// <summary>
+        /// Fired when a single difficulty has been restored.
+        /// </summary>
+        public IBindable<WeakReference<BeatmapInfo>> BeatmapRestored => beatmapModelManager.BeatmapRestored;
+
+        /// <summary>
+        /// Saves an <see cref="IBeatmap"/> file against a given <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <param name="info">The <see cref="BeatmapInfo"/> to save the content against. The file referenced by <see cref="BeatmapInfo.Path"/> will be replaced.</param>
+        /// <param name="beatmapContent">The <see cref="IBeatmap"/> content to write.</param>
+        /// <param name="beatmapSkin">The beatmap <see cref="ISkin"/> content to write, null if to be omitted.</param>
+        public virtual void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null) => beatmapModelManager.Save(info, beatmapContent, beatmapSkin);
+
+        /// <summary>
+        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
+        /// </summary>
+        /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
+        public List<BeatmapSetInfo> GetAllUsableBeatmapSets(IncludedDetails includes = IncludedDetails.All, bool includeProtected = false) => beatmapModelManager.GetAllUsableBeatmapSets(includes, includeProtected);
+
+        /// <summary>
+        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s. Note that files are not populated.
+        /// </summary>
+        /// <param name="includes">The level of detail to include in the returned objects.</param>
+        /// <param name="includeProtected">Whether to include protected (system) beatmaps. These should not be included for gameplay playable use cases.</param>
+        /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
+        public IEnumerable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes, bool includeProtected = false) => beatmapModelManager.GetAllUsableBeatmapSetsEnumerable(includes, includeProtected);
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <param name="includes">The level of detail to include in the returned objects.</param>
+        /// <returns>Results from the provided query.</returns>
+        public IEnumerable<BeatmapSetInfo> QueryBeatmapSets(Expression<Func<BeatmapSetInfo, bool>> query, IncludedDetails includes = IncludedDetails.All) => beatmapModelManager.QueryBeatmapSets(query, includes);
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public BeatmapSetInfo QueryBeatmapSet(Expression<Func<BeatmapSetInfo, bool>> query) => beatmapModelManager.QueryBeatmapSet(query);
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>Results from the provided query.</returns>
+        public IQueryable<BeatmapInfo> QueryBeatmaps(Expression<Func<BeatmapInfo, bool>> query) => beatmapModelManager.QueryBeatmaps(query);
+
+        /// <summary>
+        /// Perform a lookup query on available <see cref="BeatmapInfo"/>s.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The first result for the provided query, or null if no results were found.</returns>
+        public BeatmapInfo QueryBeatmap(Expression<Func<BeatmapInfo, bool>> query) => beatmapModelManager.QueryBeatmap(query);
+
+        /// <summary>
+        /// A default representation of a WorkingBeatmap to use when no beatmap is available.
+        /// </summary>
+        public WorkingBeatmap DefaultBeatmap => workingBeatmapCache.DefaultBeatmap;
+
+        /// <summary>
+        /// Fired when a notification should be presented to the user.
+        /// </summary>
+        public Action<Notification> PostNotification { set => beatmapModelManager.PostNotification = value; }
+
+        /// <summary>
+        /// Fired when the user requests to view the resulting import.
+        /// </summary>
+        public Action<IEnumerable<BeatmapSetInfo>> PresentImport { set => beatmapModelManager.PresentImport = value; }
+
+        /// <summary>
+        /// Delete a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to hide.</param>
+        public void Hide(BeatmapInfo beatmap) => beatmapModelManager.Hide(beatmap);
+
+        /// <summary>
+        /// Restore a beatmap difficulty.
+        /// </summary>
+        /// <param name="beatmap">The beatmap difficulty to restore.</param>
+        public void Restore(BeatmapInfo beatmap) => beatmapModelManager.Restore(beatmap);
+
+        #endregion
+
+        #region Implementation of IModelManager<BeatmapSetInfo>
+
+        public IBindable<WeakReference<BeatmapSetInfo>> ItemUpdated => beatmapModelManager.ItemUpdated;
+
+        public IBindable<WeakReference<BeatmapSetInfo>> ItemRemoved => beatmapModelManager.ItemRemoved;
+
+        public Task ImportFromStableAsync(StableStorage stableStorage)
+        {
+            return beatmapModelManager.ImportFromStableAsync(stableStorage);
+        }
+
+        public void Export(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Export(item);
+        }
+
+        public void ExportModelTo(BeatmapSetInfo model, Stream outputStream)
+        {
+            beatmapModelManager.ExportModelTo(model, outputStream);
+        }
+
+        public void Update(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Update(item);
+        }
+
+        public bool Delete(BeatmapSetInfo item)
+        {
+            return beatmapModelManager.Delete(item);
+        }
+
+        public void Delete(List<BeatmapSetInfo> items, bool silent = false)
+        {
+            beatmapModelManager.Delete(items, silent);
+        }
+
+        public void Undelete(List<BeatmapSetInfo> items, bool silent = false)
+        {
+            beatmapModelManager.Undelete(items, silent);
+        }
+
+        public void Undelete(BeatmapSetInfo item)
+        {
+            beatmapModelManager.Undelete(item);
+        }
+
+        #endregion
+
+        #region Implementation of IModelDownloader<BeatmapSetInfo>
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<BeatmapSetInfo>>> DownloadBegan => beatmapModelManager.DownloadBegan;
+
+        public IBindable<WeakReference<ArchiveDownloadRequest<BeatmapSetInfo>>> DownloadFailed => beatmapModelManager.DownloadFailed;
+
+        public bool IsAvailableLocally(BeatmapSetInfo model)
+        {
+            return beatmapModelManager.IsAvailableLocally(model);
+        }
+
+        public bool Download(BeatmapSetInfo model, bool minimiseDownloadSize = false)
+        {
+            return beatmapModelManager.Download(model, minimiseDownloadSize);
+        }
+
+        public ArchiveDownloadRequest<BeatmapSetInfo> GetExistingDownload(BeatmapSetInfo model)
+        {
+            return beatmapModelManager.GetExistingDownload(model);
+        }
+
+        #endregion
+
+        #region Implementation of ICanAcceptFiles
+
+        public Task Import(params string[] paths)
+        {
+            return beatmapModelManager.Import(paths);
+        }
+
+        public Task Import(params ImportTask[] tasks)
+        {
+            return beatmapModelManager.Import(tasks);
+        }
+
+        public Task<IEnumerable<BeatmapSetInfo>> Import(ProgressNotification notification, params ImportTask[] tasks)
+        {
+            return beatmapModelManager.Import(notification, tasks);
+        }
+
+        public Task<BeatmapSetInfo> Import(ImportTask task, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(task, lowPriority, cancellationToken);
+        }
+
+        public Task<BeatmapSetInfo> Import(ArchiveReader archive, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(archive, lowPriority, cancellationToken);
+        }
+
+        public Task<BeatmapSetInfo> Import(BeatmapSetInfo item, ArchiveReader archive = null, bool lowPriority = false, CancellationToken cancellationToken = default)
+        {
+            return beatmapModelManager.Import(item, archive, lowPriority, cancellationToken);
+        }
+
+        public IEnumerable<string> HandledExtensions => beatmapModelManager.HandledExtensions;
+
+        #endregion
+
+        #region Implementation of IWorkingBeatmapCache
+
+        public WorkingBeatmap GetWorkingBeatmap(BeatmapInfo importedBeatmap) => workingBeatmapCache.GetWorkingBeatmap(importedBeatmap);
+
+        #endregion
+
+        #region Implementation of IModelFileManager<in BeatmapSetInfo,in BeatmapSetFileInfo>
+
+        public void ReplaceFile(BeatmapSetInfo model, BeatmapSetFileInfo file, Stream contents, string filename = null)
+        {
+            beatmapModelManager.ReplaceFile(model, file, contents, filename);
+        }
+
+        public void DeleteFile(BeatmapSetInfo model, BeatmapSetFileInfo file)
+        {
+            beatmapModelManager.DeleteFile(model, file);
+        }
+
+        public void AddFile(BeatmapSetInfo model, Stream contents, string filename)
+        {
+            beatmapModelManager.AddFile(model, contents, filename);
+        }
+
+        #endregion
+    }
 }

osu.Game/Beatmaps/IWorkingBeatmapCache.cs

@@ -0,0 +1,15 @@
+// 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.
+
+namespace osu.Game.Beatmaps
+{
+    public interface IWorkingBeatmapCache
+    {
+        /// <summary>
+        /// Retrieve a <see cref="WorkingBeatmap"/> instance for the provided <see cref="BeatmapInfo"/>
+        /// </summary>
+        /// <param name="beatmapInfo">The beatmap to lookup.</param>
+        /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
+        WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo);
+    }
+}

osu.Game/Beatmaps/WorkingBeatmapCache.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using JetBrains.Annotations;
@@ -17,14 +16,12 @@ using osu.Framework.Statistics;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
-using osu.Game.Rulesets;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
-using osu.Game.Users;
 
 namespace osu.Game.Beatmaps
 {
-    public class WorkingBeatmapCache : IBeatmapResourceProvider
+    public class WorkingBeatmapCache : IBeatmapResourceProvider, IWorkingBeatmapCache
     {
         private readonly WeakList<BeatmapManagerWorkingBeatmap> workingCache = new WeakList<BeatmapManagerWorkingBeatmap>();
 
@@ -33,7 +30,7 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public readonly WorkingBeatmap DefaultBeatmap;
 
-        public BeatmapManager BeatmapManager { private get; set; }
+        public BeatmapModelManager BeatmapManager { private get; set; }
 
         private readonly AudioManager audioManager;
         private readonly IResourceStore<byte[]> resources;
@@ -74,41 +71,6 @@ namespace osu.Game.Beatmaps
             }
         }
 
-        /// <summary>
-        /// Create a new <see cref="WorkingBeatmap"/>.
-        /// </summary>
-        public WorkingBeatmap CreateNew(RulesetInfo ruleset, User user)
-        {
-            var metadata = new BeatmapMetadata
-            {
-                Author = user,
-            };
-
-            var set = new BeatmapSetInfo
-            {
-                Metadata = metadata,
-                Beatmaps = new List<BeatmapInfo>
-                {
-                    new BeatmapInfo
-                    {
-                        BaseDifficulty = new BeatmapDifficulty(),
-                        Ruleset = ruleset,
-                        Metadata = metadata,
-                        WidescreenStoryboard = true,
-                        SamplesMatchPlaybackRate = true,
-                    }
-                }
-            };
-
-            var working = BeatmapManager.Import(set).Result;
-            return GetWorkingBeatmap(working.Beatmaps.First());
-        }
-
-        /// <summary>
-        /// Retrieve a <see cref="WorkingBeatmap"/> instance for the provided <see cref="BeatmapInfo"/>
-        /// </summary>
-        /// <param name="beatmapInfo">The beatmap to lookup.</param>
-        /// <returns>A <see cref="WorkingBeatmap"/> instance correlating to the provided <see cref="BeatmapInfo"/>.</returns>
         public virtual WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
         {
             // if there are no files, presume the full beatmap info has not yet been fetched from the database.

osu.Game/OsuGameBase.cs

@@ -138,8 +138,6 @@ namespace osu.Game
 
         private UserLookupCache userCache;
 
-        private BeatmapOnlineLookupQueue onlineBeatmapLookupCache;
-
         private FileStore fileStore;
 
         private RulesetConfigCache rulesetConfigCache;
@@ -246,10 +244,6 @@ namespace osu.Game
             dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Scheduler, Host, () => difficultyCache, LocalConfig));
             dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Resources, Host, defaultBeatmap));
 
-            onlineBeatmapLookupCache = new BeatmapOnlineLookupQueue(API, Storage);
-
-            BeatmapManager.PopulateOnlineInformation = onlineBeatmapLookupCache.UpdateAsync;
-
             // this should likely be moved to ArchiveModelManager when another case appears where it is necessary
             // to have inter-dependent model managers. this could be obtained with an IHasForeign<T> interface to
             // allow lookups to be done on the child (ScoreManager in this case) to perform the cascading delete.

osu.Game/Tests/Visual/EditorTestScene.cs

@@ -123,11 +123,40 @@ namespace osu.Game.Tests.Visual
                 this.testBeatmap = testBeatmap;
             }
 
-            protected override string ComputeHash(BeatmapSetInfo item, ArchiveReader reader = null)
+            protected override BeatmapModelManager CreateBeatmapModelManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, GameHost host)
-                => string.Empty;
+            {
+                return new TestBeatmapModelManager(storage, contextFactory, rulesets, api, host);
+            }
+
+            protected override WorkingBeatmapCache CreateWorkingBeatmapCache(AudioManager audioManager, IResourceStore<byte[]> resources, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost host)
+            {
+                return new TestWorkingBeatmapCache(this, audioManager, resources, storage, defaultBeatmap, host);
+            }
+
+            private class TestWorkingBeatmapCache : WorkingBeatmapCache
+            {
+                private readonly TestBeatmapManager testBeatmapManager;
+
+                public TestWorkingBeatmapCache(TestBeatmapManager testBeatmapManager, AudioManager audioManager, IResourceStore<byte[]> resourceStore, IResourceStore<byte[]> storage, WorkingBeatmap defaultBeatmap, GameHost gameHost)
+                    : base(audioManager, resourceStore, storage, defaultBeatmap, gameHost)
+                {
+                    this.testBeatmapManager = testBeatmapManager;
+                }
 
                 public override WorkingBeatmap GetWorkingBeatmap(BeatmapInfo beatmapInfo)
-                => testBeatmap;
+                    => testBeatmapManager.testBeatmap;
+            }
+
+            internal class TestBeatmapModelManager : BeatmapModelManager
+            {
+                public TestBeatmapModelManager(Storage storage, IDatabaseContextFactory databaseContextFactory, RulesetStore rulesetStore, IAPIProvider apiProvider, GameHost gameHost)
+                    : base(storage, databaseContextFactory, rulesetStore, apiProvider, gameHost)
+                {
+                }
+
+                protected override string ComputeHash(BeatmapSetInfo item, ArchiveReader reader = null)
+                    => string.Empty;
+            }
 
             public override void Save(BeatmapInfo info, IBeatmap beatmapContent, ISkin beatmapSkin = null)
             {