Updates after testing

Erik Bylund · kirre-bylund · commit 50133535cfe9 · 2023-11-14T11:56:15.000+01:00
diff --git a/Runtime/Client/LootLockerServerRequest.cs b/Runtime/Client/LootLockerServerRequest.cs
@@ -418,7 +418,7 @@ public struct LootLockerServerRequest
 
         #region Make ServerRequest and call send (3 functions)
 
-        public static void CallAPI(string endPoint, LootLockerHTTPMethod httpMethod, string body = null, Action<LootLockerResponse> onComplete = null, bool useAuthToken = true, LootLocker.LootLockerEnums.LootLockerCallerRole callerRole = LootLocker.LootLockerEnums.LootLockerCallerRole.User)
+        public static void CallAPI(string endPoint, LootLockerHTTPMethod httpMethod, string body = null, Action<LootLockerResponse> onComplete = null, bool useAuthToken = true, LootLocker.LootLockerEnums.LootLockerCallerRole callerRole = LootLocker.LootLockerEnums.LootLockerCallerRole.User, Dictionary<string, string> additionalHeaders = null)
         {
             if (RateLimiter.Get().AddRequestAndCheckIfRateLimitHit())
             {
@@ -453,6 +453,14 @@ public static void CallAPI(string endPoint, LootLockerHTTPMethod httpMethod, str
             if (LootLockerConfig.current != null)
                 headers.Add(LootLockerConfig.current.dateVersion.key, LootLockerConfig.current.dateVersion.value);
 
+            if (additionalHeaders != null)
+            {
+                foreach (var additionalHeader in additionalHeaders)
+                {
+                    headers.Add(additionalHeader.Key, additionalHeader.Value);
+                }
+            }
+
             LootLockerBaseServerAPI.I.SwitchURL(callerRole);
 
             new LootLockerServerRequest(endPoint, httpMethod, body, headers, callerRole: callerRole).Send((response) => { onComplete?.Invoke(response); });
diff --git a/Runtime/Game/LootLockerSDKManager.cs b/Runtime/Game/LootLockerSDKManager.cs
@@ -807,6 +807,7 @@ public static void ClearLocalSession()
         #endregion
 
         #region Remote Sessions
+
         /// <summary>
         /// Start a remote session
         /// If you want to let your local user sign in using another device then you use this method. First you will get the lease information needed to allow a secondary device to authenticate.
@@ -816,15 +817,17 @@ public static void ClearLocalSession()
         /// <param name="remoteSessionLeaseInformation">Will be invoked once to provide the lease information that the secondary device can use to authenticate</param>
         /// <param name="remoteSessionLeaseStatusUpdate">Will be invoked intermittently to update the status lease process</param>
         /// <param name="onComplete">Invoked when the remote session process has run to completion containing either a valid session or information on why the process failed</param>
-        public static Guid StartRemoteSession(Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation, Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdate, Action<LootLockerStartRemoteSessionResponse> onComplete)
+        /// <param name="pollingIntervalSeconds">Optional: How often to poll the status of the remote session process</param>
+        /// <param name="timeOutAfterMinutes">Optional: How long to allow the process to take in it's entirety</param>
+        public static Guid StartRemoteSession(Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation, Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdate, Action<LootLockerStartRemoteSessionResponse> onComplete, float pollingIntervalSeconds = 1.0f, float timeOutAfterMinutes = 5.0f)
         {
             if (!CheckInitialized(true))
             {
                 onComplete?.Invoke(LootLockerResponseFactory.SDKNotInitializedError<LootLockerStartRemoteSessionResponse>());
                 return Guid.Empty;
             }
 
-            return LootLockerAPIManager.RemoteSessionPoller.GetInstance().StartRemoteSessionWithContinualPolling(remoteSessionLeaseInformation, remoteSessionLeaseStatusUpdate, onComplete);
+            return LootLockerAPIManager.RemoteSessionPoller.GetInstance().StartRemoteSessionWithContinualPolling(remoteSessionLeaseInformation, remoteSessionLeaseStatusUpdate, onComplete, pollingIntervalSeconds, timeOutAfterMinutes);
         }
 
         /// <summary>
diff --git a/Runtime/Game/Requests/RemoteSessionRequest.cs b/Runtime/Game/Requests/RemoteSessionRequest.cs
@@ -105,7 +105,7 @@ public class LootLockerLeaseRemoteSessionResponse : LootLockerResponse
     public class LootLockerRemoteSessionStatusPollingResponse : LootLockerResponse
     {
         /// <summary>
-        /// The current status of this lease process. If this is not of the status Authorized, the rest of the fields in this object will be empty.
+        /// The current status of this lease process.
         /// </summary>
         public LootLockerRemoteSessionLeaseStatus lease_status { get; set; }
     }
@@ -166,8 +166,6 @@ static void OnEnterPlaymodeInEditor(EnterPlayModeOptions options)
             }
 #endif
 
-            private static readonly double _leasingProcessTimeoutLimitInMinutes = 5.0d;
-            private static readonly float _leasingProcessPollingIntervalSeconds = 1.0f;
             private static readonly int _leasingProcessPollingRetryLimit = 5;
 
             private class LootLockerRemoteSessionProcess
@@ -176,6 +174,7 @@ private class LootLockerRemoteSessionProcess
                 public string LeaseNonce;
                 public LootLockerRemoteSessionLeaseStatus LastUpdatedStatus;
                 public DateTime LeasingProcessTimeoutTime;
+                public float PollingIntervalSeconds = 1.0f;
                 public DateTime LastUpdatedAt;
                 public int Retries = 0;
                 public bool ShouldCancel;
@@ -202,7 +201,11 @@ private static void RemoveRemoteSessionProcess(Guid processGuid)
 
             protected IEnumerator ContinualPollingAction(Guid processGuid)
             {
-                yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);
+                if (!_remoteSessionsProcesses.TryGetValue(processGuid, out var preProcess))
+                {
+                    yield break;
+                }
+                yield return new WaitForSeconds(preProcess.PollingIntervalSeconds);
                 while (_remoteSessionsProcesses.TryGetValue(processGuid, out var process))
                 {
                     // Check if we should continue the polling
@@ -221,6 +224,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)
                     {
                         LootLockerStartRemoteSessionResponse canceledResponse = new LootLockerStartRemoteSessionResponse
                         {
+                            success = false,
                             lease_status = LootLockerRemoteSessionLeaseStatus.Cancelled
                         };
                         process.ProcessCompletedCallbackAction?.Invoke(canceledResponse);
@@ -246,7 +250,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)
                         {
                             // Recoverable error
                             processAfterStatusCheck.Retries++;
-                            yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);
+                            yield return new WaitForSeconds(processAfterStatusCheck.PollingIntervalSeconds);
                             continue;
                         }
 
@@ -256,6 +260,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)
                         yield break;
                     }
 
