fix: Implement auto selection of client credentials when they are defined for the first time.

Author: paulhazen

Assets/Plugins/Source/Editor/ConfigEditors/IPlatformConfigEditor.cs

@@ -36,6 +36,8 @@ public interface IPlatformConfigEditor : IConfigEditor
         /// </returns>
         bool IsPlatformAvailable();
 
+        void SetClientCredentials(EOSClientCredentials credentials);
+        
         void SetDeployment(Deployment deployment);
 
         PlatformManager.Platform GetPlatform();

Assets/Plugins/Source/Editor/ConfigEditors/PlatformConfigEditor.cs

@@ -59,6 +59,11 @@ public void SetDeployment(Deployment deployment)
             config.deployment = deployment;
         }
 
+        public void SetClientCredentials(EOSClientCredentials credentials)
+        {
+            config.clientCredentials = credentials;
+        }
+
         public PlatformManager.Platform GetPlatform()
         {
             return config.Platform;

Assets/Plugins/Source/Editor/EditorWindows/EOSSettingsWindow.cs

@@ -96,16 +96,54 @@ public static void ShowWindow()
         protected override void OnEnable()
         {
             base.OnEnable();
-            ProductConfig.PlatformConfigsDeploymentUpdatedEvent += ReloadDeploymentSettingsForPlatformConfigEditors;
+            ProductConfig.DeploymentsUpdatedEvent += ReloadDeploymentSettingsForPlatformConfigEditors;
         }
 
         protected override void OnDestroy()
         {
-            ProductConfig.PlatformConfigsDeploymentUpdatedEvent -= ReloadDeploymentSettingsForPlatformConfigEditors;
+            ProductConfig.DeploymentsUpdatedEvent -= ReloadDeploymentSettingsForPlatformConfigEditors;
             base.OnDestroy();
         }
 
-        private void ReloadDeploymentSettingsForPlatformConfigEditors(object sender, ProductConfig.PlatformConfigsDeploymentUpdatedEventArgs e)
+        // TODO: Refactor to reduce massive overlap between this function and 
+        //       the older ReloadDeploymentSettingsForPlatformConfigEditors
+        //       function.
+        //       The Observable pattern would be appropriate - but 
+        //       such a change would constitute a not insignificant change, and
+        //       should be avoided until there is a time to properly review it.
+        private void ReloadClientCredentialsForPlatformConfigEditors(object sender,
+            ProductConfig.PlatformConfigsUpdatedEventArgs e)
+        {
+            // For each of the platform config editors
+            foreach (IPlatformConfigEditor platformConfigEditor in _platformConfigEditors)
+            {
+                // If the platform config was not one of the ones updated, then skip it.
+                if (!e.PlatformConfigsUpdated.Contains(platformConfigEditor.GetPlatform()))
+                {
+                    continue;
+                }
+
+                // If the platform config could not be read from disk
+                if (!PlatformManager.TryGetConfig(platformConfigEditor.GetPlatform(),
+                        out PlatformConfig platformConfigFromDisk))
+                {
+                    // TODO: Log warning?
+                    continue;
+                }
+
+                // Update the client credentials for the cached instance of the
+                // config within the PlatformConfigEditor.
+                platformConfigEditor.SetClientCredentials(platformConfigFromDisk.clientCredentials);
+            }
+        }
+
+        // TODO: Refactor to reduce massive overlap between this function and 
+        //       the more recently introduced
+        //       ReloadClientCredentialsForPlatformConfigEditors function.
+        //       The Observable pattern would be appropriate - but 
+        //       such a change would constitute a not insignificant change, and
+        //       should be avoided until there is a time to properly review it.
+        private void ReloadDeploymentSettingsForPlatformConfigEditors(object sender, ProductConfig.PlatformConfigsUpdatedEventArgs e)
         {
             // For each of the platform config editors
             foreach (IPlatformConfigEditor platformConfigEditor in _platformConfigEditors)

com.playeveryware.eos/Runtime/Core/Config/ProductConfig.cs

@@ -110,24 +110,37 @@ public class ProductConfig : Config
         [JsonIgnore]
         private bool _deploymentDefinedWhenLoaded;
 
+        /// <summary>
+        /// This field member is used to determine when client credentials are
+        /// first defined by the user. This determination is used to trigger the
+        /// process of setting the default deployment for the platforms.
+        /// </summary>
+        [JsonIgnore]
+        private bool _clientCredentialsDefinedWhenLoaded;
+
         /// <summary>
         /// Used to store information about what platform configs have been
         /// updated.
+        /// TODO: Implement via the Observable pattern instead.
         /// </summary>
-        public sealed class PlatformConfigsDeploymentUpdatedEventArgs : EventArgs
+        public sealed class PlatformConfigsUpdatedEventArgs : EventArgs
         {
             /// <summary>
             /// A list of all the platform configs that have been updated.
             /// </summary>
             public readonly IEnumerable<PlatformManager.Platform> PlatformConfigsUpdated;
 
-            public PlatformConfigsDeploymentUpdatedEventArgs(IEnumerable<PlatformManager.Platform> platformConfigsUpdated)
+            public PlatformConfigsUpdatedEventArgs(
+                IEnumerable<PlatformManager.Platform> platformConfigsUpdated)
             {
                 PlatformConfigsUpdated = platformConfigsUpdated;
             }
         }
 
-        public static event EventHandler<PlatformConfigsDeploymentUpdatedEventArgs> PlatformConfigsDeploymentUpdatedEvent;
+        public static event EventHandler<PlatformConfigsUpdatedEventArgs> DeploymentsUpdatedEvent;
+
+        public static event EventHandler<PlatformConfigsUpdatedEventArgs>
+            ClientCredentialsUpdatedEvent;
 
         static ProductConfig()
         {
@@ -147,6 +160,27 @@ protected override void OnReadCompleted()
             // out parameter is discarded because it is not needed at this 
             // juncture.
             _deploymentDefinedWhenLoaded = Environments.TryGetFirstDefinedNamedDeployment(out _);
+
+            // This tracks whether there is a single client credential
+            // completely defined when the product config is loaded. The out
+            // parameter is discarded because it is not needed at this juncture.
+            _clientCredentialsDefinedWhenLoaded = TryGetFirstCompleteNamedClientCredentials(out _);
+        }
+
+        public bool TryGetFirstCompleteNamedClientCredentials(out Named<EOSClientCredentials> credentials)
+        {
+            credentials = null;
+
+            foreach (var clientCredentials in Clients)
+            {
+                if (clientCredentials.Value.IsComplete)
+                {
+                    credentials = clientCredentials;
+                    break;
+                }
+            }
+
+            return (credentials != null);
         }
 
         // This compile conditional is here because the OnWriteCompleted method
@@ -165,15 +199,21 @@ protected override void BeforeWrite()
             }
         }
 
-        protected override void OnWriteCompleted()
+        // TODO: Refactor to reduce massive overlap between this function and
+        //       the more recently introduced
+        //       UpdatePlatformConfigClientCredentials function.
+        //       The Observable pattern would be appropriate - but such a change
+        //       would constitute a not insignificant refactor and should be
+        //       avoided until there is a time to properly review it.
+        private void UpdatePlatformConfigDeployments()
         {
             bool definedDeploymentExists =
                 Environments.TryGetFirstDefinedNamedDeployment(out Named<Deployment> deploymentToSetPlatformsTo);
 
             // If when the config was last read there was a deployment defined,
             // or there is not now one defined - then there is no need to try
             // and set the deployment values for each platform config.
-            if (_deploymentDefinedWhenLoaded || 
+            if (_deploymentDefinedWhenLoaded ||
                 !definedDeploymentExists)
             {
                 return;
@@ -217,8 +257,80 @@ protected override void OnWriteCompleted()
             // the event that indicates as much
             if (platformConfigsUpdated.Count > 0)
             {
-                PlatformConfigsDeploymentUpdatedEvent?.Invoke(this, new PlatformConfigsDeploymentUpdatedEventArgs(platformConfigsUpdated));
+                DeploymentsUpdatedEvent?.Invoke(this, new PlatformConfigsUpdatedEventArgs(platformConfigsUpdated));
+            }
+        }
+
+        // TODO: Refactor to reduce massive overlap between this function and
+        //       the older UpdatePlatformConfigDeployments function.
+        //       The Observable pattern would be appropriate - but such a change
+        //       would constitute a not insignificant refactor and should be
+        //       avoided until there is a time to properly review it.
+        private void UpdatePlatformConfigClientCredentials()
+        {
+            bool completeClientCredentialsExist =
+                TryGetFirstCompleteNamedClientCredentials(out Named<EOSClientCredentials> credentialsToSetPlatformsTo);
+
+            // If when the config was last read there was a set of client
+            // credentials already defined, or there is not now one defined -
+            // then there is no need to try and set the client credential values
+            // for each platform config.
+            if (_deploymentDefinedWhenLoaded ||
+                !completeClientCredentialsExist)
+            {
+                return;
             }
+
+            List<PlatformManager.Platform> platformConfigsUpdated = new();
+
+            // For each platform for which configuration can be done
+            foreach (var platform in PlatformManager.ConfigurablePlatforms)
+            {
+                // If the PlatformConfig could not be retrieved, continue to the
+                // next.
+                if (!PlatformManager.TryGetConfig(platform, out PlatformConfig config))
+                {
+                    continue;
+                }
+
+                // If the config already has a completely defined set of client
+                // credentials, then do not override, and move to the next
+                // platform config.
+                if (config.clientCredentials.IsComplete)
+                {
+                    continue;
+                }
+
+                // Add to the list of platform configs that have been updated
+                platformConfigsUpdated.Add(platform);
+
+                // Set the client credentials.
+                config.clientCredentials = credentialsToSetPlatformsTo.Value;
+
+                // Tell the user
+                Debug.Log($"Client credentials for platform " +
+                          $"\"{config.Platform}\" has been defaulted to " +
+                          $"{credentialsToSetPlatformsTo}.");
+
+                // Save the config
+                config.Write();
+            }
+
+            // If at least one platform config was updated as a result, trigger
+            // the event that indicates as much
+            if (platformConfigsUpdated.Count > 0)
+            {
+                ClientCredentialsUpdatedEvent?.Invoke(this, new PlatformConfigsUpdatedEventArgs(platformConfigsUpdated));
+            }
+        }
+
+        protected override void OnWriteCompleted()
+        {
+            // Update the platform config deployments if needed.
+            UpdatePlatformConfigDeployments();
+
+            // Update the platform config client credentials if needed.
+            UpdatePlatformConfigClientCredentials();
         }
 
 #endif