Add-ons Integration

using System;
using System.Collections.Generic;
using Meta.XR.Samples;
using Oculus.Platform;
using Oculus.Platform.Models;
using UnityEngine;

namespace UltimateGloveBall.App
{
    /// <summary>
    /// Manages in-app purchases. It's a wrapper on the Oculus.Platform.IAP functionalities.
    /// This makes it easy to fetch all products and purchases as well as make a purchase.
    /// Referenced from: https://developers.meta.com/horizon/documentation/unity/ps-iap/
    /// </summary>
    [MetaCodeSample("UltimateGloveBall")]
    public class IAPManager
    {
        #region Singleton
        private static IAPManager s_instance;

        public static IAPManager Instance
        {
            get
            {
                s_instance ??= new IAPManager();
                return s_instance;
            }
        }

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
        public static void DestroyInstance()
        {
            s_instance = null;
        }
        #endregion // Singleton

        /// <summary>
        /// The data we get from the error message json string on purchase
        /// </summary>
        private class PurchaseErrorMessage
        {
            // Since we convert from json the naming must stay the same as the json format, which is all lowercase
            public string category;
            public int code;
            public string message;
        }

        private Dictionary<string, Product> m_products = new();
        private Dictionary<string, Purchase> m_purchases = new();

        private Dictionary<string, List<string>> m_productsByCategory = new();
        private List<string> m_availableSkus = new();
        public IList<string> AvailableSkus => m_availableSkus;

        /// <summary>
        /// Asynchronously fetch all products based on the SKU
        /// </summary>
        public void FetchProducts(string[] skus, string category = null)
        {
            _ = IAP.GetProductsBySKU(skus)?.OnComplete(message =>
            {
                GetProductsBySKUCallback(message, category);
            });
        }

        /// <summary>
        /// Asynchronously fetch all purchases that were made by the user
        /// </summary>
        public void FetchPurchases()
        {
            _ = IAP.GetViewerPurchases()?.OnComplete(GetViewerPurchasesCallback);
        }

        public List<string> GetProductSkusForCategory(string category)
        {
            return m_productsByCategory.TryGetValue(category, out var categorySkus) ? categorySkus : null;
        }

        /// <summary>
        /// Returns a product by SKU, otherwise returns null
        /// </summary>
        public Product GetProduct(string sku)
        {
            if (m_products.TryGetValue(sku, out var product))
            {
                return product;
            }

            Debug.LogError($"[IAPManager] Product {sku} doesn't exist!");
            return null;
        }
        /// <summary>
        /// Returns true if the user has purchased the SKU, false if user has not purchased the SKU or if the SKU doesn't exist
        /// </summary>
        public bool IsPurchased(string sku)
        {
            return m_purchases.TryGetValue(sku, out _);
        }

        /// <summary>
        /// Returns a purchase by SKU, otherwise returns null
        /// </summary>
        public Purchase GetPurchase(string sku)
        {
            return m_purchases.TryGetValue(sku, out var purchase) ? purchase : null;
        }

        /// <summary>
        /// Initiating the checkout flow for a SKU
        /// </summary>
        public void Purchase(string sku, Action<string, bool, string> onPurchaseFlowCompleted)
        {
#if UNITY_EDITOR
            m_purchases[sku] = null; // Keep a reference to the purchase, although purchases cannot be made in Editor
            onPurchaseFlowCompleted?.Invoke(sku, true, null);
#else
            IAP.LaunchCheckoutFlow(sku).OnComplete((Message<Purchase> msg) =>
            {
                if (msg.IsError)
                {
                    var errorMsgString = msg.GetError().Message;
                    Debug.LogError($"[IAPManager] Error while purchasing: {errorMsgString}");
                    var errorData = JsonUtility.FromJson<PurchaseErrorMessage>(errorMsgString);
                    onPurchaseFlowCompleted?.Invoke(sku, false, errorData.message);
                    return;
                }

                var p = msg.GetPurchase();
                Debug.Log("[IAPManager] Purchased " + p.Sku);
                m_purchases[sku] = p;
                onPurchaseFlowCompleted?.Invoke(sku, true, null);
            });
#endif
        }

        /// <summary>
        /// Consume a purchased item on behalf of a user
        /// </summary>
        public void ConsumePurchase(string sku, Action<string, bool> onConsumptionCompleted)
        {
#if UNITY_EDITOR
            m_purchases.Remove(sku);
            onConsumptionCompleted?.Invoke(sku, true);
#else
            _ = IAP.ConsumePurchase(sku).OnComplete(msg =>
            {
                if (msg.IsError)
                {
                    Debug.LogError($"[IAPManager] Error while consuming: {msg.GetError().Message}");
                    onConsumptionCompleted?.Invoke(sku, false);
                    return;
                }

                Debug.Log("[IAPManager] Consumed " + sku);
                m_purchases.Remove(sku);
                onConsumptionCompleted?.Invoke(sku, true);
            });
#endif
        }

