com.beanbag.huaweiads 0.0.1

package/Editor/Editor/Utils/HMSPluginUpdater.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections;
+using System.IO;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace HmsPlugin
+{
+    internal class HMSPluginUpdater
+    {
+        public static string sessionState = "hms_checked_update";
+
+        static HMSPluginUpdateRequest request;
+        
+        static bool ignorePlatform
+        {
+            get
+            {
+#if UNITY_SWITCH || UNITY_GAMECORE || UNITY_PS4 || UNITY_PS5
+                return true;
+#else
+                return false;
+#endif
+            }
+        }
+
+        internal static void Request(bool ignoreSession = false)
+        {
+            if (ignorePlatform)
+            {
+                return;
+            }
+            
+            if (!ignoreSession && SessionState.GetBool(sessionState, false))
+            {
+                return;
+            }
+
+            SessionState.SetBool(sessionState, true);
+            HMSEditorUtils.UpdateAssemblyDefinitions(HMSPluginSettings.Instance.Settings.GetBool(PluginToggleEditor.PluginEnabled, true));
+
+            Task.Delay(2000).ContinueWith(t => StartUpdateRequest(ignoreSession), TaskScheduler.FromCurrentSynchronizationContext());
+        }
+
+        private static void StartUpdateRequest(bool ignoreSession)
+        {
+            var obj = new GameObject("HMSPluginUpdateRequest")
+            {
+                hideFlags = HideFlags.HideAndDontSave
+            };
+
+            request = obj.AddComponent<HMSPluginUpdateRequest>();
+            request.StartRequest(ignoreSession);
+        }
+    }
+
+    public class HMSPluginUpdateRequest : MonoBehaviour
+    {
+        public static string sessionStatePersisted = "hms_checked_update_persisted";
+
+        private IEnumerator coroutine;
+
+        public void StartRequest(bool ignoreSession = false)
+        {
+            coroutine = FetchLatestVersion(ignoreSession);
+            StartCoroutine(coroutine);
+        }
+
+        private IEnumerator FetchLatestVersion(bool ignoreSession)
+        {
+            var request = UnityWebRequest.Get("https://api.github.com/repos/EvilMindDevs/hms-unity-plugin/tags");
+            yield return request.SendWebRequest();
+
+#if UNITY_2020_1_OR_NEWER
+            var requestError =
+               request.result == UnityWebRequest.Result.ProtocolError ||
+               request.result == UnityWebRequest.Result.ConnectionError;
+#else
+            bool requestError =
+               request.isNetworkError ||
+               request.isHttpError;
+#endif
+
+            if (requestError)
+            {
+                if (request.error == null)
+                {
+                    Debug.LogError("HMS Plugin Update Checker encountered an unknown error");
+                }
+                else
+                {
+                    Debug.LogError("HMS Plugin Update Checker encountered an error: " + request.error);
+                }
+                DestroyImmediate(gameObject);
+                yield break;
+            }
+
+            var json = JsonUtility.FromJson<TagList>("{\"tags\":" + request.downloadHandler.text + "}");
+            string latestVersionString = FindTheLatestVersion(json);
+            string currentVersionString = File.ReadAllText(Application.dataPath + "/Huawei/VERSION");
+
+            long latestVersion = ConvertVersionToLong(latestVersionString);
+            long currentVersion = ConvertVersionToLong(currentVersionString);
+
+            if (latestVersion > currentVersion)
+            {
+                string updateMessage = $"A new version of the HMS Unity Plugin ({latestVersionString}) is available. You are currently using {currentVersionString}";
+                Debug.LogWarning($"{updateMessage}\nYou can check releases page of our github. https://github.com/EvilMindDevs/hms-unity-plugin/releases");
+
+                if (!ignoreSession)
+                {
+                    if (SessionState.GetBool(sessionStatePersisted, false)) yield return null;
+                    SessionState.SetBool(sessionStatePersisted, true);
+                    if (!EditorPrefs.GetBool($"{sessionStatePersisted}{latestVersionString}", false))
+                        DisplayDialog(latestVersionString, updateMessage);
+                }
+                else
+                {
+                    DisplayDialog(latestVersionString, updateMessage);
+                }
+            }
+            else if (ignoreSession)
+            {
+                EditorUtility.DisplayDialog("HMS Unity Plugin", "Your version is up to date", "Ok");
+            }
+
+
+            DestroyImmediate(gameObject);
+        }
+
+        private string FindTheLatestVersion(TagList list)
+        {
+            string latestVersion = "0.0.0";
+
+            foreach (var tag in list.tags)
+            {
+                string tempVer = tag.name.RemoveAfter('-').Replace("v", "");
+
+                if (ConvertVersionToLong(latestVersion) < ConvertVersionToLong(tempVer))
+                {
+                    latestVersion = tempVer;
+                }
+            }
+
+            return latestVersion;
+        }
+
+        // Helper method to convert version string to long
+        private long ConvertVersionToLong(string versionString)
+        {
+            if (long.TryParse(versionString.Replace(".", "0").PadRight(8, '0'), out long version))
+            {
+                return version;
+            }
+            else
+            {
+                // Handle the case where the version string could not be parsed to a long
+                // This could be setting a default value, logging an error, etc.
+                return 0;
+            }
+        }
+
+        private static void DisplayDialog(string latestVersionString, string updateMessage)
+        {
+            int option = EditorUtility.DisplayDialogComplex("HMS Unity Plugin Update available", updateMessage + ". Do you want to download the new version ?", "Don't Remind", "No", "Yes");
+            switch (option)
+            {
+                case 0:
+                    EditorPrefs.SetBool(sessionStatePersisted + latestVersionString, true);
+                    break;
+                case 1:
+                    // No action needed
+                    break;
+                case 2:
+                    Application.OpenURL("https://github.com/EvilMindDevs/hms-unity-plugin/releases");
+                    break;
+                default:
+                    // All cases are handled
+                    break;
+            }
+        }
+
+        [Serializable]
+        private class Commit
+        {
+            public string sha;
+            public string url;
+        }
+
+        [Serializable]
+        private class Tag
+        {
+            public string name;
+            public string zipball_url;
+            public string tarball_url;
+            public Commit commit;
+            public string node_id;
+        }
+
+        [Serializable]
+        private class TagList
+        {
+            public Tag[] tags;
+        }
+    }
+}

