com.taptap.sdk.core 4.3.0-aplha.5

package/Mobile/Runtime/BridgeAndroid.cs

@@ -0,0 +1,73 @@
+using System;
+using UnityEngine;
+
+namespace TapSDK.Core
+{
+    public class BridgeAndroid : IBridge
+    {
+        private string bridgeJavaClz = "com.taptap.sdk.kit.internal.enginebridge.EngineBridge";
+
+        private string instanceField = "INSTANCE";
+
+        private string registerHandlerMethod = "registerHandler";
+
+        private string callHandlerMethod = "execCommand";
+
+        private string callHandlerAsyncMethod = "execCommandAsync";
+
+        private string initMethod = "init";
+
+        private string registerMethod = "registerService";
+
+        private readonly AndroidJavaObject _mAndroidBridge;
+
+        private static readonly BridgeAndroid SInstance = new BridgeAndroid();
+
+        public static BridgeAndroid GetInstance()
+        {
+            return SInstance;
+        }
+
+        private BridgeAndroid()
+        {
+            var mCurrentActivity =
+                new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity");
+            _mAndroidBridge = new AndroidJavaClass(bridgeJavaClz).GetStatic<AndroidJavaObject>(instanceField);
+            _mAndroidBridge.Call(initMethod, mCurrentActivity);
+        }
+
+        public void Register(string serviceClzName, string serviceImplName)
+        {
+            if (_mAndroidBridge == null)
+            {
+                return;
+            }
+
+            try
+            {
+                var serviceClass = new AndroidJavaClass(serviceClzName);
+                var serviceImpl = new AndroidJavaObject(serviceImplName);
+                _mAndroidBridge.Call(registerMethod, serviceClass, serviceImpl);
+            }
+            catch (Exception e)
+            {
+                Debug.Log("register Failed:" + e);
+                //
+            }
+        }
+
+        public void Call(Command command, Action<Result> action)
+        {
+            _mAndroidBridge?.Call(callHandlerMethod, command.ToJSON(), new BridgeCallback(action));
+        }
+
+        public void Call(Command command)
+        {
+            _mAndroidBridge?.Call(callHandlerMethod, command.ToJSON(), null);
+        }
+        public string CallWithReturnValue(Command command, Action<Result> action)
+        {
+            return _mAndroidBridge?.Call<string>(callHandlerAsyncMethod, command.ToJSON());
+        }
+    }
+}

package/Mobile/Runtime/BridgeAndroid.cs.meta

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

package/Mobile/Runtime/BridgeCallback.cs

@@ -0,0 +1,35 @@
+using System;
+using UnityEngine;
+using System.Threading;
+using TapSDK.Core.Internal.Utils;
+
+namespace TapSDK.Core
+{
+
+    public class BridgeCallback : AndroidJavaProxy
+    {
+        Action<Result> callback;
+
+        public BridgeCallback(Action<Result> action) :
+            base(new AndroidJavaClass("com.taptap.sdk.kit.internal.enginebridge.EngineBridgeCallback"))
+        {
+            this.callback = action;
+        }
+
+        public override AndroidJavaObject Invoke(string method, object[] args)
+        {
+            if (method.Equals("onResult"))
+            {
+                if (args[0] is string)
+                {
+                    string result = (string)(args[0]);
+                    TapLoom.QueueOnMainThread(() =>
+                    {
+                        callback(new Result(result));
+                    });
+                }
+            }
+            return null;
+        }
+    }
+}

package/Mobile/Runtime/BridgeCallback.cs.meta

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

package/Mobile/Runtime/BridgeIOS.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Concurrent;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace TapSDK.Core
+{
+    public class BridgeIOS : IBridge
+    {
+        private static readonly BridgeIOS SInstance = new BridgeIOS();
+
+        private readonly ConcurrentDictionary<string, Action<Result>> dic;
+
+        public static BridgeIOS GetInstance()
+        {
+            return SInstance;
+        }
+
+        private BridgeIOS()
+        {
+            dic = new ConcurrentDictionary<string, Action<Result>>();
+        }
+
+        private ConcurrentDictionary<string, Action<Result>> GetConcurrentDictionary()
+        {
+            return dic;
+        }
+
+        private delegate void EngineBridgeDelegate(string result);
+
+        [AOT.MonoPInvokeCallbackAttribute(typeof(EngineBridgeDelegate))]
+        static void engineBridgeDelegate(string resultJson)
+        {
+            var result = new Result(resultJson);
+
+            var actionDic = GetInstance().GetConcurrentDictionary();
+
+            Action<Result> action = null;
+
+            if (actionDic != null && actionDic.ContainsKey(result.callbackId))
+            {
+                action = actionDic[result.callbackId];
+            }
+
+            if (action != null)
+            {
+                action(result);
+                if (result.onceTime && BridgeIOS.GetInstance().GetConcurrentDictionary()
+                    .TryRemove(result.callbackId, out Action<Result> outAction))
+                {
+                    Debug.Log($"TapSDK resolved current Action:{result.callbackId}");
+                }
+            }
+
+            Debug.Log($"TapSDK iOS BridgeAction last Count:{BridgeIOS.GetInstance().GetConcurrentDictionary().Count}");
+        }
+        
+        
+
+        public void Register(string serviceClz, string serviceImp)
+        {
+            //IOS无需注册
+        }
+
+        public void Call(Command command)
+        {
+#if UNITY_IOS
+            callHandler(command.ToJSON());
+#endif
+        }
+
+        public void Call(Command command, Action<Result> action)
+        {
+            if (!command.withCallback || string.IsNullOrEmpty(command.callbackId)) return;
+            if (!dic.ContainsKey(command.callbackId))
+            {
+                dic.GetOrAdd(command.callbackId, action);
+            }
+#if UNITY_IOS
+            registerHandler(command.ToJSON(), engineBridgeDelegate);
+#endif
+        }
+
+        public string CallWithReturnValue(Command command, Action<Result> action)
+        {
+            if (command.callbackId != null && !dic.ContainsKey(command.callbackId))
+            {
+                dic.GetOrAdd(command.callbackId, action);
+            }
+#if UNITY_IOS
+            if (action == null)
+            {
+                return callWithReturnValue(command.ToJSON(), null);
+            } else {
+                return callWithReturnValue(command.ToJSON(), engineBridgeDelegate);
+            }
+#else
+            return null;
+#endif
+        }
+
+#if UNITY_IOS
+        [DllImport("__Internal")]
+        private static extern string callWithReturnValue(string command, EngineBridgeDelegate engineBridgeDelegate);
+
+        [DllImport("__Internal")]
+        private static extern void callHandler(string command);
+
+        [DllImport("__Internal")]
+        private static extern void registerHandler(string command, EngineBridgeDelegate engineBridgeDelegate);
+#endif
+    }
+}

