Merge pull request #21762 from bdach/score-stats-updates

Add solo statistics watcher component to deliver incremental global user statistics updates

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

@@ -0,0 +1,280 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Testing;
+using osu.Game.Models;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Solo;
+using osu.Game.Online.Spectator;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [HeadlessTest]
+    public partial class TestSceneSoloStatisticsWatcher : OsuTestScene
+    {
+        protected override bool UseOnlineAPI => false;
+
+        private SoloStatisticsWatcher watcher = null!;
+
+        [Resolved]
+        private SpectatorClient spectatorClient { get; set; } = null!;
+
+        private DummyAPIAccess dummyAPI => (DummyAPIAccess)API;
+
+        private Action<GetUsersRequest>? handleGetUsersRequest;
+        private Action<GetUserRequest>? handleGetUserRequest;
+
+        private readonly Dictionary<(int userId, string rulesetName), UserStatistics> serverSideStatistics = new Dictionary<(int userId, string rulesetName), UserStatistics>();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("clear server-side stats", () => serverSideStatistics.Clear());
+            AddStep("set up request handling", () =>
+            {
+                handleGetUserRequest = null;
+                handleGetUsersRequest = null;
+
+                dummyAPI.HandleRequest = request =>
+                {
+                    switch (request)
+                    {
+                        case GetUsersRequest getUsersRequest:
+                            if (handleGetUsersRequest != null)
+                            {
+                                handleGetUsersRequest?.Invoke(getUsersRequest);
+                            }
+                            else
+                            {
+                                int userId = getUsersRequest.UserIds.Single();
+                                var response = new GetUsersResponse
+                                {
+                                    Users = new List<APIUser>
+                                    {
+                                        new APIUser
+                                        {
+                                            Id = userId,
+                                            RulesetsStatistics = new Dictionary<string, UserStatistics>
+                                            {
+                                                ["osu"] = tryGetStatistics(userId, "osu"),
+                                                ["taiko"] = tryGetStatistics(userId, "taiko"),
+                                                ["fruits"] = tryGetStatistics(userId, "fruits"),
+                                                ["mania"] = tryGetStatistics(userId, "mania"),
+                                            }
+                                        }
+                                    }
+                                };
+                                getUsersRequest.TriggerSuccess(response);
+                            }
+
+                            return true;
+
+                        case GetUserRequest getUserRequest:
+                            if (handleGetUserRequest != null)
+                            {
+                                handleGetUserRequest.Invoke(getUserRequest);
+                            }
+                            else
+                            {
+                                int userId = int.Parse(getUserRequest.Lookup);
+                                string rulesetName = getUserRequest.Ruleset.ShortName;
+                                var response = new APIUser
+                                {
+                                    Id = userId,
+                                    Statistics = tryGetStatistics(userId, rulesetName)
+                                };
+                                getUserRequest.TriggerSuccess(response);
+                            }
+
+                            return true;
+
+                        default:
+                            return false;
+                    }
+                };
+            });
+
+            AddStep("create watcher", () =>
+            {
+                Child = watcher = new SoloStatisticsWatcher();
+            });
+        }
+
+        private UserStatistics tryGetStatistics(int userId, string rulesetName)
+            => serverSideStatistics.TryGetValue((userId, rulesetName), out var stats) ? stats : new UserStatistics();
+
+        [Test]
+        public void TestStatisticsUpdateFiredAfterRegistrationAddedAndScoreProcessed()
+        {
+            int userId = getUserId();
+            long scoreId = getScoreId();
+            setUpUser(userId);
+
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(scoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, scoreId));
+            AddUntilStep("update received", () => update != null);
+            AddAssert("values before are correct", () => update!.Before.TotalScore, () => Is.EqualTo(4_000_000));
+            AddAssert("values after are correct", () => update!.After.TotalScore, () => Is.EqualTo(5_000_000));
+        }
+
+        [Test]
+        public void TestStatisticsUpdateFiredAfterScoreProcessedAndRegistrationAdded()
+        {
+            int userId = getUserId();
+            setUpUser(userId);
+
+            long scoreId = getScoreId();
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            // note ordering - in this test processing completes *before* the registration is added.
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(scoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, scoreId));
+            AddUntilStep("update received", () => update != null);
+            AddAssert("values before are correct", () => update!.Before.TotalScore, () => Is.EqualTo(4_000_000));
+            AddAssert("values after are correct", () => update!.After.TotalScore, () => Is.EqualTo(5_000_000));
+        }
+
+        [Test]
+        public void TestStatisticsUpdateNotFiredIfUserLoggedOut()
+        {
+            int userId = getUserId();
+            setUpUser(userId);
+
+            long scoreId = getScoreId();
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(scoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            AddStep("log out user", () => dummyAPI.Logout());
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, scoreId));
+            AddWaitStep("wait a bit", 5);
+            AddAssert("update not received", () => update == null);
+
+            AddStep("log in user", () => dummyAPI.Login("user", "password"));
+        }
+
+        [Test]
+        public void TestStatisticsUpdateNotFiredIfAnotherUserLoggedIn()
+        {
+            int userId = getUserId();
+            setUpUser(userId);
+
+            long scoreId = getScoreId();
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(scoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            AddStep("change user", () => dummyAPI.LocalUser.Value = new APIUser { Id = getUserId() });
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, scoreId));
+            AddWaitStep("wait a bit", 5);
+            AddAssert("update not received", () => update == null);
+        }
+
+        [Test]
+        public void TestStatisticsUpdateNotFiredIfScoreIdDoesNotMatch()
+        {
+            int userId = getUserId();
+            setUpUser(userId);
+
+            long scoreId = getScoreId();
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(scoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            AddStep("signal another score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, getScoreId()));
+            AddWaitStep("wait a bit", 5);
+            AddAssert("update not received", () => update == null);
+        }
+
+        // the behaviour exercised in this test may not be final, it is mostly assumed for simplicity.
+        // in the long run we may want each score's update to be entirely isolated from others, rather than have prior unobserved updates merge into the latest.
+        [Test]
+        public void TestIgnoredScoreUpdateIsMergedIntoNextOne()
+        {
+            int userId = getUserId();
+            setUpUser(userId);
+
+            long firstScoreId = getScoreId();
+            var ruleset = new OsuRuleset().RulesetInfo;
+
+            feignScoreProcessing(userId, ruleset, 5_000_000);
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, firstScoreId));
+
+            long secondScoreId = getScoreId();
+
+            feignScoreProcessing(userId, ruleset, 6_000_000);
+
+            SoloStatisticsUpdate? update = null;
+            registerForUpdates(secondScoreId, ruleset, receivedUpdate => update = receivedUpdate);
+
+            AddStep("signal score processed", () => ((ISpectatorClient)spectatorClient).UserScoreProcessed(userId, secondScoreId));
+            AddUntilStep("update received", () => update != null);
+            AddAssert("values before are correct", () => update!.Before.TotalScore, () => Is.EqualTo(4_000_000));
+            AddAssert("values after are correct", () => update!.After.TotalScore, () => Is.EqualTo(6_000_000));
+        }
+
+        private int nextUserId = 2000;
+        private long nextScoreId = 50000;
+
+        private int getUserId() => ++nextUserId;
+        private long getScoreId() => ++nextScoreId;
+
+        private void setUpUser(int userId)
+        {
+            AddStep("fetch initial stats", () =>
+            {
+                serverSideStatistics[(userId, "osu")] = new UserStatistics { TotalScore = 4_000_000 };
+                serverSideStatistics[(userId, "taiko")] = new UserStatistics { TotalScore = 3_000_000 };
+                serverSideStatistics[(userId, "fruits")] = new UserStatistics { TotalScore = 2_000_000 };
+                serverSideStatistics[(userId, "mania")] = new UserStatistics { TotalScore = 1_000_000 };
+
+                dummyAPI.LocalUser.Value = new APIUser { Id = userId };
+            });
+        }
+
+        private void registerForUpdates(long scoreId, RulesetInfo rulesetInfo, Action<SoloStatisticsUpdate> onUpdateReady) =>
+            AddStep("register for updates", () => watcher.RegisterForStatisticsUpdateAfter(
+                new ScoreInfo(Beatmap.Value.BeatmapInfo, new OsuRuleset().RulesetInfo, new RealmUser())
+                {
+                    Ruleset = rulesetInfo,
+                    OnlineID = scoreId
+                },
+                onUpdateReady));
+
+        private void feignScoreProcessing(int userId, RulesetInfo rulesetInfo, long newTotalScore)
+            => AddStep("feign score processing", () => serverSideStatistics[(userId, rulesetInfo.ShortName)] = new UserStatistics { TotalScore = newTotalScore });
+    }
+}

