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

package/Runtime/Internal/Standalone/PaymentFeaturesImpl.cs

@@ -0,0 +1,238 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using XD.SDK.Account;
+using XD.SDK.Common;
+using XD.SDK.Common.Internal;
+using XD.SDK.Common.Internal.Standalone;
+using Task = System.Threading.Tasks.Task;
+
+namespace XD.SDK.Payment.Internal.Standalone
+{
+    public class PaymentFeaturesImpl : IXDGPayment
+    {
+        private static volatile PaymentFeaturesImpl _instance;
+
+        // 用于线程同步的锁对象
+        private static readonly object Lock = new object();
+
+        /// <summary>
+        /// 获取 PaymentFeaturesImp 的单例实例
+        /// </summary>
+        public static PaymentFeaturesImpl Instance
+        {
+            get
+            {
+                if (_instance != null) return _instance;
+                lock (Lock)
+                {
+                    if (_instance == null)
+                    {
+                        _instance = new PaymentFeaturesImpl();
+                    }
+                }
+
+                return _instance;
+            }
+        }
+
+        /// <summary>
+        /// 私有构造函数，防止外部直接创建实例
+        /// </summary>
+        private PaymentFeaturesImpl()
+        {
+        }
+
+        public async void QueryWithProductIds(string[] productIds, Action<List<XDGProductInfo>, XDGError> callback)
+        {
+            try
+            {
+                var skuDetails = await PayModule.QueryProducts(productIds);
+                var productInfos = skuDetails.Select(sku =>
+                    new XDGProductInfo
+                    {
+                        ProductId = sku?.ProductSkuCode,
+                        DisplayPrice = sku?.DisplayPrice
+                    }
+                ).ToList();
+                callback.Invoke(productInfos, null);
+            }
+            catch (XDGError e)
+            {
+                callback.Invoke(null, e);
+            }
+        }
+
+        public async void PayWithParams(XDGPaymentParams paymentParams, Action<XDGOrderInfo, XDGError> callback)
+        {
+            if (paymentParams.CheckValid() != null)
+            {
+                callback.Invoke(null, paymentParams.CheckValid());
+                return;
+            }
+
+            if (string.IsNullOrEmpty(paymentParams.GameOrderId))
+            {
+                paymentParams.GameOrderId = Guid.NewGuid().ToString();
+            }
+
+            try
+            {
+#if XD_STEAM_SUPPORT
+                await PayModule.PayWithSteam(paymentParams.ProductId, paymentParams.ServerId, paymentParams.RoleId,
+                    paymentParams.GameOrderId,
+                    paymentParams.Extra);
+#else
+                await PayWithWeb(paymentParams);
+#endif
+                callback.Invoke(
+                    new XDGOrderInfo
+                    {
+                        ProductId = paymentParams.ProductId,
+                        GameOrderId = paymentParams.GameOrderId,
+                        Extra = paymentParams.Extra,
+                        RoleId = paymentParams.RoleId,
+                        ServerId = paymentParams.ServerId
+                    }, null);
+            }
+            catch (XDGError e)
+            {
+                callback.Invoke(null, e);
+            }
+            catch (Exception e)
+            {
+                callback.Invoke(null, new XDGError(e.Message));
+            }
+        }
+
+        public void QueryPendingPurchases(Action<List<XDGPendingPurchase>, XDGError> callback)
+        {
+            callback.Invoke(new List<XDGPendingPurchase>(), null);
+        }
+
+        public void HandlePendingPurchase(XDGPaymentParams paymentParams, Action<XDGOrderInfo, XDGError> callback)
+        {
+            callback.Invoke(null, new XDGError(ResponseCode.Common.UnavailableService,"该平台不支持"));
+        }
+
+        private async Task<List<XDGRefundDetails>> GetRefunds()
+        {
+            try
+            {
+                CancellationTokenSource cts = new CancellationTokenSource();
+                cts.CancelAfter(TimeSpan.FromSeconds(3));
+                List<PayInfo> payInfos = await PayModule.CheckPay(cts.Token);
+                return payInfos?.Cast<XDGRefundDetails>()
+                    .ToList();
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn(e.Message);
+                return new List<XDGRefundDetails>();
+            }
+        }
+
+        public async void CheckRefundStatusWithUI(Action<XDGRefundResultWrapper> callback)
+        {
+            try
+            {
+                var refunds = await GetRefunds();
+                callback?.Invoke(new XDGRefundResultWrapperClass(refunds, null));
+                var hasIOS = false;
+                var hasAndroid = false;
+                foreach (var refund in refunds)
+                {
+                    switch (refund?.platform)
+                    {
+                        case 1:
+                            hasIOS = true;
+                            break;
+                        case 2:
+                            hasAndroid = true;
+                            break;
+                    }
+                }
+
+                if (!hasIOS && !hasAndroid) return;
+                var param = new Dictionary<string, object>()
+                {
+                    { "hasIOS", hasIOS },
+                    { "hasAndroid", hasAndroid },
+                };
+                UIManager.ShowUI<PayHintAlert>(param, null);
+            }
+            catch (XDGError e)
+            {
+                callback?.Invoke(new XDGRefundResultWrapperClass(null, e));
+            }
+        }
+
+        private async Task PayWithWeb(XDGPaymentParams paymentParams)
+        {
+            var user = XDGAccount.GetCurrentUser();
+            if (user == null)
+            {
+                throw XDGErrorExtensions.NotLoginError();
+            }
+
+            AliyunTrack.PaymentStart(paymentParams.ProductId, paymentParams.RoleId);
+            var url = PayModule.GetPayUrl(paymentParams.ServerId, paymentParams.RoleId, paymentParams.ProductId, paymentParams.GameOrderId, "", 0,
+                paymentParams.Extra);
+            url = Uri.EscapeUriString(url);
+            XDGLogger.Debug("支付 pay URL: " + url);
+
+            if (ConfigModule.IsGlobal)
+            {
+                var payListener = new PayListener();
+                await payListener.Start(url);
+            }
+            else
+            {
+                var tcs = new TaskCompletionSource<object>();
+
+                var data = new Dictionary<string, object>
+                {
+                    { "url", url }
+                };
+                Action<int, object> callback = (code, obj) =>
+                {
+                    if (code == PayModule.PAY_CANCEL)
+                    {
+                        AliyunTrack.PaymentFailed("user_cancel");
+                        tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                    }
+                    else
+                    {
+                        var result = obj as string;
+                        if (result == PayModule.PAY_FRAGMENT_SUCCESS)
+                        {
+                            AliyunTrack.PaymentDone();
+                            tcs.TrySetResult(result);
+                        }
+                        else if (result == PayModule.PAY_FRAGMENT_CANCEL)
+                        {
+                            AliyunTrack.PaymentFailed("user_cancel");
+                            tcs.TrySetException(XDGErrorExtensions.CancelledError());
+                        }
+                        else
+                        {
+                            AliyunTrack.PaymentFailed($"fail message: {result}");
+                            tcs.TrySetException(XDGErrorExtensions.UnknownError(result));
+                        }
+                    }
+                };
+                UIManager.ShowUI<PaymentAlert>("PaymentAlert", data, callback);
+                AliyunTrack.PaymentCallPage();
+                await tcs.Task;
+                return;
+            }
+
+            throw new XDGError(ResponseCode.Common.Failed, "Payment failed");
+        }
+    }
+}
+#endif

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

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