        private void GetProductsBySKUCallback(Message<ProductList> msg, string category)
        {
            if (msg.IsError)
            {
                Debug.LogError($"[IAPManager] Failed to fetch products, {msg.GetError().Message}");
                return;
            }

            foreach (var p in msg.GetProductList())
            {
                Debug.LogFormat("[IAPManager] Product: sku:{0} name:{1} price:{2}", p.Sku, p.Name, p.FormattedPrice);
                m_products[p.Sku] = p;
                m_availableSkus.Add(p.Sku);
                if (!string.IsNullOrWhiteSpace(category))
                {
                    if (!m_productsByCategory.TryGetValue(category, out var categorySkus))
                    {
                        categorySkus = new List<string>();
                        m_productsByCategory[category] = categorySkus;
                    }

                    categorySkus.Add(p.Sku);
                }
            }
        }

        private void GetViewerPurchasesCallback(Message<PurchaseList> msg)
        {
            if (msg.IsError)
            {
                Debug.LogError($"[IAPManager] Failed to fetch purchased products, {msg.GetError().Message}");
                return;
            }

            foreach (var p in msg.GetPurchaseList())
            {
                Debug.Log($"[IAPManager] Purchased: sku:{p.Sku} granttime:{p.GrantTime} id:{p.ID}");
                m_purchases[p.Sku] = p;
            }
        }
    }
}

using Oculus.Platform;
using Oculus.Platform.Models;
using UnityEngine;

public class FullVersionUnlock : MonoBehaviour
{
    private const string AppId = "YOUR_APP_ID";
    private const string UnlockSku = "YOUR_UNLOCK_SKU";

    public bool HasFullVersion { get; private set; }

    private void Start()
    {
        try
        {
            Core.Initialize(AppId);
        }
        catch (UnityException e)
        {
            // Core.Initialize throws when the platform cannot start, and every IAP
            // call returns null until it does, so open the free tier and check
            // ownership again on the next launch.
            Debug.LogError($"Oculus Platform failed to initialize: {e.Message}");
            SetTrialContent();
            return;
        }

        RefreshOwnership();
    }

    // Read the live ownership list, and fall back to the device cache if it fails.
    private void RefreshOwnership()
    {
        IAP.GetViewerPurchases().OnComplete(message =>
        {
            if (message.IsError)
            {
                Debug.LogError($"GetViewerPurchases failed: {message.GetError().Message}");
                IAP.GetViewerPurchasesDurableCache().OnComplete(OnPurchaseList);
                return;
            }

            OnPurchaseList(message);
        });
    }

    private void OnPurchaseList(Message<PurchaseList> message)
    {
        if (message.IsError)
        {
            // The live call and the cache both failed. Open the free tier so the
            // app stays usable, and check ownership again on the next launch.
            Debug.LogError($"Could not read purchases: {message.GetError().Message}");
            SetTrialContent();
            return;
        }

        PurchaseList purchases = message.GetPurchaseList();

        foreach (Purchase purchase in purchases)
        {
            if (purchase.Sku == UnlockSku)
            {
                SetFullVersionUnlocked();
                return;
            }
        }

        // The list is paginated, so a user who owns many add-ons can carry the
        // unlock on a later page.
        if (purchases.HasNextPage)
        {
            IAP.GetNextPurchaseListPage(purchases).OnComplete(OnPurchaseList);
            return;
        }

        SetTrialContent();
    }

    // Wire this to the buy button on your purchase prompt.
    public void OnBuyFullVersionClicked()
    {
        IAP.LaunchCheckoutFlow(UnlockSku).OnComplete(message =>
        {
            if (message.IsError)
            {
                // When the user dismisses the checkout dialog, Error.Message holds
                // a JSON object whose "category" property is "user_canceled".
                Debug.LogError($"Checkout did not complete: {message.GetError().Message}");
                return;
            }

            SetFullVersionUnlocked();
        });
    }

    private void SetFullVersionUnlocked()
    {
        HasFullVersion = true;

        // Load your paid levels, scenes, or features here.
    }

    private void SetTrialContent()
    {
        HasFullVersion = false;

        // Load your free preview content here.
    }
}