Reduce access to various fields and events in SpectatorClient

osu.Game/Online/Spectator/OnlineSpectatorClient.cs

@@ -18,7 +18,7 @@ public partial class OnlineSpectatorClient : SpectatorClient
 
         private IHubClientConnector? connector;
 
-        public override IBindable<bool> IsConnected { get; } = new BindableBool();
+        protected override IBindable<bool> IsConnected { get; } = new BindableBool();
 
         private HubConnection? connection => connector?.CurrentConnection;
 

osu.Game/Online/Spectator/SpectatorClient.cs

@@ -33,42 +33,42 @@ public abstract partial class SpectatorClient : Component, ISpectatorClient
         /// Whether the <see cref="SpectatorClient"/> is currently connected.
         /// This is NOT thread safe and usage should be scheduled.
         /// </summary>
-        public abstract IBindable<bool> IsConnected { get; }
+        protected abstract IBindable<bool> IsConnected { get; }
 
         /// <summary>
         /// The states of all users currently being watched.
         /// </summary>
-        public virtual IBindableDictionary<int, SpectatorState> WatchedUserStates => watchedUserStates;
+        public IBindableDictionary<int, SpectatorState> WatchedUserStates => watchedUserStates;
 
         /// <summary>
         /// A global list of all players currently playing.
         /// </summary>
         public IBindableList<int> PlayingUsers => playingUsers;
 
         /// <summary>
-        /// Whether the local user is playing.
+        /// Whether the spectated user is playing.
         /// </summary>
-        protected internal bool IsPlaying { get; private set; }
+        private bool isPlaying { get; set; }
 
         /// <summary>
         /// Called whenever new frames arrive from the server.
         /// </summary>
-        public virtual event Action<int, FrameDataBundle>? OnNewFrames;
+        public event Action<int, FrameDataBundle>? OnNewFrames;
 
         /// <summary>
         /// Called whenever a user starts a play session, or immediately if the user is being watched and currently in a play session.
         /// </summary>
-        public virtual event Action<int, SpectatorState>? OnUserBeganPlaying;
+        public event Action<int, SpectatorState>? OnUserBeganPlaying;
 
         /// <summary>
         /// Called whenever a user finishes a play session.
         /// </summary>
-        public virtual event Action<int, SpectatorState>? OnUserFinishedPlaying;
+        public event Action<int, SpectatorState>? OnUserFinishedPlaying;
 
         /// <summary>
         /// Called whenever a user-submitted score has been fully processed.
         /// </summary>
-        public virtual event Action<int, long>? OnUserScoreProcessed;
+        public event Action<int, long>? OnUserScoreProcessed;
 
         /// <summary>
         /// A dictionary containing all users currently being watched, with the number of watching components for each user.
@@ -114,7 +114,7 @@ private void load()
                     }
 
                     // re-send state in case it wasn't received
-                    if (IsPlaying)
+                    if (isPlaying)
                         // TODO: this is likely sent out of order after a reconnect scenario. needs further consideration.
                         BeginPlayingInternal(currentScoreToken, currentState);
                 }
@@ -179,10 +179,10 @@ public void BeginPlaying(long? scoreToken, GameplayState state, Score score)
             // This schedule is only here to match the one below in `EndPlaying`.
             Schedule(() =>
             {
-                if (IsPlaying)
+                if (isPlaying)
                     throw new InvalidOperationException($"Cannot invoke {nameof(BeginPlaying)} when already playing");
 
-                IsPlaying = true;
+                isPlaying = true;
 
                 // transfer state at point of beginning play
                 currentState.BeatmapID = score.ScoreInfo.BeatmapInfo!.OnlineID;
@@ -202,7 +202,7 @@ public void BeginPlaying(long? scoreToken, GameplayState state, Score score)
 
         public void HandleFrame(ReplayFrame frame) => Schedule(() =>
         {
-            if (!IsPlaying)
+            if (!isPlaying)
             {
                 Logger.Log($"Frames arrived at {nameof(SpectatorClient)} outside of gameplay scope and will be ignored.");
                 return;
@@ -224,7 +224,7 @@ public void EndPlaying(GameplayState state)
             // We probably need to find a better way to handle this...
             Schedule(() =>
             {
-                if (!IsPlaying)
+                if (!isPlaying)
                     return;
 
                 // Disposal can take some time, leading to EndPlaying potentially being called after a future play session.
@@ -235,7 +235,7 @@ public void EndPlaying(GameplayState state)
                 if (pendingFrames.Count > 0)
                     purgePendingFrames();
 
-                IsPlaying = false;
+                isPlaying = false;
                 currentBeatmap = null;
 
                 if (state.HasPassed)
@@ -249,7 +249,7 @@ public void EndPlaying(GameplayState state)
             });
         }
 
-        public virtual void WatchUser(int userId)
+        public void WatchUser(int userId)
         {
             Debug.Assert(ThreadSafety.IsUpdateThread);
 

osu.Game/Tests/Visual/Spectator/TestSpectatorClient.cs

@@ -33,7 +33,7 @@ public partial class TestSpectatorClient : SpectatorClient
 
         public int FrameSendAttempts { get; private set; }
 
-        public override IBindable<bool> IsConnected { get; } = new Bindable<bool>(true);
+        protected override IBindable<bool> IsConnected { get; } = new Bindable<bool>(true);
 
         public IReadOnlyDictionary<int, ReplayFrame> LastReceivedUserFrames => lastReceivedUserFrames;