osu.Game/Online/API/Requests/GetUsersRequest.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Online.API.Requests
 {
     public class GetUsersRequest : APIRequest<GetUsersResponse>
     {
-        private readonly int[] userIds;
+        public readonly int[] UserIds;
 
         private const int max_ids_per_request = 50;
 
@@ -18,9 +18,9 @@ namespace osu.Game.Online.API.Requests
             if (userIds.Length > max_ids_per_request)
                 throw new ArgumentException($"{nameof(GetUsersRequest)} calls only support up to {max_ids_per_request} IDs at once");
 
-            this.userIds = userIds;
+            UserIds = userIds;
         }
 
-        protected override string Target => "users/?ids[]=" + string.Join("&ids[]=", userIds);
+        protected override string Target => "users/?ids[]=" + string.Join("&ids[]=", UserIds);
     }
 }

osu.Game/Online/Solo/SoloStatisticsUpdate.cs

@@ -0,0 +1,42 @@
+// 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 osu.Game.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Online.Solo
+{
+    /// <summary>
+    /// Contains data about the change in a user's profile statistics after completing a score.
+    /// </summary>
+    public class SoloStatisticsUpdate
+    {
+        /// <summary>
+        /// The score set by the user that triggered the update.
+        /// </summary>
+        public ScoreInfo Score { get; }
+
+        /// <summary>
+        /// The user's profile statistics prior to the score being set.
+        /// </summary>
+        public UserStatistics Before { get; }
+
+        /// <summary>
+        /// The user's profile statistics after the score was set.
+        /// </summary>
+        public UserStatistics After { get; }
+
+        /// <summary>
+        /// Creates a new <see cref="SoloStatisticsUpdate"/>.
+        /// </summary>
+        /// <param name="score">The score set by the user that triggered the update.</param>
+        /// <param name="before">The user's profile statistics prior to the score being set.</param>
+        /// <param name="after">The user's profile statistics after the score was set.</param>
+        public SoloStatisticsUpdate(ScoreInfo score, UserStatistics before, UserStatistics after)
+        {
+            Score = score;
+            Before = before;
+            After = after;
+        }
+    }
+}

