com.xd.sdk.payment 0.0.1 → 0.0.10-alpha

package/Runtime/Internal/Standalone/PayListener.cs

@@ -0,0 +1,83 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Net;
+using System.Threading.Tasks;
+using UnityEngine;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Payment.Internal.Standalone
+{
+    internal class PayListener
+    {
+        private const float TIMEOUT = 0.25f;
+        private float _timeLeft = 0;
+
+        internal async Task Start(string url)
+        {
+            string redirectUri = $"http://{IPAddress.Loopback}:{LocalServerUtils.GetRandomUnusedPort()}";
+            string state = LocalServerUtils.GenerateRandomDataBase64url(32);
+            string payRequest = $"{url}&redirect_uri={redirectUri}&state={state}";
+
+            XDGLogger.Debug($"pay: {payRequest}");
+            _timeLeft = TIMEOUT;
+            UIManager.ShowLoading(true);
+            Application.OpenURL(Uri.EscapeUriString(payRequest));
+            AliyunTrack.PaymentCallPage();
+            // 启动监听
+            HttpListener server = new HttpListener();
+            server.Prefixes.Add($"{redirectUri}/");
+            server.Start();
+
+            while (true)
+            {
+                UIManager.Instance.DelayAction(TIMEOUT, () => { CloseLoading(); });
+                HttpListenerContext context = await server.GetContextAsync();
+
+                Debug.Log($"Request method: {context.Request.HttpMethod}");
+
+                context.Response.StatusCode = 200;
+                context.Response.Close();
+
+                if (context.Request.HttpMethod == "OPTIONS")
+                {
+                    continue;
+                }
+
+                server.Stop();
+
+                XDGLogger.Debug($"pay callback: {context.Request.RawUrl}");
+
+                WindowUtils.BringToFront();
+
+                string result = context.Request.QueryString["pay_result"];
+                if (result == "success")
+                {
+                    CloseLoading();
+                    AliyunTrack.PaymentDone();
+                    return;
+                }
+                else if (result == "fail")
+                {
+                    CloseLoading();
+                    AliyunTrack.PaymentFailed("fail");
+                    throw new Exception("pay failed");
+                }
+                else if (result == "cancel")
+                {
+                    CloseLoading();
+                    AliyunTrack.PaymentFailed("user_cancel");
+                    throw new TaskCanceledException();
+                }
+            }
+        }
+
+        private void CloseLoading()
+        {
+            UIManager.DismissLoading();
+            _timeLeft = 0;
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/PayListener.cs.meta

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

package/Runtime/Internal/Standalone/PayModule.cs

@@ -0,0 +1,261 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+
+using System;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using UnityEngine;
+using XD.SDK.Account;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+using CommonAliyunTrack = XD.SDK.Common.Internal.Standalone.AliyunTrack;
+using XDHttpClient = XD.SDK.Common.Internal.Standalone.XDHttpClient;
+
+namespace XD.SDK.Payment.Internal.Standalone
+{
+    public class PayModule
+    {
+        // 查询补款订单信息
+        private readonly static string XDG_PAYBACK_LIST = "order/v1/user/repayOrders";
+
+        // 创建订单
+        private readonly static string XDG_CREATE_ORDER = "trade/v1/client/createOrder";
+
+        // 上报订单
+        private readonly static string XDG_REPORT_ORDER = "callback/v1/client/pay/notify";
+
+        // 查询商品
+        private readonly static string XDG_QUERY_PRODUCTS = "payment/product/v1/query/game/skus";
+        // 查询 silent 商品价格
+        private readonly static string XDG_QUERY_PRODUCTS_V2 = "payment/product/v2/query/game/skus";
+
+        internal readonly static int PAY_DONE = 0;
+
+        internal readonly static int PAY_CANCEL = -1;
+
+        internal readonly static string PAY_FRAGMENT_SUCCESS = "#success";
+
+        internal readonly static string PAY_FRAGMENT_FAILURE = "#fail";
+
+        internal readonly static string PAY_FRAGMENT_CANCEL = "#cancel";
+
+        private readonly static int STEAM_CHANNEL_TYPE = 17;
+
+        private readonly static int STEAM_PAYMENT_TYPE = 0;
+
+        private readonly static int STEAM_PAY_ORDER_TYPE = 0;
+
+        public static string GetPayUrl(string serverId, string roleId, string productId,
+            string orderId = null,
+            string productName = null,
+            double payAmount = 0,
+            string extras = null)
+        {
+            Dictionary<string, object> queryParmas = new Dictionary<string, object>
+            {
+                { "appId", ConfigModule.AppId },
+                { "serverId", serverId },
+                { "roleId", roleId },
+                { "productSkuCode", productId },
+                { "lang", XDLocalization.GetLanguageKey() },
+                { "platform", XDUtility.GetPlatform() },
+                { "sign", Sign(serverId, roleId, productId, ConfigModule.ClientId) },
+                { "eventSessionId", AliyunTrack.PaymentEventSessionId },
+                { "account", XDGAccount.GetCurrentUser()?.UserId },
+                { "loginType", XDGAccount.GetCurrentUser()?.LoginType },
+                { "userLoginType", XDGAccount.GetCurrentUser()?.LoginType },
+                { "deviceId", SystemInfo.deviceUniqueIdentifier },
+                { "xdClientId", ConfigModule.ClientId },
+                { "sessionUUID", CommonAliyunTrack.CurrentSessionUUId },
+                { "sdkVer", XDGConstants.SDK_VERSION },
+                { "os", CommonAliyunTrack.GetPlatform() },
+                { "os_version", SystemInfo.operatingSystem }
+            };
+            if (!string.IsNullOrEmpty(ConfigModule.TargetCountryOrRegion))
+            {
+                queryParmas.Add("region", ConfigModule.TargetCountryOrRegion);
+            }
+
+            if (!string.IsNullOrEmpty(orderId))
+            {
+                queryParmas.Add("orderId", orderId);
+            }
+
+            if (!string.IsNullOrEmpty(productName))
+            {
+                queryParmas.Add("productName", productName);
+            }
+
+            if (Math.Abs(payAmount) > float.Epsilon)
+            {
+                queryParmas.Add("payAmount", payAmount);
+            }
+
+            if (!string.IsNullOrEmpty(extras))
+            {
+                queryParmas.Add("extras", extras);
+            }
+
+            return $"{ConfigModule.WebPayUrlForPC}?{XDUrlUtils.ToQueryString(queryParmas)}";
+        }
+
+        public static async Task<List<PayInfo>> CheckPay(CancellationToken cancellationToken = default)
+        {
+            var user = XDGAccount.GetCurrentUser();
+
+            Dictionary<string, object> param = new Dictionary<string, object>()
+            {
+                { "userId", user.UserId },
+            };
+            PayCheckResponse response = await XDHttpClient.Client.GetAsync<PayCheckResponse>(XDG_PAYBACK_LIST,
+                queryParams: param,
+                cancellationToken: cancellationToken);
+            return response.Result.List;
+        }
+
+        public static async Task PayWithSteam(string productId, string serverId, string roldId, string orderId, string ext)
+        {
+            // 开始支付
+            AliyunTrack.PaymentStart(productId, AliyunTrack.PAY_PLATFORM_STEAM, AliyunTrack.PAY_TYPE_STEAM, AliyunTrack.PAY_CHANNEL_STEAM);
+            string xdOrderId = null;
+            try
+            {
+                CreateOrderResult createOrderResult = await CreateSteamOrder(productId, serverId, roldId, orderId, ext);
+
+                string microTxn = await SteamUtils.Instance.GetMicroTxn(createOrderResult.TradeNo);
+                AliyunTrack.ReceiveSteamOrder(createOrderResult.TradeNo.ToString());
+                await ReportSteamOrder(productId, createOrderResult.TradeNo, microTxn);
+            }
+            catch (XDGError e)
+            {
+                // 支付失败
+                AliyunTrack.PayFailure(xdOrderId, e.Code, e.ErrorMsg);
+                throw e;
+            }
+        }
+
+        private static async Task<CreateOrderResult> CreateSteamOrder(string productId, string serverId, string roldId, string orderId, string ext)
+        {
+            // 创建订单
+            AliyunTrack.CreateOrder();
+            try
+            {
+                string steamId = SteamUtils.Instance.GetSteamId();
+                string steamLanguage = SteamUtils.Instance.GetSteamLanguage();
+                Dictionary<string, object> data = new Dictionary<string, object>
+                {
+                    { "productId", productId },
+                    { "appServerId", serverId },
+                    { "appRoleId", roldId },
+                    { "outTradeNo", orderId },
+                    { "channelType", STEAM_CHANNEL_TYPE },
+                    { "paymentType", STEAM_PAYMENT_TYPE },
+                    { "orderType", STEAM_PAY_ORDER_TYPE },
+                    { "steamId", steamId },
+                    { "steamLanguage", steamLanguage },
+                };
+                if (string.IsNullOrEmpty(ext))
+                {
+                    data["remark"] = ext;
+                }
+
+                CreateOrderResponse response = await XDHttpClient.Client.PostAsync<CreateOrderResponse>(XDG_CREATE_ORDER, data: data);
+                // 创建订单成功
+                AliyunTrack.CreateOrderSuccess();
+                return response.Result;
+            }
+            catch (XDGError e)
+            {
+                // 创建订单失败
+                AliyunTrack.CreateOrderFailure(e.Code);
+                if (e.Code == 40023 || e.Code == 42902)
+                {
+                    // 防沉迷错误
+                    TaskCompletionSource<CreateOrderResult> tcs = new TaskCompletionSource<CreateOrderResult>();
+                    LocalizableString localizable = XDLocalization.GetCurrentLocalizableString();
+                    Dictionary<string, object> config = new Dictionary<string, object>
+                    {
+                        { Dialog.TITLE_KEY, e.ExtraData["title"] },
+                        { Dialog.CONTENT_KEY, e.ExtraData["content"] },
+                        { Dialog.PRIMARY_TEXT_KEY, localizable.Confirm2 }
+                    };
+                    UIManager.ShowUI<Dialog>("Dialog", config, (code, data) =>
+                    {
+                        UIManager.Dismiss();
+                        tcs.TrySetException(e);
+                    });
+                    return await tcs.Task;
+                }
+
+                throw e;
+            }
+        }
+
+        private static async Task<ReportOrderResult> ReportSteamOrder(string productId, ulong tradeNo, string microTxn)
+        {
+            // 上报票据
+            AliyunTrack.ReportOrder(tradeNo.ToString());
+            try
+            {
+                Dictionary<string, object> data = new Dictionary<string, object>
+                {
+                    { "productId", productId },
+                    { "tradeNo", tradeNo },
+                    { "rawCallback", microTxn },
+                    { "channelType", STEAM_CHANNEL_TYPE },
+                    { "paymentType", STEAM_PAYMENT_TYPE },
+                    { "orderType", STEAM_PAY_ORDER_TYPE },
+                };
+                ReportOrderResponse response = await XDHttpClient.Client.PostAsync<ReportOrderResponse>(XDG_REPORT_ORDER, data: data);
+                // 上报票据成功
+                AliyunTrack.ReportOrderSuccess(tradeNo.ToString());
+                return response.Result;
+            }
+            catch (XDGError e)
+            {
+                // 上报票据失败
+                AliyunTrack.ReportOrderFailure(tradeNo.ToString(), e.Code, e.ErrorMsg);
+                throw e;
+            }
+        }
+        
+        public static async Task<List<SkuDetailBean>> QueryProducts(string[] productIds)
+        {
+            if (productIds == null || productIds.Length == 0)
+            {
+                return new List<SkuDetailBean>();
+            }
+
+            var queryParams = new Dictionary<string, object>
+            {
+                { "skus", string.Join(",", productIds) }
+            };
+            var url = XDG_QUERY_PRODUCTS_V2;
+#if XD_STEAM_SUPPORT
+            queryParams.Add("steamId", SteamUtils.Instance.GetSteamId());
+            url = XDG_QUERY_PRODUCTS;
+#endif
+            var response = await XDHttpClient.Client.GetAsync<QueryProductsResponse>(XDG_QUERY_PRODUCTS,
+                queryParams: queryParams);
+            return response.Products;
+        }
+
+        static string Sign(string serverId, string roleId, string productId, string clientId)
+        {
+            MD5 md5 = MD5.Create();
+            long timestamp = ServerTime.GetTimestamp();
+            byte[] data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{productId}{roleId}{serverId}{timestamp}{clientId}"));
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < data.Length; i++)
+            {
+                sb.Append(data[i].ToString("x2"));
+            }
+
+            return $"{sb},{timestamp}";
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/PayModule.cs.meta

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

package/Runtime/Internal/Standalone/PaymentAlert.cs

@@ -0,0 +1,112 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using Vuplex.WebView;
+using XD.SDK.Common.Internal.Standalone;
+
+namespace XD.SDK.Payment.Internal.Standalone
+{
+    public class PaymentAlert : UIElement
+    {
+        CanvasWebViewPrefab canvasWebViewPrefab;
+        Button closeButton;
+
+        GameObject loadFailedGO;
+        Text loadFailedTipsText;
+        Button loadFaieldRetryButton;
+
+        private void Awake()
+        {
+            GameObject webviewGO = Instantiate(Resources.Load("CanvasWebViewPrefab")) as GameObject;
+            canvasWebViewPrefab = webviewGO.GetComponent<CanvasWebViewPrefab>();
+            canvasWebViewPrefab.Resolution = 2;
+
+            webviewGO.transform.SetParent(transform.Find("WebViewContainer"));
+            RectTransform rectTransform = webviewGO.GetComponent<RectTransform>();
+            rectTransform.offsetMin = Vector2.zero;
+            rectTransform.offsetMax = Vector2.zero;
+            canvasWebViewPrefab = webviewGO.GetComponent<CanvasWebViewPrefab>();
+
+            closeButton = GameObject.Find("CloseButton").GetComponent<Button>();
+            closeButton.onClick.AddListener(OnCloseButtonClicked);
+
+            loadFailedGO = GameObject.Find("PayLoadFailedView");
+            loadFailedTipsText = loadFailedGO.transform.Find("TipsText").GetComponent<Text>();
+            loadFaieldRetryButton = loadFailedGO.transform.Find("RetryButton").GetComponent<Button>();
+            loadFaieldRetryButton.onClick.AddListener(OnRetryButtonClicked);
+
+            Text retryText = loadFaieldRetryButton.transform.Find("Container/Text").GetComponent<Text>();
+            retryText.text = XDLocalization.GetCurrentLocalizableString().Retry;
+
+            loadFailedGO.SetActive(false);
+        }
+
+        private async void Start()
+        {
+            await canvasWebViewPrefab.WaitUntilInitialized();
+
+            canvasWebViewPrefab.WebView.UrlChanged += OnUrlChanged;
+            canvasWebViewPrefab.WebView.PageLoadFailed += OnPageLoadFailed;
+
+            LoadPaymentPage();
+        }
+
+        void LoadPaymentPage()
+        {
+            if (Application.internetReachability == NetworkReachability.NotReachable)
+            {
+                // 没网
+                ShowError(XDLocalization.GetCurrentLocalizableString().NetError);
+            }
+            else
+            {
+                string url = Extra["url"] as string;
+                canvasWebViewPrefab.WebView.LoadUrl(url);
+            }
+        }
+
+        private void OnDestroy()
+        {
+            canvasWebViewPrefab.WebView.UrlChanged -= OnUrlChanged;
+            canvasWebViewPrefab.WebView.PageLoadFailed -= OnPageLoadFailed;
+        }
+
+        void OnUrlChanged(object sender, UrlChangedEventArgs eventArgs)
+        {
+            string url = eventArgs.Url;
+            Uri uri = new Uri(url);
+            string fragment = uri.Fragment;
+            if (!string.IsNullOrEmpty(fragment))
+            {
+                // 只有返回 fragment 才认为是完成
+                UIManager.Dismiss();
+                OnCallback(PayModule.PAY_DONE, fragment);
+            }
+        }
+
+        void OnPageLoadFailed(object sender, EventArgs eventArgs)
+        {
+            ShowError(XDLocalization.GetCurrentLocalizableString().LoadError);
+        }
+
+        void OnCloseButtonClicked()
+        {
+            UIManager.Dismiss();
+            OnCallback(PayModule.PAY_CANCEL, null);
+        }
+
+        void OnRetryButtonClicked()
+        {
+            loadFailedGO.SetActive(false);
+            LoadPaymentPage();
+        }
+
+        void ShowError(string message)
+        {
+            loadFailedTipsText.text = message;
+            loadFailedGO.SetActive(true);
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/PaymentAlert.cs.meta

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