Environment Requirements

• Supports Unity 2019.4 or higher.

Getting Ready

• Refer to Before You Start to create an app, enable app configuration, and bind API domains;
• Refer to TapSDK Quickstart to configure package name and signature certificate;

Getting the SDK

External Dependency Manager for Unity(EDM4U)

Tap payment depends on EDM4U to handle android dependency.

install via OpenUPM

EDM4U is available via OpenUPM, you can add it via Edit -> Project Settings -> Package Manager

local UPM Package

You can also download UPM version from Google APIs for Unity. And install as a local file

TapPayment SDK

Payment SDK is available via NPMJS, you can add it via Edit -> Project Settings -> Package Manager

Then you will be able to install Taptap Payment Global V2 from Window -> Package Manager

Android Dependency

EDM4U will automatically monitor Android dependency introduced by TapPayment SDK, but under some circumstances the auto resolve can fail. You can always go to Assets -> External Dependency Manager -> Android Resolver -> Force Resolve to force resolving dependencies. Please make sure com.taptap.android.payment:unity is successfully added as dependency to mainTemplate.gradle, if this is not done by the EDM4U you can also add this manually.

SDK Guide

We provide a new store implementation for the Unity IAP flow, which requires minmal changes if your game already have an IAP flow with Google Play or App Store. If you are implementing IAP for the first time, we will briefly cover the IAP flow and you can always find more details on Unity Documentation

Initialize Unity Gaming Services

Call UnityServices.InitializeAsync() to initialize all Unity Gaming Services at once. It returns a Task that enables you to monitor the initialization's progression.

using System;
using Unity.Services.Core;
using Unity.Services.Core.Environments;
using UnityEngine;

public class InitializeUnityServices : MonoBehaviour
{
    public string environment = "production";

    async void Start()
    {
        try
        {
            var options = new InitializationOptions()
                .SetEnvironmentName(environment);

            await UnityServices.InitializeAsync(options);
        }
        catch (Exception exception)
        {
            // An error occurred during services initialization.
        }
    }
}

Initialize IAP

Make sure you add TapPurchasingModule and set the correct clientId and clientToken in the config.

using UnityEngine;
using UnityEngine.Purchasing;
using TapTap.Payments.Global.V2;

public class MyIAPManager : IStoreListener {

    private IStoreController controller;
    private IExtensionProvider extensions;

    public MyIAPManager () {
        var builder = ConfigurationBuilder.Instance(
            TapPurchasingModule.Instance, 
            StandardPurchasingModule.Instance);
        builder.Configure<ITapConfiguration>().SetClientId("Your Client ID Here");
        builder.Configure<ITapConfiguration>().SetClientToken("Your Client Token Here");
        builder.AddProduct("100_gold_coins", ProductType.Consumable, new IDs
        {
            {"100_gold_coins_google", GooglePlay.Name},
            {"100_gold_coins_mac", MacAppStore.Name}
        });

        UnityPurchasing.Initialize (this, builder);
    }

    /// <summary>
    /// Called when Unity IAP is ready to make purchases.
    /// </summary>
    public void OnInitialized (IStoreController controller, IExtensionProvider extensions)
    {
        this.controller = controller;
        this.extensions = extensions;
    }

    /// <summary>
    /// Called when Unity IAP encounters an unrecoverable initialization error.
    ///
    /// Note that this will not be called if Internet is unavailable; Unity IAP
    /// will attempt initialization until it becomes available.
    /// </summary>
    public void OnInitializeFailed (InitializationFailureReason error)
    {
    }

    /// <summary>
    /// Called when a purchase completes.
    ///
    /// May be called at any time after OnInitialized().
    /// </summary>
    public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
    {
        return PurchaseProcessingResult.Complete;
    }

    /// <summary>
    /// Called when a purchase fails.
    /// </summary>
    public void OnPurchaseFailed (Product i, PurchaseFailureReason p)
    {
    }
}

Launch Purchase Flow

Once IAP is successfully initialized, you can now start purchase flow using IStoreController.InitiatePurchase

// Example method called when the user presses a 'buy' button
// to start the purchase process.
public void OnPurchaseClicked(string productId) {
    controller.InitiatePurchase(productId);
}

Processing Purchases

The ProcessPurchase function of your store listener is called when a purchase completes. Your application should fulfil whatever the user has bought; for example, unlocking local content or sending purchase receipts to a server to update a server-side game model.

A result is returned to indicate whether or not your Application has finished processing the purchase:

Note that ProcessPurchase may be called at any point following a successful initialization. If your application crashes during execution of the ProcessPurchase handler, then it is invoked again the next time Unity IAP initializes, so you may wish to implement your own additional de-duplication.

Reliability

Unity IAP requires explicit acknowledgement of purchases to ensure that purchases are reliably fulfilled in the event of network outages or application crashes. Any purchases that complete while the application is offline will be sent to the application on next initialization.

Completing purchases immediately

When PurchaseProcessingResult.Complete is returned, Unity IAP finishes the transaction immediately (as shown in the diagram below).

You must not return PurchaseProcessingResult.Complete if you are selling consumable products and fulfilling them from a server (for example, providing currency in an online game).

If you do, there is a risk that consumable purchases will be lost if your Application is uninstalled before the cloud save takes place.

Saving purchases to the cloud

If you are saving consumable purchases to the cloud, you must return PurchaseProcessingResult.Pending and call ConfirmPendingPurchase only when you have successfully persisted the purchase.

When returning Pending, Unity IAP keeps transactions open on the underlying store until confirmed as processed, ensuring consumable purchases are not lost even if a user reinstalls your application while a consumable is in this state.