feat: host delete lobby when shutdown [MTT-4798] [MTT-4576] (#772)

LPLafontaineB · web-flow · commit 69cb3a62148f · 2022-11-07T10:35:49.000-05:00
* moving lobby error handling responsibility to LobbyServiceFacade

* making host delete lobby when leaving
diff --git a/Assets/Scripts/UnityServices/Lobbies/LobbyAPIInterface.cs b/Assets/Scripts/UnityServices/Lobbies/LobbyAPIInterface.cs
@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Unity.BossRoom.Infrastructure;
 using Unity.Services.Lobbies;
 using Unity.Services.Lobbies.Models;
 using UnityEngine;
-using VContainer;
 
 namespace Unity.BossRoom.UnityServices.Lobbies
 {
@@ -16,15 +14,11 @@ public class LobbyAPIInterface
     {
         const int k_MaxLobbiesToShow = 16; // If more are necessary, consider retrieving paginated results or using filters.
 
-        readonly IPublisher<UnityServiceErrorMessage> m_UnityServiceErrorMessagePublisher;
         readonly List<QueryFilter> m_Filters;
         readonly List<QueryOrder> m_Order;
 
-        [Inject]
-        public LobbyAPIInterface(IPublisher<UnityServiceErrorMessage> unityServiceErrorMessagePublisher)
+        public LobbyAPIInterface()
         {
-            m_UnityServiceErrorMessagePublisher = unityServiceErrorMessagePublisher;
-
             // Filter for open lobbies only
             m_Filters = new List<QueryFilter>()
             {
@@ -43,34 +37,6 @@ public LobbyAPIInterface(IPublisher<UnityServiceErrorMessage> unityServiceErrorM
             };
         }
 
-        async Task<T> ExceptionHandling<T>(Task<T> task)
-        {
-            try
-            {
-                return await task;
-            }
-            catch (Exception e)
-            {
-                var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.
-                m_UnityServiceErrorMessagePublisher.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));
-                throw;
-            }
-        }
-
-        async Task ExceptionHandling(Task task)
-        {
-            try
-            {
-                await task;
-            }
-            catch (Exception e)
-            {
-                var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.
-                m_UnityServiceErrorMessagePublisher.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));
-                throw;
-            }
-        }
-
         public async Task<Lobby> CreateLobby(string requesterUasId, string lobbyName, int maxPlayers, bool isPrivate, Dictionary<string, PlayerDataObject> hostUserData, Dictionary<string, DataObject> lobbyData)
         {
             CreateLobbyOptions createOptions = new CreateLobbyOptions
@@ -80,24 +46,24 @@ public async Task<Lobby> CreateLobby(string requesterUasId, string lobbyName, in
                 Data = lobbyData
             };
 
-            return await ExceptionHandling(LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions));
+            return await LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions);
         }
 
         public async Task DeleteLobby(string lobbyId)
         {
-            await ExceptionHandling(LobbyService.Instance.DeleteLobbyAsync(lobbyId));
+            await LobbyService.Instance.DeleteLobbyAsync(lobbyId);
         }
 
         public async Task<Lobby> JoinLobbyByCode(string requesterUasId, string lobbyCode, Dictionary<string, PlayerDataObject> localUserData)
         {
             JoinLobbyByCodeOptions joinOptions = new JoinLobbyByCodeOptions { Player = new Player(id: requesterUasId, data: localUserData) };
-            return await ExceptionHandling(LobbyService.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions));
+            return await LobbyService.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions);
         }
 
         public async Task<Lobby> JoinLobbyById(string requesterUasId, string lobbyId, Dictionary<string, PlayerDataObject> localUserData)
         {
             JoinLobbyByIdOptions joinOptions = new JoinLobbyByIdOptions { Player = new Player(id: requesterUasId, data: localUserData) };
-            return await ExceptionHandling(LobbyService.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions));
+            return await LobbyService.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions);
         }
 
         public async Task<Lobby> QuickJoinLobby(string requesterUasId, Dictionary<string, PlayerDataObject> localUserData)