+                    // Authorized = We're done
                     if (startSessionResponse.lease_status == LootLockerRemoteSessionLeaseStatus.Authorized)
                     {
                         processAfterStatusCheck.ProcessCompletedCallbackAction?.Invoke(startSessionResponse);
@@ -269,16 +274,19 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)
                             startSessionResponse);
                     processAfterStatusCheck.UpdateCallbackAction?.Invoke(pollingResponse);
                     processAfterStatusCheck.LastUpdatedAt = DateTime.UtcNow;
+                    processAfterStatusCheck.LastUpdatedStatus = pollingResponse.lease_status;
 
                     // Sleep for a bit before checking again
-                    yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);
+                    yield return new WaitForSeconds(processAfterStatusCheck.PollingIntervalSeconds);
                 }
             }
 
             public Guid StartRemoteSessionWithContinualPolling(
                 Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation,
                 Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdateCallback,
-                Action<LootLockerStartRemoteSessionResponse> remoteSessionCompleted)
+                Action<LootLockerStartRemoteSessionResponse> remoteSessionCompleted,
+                float pollingIntervalSeconds = 1.0f,
+                float timeOutAfterMinutes = 5.0f)
             {
                 if (_remoteSessionsProcesses.Count > 0)
                 {
@@ -292,7 +300,8 @@ public Guid StartRemoteSessionWithContinualPolling(
                 LootLockerRemoteSessionProcess lootLockerRemoteSessionProcess = new LootLockerRemoteSessionProcess()
                 {
                     LastUpdatedAt = DateTime.UtcNow,
-                    LeasingProcessTimeoutTime = DateTime.UtcNow.AddMinutes(_leasingProcessTimeoutLimitInMinutes),
+                    LeasingProcessTimeoutTime = DateTime.UtcNow.AddMinutes(timeOutAfterMinutes),
+                    PollingIntervalSeconds = pollingIntervalSeconds,
                     UpdateCallbackAction = remoteSessionLeaseStatusUpdateCallback,
                     ProcessCompletedCallbackAction = remoteSessionCompleted
                 };
@@ -310,6 +319,7 @@ public Guid StartRemoteSessionWithContinualPolling(
                         remoteSessionLeaseInformation?.Invoke(leaseRemoteSessionResponse);
                         return;
                     }
+                    remoteSessionLeaseInformation?.Invoke(leaseRemoteSessionResponse);
 
                     process.LeaseCode = leaseRemoteSessionResponse.code;
                     process.LeaseNonce = leaseRemoteSessionResponse.nonce;
@@ -365,7 +375,7 @@ private void StartRemoteSession(string leaseCode, string nonce, Action<LootLocke
                         CurrentPlatform.Set(Platforms.Remote);
                         LootLockerConfig.current.token = response.session_token;
                         LootLockerConfig.current.refreshToken = response.refresh_token;
-                        LootLockerConfig.current.deviceID = response.player_identifier;
+                        LootLockerConfig.current.deviceID = response.player_ulid;
                     }
 
                     onComplete?.Invoke(response);

Original file line number	Diff line number	Diff line change
`@@ -807,6 +807,7 @@ public static void ClearLocalSession()`
`807`	`807`	`#endregion`
`808`	`808`
`809`	`809`	`#region Remote Sessions`
	`810`	`+`
`810`	`811`	`/// <summary>`
`811`	`812`	`/// Start a remote session`
`812`	`813`	`/// If you want to let your local user sign in using another device then you use this method. First you will get the lease information needed to allow a secondary device to authenticate.`
`@@ -816,15 +817,17 @@ public static void ClearLocalSession()`
`816`	`817`	`/// <param name="remoteSessionLeaseInformation">Will be invoked once to provide the lease information that the secondary device can use to authenticate</param>`
`817`	`818`	`/// <param name="remoteSessionLeaseStatusUpdate">Will be invoked intermittently to update the status lease process</param>`
`818`	`819`	`/// <param name="onComplete">Invoked when the remote session process has run to completion containing either a valid session or information on why the process failed</param>`
`819`		`- public static Guid StartRemoteSession(Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation, Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdate, Action<LootLockerStartRemoteSessionResponse> onComplete)`
	`820`	`+ /// <param name="pollingIntervalSeconds">Optional: How often to poll the status of the remote session process</param>`
	`821`	`+ /// <param name="timeOutAfterMinutes">Optional: How long to allow the process to take in it's entirety</param>`
	`822`	`+ public static Guid StartRemoteSession(Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation, Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdate, Action<LootLockerStartRemoteSessionResponse> onComplete, float pollingIntervalSeconds = 1.0f, float timeOutAfterMinutes = 5.0f)`
`820`	`823`	`{`
`821`	`824`	`if (!CheckInitialized(true))`
`822`	`825`	`{`
`823`	`826`	`onComplete?.Invoke(LootLockerResponseFactory.SDKNotInitializedError<LootLockerStartRemoteSessionResponse>());`
`824`	`827`	`return Guid.Empty;`
`825`	`828`	`}`
`826`	`829`
`827`		`- return LootLockerAPIManager.RemoteSessionPoller.GetInstance().StartRemoteSessionWithContinualPolling(remoteSessionLeaseInformation, remoteSessionLeaseStatusUpdate, onComplete);`
	`830`	`+ return LootLockerAPIManager.RemoteSessionPoller.GetInstance().StartRemoteSessionWithContinualPolling(remoteSessionLeaseInformation, remoteSessionLeaseStatusUpdate, onComplete, pollingIntervalSeconds, timeOutAfterMinutes);`
`828`	`831`	`}`
`829`	`832`
`830`	`833`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public class LootLockerLeaseRemoteSessionResponse : LootLockerResponse`
`105`	`105`	`public class LootLockerRemoteSessionStatusPollingResponse : LootLockerResponse`
`106`	`106`	`{`
`107`	`107`	`/// <summary>`
`108`		`- /// The current status of this lease process. If this is not of the status Authorized, the rest of the fields in this object will be empty.`
	`108`	`+ /// The current status of this lease process.`
`109`	`109`	`/// </summary>`
`110`	`110`	`public LootLockerRemoteSessionLeaseStatus lease_status { get; set; }`
`111`	`111`	`}`
`@@ -166,8 +166,6 @@ static void OnEnterPlaymodeInEditor(EnterPlayModeOptions options)`
`166`	`166`	`}`
`167`	`167`	`#endif`
`168`	`168`
`169`		`- private static readonly double _leasingProcessTimeoutLimitInMinutes = 5.0d;`
`170`		`- private static readonly float _leasingProcessPollingIntervalSeconds = 1.0f;`
`171`	`169`	`private static readonly int _leasingProcessPollingRetryLimit = 5;`
`172`	`170`
`173`	`171`	`private class LootLockerRemoteSessionProcess`
`@@ -176,6 +174,7 @@ private class LootLockerRemoteSessionProcess`
`176`	`174`	`public string LeaseNonce;`
`177`	`175`	`public LootLockerRemoteSessionLeaseStatus LastUpdatedStatus;`
`178`	`176`	`public DateTime LeasingProcessTimeoutTime;`
	`177`	`+ public float PollingIntervalSeconds = 1.0f;`
`179`	`178`	`public DateTime LastUpdatedAt;`
`180`	`179`	`public int Retries = 0;`
`181`	`180`	`public bool ShouldCancel;`
`@@ -202,7 +201,11 @@ private static void RemoveRemoteSessionProcess(Guid processGuid)`
`202`	`201`
`203`	`202`	`protected IEnumerator ContinualPollingAction(Guid processGuid)`
`204`	`203`	`{`
`205`		`- yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);`
	`204`	`+ if (!_remoteSessionsProcesses.TryGetValue(processGuid, out var preProcess))`
	`205`	`+ {`
	`206`	`+ yield break;`
	`207`	`+ }`
	`208`	`+ yield return new WaitForSeconds(preProcess.PollingIntervalSeconds);`
`206`	`209`	`while (_remoteSessionsProcesses.TryGetValue(processGuid, out var process))`
`207`	`210`	`{`
`208`	`211`	`// Check if we should continue the polling`
`@@ -221,6 +224,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)`
`221`	`224`	`{`
`222`	`225`	`LootLockerStartRemoteSessionResponse canceledResponse = new LootLockerStartRemoteSessionResponse`
`223`	`226`	`{`
	`227`	`+ success = false,`
`224`	`228`	`lease_status = LootLockerRemoteSessionLeaseStatus.Cancelled`
`225`	`229`	`};`
`226`	`230`	`process.ProcessCompletedCallbackAction?.Invoke(canceledResponse);`
`@@ -246,7 +250,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)`
`246`	`250`	`{`
`247`	`251`	`// Recoverable error`
`248`	`252`	`processAfterStatusCheck.Retries++;`
`249`		`- yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);`
	`253`	`+ yield return new WaitForSeconds(processAfterStatusCheck.PollingIntervalSeconds);`
`250`	`254`	`continue;`
`251`	`255`	`}`
`252`	`256`
`@@ -256,6 +260,7 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)`
`256`	`260`	`yield break;`
`257`	`261`	`}`
`258`	`262`
	`263`	`+ // Authorized = We're done`
`259`	`264`	`if (startSessionResponse.lease_status == LootLockerRemoteSessionLeaseStatus.Authorized)`
`260`	`265`	`{`
`261`	`266`	`processAfterStatusCheck.ProcessCompletedCallbackAction?.Invoke(startSessionResponse);`
`@@ -269,16 +274,19 @@ protected IEnumerator ContinualPollingAction(Guid processGuid)`
`269`	`274`	`startSessionResponse);`
`270`	`275`	`processAfterStatusCheck.UpdateCallbackAction?.Invoke(pollingResponse);`
`271`	`276`	`processAfterStatusCheck.LastUpdatedAt = DateTime.UtcNow;`
	`277`	`+ processAfterStatusCheck.LastUpdatedStatus = pollingResponse.lease_status;`
`272`	`278`
`273`	`279`	`// Sleep for a bit before checking again`
`274`		`- yield return new WaitForSeconds(_leasingProcessPollingIntervalSeconds);`
	`280`	`+ yield return new WaitForSeconds(processAfterStatusCheck.PollingIntervalSeconds);`
`275`	`281`	`}`
`276`	`282`	`}`
`277`	`283`
`278`	`284`	`public Guid StartRemoteSessionWithContinualPolling(`
`279`	`285`	`Action<LootLockerLeaseRemoteSessionResponse> remoteSessionLeaseInformation,`
`280`	`286`	`Action<LootLockerRemoteSessionStatusPollingResponse> remoteSessionLeaseStatusUpdateCallback,`
`281`		`- Action<LootLockerStartRemoteSessionResponse> remoteSessionCompleted)`
	`287`	`+ Action<LootLockerStartRemoteSessionResponse> remoteSessionCompleted,`
	`288`	`+ float pollingIntervalSeconds = 1.0f,`
	`289`	`+ float timeOutAfterMinutes = 5.0f)`
`282`	`290`	`{`
`283`	`291`	`if (_remoteSessionsProcesses.Count > 0)`
`284`	`292`	`{`
`@@ -292,7 +300,8 @@ public Guid StartRemoteSessionWithContinualPolling(`
`292`	`300`	`LootLockerRemoteSessionProcess lootLockerRemoteSessionProcess = new LootLockerRemoteSessionProcess()`
`293`	`301`	`{`
`294`	`302`	`LastUpdatedAt = DateTime.UtcNow,`
`295`		`- LeasingProcessTimeoutTime = DateTime.UtcNow.AddMinutes(_leasingProcessTimeoutLimitInMinutes),`
	`303`	`+ LeasingProcessTimeoutTime = DateTime.UtcNow.AddMinutes(timeOutAfterMinutes),`
	`304`	`+ PollingIntervalSeconds = pollingIntervalSeconds,`
`296`	`305`	`UpdateCallbackAction = remoteSessionLeaseStatusUpdateCallback,`
`297`	`306`	`ProcessCompletedCallbackAction = remoteSessionCompleted`
`298`	`307`	`};`
`@@ -310,6 +319,7 @@ public Guid StartRemoteSessionWithContinualPolling(`
`310`	`319`	`remoteSessionLeaseInformation?.Invoke(leaseRemoteSessionResponse);`
`311`	`320`	`return;`
`312`	`321`	`}`
	`322`	`+ remoteSessionLeaseInformation?.Invoke(leaseRemoteSessionResponse);`
`313`	`323`
`314`	`324`	`process.LeaseCode = leaseRemoteSessionResponse.code;`
`315`	`325`	`process.LeaseNonce = leaseRemoteSessionResponse.nonce;`
`@@ -365,7 +375,7 @@ private void StartRemoteSession(string leaseCode, string nonce, Action<LootLocke`
`365`	`375`	`CurrentPlatform.Set(Platforms.Remote);`
`366`	`376`	`LootLockerConfig.current.token = response.session_token;`
`367`	`377`	`LootLockerConfig.current.refreshToken = response.refresh_token;`
`368`		`- LootLockerConfig.current.deviceID = response.player_identifier;`
	`378`	`+ LootLockerConfig.current.deviceID = response.player_ulid;`
`369`	`379`	`}`
`370`	`380`
`371`	`381`	`onComplete?.Invoke(response);`