+version 0.1.1

Author: HanzaRu

.icon.png

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2015, Unity Technologies
+
+Copyright (c) 2020 Game Workstore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.md

@@ -0,0 +1,33 @@
+# Async Network Engine
+
+Unity http requests made easy to interoperability with Go Lang + Google Protobuf functions!
+
+Supported Cloud Functions:
+- Google Cloud Functions
+- Amazon Web Services Lambdas
+
+Use at your own risk!
+
+# How to install
+
+At package.json, add these 3 lines of code:
+```json
+"com.gameworkstore.asyncnetworkengine": "git://github.com/GameWorkstore/async-network-engine.git",
+"com.gameworkstore.googleprotobufunity": "git://github.com/GameWorkstore/google-protobuf-unity.git",
+"com.gameworkstore.patterns": "git://github.com/GameWorkstore/patterns.git"
+```
+
+And wait for unity to download and compile the package.
+
+for update package for a newer version, install UpmGitExtension and update on [ Window > Package Manager ]!
+> https://github.com/mob-sakai/UpmGitExtension
+
+# Contributions
+
+If you are using this library and want to submit a change, go ahead! Overall, this project accepts contributions if:
+- Is a bug fix;
+- Or, is a generalization of a well-known issue;
+- Or is performance improvement;
+- Or is an improvement to already supported feature.
+
+Also, you can donate to allow us to drink coffee while we improve it for you!

LICENSE.md.meta

@@ -0,0 +1,121 @@
+using Google.Protobuf;
+using GameWorkstore.Patterns;
+using System;
+using System.Collections;
+using System.Text;
+using UnityEngine.Networking;
+
+namespace GameWorkstore.AsyncNetworkEngine
+{
+    public enum AsyncNetworkResult
+    {
+        SUCCESS,
+        E_NETWORK,
+        E_PROCESS,
+        E_DATA_NULL,
+        E_DATA_EMPTY,
+        E_PARSER
+    }
+
+    public enum AsyncNetworkEngineCloud
+    {
+        GCP = 0,
+        AWS = 1
+    }
+
+    /// <summary>
+    /// Implements a UnityRequest for google protobuf web functions.
+    /// </summary>
+    /// <typeparam name="TR">Request</typeparam>
+    /// <typeparam name="TU">Response</typeparam>
+    public static class AsyncNetworkEngine<TR, TU>
+        where TR : IMessage<TR>, new()
+        where TU : IMessage<TU>, new()
+    {
+        public static AsyncNetworkEngineCloud Cloud = AsyncNetworkEngineCloud.AWS;
+        private static readonly MessageParser<TU> _tuParser = new MessageParser<TU>(() => new TU());
+        private static readonly MessageParser<GenericErrorResponse> _tvParser = new MessageParser<GenericErrorResponse>(() => new GenericErrorResponse());
+        private static EventService _eventService = null;
+
+        public static void Send(string uri, TR request, Action<AsyncNetworkResult, TU, GenericErrorResponse> result)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(uri, request, result));
+        }
+
+        public static IEnumerator SendRequest(string uri, TR request, Action<AsyncNetworkResult, TU, GenericErrorResponse> result)
+        {
+            //Notice: APIGateway automatically converts binary data into base64 strings
+            using var rqt = new UnityWebRequest(uri, "POST")
+            {
+                uploadHandler = new UploadHandlerRaw(request.ToByteArray()),
+                downloadHandler = new DownloadHandlerBuffer()
+            };
+            yield return rqt.SendWebRequest();
+
+            switch (rqt.result)
+            {
+                case UnityWebRequest.Result.ConnectionError:
+                    Return(AsyncNetworkResult.E_NETWORK, result);
+                    break;
+                case UnityWebRequest.Result.ProtocolError:
+                    while (!rqt.downloadHandler.isDone) yield return null;
+                    if (rqt.downloadHandler.data == null) { Return(AsyncNetworkResult.E_DATA_NULL, result); yield break; }
+                    if (rqt.downloadHandler.data.Length <= 0) { Return(AsyncNetworkResult.E_DATA_EMPTY, result); yield break; }
+                    try
+                    {
+                        if (Cloud == AsyncNetworkEngineCloud.AWS)
+                        {
+                            var data = Base64Url.Decode(Encoding.ASCII.GetString(rqt.downloadHandler.data));
+                            var error = _tvParser.ParseFrom(data);
+                            Return(AsyncNetworkResult.E_PROCESS, default, error, result);
+                        }
+                        else
+                        {
+                            var error = _tvParser.ParseFrom(rqt.downloadHandler.data);
+                            Return(AsyncNetworkResult.E_PROCESS, default, error, result);
+                        }
+                    }
+                    catch
+                    {
+                        Return(AsyncNetworkResult.E_PROCESS, result);
+                    }
+                    break;
+                case UnityWebRequest.Result.Success:
+                    while (!rqt.downloadHandler.isDone) yield return null;
+                    if (rqt.downloadHandler.data == null) { Return(AsyncNetworkResult.E_DATA_NULL, result); yield break; }
+                    if (rqt.downloadHandler.data.Length <= 0) { Return(AsyncNetworkResult.E_DATA_EMPTY, result); yield break; }
+                    try
+                    {
+                        if (Cloud == AsyncNetworkEngineCloud.AWS)
+                        {
+                            var data = Base64Url.Decode(Encoding.ASCII.GetString(rqt.downloadHandler.data));
+                            var packet = _tuParser.ParseFrom(data);
+                            Return(AsyncNetworkResult.SUCCESS, packet, default, result);
+                        }
+                        else
+                        {
+                            var packet = _tuParser.ParseFrom(rqt.downloadHandler.data);
+                            Return(AsyncNetworkResult.SUCCESS, packet, default, result);
+                        }
+                    }
+                    catch
+                    {
+                        Return(AsyncNetworkResult.E_PARSER, result);
+                    }
+                    break;
+            }
+        }
+
+        private static void Return(AsyncNetworkResult result, Action<AsyncNetworkResult, TU, GenericErrorResponse> callback)
+        {
+            Return(result, default, default, callback);
+        }
+
+        private static void Return(AsyncNetworkResult result, TU data, GenericErrorResponse error, Action<AsyncNetworkResult, TU, GenericErrorResponse> callback)
+        {
+            if (callback == null) return;
+            _eventService.QueueAction(() => callback.Invoke(result, data, error));
+        }
+    }
+}

README.md

@@ -0,0 +1,42 @@
+using System;
+
+namespace GameWorkstore.AsyncNetworkEngine
+{
+
+    public static class Base64Url
+    {
+        public static string Encode(byte[] input)
+        {
+            var output = Convert.ToBase64String(input);
+            output = output.Replace('+', '-'); // 62nd char of encoding
+            output = output.Replace('/', '_'); // 63rd char of encoding
+            output = output.Split('=')[0]; // Remove any trailing '='s
+
+            return output;
+        }
+
+        public static byte[] Decode(string input)
+        {
+            var output = input;
+
+            output = output.Replace('-', '+'); // 62nd char of encoding
+            output = output.Replace('_', '/'); // 63rd char of encoding
+
+            switch (output.Length % 4) // Pad with trailing '='s
+            {
+                case 0:
+                    break; // No pad chars in this case
+                case 2:
+                    output += "==";
+                    break; // Two pad chars
+                case 3:
+                    output += "=";
+                    break; // One pad char
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(input), "Illegal base64url string!");
+            }
+
+            return Convert.FromBase64String(output);
+        }
+    }
+}