Introduce GameSwiftConfig and client auth secret

Author: patrykf-dev

Core/GameSwiftConfig.cs

@@ -0,0 +1,96 @@
+using UnityEngine;
+using System.IO;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace GameSwiftSDK.Core
+{
+    /// <summary>
+    /// Multiple account login attempts blocker configuration file.
+    /// </summary>
+    public class GameSwiftConfig : ScriptableObject
+    {
+        private const string DIRECTORY_IN_RESOURCES = "GameSwiftSDK";
+        private const string CONFIG_FILE_NAME = "GameSwiftConfig";
+
+        /// <summary>
+        /// Mandatory API authentication secret, distributed by GameSwift. Is is unique for every game using the SDK.
+        /// </summary>
+        [field: SerializeField]
+        private string ClientAuthenticationSecret { get; set; }
+
+        /// <summary>
+        /// Turns on/off multiple account login attempts blocker.
+        /// </summary>
+        [field: SerializeField]
+        public bool CheckMultipleLoginAttempts { get; private set; } = true;
+
+        /// <summary>
+        /// Time rate, measured in seconds, at which "GET /api/{idVersion}/oauth/me" call will be made to maintain multiple account login attempts lock.
+        /// </summary>
+        [field: SerializeField, Range(5, 500)]
+        public int BlockerHeartbeatRate { get; private set; } = 60;
+
+        private static GameSwiftConfig _instance;
+
+        public string GetClientAuthenticationSecret()
+        {
+            if (string.IsNullOrEmpty(ClientAuthenticationSecret))
+            {
+                Debug.LogError($"{nameof(ClientAuthenticationSecret)} is not filled! All sdk calls will fail!");
+            }
+
+            return ClientAuthenticationSecret;
+        }
+
+        public static GameSwiftConfig Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    var pathInResources = Path.Combine(DIRECTORY_IN_RESOURCES, CONFIG_FILE_NAME);
+                    _instance = Resources.Load<GameSwiftConfig>(pathInResources);
+                }
+
+                return _instance;
+            }
+        }
+
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+        private static void AttachAssetCheckToEditorUpdate()
+        {
+            EditorApplication.update += InitializeMultipleLoginsBlockerData;
+        }
+
+        private static void InitializeMultipleLoginsBlockerData()
+        {
+            var isRefreshing = EditorApplication.isCompiling || EditorApplication.isUpdating;
+            if (isRefreshing == false)
+            {
+                
+                EditorApplication.update -= InitializeMultipleLoginsBlockerData;
+                if (Instance == null)
+                {
+                    var createdConfig = CreateInstance<GameSwiftConfig>();
+
+                    var relativeResourcesPath = Path.Combine("Resources", DIRECTORY_IN_RESOURCES);
+                    Directory.CreateDirectory(Path.Combine(Application.dataPath, relativeResourcesPath));
+                    
+                    var resourcesPath = Path.Combine("Assets", relativeResourcesPath);
+                    var createdConfigPath = Path.Combine(resourcesPath, $"{CONFIG_FILE_NAME}.asset");
+                    AssetDatabase.CreateAsset(createdConfig, createdConfigPath);
+                    
+                    var oldAsset = Path.Combine(resourcesPath, "MultipleLoginsBlockerData.asset");
+                    AssetDatabase.DeleteAsset(oldAsset);
+                    
+                    AssetDatabase.SaveAssets();
+                    Debug.Log($"Config file created successfully at {createdConfigPath}.");
+                }
+            }
+        }
+#endif
+    }
+}

ID/LoginBlock/MultipleLoginsBlockerData.cs.meta renamed to Core/GameSwiftConfig.cs.meta

@@ -12,6 +12,8 @@ namespace GameSwiftSDK.Core
 	/// </summary>
 	public class GameSwiftSdkCore : MonoBehaviour
 	{
+		public const string GS_AUTH_HEADER = "gs-authentication";
+		
 		private static GameSwiftSdkCore _instance;
 
 		/// <summary>
@@ -23,14 +25,20 @@ public static GameSwiftSdkCore Instance
 			{
 				if (_instance == null)
 				{
-					var go = new GameObject("GameSwiftSDKCore");
-					_instance = go.AddComponent<GameSwiftSdkCore>();
-					DontDestroyOnLoad(go);
+					Instantiate();
 				}
 
 				return _instance;
 			}
 		}
+		
+		[RuntimeInitializeOnLoadMethod]
+		private static void Instantiate()
+		{
+			var go = new GameObject("GameSwiftSDKCore");
+			_instance = go.AddComponent<GameSwiftSdkCore>();
+			DontDestroyOnLoad(go);
+		}
 
 		/// <summary>
 		/// Sends a GET request.
@@ -100,6 +108,8 @@ private static void AddHeaders (UnityWebRequest request, RequestData data)
 			{
 				request.SetRequestHeader(header.Key, header.Value);
 			}
+			
+			request.SetRequestHeader(GS_AUTH_HEADER,  GameSwiftConfig.Instance.GetClientAuthenticationSecret());
 		}
 
 		/// <summary>

Core/GameSwiftSdkCore.cs

@@ -1,4 +1,4 @@
-using GameSwiftSDK.Id.LoginBlock;
+using GameSwiftSDK.Core;
 using UnityEngine;
 
 namespace GameSwiftSDK.Id
@@ -49,13 +49,15 @@ public static GameSwiftSdkId Instance
 
 		private bool _accessTokenRetrieved;
 
+		[RuntimeInitializeOnLoadMethod]
 		private static void Instantiate ()
 		{
-			_instance = Core.GameSwiftSdkCore.Instance.gameObject.AddComponent<GameSwiftSdkId>();
-
-			if (MultipleLoginsBlockerData.Instance.CheckMultipleLoginAttempts)
+			var parentObject = GameSwiftSdkCore.Instance.gameObject;
+			_instance = parentObject.AddComponent<GameSwiftSdkId>();
+			
+			if (GameSwiftConfig.Instance.CheckMultipleLoginAttempts)
 			{
-				Instance.MultipleLoginsBlocker = Instance.gameObject.AddComponent<MultipleLoginsBlocker>();
+				Instance.MultipleLoginsBlocker = parentObject.AddComponent<MultipleLoginsBlocker>();
 			}
 		}
 	}

ID/GameSwiftSdkId.cs

@@ -4,7 +4,7 @@
 using GameSwiftSDK.Id.Responses;
 using UnityEngine;
 
-namespace GameSwiftSDK.Id.LoginBlock
+namespace GameSwiftSDK.Id
 {
 	/// <summary>
 	/// Component used to prevent multiple account login attempts. If multiple logins blocker is turned on this component
@@ -34,7 +34,7 @@ private IEnumerator CheckForMultipleLoginAttempts ()
 		{
 			for (;;)
 			{
-				yield return new WaitForSeconds(MultipleLoginsBlockerData.Instance.BlockerHeartbeatRate);
+				yield return new WaitForSeconds(GameSwiftConfig.Instance.BlockerHeartbeatRate);
 				SendBlockerHeartbeat();
 			}
 		}

ID/LoginBlock.meta

@@ -1,6 +1,6 @@
 {
     "name": "com.gameswift.sdk",
-    "version": "1.1.2",
+    "version": "2.0.0",
     "displayName": "GameSwiftSDK",
     "description": "Unity package making it easy to connect with GameSwift ecosystem via GameSwift ID.",
 	"documentationUrl": "https://docs.gameswift.io/gameswift-products/sdk",

ID/LoginBlock/MultipleLoginsBlockerData.cs

@@ -8,6 +8,8 @@ In order to integrate your Unity game with GameSwift gaming ecosystem, [import](
 https://github.com/GameSwift/gameswift-unity-sdk.git
 ```
 
+After successful import, fill `ClientAuthenticationSecret` field in `Assets/Resources/GameSwiftSDK/GameSwiftConfig.asset`. It is a mandatory api authentication token, which is unique for every game using the SDK. These secrets are [distributed by GameSwift](#contact-us).
+
 You can handle GameSwift login in 2 ways: [with launcher](#logging-in-from-launcher) or [without launcher](#logging-in-without-launcher). You can download GameSwift launcher [here](https://launcher.gameswift.io/).
 As long as your game targets Windows or MacOS, we strongly recommend to use data passed from our launcher. By doing so, you won't need to implement any login screen for your game as launcher already handles user credentials in a secure way.
 If you are building for mobile or web, you will need to create a login screen and implement connection with GameSwift backend manually.
@@ -122,7 +124,7 @@ Though we highly recommend using the above method, if you want to implement some
 
 ### Multiple Logins Blocker
 You need to have your client set up to block multiple login attempts for this component to work.
-To configure `Multiple Logins Blocker` you need to edit `MultipleLoginsBlockerData.asset` scriptable object which should be automatically created on Unity asset refresh in the `Assets/Resources/GameSwiftSDK/` directory.
+To configure `Multiple Logins Blocker` you need to edit `GameSwiftConfig.asset` scriptable object which should be automatically created with package import in the `Assets/Resources/GameSwiftSDK/` directory.
 When SDK instance in created this component will start working automatically in the background (if is turned on in the config file). Every specified number of seconds it will be sending hearbeats do the server to keep the lock.
 If you don't use our recommended login approaches, remember to call `GameSwiftSdkId.GetOauthUserInformation` method as the last step of login process. This will be your first sent heartbeat and will initialize the process.