package/Mobile/Runtime/BridgeIOS.cs.meta

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

package/Mobile/Runtime/Command.cs

@@ -0,0 +1,119 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace TapSDK.Core
+{
+    public class Command
+    {
+        [SerializeField] public string service;
+        [SerializeField] public string method;
+        [SerializeField] public string args;
+        [SerializeField] public bool withCallback;
+        [SerializeField] public string callbackId;
+        [SerializeField] public bool disposable;
+        
+        public Command()
+        {
+
+        }
+
+        public Command(string json)
+        {
+            JsonUtility.FromJsonOverwrite(json, this);
+        }
+
+        public string ToJSON()
+        {
+            return JsonUtility.ToJson(this);
+        }
+
+        public Command(string service, string method, bool callback, Dictionary<string, object> dic)
+        {
+            this.args = dic == null ? null : Json.Serialize(dic);
+            this.service = service;
+            this.method = method;
+            this.withCallback = callback;
+            this.callbackId = this.withCallback ? TapUUID.UUID() : null;
+        }
+
+        public Command(string service, string method, bool callback, bool onceTime, Dictionary<string, object> dic)
+        {
+            this.args = dic == null ? null : Json.Serialize(dic);
+            this.service = service;
+            this.method = method;
+            this.withCallback = callback;
+            this.callbackId = this.withCallback ? TapUUID.UUID() : null;
+            this.disposable = onceTime;
+        }
+
+        public class Builder
+        {
+            private string service;
+
+            private string method;
+
+            private bool withCallback;
+
+            private string callbackId;
+
+            private bool disposable;
+
+            private Dictionary<string, object> args;
+
+            public Builder()
+            {
+
+            }
+
+            public Builder Service(string service)
+            {
+                this.service = service;
+                return this;
+            }
+
+            public Builder Method(string method)
+            {
+                this.method = method;
+                return this;
+            }
+
+            public Builder OnceTime(bool onceTime)
+            {
+                this.disposable = onceTime;
+                return this;
+            }
+
+            public Builder Args(Dictionary<string, object> dic)
+            {
+                this.args = dic;
+                return this;
+            }
+
+            public Builder Args(string key, object value)
+            {
+                if (this.args == null)
+                {
+                    this.args = new Dictionary<string, object>();
+                }
+                if(value is Dictionary<string,object>)
+                {
+                    value = Json.Serialize(value);
+                }
+                this.args.Add(key, value);
+                return this;
+            }
+
+            public Builder Callback(bool callback)
+            {
+                this.withCallback = callback;
+                this.callbackId = this.withCallback ? TapUUID.UUID() : null;
+                return this;
+            }
+
+            public Command CommandBuilder()
+            {
+                return new Command(this.service, this.method, this.withCallback, this.disposable, this.args);
+            }
+        }
+    }
+}

package/Mobile/Runtime/Command.cs.meta

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

package/Mobile/Runtime/Constants.cs

@@ -0,0 +1,9 @@
+namespace TapSDK.Core
+{
+    public static class Constants
+    {
+        public const string VersionKey = "Engine-Version";
+
+        public const string PlatformKey = "Engine-Platform";
+    }
+}

package/Mobile/Runtime/Constants.cs.meta

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

package/Mobile/Runtime/EngineBridgeInitializer.cs

@@ -0,0 +1,33 @@
+using UnityEngine;
+using TapSDK.Core.Internal;
+
+namespace TapSDK.Core.Mobile
+{
+    public static class EngineBridgeInitializer
+    {
+        private static bool isInitialized = false;
+        private const string SERVICE_NAME = "BridgeCoreService";
+
+        public static void Initialize()
+        {
+            if (!isInitialized)
+            {
+                Debug.Log("Initializing EngineBridge");
+
+                // TODO: android 注册桥接
+                // #if UNITY_ANDROID
+                EngineBridge.GetInstance().Register(
+                    "com.taptap.sdk.core.unity.BridgeCoreService",
+                    "com.taptap.sdk.core.unity.BridgeCoreServiceImpl");
+                // #endif
+
+                isInitialized = true;
+            }
+        }
+
+        public static Command.Builder GetBridgeServer()
+        {
+            return new Command.Builder().Service(SERVICE_NAME);
+        }
+    }
+}

package/Mobile/Runtime/EngineBridgeInitializer.cs.meta

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

package/Mobile/Runtime/IBridge.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace TapSDK.Core
+{
+    public interface IBridge
+    {
+        void Register(string serviceClzName, string serviceImplName);
+
+        void Call(Command command);
+
+        void Call(Command command, Action<Result> action);
+        string CallWithReturnValue(Command command, Action<Result> action);
+        
+    }
+}

package/Mobile/Runtime/IBridge.cs.meta

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