@@ -108,19 +74,19 @@ public async Task<Lobby> QuickJoinLobby(string requesterUasId, Dictionary<string
                 Player = new Player(id: requesterUasId, data: localUserData)
             };
 
-            return await ExceptionHandling(LobbyService.Instance.QuickJoinLobbyAsync(joinRequest));
+            return await LobbyService.Instance.QuickJoinLobbyAsync(joinRequest);
         }
 
         public async Task<Lobby> ReconnectToLobby(string lobbyId)
         {
-            return await ExceptionHandling(LobbyService.Instance.ReconnectToLobbyAsync(lobbyId));
+            return await LobbyService.Instance.ReconnectToLobbyAsync(lobbyId);
         }
 
         public async Task RemovePlayerFromLobby(string requesterUasId, string lobbyId)
         {
             try
             {
-                await ExceptionHandling(LobbyService.Instance.RemovePlayerAsync(lobbyId, requesterUasId));
+                await LobbyService.Instance.RemovePlayerAsync(lobbyId, requesterUasId);
             }
             catch (LobbyServiceException e)
                 when (e is { Reason: LobbyExceptionReason.PlayerNotFound })
@@ -138,18 +104,18 @@ public async Task<QueryResponse> QueryAllLobbies()
                 Order = m_Order
             };
 
-            return await ExceptionHandling(LobbyService.Instance.QueryLobbiesAsync(queryOptions));
+            return await LobbyService.Instance.QueryLobbiesAsync(queryOptions);
         }
 
         public async Task<Lobby> GetLobby(string lobbyId)
         {
-            return await ExceptionHandling(LobbyService.Instance.GetLobbyAsync(lobbyId));
+            return await LobbyService.Instance.GetLobbyAsync(lobbyId);
         }
 
         public async Task<Lobby> UpdateLobby(string lobbyId, Dictionary<string, DataObject> data, bool shouldLock)
         {
             UpdateLobbyOptions updateOptions = new UpdateLobbyOptions { Data = data, IsLocked = shouldLock };
-            return await ExceptionHandling(LobbyService.Instance.UpdateLobbyAsync(lobbyId, updateOptions));
+            return await LobbyService.Instance.UpdateLobbyAsync(lobbyId, updateOptions);
         }
 
         public async Task<Lobby> UpdatePlayer(string lobbyId, string playerId, Dictionary<string, PlayerDataObject> data, string allocationId, string connectionInfo)
@@ -160,12 +126,12 @@ public async Task<Lobby> UpdatePlayer(string lobbyId, string playerId, Dictionar
                 AllocationId = allocationId,
                 ConnectionInfo = connectionInfo
             };
-            return await ExceptionHandling(LobbyService.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions));
+            return await LobbyService.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions);
         }
 
         public async void SendHeartbeatPing(string lobbyId)
         {
-            await ExceptionHandling(LobbyService.Instance.SendHeartbeatPingAsync(lobbyId));
+            await LobbyService.Instance.SendHeartbeatPingAsync(lobbyId);
         }
     }
 }
diff --git a/Assets/Scripts/UnityServices/Lobbies/LobbyServiceFacade.cs b/Assets/Scripts/UnityServices/Lobbies/LobbyServiceFacade.cs
@@ -91,9 +91,18 @@ public Task EndTracking()
             {
                 CurrentUnityLobby = null;
 
-                if (!string.IsNullOrEmpty(m_LocalLobby?.LobbyID))
+                var lobbyId = m_LocalLobby?.LobbyID;
+
+                if (!string.IsNullOrEmpty(lobbyId))
                 {
-                    task = LeaveLobbyAsync(m_LocalLobby?.LobbyID);
+                    if (m_LocalUser.IsHost)
+                    {
+                        task = DeleteLobbyAsync(lobbyId);
+                    }
+                    else
+                    {
+                        task = LeaveLobbyAsync(lobbyId);
+                    }
                 }
 
                 m_LocalUser.ResetState();
@@ -146,6 +155,10 @@ async void UpdateLobby(float unused)
                 {
                     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);
+                }
             }
         }
 
@@ -171,6 +184,10 @@ async void UpdateLobby(float unused)
                 {
                     m_RateLimitHost.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
             }
 
             return (false, null);
@@ -207,6 +224,10 @@ async void UpdateLobby(float unused)
                 {
                     m_RateLimitJoin.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
             }
 
             return (false, null);
@@ -234,6 +255,10 @@ async void UpdateLobby(float unused)
                 {
                     m_RateLimitQuickJoin.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
             }
 
             return (false, null);
@@ -261,12 +286,29 @@ public async Task RetrieveAndPublishLobbyListAsync()
                 {
                     m_RateLimitQuery.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
             }
         }
 
         public async Task<Lobby> ReconnectToLobbyAsync(string lobbyId)
         {
-            return await m_LobbyApiInterface.ReconnectToLobby(lobbyId);
+            try
+            {
+                return await m_LobbyApiInterface.ReconnectToLobby(lobbyId);
+            }
+            catch (LobbyServiceException e)
+            {
+                // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.
+                if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)
+                {
+                    PublishError(e);
+                }
+            }
+
+            return null;
         }
 
         /// <summary>
@@ -280,9 +322,12 @@ public async Task LeaveLobbyAsync(string lobbyId)
                 await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);
             }
             catch (LobbyServiceException e)
-                when (e is { Reason: LobbyExceptionReason.LobbyNotFound })
             {
-                // If Lobby is not found, it has already been deleted. No need to throw here.
+                // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.
+                if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)
+                {
+                    PublishError(e);
+                }
             }
 
         }
@@ -291,19 +336,33 @@ public async void RemovePlayerFromLobbyAsync(string uasId, string lobbyId)
         {
             if (m_LocalUser.IsHost)
             {
-                await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);
+                try
+                {
+                    await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);
+                }
+                catch (LobbyServiceException e)
+                {
+                    PublishError(e);
+                }
             }
             else
             {
                 Debug.LogError("Only the host can remove other players from the lobby.");
             }
         }
 
-        public async void DeleteLobbyAsync(string lobbyId)
+        public async Task DeleteLobbyAsync(string lobbyId)
         {
             if (m_LocalUser.IsHost)
             {
-                await m_LobbyApiInterface.DeleteLobby(lobbyId);
+                try
+                {
+                    await m_LobbyApiInterface.DeleteLobby(lobbyId);
+                }
+                catch (LobbyServiceException e)
+                {
+                    PublishError(e);
+                }
             }
             else
             {
@@ -336,6 +395,10 @@ public async Task UpdatePlayerDataAsync(Dictionary<string, PlayerDataObject> dat
                 {
                     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);
+                }
             }
         }
 
@@ -359,6 +422,10 @@ public async Task UpdatePlayerRelayInfoAsync(string allocationId, string connect
                 {
                     m_RateLimitQuery.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
 
                 //todo - retry logic? SDK is supposed to handle this eventually
             }
@@ -406,6 +473,10 @@ public async Task UpdateLobbyDataAsync(Dictionary<string, DataObject> data)
                 {
                     m_RateLimitQuery.PutOnCooldown();
                 }
+                else
+                {
+                    PublishError(e);
+                }
             }
         }
 
@@ -418,8 +489,25 @@ public void DoLobbyHeartbeat(float dt)
             if (m_HeartbeatTime > k_HeartbeatPeriod)
             {
                 m_HeartbeatTime -= k_HeartbeatPeriod;
-                m_LobbyApiInterface.SendHeartbeatPing(CurrentUnityLobby.Id);
+                try
+                {
+                    m_LobbyApiInterface.SendHeartbeatPing(CurrentUnityLobby.Id);
+                }
+                catch (LobbyServiceException e)
+                {
+                    // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.
+                    if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)
+                    {
+                        PublishError(e);
+                    }
+                }
             }
         }