package/Editor/Editor/Utils/HMSPluginUpdater.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 470802db5c993e94582a0910e14daf32
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Editor/Utils/HMSPluginUpdaterInit.cs

@@ -0,0 +1,20 @@
+#if UNITY_EDITOR
+using UnityEditor;
+namespace HmsPlugin
+{
+    [InitializeOnLoad]
+    public class HMSPluginUpdaterInit : AssetPostprocessor
+    {
+        static HMSPluginUpdaterInit()
+        {
+            EditorApplication.delayCall += () =>
+            {
+                EditorApplication.delayCall += () =>
+                {
+                    EditorApplication.delayCall += () => HMSPluginUpdater.Request();
+                };
+            };
+        }
+    }
+}
+#endif

package/Editor/Editor/Utils/HMSPluginUpdaterInit.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e4322d6b07915a48ab9f020f3b6cbb3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Editor/Utils/HMSWebRequestHelper.cs

@@ -0,0 +1,388 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace HmsPlugin
+{
+    internal class HMSWebRequestHelper
+    {
+        private static HMSWebRequestHelper _instance;
+        public static HMSWebRequestHelper Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new HMSWebRequestHelper();
+                }
+                if (persistedObj == null || behavior == null)
+                {
+                    _instance.CheckPersistency();
+                }
+
+                return _instance;
+            }
+        }
+
+        private static GameObject persistedObj;
+        private static HMSWebRequestBehaviour behavior;
+
+        public void CheckPersistency()
+        {
+            var objs = GameObject.FindObjectsOfType<HMSWebRequestBehaviour>();
+            if (objs != null && objs.Any())
+            {
+                foreach (var item in objs)
+                {
+                    UnityEngine.Object.DestroyImmediate(item.gameObject);
+                }
+            }
+            persistedObj = new GameObject("[HMSWebRequestHelper]");
+            persistedObj.hideFlags = HideFlags.HideAndDontSave;
+            behavior = persistedObj.AddComponent<HMSWebRequestBehaviour>();
+        }
+
+        internal void PostRequest(string url, string bodyJsonString, Action<UnityWebRequest> callback)
+        {
+            behavior.Post(url, bodyJsonString, callback);
+        }
+
+        internal async Task<UnityWebRequest> PostRequest(string url, string bodyJsonString)
+        {
+            return await behavior.PostAsync(url, bodyJsonString);
+        }
+
+        internal void PostRequest(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            behavior.Post(url, bodyJsonString, requestHeaders, callback);
+        }
+
+        internal void GetRequest(string url, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            behavior.Get(url, requestHeaders, callback);
+        }
+        internal void PostFormRequest(string url, MultipartFormFileSection file, string authCode, string fileCount, string parseType, Action<UnityWebRequest> callback, string progressBarTitle = null, string progressBarDesc = null)
+        {
+            behavior.PostFormData(url, file, authCode, fileCount, parseType, callback, progressBarTitle, progressBarDesc);
+        }
+        internal void PutRequest(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            behavior.Put(url, bodyJsonString, requestHeaders, callback);
+        }
+
+        internal void GetFile(string url, string path, Action<bool> result = null)
+        {
+            behavior.GetFile(url, path, result);
+        }
+    }
+
+    public class HMSWebRequestBehaviour : MonoBehaviour
+    {
+        public void Post(string url, string bodyJsonString, Action<UnityWebRequest> callback)
+        {
+            StartCoroutine(PostCoroutine(url, bodyJsonString, callback));
+        }
+
+        public void Get(string url, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            StartCoroutine(GetCoroutine(url, requestHeaders, callback));
+        }
+
+        public void Post(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            StartCoroutine(PostCoroutine(url, bodyJsonString, requestHeaders, callback));
+        }
+
+        public void Put(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            StartCoroutine(PutCoroutine(url, bodyJsonString, requestHeaders, callback));
+        }
+
+        public void PostFormData(string url, MultipartFormFileSection file, string authCode, string fileCount, string parseType, Action<UnityWebRequest> callback, string progressBarTitle = null, string progressBarDesc = null)
+        {
+            StartCoroutine(PostFormDataCoroutine(url, file, authCode, fileCount, parseType, callback, progressBarTitle, progressBarDesc));
+        }
+
+        public void GetFile(string url, string path, Action<bool> result = null)
+        {
+            StartCoroutine(GetFileCoroutine(url, path, result));
+        }
+
+        public async Task<UnityWebRequest> PostAsync(string url, string bodyJsonString)
+        {
+            return await PostAsync(url, bodyJsonString, null);
+        }
+
+        public async Task<UnityWebRequest> PostAsync(string url, string bodyJsonString, Dictionary<string, string> requestHeaders)
+        {
+            UnityWebRequest request = new UnityWebRequest(url, "POST");
+            byte[] bodyRaw = Encoding.UTF8.GetBytes(bodyJsonString);
+            request.uploadHandler = (UploadHandler)new UploadHandlerRaw(bodyRaw);
+            request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
+            request.SetRequestHeader("Content-Type", "application/json");
+            if (requestHeaders != null)
+            {
+                foreach (var item in requestHeaders)
+                {
+                    request.SetRequestHeader(item.Key, item.Value);
+                }
+            }
+            var asyncOp = request.SendWebRequest();
+            while (true)
+            {
+                if (asyncOp.progress == 1)
+                    break;
+            }
+            return request;
+        }
+
+        public async Task<UnityWebRequest> PutAsync(string url, string bodyJsonString, Dictionary<string, string> requestHeaders)
+        {
+            UnityWebRequest request = new UnityWebRequest(url, "PUT");
+            byte[] bodyRaw = Encoding.UTF8.GetBytes(bodyJsonString);
+            request.uploadHandler = (UploadHandler)new UploadHandlerRaw(bodyRaw);
+            request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
+            request.SetRequestHeader("Content-Type", "application/json");
+            if (requestHeaders != null)
+            {
+                foreach (var item in requestHeaders)
+                {
+                    request.SetRequestHeader(item.Key, item.Value);
+                }
+            }
+            var asyncOp = request.SendWebRequest();
+            while (true)
+            {
+                if (asyncOp.progress == 1)
+                    break;
+            }
+            return request;
+        }
+
+        private IEnumerator PostCoroutine(string url, string bodyJsonString, Action<UnityWebRequest> callback)
+        {
+            yield return PostCoroutine(url, bodyJsonString, null, callback);
+        }
+
+        private IEnumerator PostFormDataCoroutine(string url, MultipartFormFileSection file, string authCode, string fileCount, string parseType, Action<UnityWebRequest> callback, string progressBarTitle = null, string progressBarDesc = null)
+        {
+            var formData = new List<IMultipartFormSection>
+            {
+                new MultipartFormDataSection("authCode", authCode),
+                new MultipartFormDataSection("fileCount", fileCount),
+                new MultipartFormDataSection("parseType", parseType),
+                file
+            };
+
+            UnityWebRequest request = UnityWebRequest.Post(url, formData);
+            var asyncOp = request.SendWebRequest();
+            if (progressBarTitle != null && progressBarDesc != null)
+            {
+                while (!asyncOp.isDone)
+                {
+                    EditorUtility.DisplayProgressBar(progressBarTitle, progressBarDesc, asyncOp.progress);
+                    yield return null;
+                }
+            }
+            else
+            {
+                yield return asyncOp;
+            }
+
+#if UNITY_2020_1_OR_NEWER
+            var requestError =
+               request.result == UnityWebRequest.Result.ProtocolError ||
+               request.result == UnityWebRequest.Result.ConnectionError;
+#else
+            bool requestError =
+               request.isNetworkError ||
+               request.isHttpError;
+#endif
+
+            if (requestError)
+            {
+                if (request.error == null)
+                {
+                    Debug.LogError("HMSWebRequestHelper encountered an unknown error");
+                }
+                else
+                {
+                    Debug.LogError("HMSWebRequestHelper encountered an error: " + request.error);
+                }
+                yield break;
+            }
+
+            callback(request);
+        }
+
+        private IEnumerator PostCoroutine(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
+            {
+                byte[] bodyRaw = Encoding.UTF8.GetBytes(bodyJsonString);
+                request.uploadHandler = (UploadHandler)new UploadHandlerRaw(bodyRaw);
+                request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
+                request.SetRequestHeader("Content-Type", "application/json");
+                if (requestHeaders != null)
+                {
+                    foreach (var item in requestHeaders)
+                    {
+                        request.SetRequestHeader(item.Key, item.Value);
+                    }
+                }
+                yield return request.SendWebRequest();
+
+#if UNITY_2020_1_OR_NEWER
+                var requestError =
+                   request.result == UnityWebRequest.Result.ProtocolError ||
+                   request.result == UnityWebRequest.Result.ConnectionError;
+#else
+                bool requestError =
+                   request.isNetworkError ||
+                   request.isHttpError;
+#endif
+
+                if (requestError)
+                {
+                    if (request.error == null)
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an unknown error");
+                    }
+                    else
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an error: " + request.error);
+                    }
+                    yield break;
+                }
+
+                callback(request);
+            }
+        }
+
+        private IEnumerator PutCoroutine(string url, string bodyJsonString, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            using (UnityWebRequest request = new UnityWebRequest(url, "PUT"))
+            {
+                byte[] bodyRaw = Encoding.UTF8.GetBytes(bodyJsonString);
+                request.uploadHandler = (UploadHandler)new UploadHandlerRaw(bodyRaw);
+                request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
+                request.SetRequestHeader("Content-Type", "application/json");
+                if (requestHeaders != null)
+                {
+                    foreach (var item in requestHeaders)
+                    {
+                        request.SetRequestHeader(item.Key, item.Value);
+                    }
+                }
+                yield return request.SendWebRequest();
+
+#if UNITY_2020_1_OR_NEWER
+                var requestError =
+                   request.result == UnityWebRequest.Result.ProtocolError ||
+                   request.result == UnityWebRequest.Result.ConnectionError;
+#else
+                bool requestError =
+                   request.isNetworkError ||
+                   request.isHttpError;
+#endif
+
+                if (requestError)
+                {
+                    if (request.error == null)
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an unknown error");
+                    }
+                    else
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an error: " + request.error);
+                    }
+                    yield break;
+                }
+
+                callback(request);
+            }
+        }
+
+        private IEnumerator GetCoroutine(string url, Dictionary<string, string> requestHeaders, Action<UnityWebRequest> callback)
+        {
+            using (UnityWebRequest request = new UnityWebRequest(url, "GET"))
+            {
+                request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
+                request.SetRequestHeader("Content-Type", "application/json");
+                if (requestHeaders != null)
+                {
+                    foreach (var item in requestHeaders)
+                    {
+                        request.SetRequestHeader(item.Key, item.Value);
+                    }
+                }
+                yield return request.SendWebRequest();
+
+#if UNITY_2020_1_OR_NEWER
+                var requestError =
+                   request.result == UnityWebRequest.Result.ProtocolError ||
+                   request.result == UnityWebRequest.Result.ConnectionError;
+#else
+                bool requestError =
+                   request.isNetworkError ||
+                   request.isHttpError;
+#endif
+
+                if (requestError)
+                {
+                    if (request.error == null)
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an unknown error");
+                    }
+                    else
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an error: " + request.error);
+                    }
+                    yield break;
+                }
+
+                callback(request);
+            }
+        }
+
+        private IEnumerator GetFileCoroutine(string url, string path, Action<bool> result = null)
+        {
+            using (UnityWebRequest request = new UnityWebRequest(url, "GET"))
+            {
+                request.downloadHandler = new DownloadHandlerFile(path, true);
+                yield return request.SendWebRequest();
+
+#if UNITY_2020_1_OR_NEWER
+                var requestError =
+                   request.result == UnityWebRequest.Result.ProtocolError ||
+                   request.result == UnityWebRequest.Result.ConnectionError;
+#else
+                bool requestError =
+                   request.isNetworkError ||
+                   request.isHttpError;
+#endif
+
+                if (requestError)
+                {
+                    if (request.error == null)
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an unknown error");
+                    }
+                    else
+                    {
+                        Debug.LogError("HMSWebRequestHelper encountered an error: " + request.error);
+                    }
+                    result?.Invoke(false);
+                    yield break;
+                }
+                result?.Invoke(true);
+            }
+        }
+    }
+}

package/Editor/Editor/Utils/HMSWebRequestHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5dd11ede01a6b5345a1a66034b650ad1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: