1
0
mirror of https://github.com/ppy/osu.git synced 2024-11-06 06:57:39 +08:00
osu-lazer/osu.Game/Collections/CollectionManager.cs

210 lines
6.9 KiB
C#
Raw Normal View History

2020-09-01 16:28:41 +08:00
// 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.Threading;
using System.Threading.Tasks;
2020-09-01 18:33:06 +08:00
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics.Containers;
using osu.Framework.Logging;
2020-09-01 16:28:41 +08:00
using osu.Framework.Platform;
using osu.Game.Beatmaps;
using osu.Game.IO.Legacy;
namespace osu.Game.Collections
{
2020-09-01 18:33:06 +08:00
public class CollectionManager : CompositeDrawable
2020-09-01 16:28:41 +08:00
{
/// <summary>
/// Database version in YYYYMMDD format (matching stable).
/// </summary>
private const int database_version = 30000000;
2020-09-01 18:33:06 +08:00
private const string database_name = "collection.db";
2020-09-01 16:28:41 +08:00
[Resolved]
private GameHost host { get; set; }
2020-09-01 18:33:06 +08:00
public IBindableList<BeatmapCollection> Collections => collections;
private readonly BindableList<BeatmapCollection> collections = new BindableList<BeatmapCollection>();
2020-09-01 16:28:41 +08:00
2020-09-01 18:33:06 +08:00
[Resolved]
private BeatmapManager beatmaps { get; set; }
[BackgroundDependencyLoader]
private void load()
2020-09-01 16:28:41 +08:00
{
2020-09-01 18:33:06 +08:00
if (host.Storage.Exists(database_name))
{
using (var stream = host.Storage.GetStream(database_name))
collections.AddRange(readCollection(stream));
}
foreach (var c in collections)
c.Changed += backgroundSave;
collections.CollectionChanged += (_, __) => backgroundSave();
2020-09-01 16:28:41 +08:00
}
/// <summary>
/// Set a storage with access to an osu-stable install for import purposes.
/// </summary>
public Func<Storage> GetStableStorage { private get; set; }
/// <summary>
/// This is a temporary method and will likely be replaced by a full-fledged (and more correctly placed) migration process in the future.
/// </summary>
2020-09-01 18:33:06 +08:00
// public Task ImportFromStableAsync()
// {
// var stable = GetStableStorage?.Invoke();
//
// if (stable == null)
// {
// Logger.Log("No osu!stable installation available!", LoggingTarget.Information, LogLevel.Error);
// return Task.CompletedTask;
// }
//
// if (!stable.ExistsDirectory(database_name))
// {
// // This handles situations like when the user does not have a Skins folder
// Logger.Log($"No {database_name} folder available in osu!stable installation", LoggingTarget.Information, LogLevel.Error);
// return Task.CompletedTask;
// }
//
// return Task.Run(async () => await Import(GetStableImportPaths(GetStableStorage()).Select(f => stable.GetFullPath(f)).ToArray()));
// }
2020-09-01 16:28:41 +08:00
private List<BeatmapCollection> readCollection(Stream stream)
{
var result = new List<BeatmapCollection>();
try
{
using (var sr = new SerializationReader(stream))
{
sr.ReadInt32(); // Version
int collectionCount = sr.ReadInt32();
result.Capacity = collectionCount;
for (int i = 0; i < collectionCount; i++)
{
var collection = new BeatmapCollection { Name = sr.ReadString() };
int mapCount = sr.ReadInt32();
for (int j = 0; j < mapCount; j++)
{
string checksum = sr.ReadString();
var beatmap = beatmaps.QueryBeatmap(b => b.MD5Hash == checksum);
if (beatmap != null)
collection.Beatmaps.Add(beatmap);
}
result.Add(collection);
}
}
}
catch (Exception e)
2020-09-01 16:28:41 +08:00
{
Logger.Error(e, "Failed to read collections");
}
2020-09-01 16:28:41 +08:00
return result;
}
2020-09-01 16:28:41 +08:00
private readonly object saveLock = new object();
private int lastSave;
private int saveFailures;
/// <summary>
/// Perform a save with debounce.
/// </summary>
private void backgroundSave()
{
var current = Interlocked.Increment(ref lastSave);
Task.Delay(100).ContinueWith(task =>
{
if (current != lastSave)
return;
if (!save())
backgroundSave();
});
}
private bool save()
{
lock (saveLock)
{
Interlocked.Increment(ref lastSave);
try
2020-09-01 16:28:41 +08:00
{
// This is NOT thread-safe!!
2020-09-01 16:28:41 +08:00
using (var sw = new SerializationWriter(host.Storage.GetStream(database_name, FileAccess.Write)))
2020-09-01 16:28:41 +08:00
{
sw.Write(database_version);
sw.Write(collections.Count);
2020-09-01 16:28:41 +08:00
foreach (var c in collections)
{
sw.Write(c.Name);
sw.Write(c.Beatmaps.Count);
foreach (var b in c.Beatmaps)
sw.Write(b.MD5Hash);
}
2020-09-01 16:28:41 +08:00
}
2020-09-01 18:33:06 +08:00
2020-09-02 22:42:44 +08:00
if (saveFailures < 10)
saveFailures = 0;
return true;
}
catch (Exception e)
{
// Since this code is not thread-safe, we may run into random exceptions (such as collection enumeration or out of range indexing).
2020-09-02 22:42:44 +08:00
// Failures are thus only alerted if they exceed a threshold (once) to indicate "actual" errors having occurred.
if (++saveFailures == 10)
Logger.Error(e, "Failed to save collections");
2020-09-01 16:28:41 +08:00
}
return false;
}
2020-09-01 16:28:41 +08:00
}
2020-09-02 22:32:08 +08:00
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
save();
}
2020-09-01 16:28:41 +08:00
}
public class BeatmapCollection
{
/// <summary>
/// Invoked whenever any change occurs on this <see cref="BeatmapCollection"/>.
/// </summary>
public event Action Changed;
2020-09-01 16:28:41 +08:00
public string Name;
public readonly BindableList<BeatmapInfo> Beatmaps = new BindableList<BeatmapInfo>();
2020-09-02 20:19:15 +08:00
public DateTimeOffset LastModifyTime { get; private set; }
public BeatmapCollection()
{
LastModifyTime = DateTimeOffset.UtcNow;
Beatmaps.CollectionChanged += (_, __) =>
{
LastModifyTime = DateTimeOffset.Now;
Changed?.Invoke();
};
2020-09-02 20:19:15 +08:00
}
2020-09-01 16:28:41 +08:00
}
}