+
+        void PublishError(LobbyServiceException e)
+        {
+            var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.
+            m_UnityServiceErrorMessagePub.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));
+        }
     }
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,15 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
-## [unreleased] - yyy-mm-dd
+## [unreleased] - aaaa-mm-dd
+
 ### Added
- * 
+*
 ### Changed
- * 
+* Hosts now delete their lobby when shutting down instead of only leaving it (#772) Since Boss Room doesn't support host migration, there is no need to keep the lobby alive after the host shuts down. This also changes how LobbyServiceExceptions are handled to prevent popup messages on clients trying to leave a lobby that is already deleted, following the best practices outlined in this doc : https://docs.unity.com/lobby/delete-a-lobby.html
+* 
 ### Cleanup
- * 
+*
 ### Fixed
- * 
+*
 
 ## [2.0.2] - 2022-11-01
 ### Fixed

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,9 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Threading.Tasks;`
`4`		`-using Unity.BossRoom.Infrastructure;`
`5`	`4`	`using Unity.Services.Lobbies;`
`6`	`5`	`using Unity.Services.Lobbies.Models;`
`7`	`6`	`using UnityEngine;`
`8`		`-using VContainer;`
`9`	`7`
`10`	`8`	`namespace Unity.BossRoom.UnityServices.Lobbies`
`11`	`9`	`{`
`@@ -16,15 +14,11 @@ public class LobbyAPIInterface`
`16`	`14`	`{`
`17`	`15`	`const int k_MaxLobbiesToShow = 16; // If more are necessary, consider retrieving paginated results or using filters.`
`18`	`16`
`19`		`- readonly IPublisher<UnityServiceErrorMessage> m_UnityServiceErrorMessagePublisher;`
`20`	`17`	`readonly List<QueryFilter> m_Filters;`
`21`	`18`	`readonly List<QueryOrder> m_Order;`
`22`	`19`
`23`		`- [Inject]`
`24`		`- public LobbyAPIInterface(IPublisher<UnityServiceErrorMessage> unityServiceErrorMessagePublisher)`
	`20`	`+ public LobbyAPIInterface()`
`25`	`21`	`{`
`26`		`- m_UnityServiceErrorMessagePublisher = unityServiceErrorMessagePublisher;`
`27`		`-`
`28`	`22`	`// Filter for open lobbies only`
`29`	`23`	`m_Filters = new List<QueryFilter>()`
`30`	`24`	`{`
`@@ -43,34 +37,6 @@ public LobbyAPIInterface(IPublisher<UnityServiceErrorMessage> unityServiceErrorM`
`43`	`37`	`};`
`44`	`38`	`}`
`45`	`39`
`46`		`- async Task<T> ExceptionHandling<T>(Task<T> task)`
`47`		`- {`
`48`		`- try`
`49`		`- {`
`50`		`- return await task;`
`51`		`- }`
`52`		`- catch (Exception e)`
`53`		`- {`
`54`		`- var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.`
`55`		`- m_UnityServiceErrorMessagePublisher.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));`
`56`		`- throw;`
`57`		`- }`
`58`		`- }`
`59`		`-`
`60`		`- async Task ExceptionHandling(Task task)`
`61`		`- {`
`62`		`- try`
`63`		`- {`
`64`		`- await task;`
`65`		`- }`
`66`		`- catch (Exception e)`
`67`		`- {`
`68`		`- var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.`
`69`		`- m_UnityServiceErrorMessagePublisher.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));`
`70`		`- throw;`
`71`		`- }`
`72`		`- }`
`73`		`-`
`74`	`40`	`public async Task<Lobby> CreateLobby(string requesterUasId, string lobbyName, int maxPlayers, bool isPrivate, Dictionary<string, PlayerDataObject> hostUserData, Dictionary<string, DataObject> lobbyData)`
`75`	`41`	`{`
`76`	`42`	`CreateLobbyOptions createOptions = new CreateLobbyOptions`
`@@ -80,24 +46,24 @@ public async Task<Lobby> CreateLobby(string requesterUasId, string lobbyName, in`
`80`	`46`	`Data = lobbyData`
`81`	`47`	`};`
`82`	`48`
`83`		`- return await ExceptionHandling(LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions));`
	`49`	`+ return await LobbyService.Instance.CreateLobbyAsync(lobbyName, maxPlayers, createOptions);`
`84`	`50`	`}`
`85`	`51`
`86`	`52`	`public async Task DeleteLobby(string lobbyId)`
`87`	`53`	`{`
`88`		`- await ExceptionHandling(LobbyService.Instance.DeleteLobbyAsync(lobbyId));`
	`54`	`+ await LobbyService.Instance.DeleteLobbyAsync(lobbyId);`
`89`	`55`	`}`
`90`	`56`
`91`	`57`	`public async Task<Lobby> JoinLobbyByCode(string requesterUasId, string lobbyCode, Dictionary<string, PlayerDataObject> localUserData)`
`92`	`58`	`{`
`93`	`59`	`JoinLobbyByCodeOptions joinOptions = new JoinLobbyByCodeOptions { Player = new Player(id: requesterUasId, data: localUserData) };`
`94`		`- return await ExceptionHandling(LobbyService.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions));`
	`60`	`+ return await LobbyService.Instance.JoinLobbyByCodeAsync(lobbyCode, joinOptions);`
`95`	`61`	`}`
`96`	`62`
`97`	`63`	`public async Task<Lobby> JoinLobbyById(string requesterUasId, string lobbyId, Dictionary<string, PlayerDataObject> localUserData)`
`98`	`64`	`{`
`99`	`65`	`JoinLobbyByIdOptions joinOptions = new JoinLobbyByIdOptions { Player = new Player(id: requesterUasId, data: localUserData) };`
`100`		`- return await ExceptionHandling(LobbyService.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions));`
	`66`	`+ return await LobbyService.Instance.JoinLobbyByIdAsync(lobbyId, joinOptions);`
`101`	`67`	`}`
`102`	`68`
`103`	`69`	`public async Task<Lobby> QuickJoinLobby(string requesterUasId, Dictionary<string, PlayerDataObject> localUserData)`
`@@ -108,19 +74,19 @@ public async Task<Lobby> QuickJoinLobby(string requesterUasId, Dictionary<string`
`108`	`74`	`Player = new Player(id: requesterUasId, data: localUserData)`
`109`	`75`	`};`
`110`	`76`
`111`		`- return await ExceptionHandling(LobbyService.Instance.QuickJoinLobbyAsync(joinRequest));`
	`77`	`+ return await LobbyService.Instance.QuickJoinLobbyAsync(joinRequest);`
`112`	`78`	`}`
`113`	`79`
`114`	`80`	`public async Task<Lobby> ReconnectToLobby(string lobbyId)`
`115`	`81`	`{`
`116`		`- return await ExceptionHandling(LobbyService.Instance.ReconnectToLobbyAsync(lobbyId));`
	`82`	`+ return await LobbyService.Instance.ReconnectToLobbyAsync(lobbyId);`
`117`	`83`	`}`
`118`	`84`
`119`	`85`	`public async Task RemovePlayerFromLobby(string requesterUasId, string lobbyId)`
`120`	`86`	`{`
`121`	`87`	`try`
`122`	`88`	`{`
`123`		`- await ExceptionHandling(LobbyService.Instance.RemovePlayerAsync(lobbyId, requesterUasId));`
	`89`	`+ await LobbyService.Instance.RemovePlayerAsync(lobbyId, requesterUasId);`
`124`	`90`	`}`
`125`	`91`	`catch (LobbyServiceException e)`
`126`	`92`	`when (e is { Reason: LobbyExceptionReason.PlayerNotFound })`
`@@ -138,18 +104,18 @@ public async Task<QueryResponse> QueryAllLobbies()`
`138`	`104`	`Order = m_Order`
`139`	`105`	`};`
`140`	`106`
`141`		`- return await ExceptionHandling(LobbyService.Instance.QueryLobbiesAsync(queryOptions));`
	`107`	`+ return await LobbyService.Instance.QueryLobbiesAsync(queryOptions);`
`142`	`108`	`}`
`143`	`109`
`144`	`110`	`public async Task<Lobby> GetLobby(string lobbyId)`
`145`	`111`	`{`
`146`		`- return await ExceptionHandling(LobbyService.Instance.GetLobbyAsync(lobbyId));`
	`112`	`+ return await LobbyService.Instance.GetLobbyAsync(lobbyId);`
`147`	`113`	`}`
`148`	`114`
`149`	`115`	`public async Task<Lobby> UpdateLobby(string lobbyId, Dictionary<string, DataObject> data, bool shouldLock)`
`150`	`116`	`{`
`151`	`117`	`UpdateLobbyOptions updateOptions = new UpdateLobbyOptions { Data = data, IsLocked = shouldLock };`
`152`		`- return await ExceptionHandling(LobbyService.Instance.UpdateLobbyAsync(lobbyId, updateOptions));`
	`118`	`+ return await LobbyService.Instance.UpdateLobbyAsync(lobbyId, updateOptions);`
`153`	`119`	`}`
`154`	`120`
`155`	`121`	`public async Task<Lobby> UpdatePlayer(string lobbyId, string playerId, Dictionary<string, PlayerDataObject> data, string allocationId, string connectionInfo)`
`@@ -160,12 +126,12 @@ public async Task<Lobby> UpdatePlayer(string lobbyId, string playerId, Dictionar`
`160`	`126`	`AllocationId = allocationId,`
`161`	`127`	`ConnectionInfo = connectionInfo`
`162`	`128`	`};`
`163`		`- return await ExceptionHandling(LobbyService.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions));`
	`129`	`+ return await LobbyService.Instance.UpdatePlayerAsync(lobbyId, playerId, updateOptions);`
`164`	`130`	`}`
`165`	`131`
`166`	`132`	`public async void SendHeartbeatPing(string lobbyId)`
`167`	`133`	`{`
`168`		`- await ExceptionHandling(LobbyService.Instance.SendHeartbeatPingAsync(lobbyId));`
	`134`	`+ await LobbyService.Instance.SendHeartbeatPingAsync(lobbyId);`
`169`	`135`	`}`
`170`	`136`	`}`
`171`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,9 +91,18 @@ public Task EndTracking()`
`91`	`91`	`{`
`92`	`92`	`CurrentUnityLobby = null;`
`93`	`93`
`94`		`- if (!string.IsNullOrEmpty(m_LocalLobby?.LobbyID))`
	`94`	`+ var lobbyId = m_LocalLobby?.LobbyID;`
	`95`	`+`
	`96`	`+ if (!string.IsNullOrEmpty(lobbyId))`
`95`	`97`	`{`
`96`		`- task = LeaveLobbyAsync(m_LocalLobby?.LobbyID);`
	`98`	`+ if (m_LocalUser.IsHost)`
	`99`	`+ {`
	`100`	`+ task = DeleteLobbyAsync(lobbyId);`
	`101`	`+ }`
	`102`	`+ else`
	`103`	`+ {`
	`104`	`+ task = LeaveLobbyAsync(lobbyId);`
	`105`	`+ }`
`97`	`106`	`}`
`98`	`107`
`99`	`108`	`m_LocalUser.ResetState();`
`@@ -146,6 +155,10 @@ async void UpdateLobby(float unused)`
`146`	`155`	`{`
`147`	`156`	`m_RateLimitQuery.PutOnCooldown();`
`148`	`157`	`}`
	`158`	`+ 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.`
	`159`	`+ {`
	`160`	`+ PublishError(e);`
	`161`	`+ }`
`149`	`162`	`}`
`150`	`163`	`}`
`151`	`164`
`@@ -171,6 +184,10 @@ async void UpdateLobby(float unused)`
`171`	`184`	`{`
`172`	`185`	`m_RateLimitHost.PutOnCooldown();`
`173`	`186`	`}`
	`187`	`+ else`
	`188`	`+ {`
	`189`	`+ PublishError(e);`
	`190`	`+ }`
`174`	`191`	`}`
`175`	`192`
`176`	`193`	`return (false, null);`
`@@ -207,6 +224,10 @@ async void UpdateLobby(float unused)`
`207`	`224`	`{`
`208`	`225`	`m_RateLimitJoin.PutOnCooldown();`
`209`	`226`	`}`
	`227`	`+ else`
	`228`	`+ {`
	`229`	`+ PublishError(e);`
	`230`	`+ }`
`210`	`231`	`}`
`211`	`232`
`212`	`233`	`return (false, null);`
`@@ -234,6 +255,10 @@ async void UpdateLobby(float unused)`
`234`	`255`	`{`
`235`	`256`	`m_RateLimitQuickJoin.PutOnCooldown();`
`236`	`257`	`}`
	`258`	`+ else`
	`259`	`+ {`
	`260`	`+ PublishError(e);`
	`261`	`+ }`
`237`	`262`	`}`
`238`	`263`
`239`	`264`	`return (false, null);`
`@@ -261,12 +286,29 @@ public async Task RetrieveAndPublishLobbyListAsync()`
`261`	`286`	`{`
`262`	`287`	`m_RateLimitQuery.PutOnCooldown();`
`263`	`288`	`}`
	`289`	`+ else`
	`290`	`+ {`
	`291`	`+ PublishError(e);`
	`292`	`+ }`
`264`	`293`	`}`
`265`	`294`	`}`
`266`	`295`
`267`	`296`	`public async Task<Lobby> ReconnectToLobbyAsync(string lobbyId)`
`268`	`297`	`{`
`269`		`- return await m_LobbyApiInterface.ReconnectToLobby(lobbyId);`
	`298`	`+ try`
	`299`	`+ {`
	`300`	`+ return await m_LobbyApiInterface.ReconnectToLobby(lobbyId);`
	`301`	`+ }`
	`302`	`+ catch (LobbyServiceException e)`
	`303`	`+ {`
	`304`	`+ // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.`
	`305`	`+ if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)`
	`306`	`+ {`
	`307`	`+ PublishError(e);`
	`308`	`+ }`
	`309`	`+ }`
	`310`	`+`
	`311`	`+ return null;`
`270`	`312`	`}`
`271`	`313`
`272`	`314`	`/// <summary>`
`@@ -280,9 +322,12 @@ public async Task LeaveLobbyAsync(string lobbyId)`
`280`	`322`	`await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);`
`281`	`323`	`}`
`282`	`324`	`catch (LobbyServiceException e)`
`283`		`- when (e is { Reason: LobbyExceptionReason.LobbyNotFound })`
`284`	`325`	`{`
`285`		`- // If Lobby is not found, it has already been deleted. No need to throw here.`
	`326`	`+ // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.`
	`327`	`+ if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)`
	`328`	`+ {`
	`329`	`+ PublishError(e);`
	`330`	`+ }`
`286`	`331`	`}`
`287`	`332`
`288`	`333`	`}`
`@@ -291,19 +336,33 @@ public async void RemovePlayerFromLobbyAsync(string uasId, string lobbyId)`
`291`	`336`	`{`
`292`	`337`	`if (m_LocalUser.IsHost)`
`293`	`338`	`{`
`294`		`- await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);`
	`339`	`+ try`
	`340`	`+ {`
	`341`	`+ await m_LobbyApiInterface.RemovePlayerFromLobby(uasId, lobbyId);`
	`342`	`+ }`
	`343`	`+ catch (LobbyServiceException e)`
	`344`	`+ {`
	`345`	`+ PublishError(e);`
	`346`	`+ }`
`295`	`347`	`}`
`296`	`348`	`else`
`297`	`349`	`{`
`298`	`350`	`Debug.LogError("Only the host can remove other players from the lobby.");`
`299`	`351`	`}`
`300`	`352`	`}`
`301`	`353`
`302`		`- public async void DeleteLobbyAsync(string lobbyId)`
	`354`	`+ public async Task DeleteLobbyAsync(string lobbyId)`
`303`	`355`	`{`
`304`	`356`	`if (m_LocalUser.IsHost)`
`305`	`357`	`{`
`306`		`- await m_LobbyApiInterface.DeleteLobby(lobbyId);`
	`358`	`+ try`
	`359`	`+ {`
	`360`	`+ await m_LobbyApiInterface.DeleteLobby(lobbyId);`
	`361`	`+ }`
	`362`	`+ catch (LobbyServiceException e)`
	`363`	`+ {`
	`364`	`+ PublishError(e);`
	`365`	`+ }`
`307`	`366`	`}`
`308`	`367`	`else`
`309`	`368`	`{`
`@@ -336,6 +395,10 @@ public async Task UpdatePlayerDataAsync(Dictionary<string, PlayerDataObject> dat`
`336`	`395`	`{`
`337`	`396`	`m_RateLimitQuery.PutOnCooldown();`
`338`	`397`	`}`
	`398`	`+ 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.`
	`399`	`+ {`
	`400`	`+ PublishError(e);`
	`401`	`+ }`
`339`	`402`	`}`
`340`	`403`	`}`
`341`	`404`
`@@ -359,6 +422,10 @@ public async Task UpdatePlayerRelayInfoAsync(string allocationId, string connect`
`359`	`422`	`{`
`360`	`423`	`m_RateLimitQuery.PutOnCooldown();`
`361`	`424`	`}`
	`425`	`+ else`
	`426`	`+ {`
	`427`	`+ PublishError(e);`
	`428`	`+ }`
`362`	`429`
`363`	`430`	`//todo - retry logic? SDK is supposed to handle this eventually`
`364`	`431`	`}`
`@@ -406,6 +473,10 @@ public async Task UpdateLobbyDataAsync(Dictionary<string, DataObject> data)`
`406`	`473`	`{`
`407`	`474`	`m_RateLimitQuery.PutOnCooldown();`
`408`	`475`	`}`
	`476`	`+ else`
	`477`	`+ {`
	`478`	`+ PublishError(e);`
	`479`	`+ }`
`409`	`480`	`}`
`410`	`481`	`}`
`411`	`482`
`@@ -418,8 +489,25 @@ public void DoLobbyHeartbeat(float dt)`
`418`	`489`	`if (m_HeartbeatTime > k_HeartbeatPeriod)`
`419`	`490`	`{`
`420`	`491`	`m_HeartbeatTime -= k_HeartbeatPeriod;`
`421`		`- m_LobbyApiInterface.SendHeartbeatPing(CurrentUnityLobby.Id);`
	`492`	`+ try`
	`493`	`+ {`
	`494`	`+ m_LobbyApiInterface.SendHeartbeatPing(CurrentUnityLobby.Id);`
	`495`	`+ }`
	`496`	`+ catch (LobbyServiceException e)`
	`497`	`+ {`
	`498`	`+ // If Lobby is not found and if we are not the host, it has already been deleted. No need to publish the error here.`
	`499`	`+ if (e.Reason != LobbyExceptionReason.LobbyNotFound && !m_LocalUser.IsHost)`
	`500`	`+ {`
	`501`	`+ PublishError(e);`
	`502`	`+ }`
	`503`	`+ }`
`422`	`504`	`}`
`423`	`505`	`}`
	`506`	`+`
	`507`	`+ void PublishError(LobbyServiceException e)`
	`508`	`+ {`
	`509`	`+ var reason = $"{e.Message} ({e.InnerException?.Message})"; // Lobby error type, then HTTP error type.`
	`510`	`+ m_UnityServiceErrorMessagePub.Publish(new UnityServiceErrorMessage("Lobby Error", reason, UnityServiceErrorMessage.Service.Lobby, e));`
	`511`	`+ }`
`424`	`512`	`}`
`425`	`513`	`}`