garden_client/Assets/Plugins/UnityPurchasing/script/IAPButton.cs

#if UNITY_PURCHASING
using UnityEngine.Events;
using UnityEngine.UI;
using System.IO;
using System.Collections.Generic;

namespace UnityEngine.Purchasing
{
	[RequireComponent (typeof (Button))]
	[AddComponentMenu("Unity IAP/IAP Button")]
	[HelpURL("https://docs.unity3d.com/Manual/UnityIAP.html")]
	public class IAPButton : MonoBehaviour
	{
		public enum ButtonType
		{
			Purchase,
			Restore
		}

		[System.Serializable]
		public class OnPurchaseCompletedEvent : UnityEvent<Product> {};

		[System.Serializable]
		public class OnPurchaseFailedEvent : UnityEvent<Product, PurchaseFailureReason> {};

		[HideInInspector]
		public string productId;

		[Tooltip("The type of this button, can be either a purchase or a restore button")]
		public ButtonType buttonType = ButtonType.Purchase;

		[Tooltip("Consume the product immediately after a successful purchase")]
		public bool consumePurchase = true;

		[Tooltip("Event fired after a successful purchase of this product")]
		public OnPurchaseCompletedEvent onPurchaseComplete;

		[Tooltip("Event fired after a failed purchase of this product")]
		public OnPurchaseFailedEvent onPurchaseFailed;

		[Tooltip("[Optional] Displays the localized title from the app store")]
		public Text titleText;

		[Tooltip("[Optional] Displays the localized description from the app store")]
		public Text descriptionText;

		[Tooltip("[Optional] Displays the localized price from the app store")]
		public Text priceText;

		void Start ()
		{
			Button button = GetComponent<Button>();

			if (buttonType == ButtonType.Purchase) {
				if (button) {
					button.onClick.AddListener(PurchaseProduct);
				}

				if (string.IsNullOrEmpty(productId)) {
					Debug.LogError("IAPButton productId is empty");
				}

				if (!IAPButtonStoreManager.Instance.HasProductInCatalog(productId)) {
					Debug.LogWarning("The product catalog has no product with the ID \"" + productId + "\"");
				}
			} else if (buttonType == ButtonType.Restore) {
				if (button) {
					button.onClick.AddListener(Restore);
				}
			}
		}

		void OnEnable()
		{
			if (buttonType == ButtonType.Purchase) {
				IAPButtonStoreManager.Instance.AddButton(this);
				UpdateText();
			}
		}

		void OnDisable()
		{
			if (buttonType == ButtonType.Purchase) {
				IAPButtonStoreManager.Instance.RemoveButton(this);
			}
		}

		void PurchaseProduct()
		{
			if (buttonType == ButtonType.Purchase) {
				Debug.Log("IAPButton.PurchaseProduct() with product ID: " + productId);

				IAPButtonStoreManager.Instance.InitiatePurchase(productId);
			}
		}

		void Restore()
		{
			if (buttonType == ButtonType.Restore) {
				if (Application.platform == RuntimePlatform.WSAPlayerX86 || Application.platform == RuntimePlatform.WSAPlayerX64 || Application.platform == RuntimePlatform.WSAPlayerARM) {
					IAPButtonStoreManager.Instance.ExtensionProvider.GetExtension<IMicrosoftExtensions>().RestoreTransactions();
				} else if (Application.platform == RuntimePlatform.IPhonePlayer || Application.platform == RuntimePlatform.OSXPlayer || Application.platform == RuntimePlatform.tvOS) {
					IAPButtonStoreManager.Instance.ExtensionProvider.GetExtension<IAppleExtensions>().RestoreTransactions(OnTransactionsRestored);
				} else if (Application.platform == RuntimePlatform.Android && StandardPurchasingModule.Instance().appStore == AppStore.SamsungApps) {
					IAPButtonStoreManager.Instance.ExtensionProvider.GetExtension<ISamsungAppsExtensions>().RestoreTransactions(OnTransactionsRestored);
				} else if (Application.platform == RuntimePlatform.Android && StandardPurchasingModule.Instance().appStore == AppStore.CloudMoolah) {
					IAPButtonStoreManager.Instance.ExtensionProvider.GetExtension<IMoolahExtension>().RestoreTransactionID((restoreTransactionIDState) => {
						OnTransactionsRestored(restoreTransactionIDState != RestoreTransactionIDState.RestoreFailed && restoreTransactionIDState != RestoreTransactionIDState.NotKnown);
					});
				} else {
					Debug.LogWarning(Application.platform.ToString() + " is not a supported platform for the Codeless IAP restore button");
				}
			}
		}

		void OnTransactionsRestored(bool success)
		{
			Debug.Log("Transactions restored: " + success);
		}

		/**
		 *  Invoked to process a purchase of the product associated with this button
		 */
		public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
		{
			Debug.Log(string.Format("IAPButton.ProcessPurchase(PurchaseEventArgs {0} - {1})", e, e.purchasedProduct.definition.id));

			onPurchaseComplete.Invoke(e.purchasedProduct);

			return (consumePurchase) ? PurchaseProcessingResult.Complete : PurchaseProcessingResult.Pending;
		}