osu.Game/Online/Solo/SoloStatisticsWatcher.cs

@@ -0,0 +1,144 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
+using osu.Game.Extensions;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Spectator;
+using osu.Game.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Online.Solo
+{
+    /// <summary>
+    /// A persistent component that binds to the spectator server and API in order to deliver updates about the logged in user's gameplay statistics.
+    /// </summary>
+    public partial class SoloStatisticsWatcher : Component
+    {
+        [Resolved]
+        private SpectatorClient spectatorClient { get; set; } = null!;
+
+        [Resolved]
+        private IAPIProvider api { get; set; } = null!;
+
+        private readonly Dictionary<long, StatisticsUpdateCallback> callbacks = new Dictionary<long, StatisticsUpdateCallback>();
+        private long? lastProcessedScoreId;
+
+        private Dictionary<string, UserStatistics>? latestStatistics;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            api.LocalUser.BindValueChanged(user => onUserChanged(user.NewValue), true);
+            spectatorClient.OnUserScoreProcessed += userScoreProcessed;
+        }
+
+        /// <summary>
+        /// Registers for a user statistics update after the given <paramref name="score"/> has been processed server-side.
+        /// </summary>
+        /// <param name="score">The score to listen for the statistics update for.</param>
+        /// <param name="onUpdateReady">The callback to be invoked once the statistics update has been prepared.</param>
+        public void RegisterForStatisticsUpdateAfter(ScoreInfo score, Action<SoloStatisticsUpdate> onUpdateReady) => Schedule(() =>
+        {
+            if (!api.IsLoggedIn)
+                return;
+
+            if (!score.Ruleset.IsLegacyRuleset())
+                return;
+
+            var callback = new StatisticsUpdateCallback(score, onUpdateReady);
+
+            if (lastProcessedScoreId == score.OnlineID)
+            {
+                requestStatisticsUpdate(api.LocalUser.Value.Id, callback);
+                return;
+            }
+
+            callbacks.Add(score.OnlineID, callback);
+        });
+
+        private void onUserChanged(APIUser? localUser) => Schedule(() =>
+        {
+            callbacks.Clear();
+            lastProcessedScoreId = null;
+            latestStatistics = null;
+
+            if (localUser == null || localUser.OnlineID <= 1)
+                return;
+
+            var userRequest = new GetUsersRequest(new[] { localUser.OnlineID });
+            userRequest.Success += response => Schedule(() =>
+            {
+                latestStatistics = new Dictionary<string, UserStatistics>();
+                foreach (var rulesetStats in response.Users.Single().RulesetsStatistics)
+                    latestStatistics.Add(rulesetStats.Key, rulesetStats.Value);
+            });
+            api.Queue(userRequest);
+        });
+
+        private void userScoreProcessed(int userId, long scoreId)
+        {
+            if (userId != api.LocalUser.Value?.OnlineID)
+                return;
+
+            lastProcessedScoreId = scoreId;
+
+            if (!callbacks.TryGetValue(scoreId, out var callback))
+                return;
+
+            requestStatisticsUpdate(userId, callback);
+            callbacks.Remove(scoreId);
+        }
+
+        private void requestStatisticsUpdate(int userId, StatisticsUpdateCallback callback)
+        {
+            var request = new GetUserRequest(userId, callback.Score.Ruleset);
+            request.Success += user => Schedule(() => dispatchStatisticsUpdate(callback, user.Statistics));
+            api.Queue(request);
+        }
+
+        private void dispatchStatisticsUpdate(StatisticsUpdateCallback callback, UserStatistics updatedStatistics)
+        {
+            string rulesetName = callback.Score.Ruleset.ShortName;
+
+            if (latestStatistics == null)
+                return;
+
+            latestStatistics.TryGetValue(rulesetName, out UserStatistics? latestRulesetStatistics);
+            latestRulesetStatistics ??= new UserStatistics();
+
+            var update = new SoloStatisticsUpdate(callback.Score, latestRulesetStatistics, updatedStatistics);
+            callback.OnUpdateReady.Invoke(update);
+
+            latestStatistics[rulesetName] = updatedStatistics;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (spectatorClient.IsNotNull())
+                spectatorClient.OnUserScoreProcessed -= userScoreProcessed;
+
+            base.Dispose(isDisposing);
+        }
+
+        private class StatisticsUpdateCallback
+        {
+            public ScoreInfo Score { get; }
+            public Action<SoloStatisticsUpdate> OnUpdateReady { get; }
+
+            public StatisticsUpdateCallback(ScoreInfo score, Action<SoloStatisticsUpdate> onUpdateReady)
+            {
+                Score = score;
+                OnUpdateReady = onUpdateReady;
+            }
+        }
+    }
+}