package/{Mobile/Editor.meta → Runtime/Internal/Standalone.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: b1fec97a6971f4239b1cefe5f42fd88d
+guid: 0044ca95b22649cbb35240453007378b
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Internal/XDGPaymentInternal.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using XD.SDK.Common;
+
+namespace XD.SDK.Payment.Internal
+{
+    public class XDGPaymentInternal
+    {
+        private static readonly IXDGPayment PlatformWrapper;
+
+        static XDGPaymentInternal()
+        {
+#if UNITY_IOS || UNITY_ANDROID
+            PlatformWrapper = Internal.Mobile.PaymentFeaturesImpl.Instance;
+#elif UNITY_STANDALONE
+            PlatformWrapper = Internal.Standalone.PaymentFeaturesImpl.Instance;
+#endif
+            if (PlatformWrapper == null)
+            {
+                XDGLogger.Error("unsupported platform: " + Application.platform);
+            }
+        }
+
+        public static void QueryWithProductIds(string[] productIds, Action<List<XDGProductInfo>, XDGError> callback)
+        {
+            PlatformWrapper.QueryWithProductIds(productIds, callback);
+        }
+
+        public static void PayWithParams(XDGPaymentParams paymentParams, Action<XDGOrderInfo, XDGError> callback)
+        {
+            PlatformWrapper.PayWithParams(paymentParams, callback);
+        }
+
+        public static void QueryPendingPurchases(Action<List<XDGPendingPurchase>, XDGError> callback)
+        {
+            PlatformWrapper.QueryPendingPurchases(callback);
+        }
+
+        public static void HandlePendingPurchase(XDGPaymentParams paymentParams,
+            Action<XDGOrderInfo, XDGError> callback)
+        {
+            PlatformWrapper.HandlePendingPurchase(paymentParams, callback);
+        }
+    }
+}

package/Runtime/Internal/XDGPaymentInternal.cs.meta

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

package/Runtime/{XDGRefundDetails.cs → Internal/XDGRefundDetails.cs}

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using TapTap.Common;
-
-namespace XD.SDK.Payment
+namespace XD.SDK.Payment.Internal
 {
     public interface XDGRefundDetails
     {
@@ -12,10 +8,12 @@ namespace XD.SDK.Payment
         string outTradeNo { get; }
         double refundAmount { get; }
         int supplyStatus { get; }
+
         /// <summary>
         /// 1- iOS;2-Android;3-Web;4-macOS;5-Windows;6-unknown
         /// </summary>
         int platform { get; }
+
         int channelType { get; }
     }
 }

package/Runtime/Internal/XDGRefundDetails.cs.meta

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

package/Runtime/{XDGRefundResultWrapper.cs → Internal/XDGRefundResultWrapper.cs}

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using XD.SDK.Common;
 
-namespace XD.SDK.Payment
+namespace XD.SDK.Payment.Internal
 {
     public interface XDGRefundResultWrapper
     {

package/Runtime/Internal/XDGRefundResultWrapper.cs.meta

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

package/{Editor.meta → Runtime/Internal.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: c841b1117b1964496a09e70b7b5d0edd
+guid: 3d1249f71a9540a0ac725d73cc1433da
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Public/XDGPayment.Deprecated.cs

@@ -0,0 +1,231 @@
+#if XDSDK_DEPRECATED
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using UnityEngine;
+using XD.SDK.Common;
+
+namespace XD.SDK.Payment
+{
+    partial class XDGPayment
+    {
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void PayWithParams(XDGPaymentParams paymentParams, Action<XDGOrderInfoWrapper> callback)
+        {
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void PayWithProduct(string orderId, string productId, string roleId, string serverId, string ext,
+            Action<XDGOrderInfoWrapper> callback){
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void PayWithWeb(
+            string orderId,
+            string productId,
+            string productName,
+            double payAmount,
+            string roleId, 
+            string serverId,
+            string extras,
+            Action<WebPayResultType, string> callback){
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void QueryWithProductIds(string[] productIds, Action<XDGSkuDetailInfo> callback){
+        }
+
+        [Obsolete("Deprecated in XDSDK 7.x")]
+        public static void QueryRestoredPurchase(Action<List<XDGRestoredPurchase>> callback){
+        }
+    }
+
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public interface XDGOrderInfoWrapper
+    {
+        XDGError xdgError { get; }
+        XDGOrderInfo orderInfo { get; }
+        string debugMsg { get; }
+    }
+
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public enum WebPayResultType
+    {
+        OK = 0,
+        Cancel = 1,
+        Processing = 2,
+        Error = -1,
+    }
+
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public interface XDGSkuDetailInfo
+    {
+        XDGError xdgError { get; }
+
+        List<SkuDetailBean> skuDetailList { get; }
+    }
+
+    #if UNITY_IOS
+    [Serializable]
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public class SkuDetailBean
+    {
+        public string localizedDescription;
+
+        public string localizedTitle;
+
+        public double price;
+
+        public string productIdentifier;
+
+        public string localeIdentifier;
+
+        public PriceLocale priceLocale;
+
+        public SkuDetailBean(string json)
+        {
+           
+        }
+
+        public SkuDetailBean(Dictionary<string,object> dic)
+        {
+            
+        }
+
+        public SkuDetailBean()
+        {
+
+        }
+
+        public string ToJSON(){
+            return JsonUtility.ToJson(this);
+        }
+        
+
+    }
+    [Serializable]
+    public class PriceLocale
+    {
+        public string localeIdentifier;
+
+        public string languageCode;
+
+        public string countryCode;
+
+        public string scriptCode;
+
+        public string calendarIdentifier;
+
+        public string decimalSeparator;
+
+        public string currencySymbol;
+
+        public PriceLocale(Dictionary<string,object> dic)
+        {
+            
+        }
+    }
+
+#elif UNITY_ANDROID
+    [Serializable]
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public class SkuDetailBean
+    {
+        private string _originString;
+        public string description;
+        public string name;
+        public string productId;
+        public string productType;
+        public string title;
+        public GoogleOneTimePurchaseOfferDetails googleOneTimePurchaseOfferDetails;
+
+        public override string ToString()
+        {
+            return _originString;
+        }
+
+        public SkuDetailBean(Dictionary<string, object> dic)
+        {
+            
+        }
+    }
+    
+    [Serializable]
+        public class GoogleOneTimePurchaseOfferDetails
+        {
+            public string formattedPrice;
+            public long priceAmountMicros;
+            public string priceCurrencyCode;
+
+            public GoogleOneTimePurchaseOfferDetails(Dictionary<string, object> dic)
+            {
+               
+            }
+        }
+#else
+    public class SkuDetailBean
+    {
+        [JsonProperty("productSkuName")]
+        public string ProductSkuName { get; set; }
+
+        [JsonProperty("productSkuCode")]
+        public string ProductSkuCode { get; set; }
+
+        [JsonProperty("desc")]
+        public string Desc { get; set; }
+
+        [JsonProperty("channelSkuCode")]
+        public string ChannelSkuCode { get; set; }
+
+        [JsonProperty("currency")]
+        public string Currency { get; set; }
+
+        [JsonProperty("region")]
+        public string Region { get; set; }
+
+        [JsonProperty("costPrice")]
+        public double CostPrice { get; set; }
+
+        [JsonProperty("salePrice")]
+        public double SalePrice { get; set; }
+
+        public string ToJSON(){
+            return JsonConvert.SerializeObject(this);
+        }
+    }
+#endif
+
+    [Serializable]
+    [Obsolete("Deprecated in XDSDK 7.x")]
+    public class XDGRestoredPurchase
+    {
+        public string purchaseToken;
+        
+        public string productId;
+
+#if UNITY_ANDROID
+        public string orderId;
+
+        public string packageName;
+
+        public long purchaseTime;
+
+        public int purchaseState;
+
+        public string developerPayload;
+
+        public bool acknowledged;
+
+        public bool autoRenewing;
+#endif
+        public XDGRestoredPurchase(string json)
+        {
+        }
+
+        public XDGRestoredPurchase(Dictionary<string, object> dic)
+        {
+
+        }
+    }
+}
+#endif

package/Runtime/Public/XDGPayment.Deprecated.cs.meta

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