replacing polling for lobby updates with lobby events

Author: LPLafontaineB

Assets/Scripts/UnityServices/Lobbies/LobbyAPIInterface.cs

@@ -133,5 +133,10 @@ public async void SendHeartbeatPing(string lobbyId)
         {
             await LobbyService.Instance.SendHeartbeatPingAsync(lobbyId);
         }
+
+        public async Task<ILobbyEvents> SubscribeToLobby(string lobbyId, LobbyEventCallbacks eventCallbacks)
+        {
+            return await LobbyService.Instance.SubscribeToLobbyEventsAsync(lobbyId, eventCallbacks);
+        }
     }
 }

Assets/Scripts/UnityServices/Lobbies/LobbyServiceFacade.cs

@@ -37,6 +37,9 @@ public class LobbyServiceFacade : IDisposable, IStartable
 
         public Lobby CurrentUnityLobby { get; private set; }
 
+        LobbyEventCallbacks m_LobbyEventCallbacks;
+        ILobbyEvents m_LobbyEvents;
+
         bool m_IsTracking = false;
 
         public void Start()
@@ -74,12 +77,10 @@ public void SetRemoteLobby(Lobby lobby)
 
         public void BeginTracking()
         {
+            SubscribeToJoinedLobby();
             if (!m_IsTracking)
             {
                 m_IsTracking = true;
-                // 2s update cadence is arbitrary and is here to demonstrate the fact that this update can be rather infrequent
-                // the actual rate limits are tracked via the RateLimitCooldown objects defined above
-                m_UpdateRunner.Subscribe(UpdateLobby, 2f);
                 m_JoinedLobbyContentHeartbeat.BeginTracking();
             }
         }
@@ -109,59 +110,16 @@ public Task EndTracking()
                 m_LocalLobby?.Reset(m_LocalUser);
             }
 
+            m_LobbyEvents?.UnsubscribeAsync();
             if (m_IsTracking)
             {
-                m_UpdateRunner.Unsubscribe(UpdateLobby);
                 m_IsTracking = false;
                 m_HeartbeatTime = 0;
                 m_JoinedLobbyContentHeartbeat.EndTracking();
             }
-
             return task;
         }
 
-        async void UpdateLobby(float unused)
-        {
-            if (!m_RateLimitQuery.CanCall)
-            {
-                return;
-            }
-
-            try
-            {
-                var lobby = await m_LobbyApiInterface.GetLobby(m_LocalLobby.LobbyID);
-
-                CurrentUnityLobby = lobby;
-                m_LocalLobby.ApplyRemoteData(lobby);
-
-                // as client, check if host is still in lobby
-                if (!m_LocalUser.IsHost)
-                {
-                    foreach (var lobbyUser in m_LocalLobby.LobbyUsers)
-                    {
-                        if (lobbyUser.Value.IsHost)
-                        {
-                            return;
-                        }
-                    }
-                    m_UnityServiceErrorMessagePub.Publish(new UnityServiceErrorMessage("Host left the lobby", "Disconnecting.", UnityServiceErrorMessage.Service.Lobby));
-                    await EndTracking();
-                    // no need to disconnect Netcode, it should already be handled by Netcode's callback to disconnect
-                }
-            }
-            catch (LobbyServiceException e)
-            {
-                if (e.Reason == LobbyExceptionReason.RateLimited)
-                {
-                    m_RateLimitQuery.PutOnCooldown();
-                }
-                else if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost) // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.
-                {
-                    PublishError(e);
-                }
-            }
-        }
-
         /// <summary>
         /// Attempt to create a new lobby and then join it.
         /// </summary>
@@ -264,6 +222,66 @@ async void UpdateLobby(float unused)
             return (false, null);
         }
 
+        async void OnLobbyChanges(ILobbyChanges changes)
+        {
+            Debug.Log("Lobby updated");
+            changes.ApplyToLobby(CurrentUnityLobby);
+            m_LocalLobby.ApplyRemoteData(CurrentUnityLobby);
+
+            // as client, check if host is still in lobby
+            if (!m_LocalUser.IsHost)
+            {
+                foreach (var lobbyUser in m_LocalLobby.LobbyUsers)
+                {
+                    if (lobbyUser.Value.IsHost)
+                    {
+                        return;
+                    }
+                }
+
+                m_UnityServiceErrorMessagePub.Publish(new UnityServiceErrorMessage("Host left the lobby", "Disconnecting.", UnityServiceErrorMessage.Service.Lobby));
+                await EndTracking();
+
+                // no need to disconnect Netcode, it should already be handled by Netcode's callback to disconnect
+            }
+        }
+
+        void OnKickedFromLobby()
+        {
+            throw new NotImplementedException();
+        }
+
+        void OnLobbyEventConnectionStateChanged(LobbyEventConnectionState lobbyEventConnectionState)
+        {
+            switch (lobbyEventConnectionState)
+            {
+                case LobbyEventConnectionState.Unknown:
+                    break;
+                case LobbyEventConnectionState.Unsubscribed:
+                    break;
+                case LobbyEventConnectionState.Subscribing:
+                    break;
+                case LobbyEventConnectionState.Subscribed:
+                    break;
+                case LobbyEventConnectionState.Unsynced:
+                    break;
+                case LobbyEventConnectionState.Error:
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(lobbyEventConnectionState), lobbyEventConnectionState, null);
+            }
+        }
+
+        async void SubscribeToJoinedLobby()
+        {
+            var lobbyEventCallbacks = new LobbyEventCallbacks();
+            lobbyEventCallbacks.LobbyChanged += OnLobbyChanges;
+            lobbyEventCallbacks.KickedFromLobby += OnKickedFromLobby;
+            lobbyEventCallbacks.LobbyEventConnectionStateChanged += OnLobbyEventConnectionStateChanged;
+            m_LobbyEvents = await m_LobbyApiInterface.SubscribeToLobby(m_LocalLobby.LobbyID, m_LobbyEventCallbacks);
+            m_JoinedLobbyContentHeartbeat.BeginTracking();
+        }
+
         /// <summary>
         /// Used for getting the list of all active lobbies, without needing full info for each.
         /// </summary>

Packages/manifest.json

@@ -17,6 +17,7 @@
     "com.unity.services.authentication": "2.3.1",
     "com.unity.services.lobby": "1.0.3",
     "com.unity.services.relay": "1.0.3",
+    "com.unity.services.wire": "1.0.0",
     "com.unity.test-framework": "1.1.31",
     "com.unity.textmeshpro": "3.0.6",
     "com.unity.timeline": "1.6.4",

Packages/packages-lock.json

@@ -286,6 +286,17 @@
       },
       "url": "https://packages.unity.com"
     },
+    "com.unity.services.wire": {
+      "version": "1.0.0",
+      "depth": 0,
+      "source": "registry",
+      "dependencies": {
+        "com.unity.services.core": "1.2.0",
+        "com.unity.nuget.newtonsoft-json": "3.0.1",
+        "com.unity.services.authentication": "1.0.0-pre.37"
+      },
+      "url": "https://packages.unity.com"
+    },
     "com.unity.settings-manager": {
       "version": "1.0.3",
       "depth": 1,