		/**
		 *  Invoked on a failed purchase of the product associated with this button
		 */
		public void OnPurchaseFailed (Product product, PurchaseFailureReason reason)
		{
			Debug.Log(string.Format("IAPButton.OnPurchaseFailed(Product {0}, PurchaseFailureReason {1})", product, reason));

			onPurchaseFailed.Invoke(product, reason);
		}

		private void UpdateText()
		{
			var product = IAPButtonStoreManager.Instance.GetProduct(productId);
			if (product != null) {
				if (titleText != null) {
					titleText.text = product.metadata.localizedTitle;
				}

				if (descriptionText != null) {
					descriptionText.text = product.metadata.localizedDescription;
				}

				if (priceText != null) {
					priceText.text = product.metadata.localizedPriceString;
				}
			}
		}

		public class IAPButtonStoreManager : IStoreListener
		{
			private static IAPButtonStoreManager instance = new IAPButtonStoreManager();
			private ProductCatalog catalog;
			private List<IAPButton> activeButtons = new List<IAPButton>();
            private IAPListener m_Listener;

			protected IStoreController controller;
			protected IExtensionProvider extensions;

			private IAPButtonStoreManager()
			{
				catalog = ProductCatalog.LoadDefaultCatalog();

				StandardPurchasingModule module = StandardPurchasingModule.Instance();
				module.useFakeStoreUIMode = FakeStoreUIMode.StandardUser;

				ConfigurationBuilder builder = ConfigurationBuilder.Instance(module);

				IAPConfigurationHelper.PopulateConfigurationBuilder(ref builder, catalog);

				UnityPurchasing.Initialize (this, builder);
			}

			public static IAPButtonStoreManager Instance {
				get {
					return instance;
				}
			}

			public IStoreController StoreController {
				get {
					return controller;
				}
			}

			public IExtensionProvider ExtensionProvider {
				get {
					return extensions;
				}
			}

			public bool HasProductInCatalog(string productID)
			{
				foreach (var product in catalog.allProducts) {
					if (product.id == productID) {
						return true;
					}
				}
				return false;
			}

			public Product GetProduct(string productID)
			{
				if (controller != null && controller.products != null && !string.IsNullOrEmpty(productID)) {
					return controller.products.WithID(productID);
				}
				return null;
			}

			public void AddButton(IAPButton button)
			{
				activeButtons.Add(button);
			}

			public void RemoveButton(IAPButton button)
			{
				activeButtons.Remove(button);
			}

            public void AddListener(IAPListener listener)
            {
                if (m_Listener != null)
                    Debug.LogWarning("There is more than one active IAPListener. Only the most recent IAPListener will receive purchase events.");
                m_Listener = listener;
            }

            public void RemoveListener(IAPListener listener)
            {
                if (m_Listener == listener)
                    m_Listener = null;
            }

			public void InitiatePurchase(string productID)
			{
				if (controller == null) {
					Debug.LogError("Purchase failed because Purchasing was not initialized correctly");

					foreach (var button in activeButtons) {
						if (button.productId == productID) {
							button.OnPurchaseFailed(null, Purchasing.PurchaseFailureReason.PurchasingUnavailable);
						}
					}
					return;
				}

				controller.InitiatePurchase(productID);
			}

			public void OnInitialized (IStoreController controller, IExtensionProvider extensions)
			{
				this.controller = controller;
				this.extensions = extensions;

				foreach (var button in activeButtons) {
					button.UpdateText();
				}
			}

			public void OnInitializeFailed (InitializationFailureReason error)
			{
				Debug.LogError(string.Format("Purchasing failed to initialize. Reason: {0}", error.ToString()));
			}

			public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
			{
				foreach (var button in activeButtons) {
					if (button.productId == e.purchasedProduct.definition.id) {
						return button.ProcessPurchase(e);
					}
				}

                if (m_Listener != null) {
                    return m_Listener.ProcessPurchase(e);
                } else {
				    Debug.LogWarning("Purchase not correctly processed for product \"" + e.purchasedProduct.definition.id + "\". Add an active IAPButton to process this purchase, or add an IAPListener to receive any unhandled purchase events.");
				    return PurchaseProcessingResult.Pending;
                }
			}

			public void OnPurchaseFailed (Product product, PurchaseFailureReason reason)
			{
				foreach (var button in activeButtons) {
					if (button.productId == product.definition.id) {
						button.OnPurchaseFailed(product, reason);
						return;
					}
				}

                if (m_Listener != null) {
                    m_Listener.OnPurchaseFailed(product, reason);
                    return;
                } else {
				    Debug.LogWarning("Failed purchase not correctly handled for product \"" + product.definition.id + "\". Add an active IAPButton to handle this failure, or add an IAPListener to receive any unhandled purchase failures.");
                }
			}
		}
	}
}
#endif