How to Implement In-App Purchases in an Android App

This blog is about implementing in-app purchasing (IAP) for a non-consumable product in an Android™ app. As a reminder, a non-consumable is a product that once purchased, is permanently available to the user.

The next section shows an overview of an app that was developed for the purpose of demonstrating in-app purchasing.

Important Note

You will need a Google Play Console account to deploy your app and add an in-app product on the Google Play Store. This tutorial does not cover the steps for setting up the app and in-app product on Google Play Console. So it is assumed that both the app and its in-app product are already configured.

Project Overview

User Interface

The user interface (UI) contains one buy button that simulates buying a non-consumable product.

Android Studio Project

The following screenshot from Android Studio, illustrates the structure of the project.

The next few sections go over the dependencies and source files of the project.

Dependencies

First, you need to add the dependencies required for the project. In build.gradle (under Gradle Scripts), append the following lines to the dependencies then click on Sync Now at the top when it appears.

// UI.
implementation "androidx.constraintlayout:constraintlayout:2.1.4"
implementation "com.google.android.material:material:1.12.0"

// Billing.
implementation "com.android.billingclient:billing:7.1.1"

Java Class/Interface Definitions

This section contains the Java source code where each sub-section shows a class/interface. You will find explanations in the code comments where necessary.

IBillingUpdatesListener

package com.example.androidiapdemo;

/**
 * Interface that activities must implement to receive notifications from BillingManager.
 */
public interface IBillingUpdatesListener {
    enum BillingManagerResponse {
        USER_HAS_PURCHASED_ITEM,
        USER_PURCHASED_OWNED_ITEM,
        UNKNOWN_ERROR,
        FAILED_TO_INITIATE_PURCHASE,
        FAILED_TO_VALIDATE_PURCHASE
    }
    void onPurchaseUpdated(BillingManagerResponse billingResponse);
    void onFailedBillingSetup();
}

BillingManager

package com.example.androidiapdemo;

import android.app.Activity;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.android.billingclient.api.AcknowledgePurchaseParams;
import com.android.billingclient.api.AcknowledgePurchaseResponseListener;
import com.android.billingclient.api.BillingClient;
import com.android.billingclient.api.BillingClientStateListener;
import com.android.billingclient.api.BillingFlowParams;
import com.android.billingclient.api.BillingResult;
import com.android.billingclient.api.PendingPurchasesParams;
import com.android.billingclient.api.Purchase;
import com.android.billingclient.api.PurchasesUpdatedListener;
import com.android.billingclient.api.QueryProductDetailsParams;
import com.android.billingclient.api.QueryPurchasesParams;

import java.util.ArrayList;
import java.util.List;

/**
 * Class that handles billing events.
 */
public class BillingManager implements PurchasesUpdatedListener, BillingClientStateListener {
    private BillingClient m_billingClient;
    private IBillingUpdatesListener billingUpdatesListener;
    private Activity m_activity;
    private AcknowledgePurchaseResponseListener acknowledgePurchaseResponseListener;

    // Note: the ID should match your in-app product ID on Google Play console.
    private static final String IAP_PROD_ID = "com.example.androidiapdemo.nonconsumable";
    private static final String TAG = "Billing Manager";

    public BillingManager(MainActivity activity) {
        m_activity = activity;
        acknowledgePurchaseResponseListener = activity;
        billingUpdatesListener = activity;
    }

    /**
     * Closes the connection to the billing service.
     */
    public void destroy() {
        if (m_billingClient != null) {
            m_billingClient.endConnection();
            m_billingClient = null;
            m_activity = null;
            billingUpdatesListener = null;
            acknowledgePurchaseResponseListener = null;
        }
    }

    /**
     * This is called when the connection to the billing service is lost.
     * You can implement logic to retry connecting to the service in this function.
     * For our purpose, we are only adding a debug log.
     */
    @Override
    public void onBillingServiceDisconnected() {
        Log.d(TAG, "Connection to the billing service is lost.");
    }

    /**
     * This is called when the billing setup is complete.
     * When the setup succeeds, a query is made to the billing service to retrieve the purchases.
     * When the setup fails, we'll let MainActivity, which implements IBillingUpdatesListener, 
     * decides how to handle the failure.
     */
    @Override
    public void onBillingSetupFinished(@NonNull BillingResult billingResult) {
        if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
            Log.d(TAG, "Billing setup successful.");

            // Get purchase status.
            queryPurchases();
        } else {
            Log.e(TAG, "Billing setup failed with response code " + billingResult.getResponseCode());
            billingUpdatesListener.onFailedBillingSetup();
        }
    }

    /**
     * Performs actions after receiving notifications about purchase updates.
     */
    @Override
    public void onPurchasesUpdated(
            @NonNull BillingResult billingResult, 
            @Nullable List<Purchase> purchases) {
        processPurchase(billingResult, purchases);
    }

    /**
     * Handles purchase status updates.
     */
    public void processPurchase(BillingResult billingResult, List<Purchase> purchases) {
        if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
            if (purchases != null) {
                for (Purchase purchase : purchases) {
                    int purchaseState = purchase.getPurchaseState();
                    if (purchaseState == Purchase.PurchaseState.PURCHASED) {
                        verifyPurchase(purchase);
                    } else if (purchaseState == Purchase.PurchaseState.PENDING) {
                        Log.d(TAG, "Purchase pending...");

                        // Nothing to do here.
                        // When purchase transitions from pending to purchased while the app 
                        // is still open, onPurchasesUpdated will be invoked again. 
                        // If the transition happened when the app was closed, 
                        // the status update will be picked up when the app
                        // connects to the billing service again.
                    }
                }
            }
        } else if (billingResult.getResponseCode() ==
                   BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED) {
            billingUpdatesListener.onPurchaseUpdated(
                    IBillingUpdatesListener.BillingManagerResponse.USER_PURCHASED_OWNED_ITEM);
        } else if (billingResult.getResponseCode() ==
                   BillingClient.BillingResponseCode.USER_CANCELED) {
            // Don't do anything if user cancels.
            Log.d(TAG, "user canceled");
        } else if (billingResult.getResponseCode() ==
                   BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE) {
            // When Google billing is not available or there is no internet connection,
            // Google billing API will display a message in its own UI. So, in this case,
            // we are only logging a message.
            Log.d(TAG, "billing service unavailable");
        } else if (billingResult.getResponseCode() ==
                   BillingClient.BillingResponseCode.DEVELOPER_ERROR) {
            Log.d(TAG,
             "Check that the product ID on Google Play Console matches the ID used in the code " +
                  "and ensure the APK is signed with release keys.");
        } else {
            billingUpdatesListener.onPurchaseUpdated(
                    IBillingUpdatesListener.BillingManagerResponse.UNKNOWN_ERROR);
        }
    }

    /**
     * Validates a purchase and acknowledges it if it's a new purchase.
     */
    public void verifyPurchase(Purchase purchase) {
        if (!isPurchaseValid(purchase)) {
            billingUpdatesListener.onPurchaseUpdated(
                    IBillingUpdatesListener.BillingManagerResponse.FAILED_TO_VALIDATE_PURCHASE);
        } else if (!purchase.isAcknowledged()) {
            // Acknowledging the purchase. Otherwise, the purchase is automatically
            // refunded to the user after 3 days from the purchase date.
            AcknowledgePurchaseParams acknowledgePurchaseParams =
                    AcknowledgePurchaseParams.newBuilder()
                            .setPurchaseToken(purchase.getPurchaseToken())
                            .build();
            m_billingClient.acknowledgePurchase(acknowledgePurchaseParams, 
                                                acknowledgePurchaseResponseListener);
        } else {
            // Purchase valid and already acknowledged.
            billingUpdatesListener.onPurchaseUpdated(
                    IBillingUpdatesListener.BillingManagerResponse.USER_HAS_PURCHASED_ITEM);
        }
    }

    /**
     * Initiates the purchase through the billing service.
     */
    public void initiatePurchaseFlow() {
        QueryProductDetailsParams.Product product = QueryProductDetailsParams.Product.newBuilder()
                .setProductType(BillingClient.ProductType.INAPP)
                .setProductId(IAP_PROD_ID).build();

        List<QueryProductDetailsParams.Product> productList = new ArrayList<>();
        productList.add(product);

        QueryProductDetailsParams params = QueryProductDetailsParams.newBuilder()
                                           .setProductList(productList)
                                           .build();

        m_billingClient.queryProductDetailsAsync(params,
                (billingResult, productDetailsList) ->
                {
                    if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
                        BillingFlowParams.ProductDetailsParams productDetailsParams =
                                BillingFlowParams.ProductDetailsParams.newBuilder()
                                        .setProductDetails(productDetailsList.get(0))
                                        .build();

                        startPurchase(productDetailsParams);
                    } else {
                        Log.e(TAG, "Filed to obtain product details on purchase initiation. " +
                                "Billing response code: " + billingResult.getResponseCode());
                        billingUpdatesListener.onPurchaseUpdated(
                                IBillingUpdatesListener.
                                BillingManagerResponse.
                                FAILED_TO_INITIATE_PURCHASE);
                    }
                });
    }

    /**
     * Connects to the billing service then waits for it to pull the purchases or query the purchases
     * directly if a connection to the billing service was already established.
     * <p>
     * Note: When billing service connects, we will get notified through onBillingSetupFinished.
     * At that point queryPurchases will be called to pull the purchases.
     */
    public void restorePurchases() {
        if (m_billingClient == null || !m_billingClient.isReady()) {
            // Connect and query for purchases.
            connectToGooglePlay();
        } else {
            // Already connected. Just need to query the purchases.
            queryPurchases();
        }
    }

    /**
     * Validates a purchase.
     * <p>
     * Note: the implementation is not complete. You will need to implement this function once
     * you setup a server with a backend that performs the purchase validation.
     *
     * @param purchase Instance of Purchase to be validated.
     */
    private boolean isPurchaseValid(Purchase purchase) {
        // Do the following steps to implement this function:
        // 1. Get the purchase token.
        String token = purchase.getPurchaseToken();

        // 2. Send the token to your server to verify purchase's status and validity.

        // 3. return true if the purchase is valid or false otherwise.

        // For the purpose of this example, this function will always return true.
        return true;
    }

    /**
     * Connects to Google Play's billing service.
     */
    private void connectToGooglePlay() {
        if (m_billingClient == null) {
            PendingPurchasesParams pendingPurchasesParams =
                    PendingPurchasesParams.newBuilder()
                            .enableOneTimeProducts().build();
            m_billingClient = BillingClient.newBuilder(m_activity)
                    .setListener(this)
                    .enablePendingPurchases(pendingPurchasesParams)
                    .build();
        }

        // Check if billing client is not already connected or is not connecting.
        if (!m_billingClient.isReady() &&
                m_billingClient.getConnectionState() != BillingClient.ConnectionState.CONNECTING) {
            m_billingClient.startConnection(this);
        } else {
            Log.d(TAG, "Billing client is connecting or is already connected. Connection state: "
                    + m_billingClient.getConnectionState());
        }
    }

    /**
     * Pulls purchases from the billing service.
     * For the purpose of this example, we are only using 1 non-consumable in-app product.
     */
    private void queryPurchases() {
        QueryPurchasesParams params =
                QueryPurchasesParams.newBuilder()
                .setProductType(BillingClient.ProductType.INAPP)
                .build();
        
        m_billingClient.queryPurchasesAsync(
                params,
                (result, list) ->
                {
                    if (result.getResponseCode() == BillingClient.BillingResponseCode.OK) {
                        processPurchase(result, list);
                    } else {
                        Log.d(TAG, 
                              String.format("query purchases status: %s.", 
                              result.getResponseCode()));
                    }
                }
        );
    }

    /**
     * Initiates a purchase.
     *
     * @param params instance that contains the details of the product being purchased.
     */
    private void startPurchase(BillingFlowParams.ProductDetailsParams params) {
        List<BillingFlowParams.ProductDetailsParams> paramsList = new ArrayList<>();
        paramsList.add(params);

        BillingFlowParams flowParams = BillingFlowParams.newBuilder()
                .setProductDetailsParamsList(paramsList)
                .build();
        m_billingClient.launchBillingFlow(m_activity, flowParams);
    }
}

MainActivity

package com.example.androidiapdemo;

import android.os.Bundle;
import android.util.Log;
import android.widget.Button;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;

import com.android.billingclient.api.AcknowledgePurchaseResponseListener;
import com.android.billingclient.api.BillingClient;
import com.android.billingclient.api.BillingResult;
import com.google.android.material.dialog.MaterialAlertDialogBuilder;

public class MainActivity extends AppCompatActivity
        implements AcknowledgePurchaseResponseListener, IBillingUpdatesListener {
    private BillingManager m_billingManager;
    private Button m_buyButton;

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        m_billingManager = new BillingManager(this);

        m_buyButton = findViewById(R.id.buyButton);
        m_buyButton.setOnClickListener(v -> m_billingManager.initiatePurchaseFlow());
    }

    @Override
    protected void onDestroy() {
        if (m_billingManager != null) {
            m_billingManager.destroy();
            m_billingManager = null;
        }
        super.onDestroy();
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (m_billingManager == null) {
            m_billingManager = new BillingManager(this);
        }
        m_billingManager.restorePurchases();
    }

    @Override
    public void onAcknowledgePurchaseResponse(@NonNull BillingResult billingResult) {
        if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
            // Here you can implement the logic to the unlock the product for the user.
            // ...
            //////

            runOnUiThread(() -> {
                m_buyButton.setText(getString(R.string.iap_buy_button_disabled_label));
                m_buyButton.setEnabled(false);

                String dialogTitle = getString(R.string.iap_purchase_successful_title);
                String dialogMsg = getString(R.string.iap_purchase_successful_msg);
                AlertDialog successfulPurchaseDialog = createSimpleAlertDialog(dialogTitle, dialogMsg);
                successfulPurchaseDialog.show();
            });
        } else {
            Log.d(TAG, String.format("Purchase ack returned an error. response code: %d.",
                    billingResult.getResponseCode()));
        }
    }

    @Override
    public void onPurchaseUpdated(BillingManagerResponse billingResponse) {
        if (billingResponse != null) {
            runOnUiThread(() -> {
                if (billingResponse == BillingManagerResponse.USER_HAS_PURCHASED_ITEM ||
                        billingResponse == BillingManagerResponse.USER_PURCHASED_OWNED_ITEM) {
                    m_buyButton.setText(getString(R.string.iap_buy_button_disabled_label));
                    m_buyButton.setEnabled(false);

                    // Here you may need to add logic to ensure that the purchased product is unlocked
                    // for the user.
                } else {
                    m_buyButton.setText(getString(R.string.iap_buy_button_enabled_label));
                    m_buyButton.setEnabled(true);

                    // Here you can handle the errors as you see fit. For the purpose of this demo,
                    // we are only handling purchase initiation and validation errors.
                    if (billingResponse == BillingManagerResponse.FAILED_TO_INITIATE_PURCHASE) {
                        AlertDialog errorDialog = createSimpleAlertDialog(
                                getString(R.string.iap_purchase_failed_title),
                                getString(R.string.iap_failed_to_initiate_purchase_msg)
                        );
                        errorDialog.show();
                    } else if (billingResponse == BillingManagerResponse.FAILED_TO_VALIDATE_PURCHASE) {
                        AlertDialog errorDialog = createSimpleAlertDialog(
                                getString(R.string.iap_purchase_failed_title),
                                getString(R.string.iap_purchase_validation_failed_msg)
                        );
                        errorDialog.show();
                    }
                }
            });
        }
    }

    @Override
    public void onFailedBillingSetup() {
        Log.d(TAG, "Billing setup failed");
    }

    private AlertDialog createSimpleAlertDialog(String title, String message) {
        return new MaterialAlertDialogBuilder(this)
                .setTitle(title)
                .setMessage(message)
                .setPositiveButton(R.string.iap_close_button_label, (dialog, which) -> dialog.cancel())
                .create();
    }
}

Tip

To prevent potential side effects from multiple active connections to the billing service, avoid creating more than one BillingClient instance. One of the side effects is discussed here in details.

strings.xml (values)

These are the string values used in the UI.

<resources>
    <string name="app_name">Android IAP Demo</string>

    <string name="iap_purchase_failed_title">Error</string>
    <string name="iap_failed_to_initiate_purchase_msg">Failed to initiate the purchase. Please try again later.</string>
    <string name="iap_purchase_validation_failed_msg">Failed to validate the purchase.</string>
    <string name="iap_buy_button_enabled_label">Buy</string>
    <string name="iap_buy_button_disabled_label">Item Bought</string>
    <string name="iap_close_button_label">Close</string>
    <string name="iap_purchase_successful_msg">Your purchase was successful!</string>
    <string name="iap_purchase_successful_title">Thank You!</string>
</resources>

main_activity.xml (Layout)

This is for defining the app’s UI, as depicted in the Project Overview.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.button.MaterialButton
        android:id="@+id/buyButton"
        style="?attr/materialButtonStyle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Buy"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Why You Should Avoid Using Multiple Billing Clients

Consider a scenario where two activities are involved, each establishing a new connection to the billing service within the onCreate() method. Suppose the user first opens Activity A and then navigates to Activity B. At this point, Activity B is in the foreground, while Activity A remains in the background but is not yet destroyed by the operating system. As long as Activity A hasn’t been destroyed and its connection to the billing service is still active, its billing client may continue to listen for updates, even though it’s in the background.

Now, imagine the user completes a successful purchase through Activity B. When the billing manager acknowledges the purchase, the acknowledgment will only be processed once. If Activity A’s billing client was initialized first, it may receive the acknowledgment, but only one client can process the acknowledgment. If Activity A receives the acknowledgment, the acknowledgment handler in Activity B will not be executed because the acknowledgment will only be processed by one client at a time. This highlights one of the risks of using multiple billing client instances across activities.

It’s important to note that this scenario assumes the connection to the billing service is closed when the activity is destroyed (i.e., in the onDestroy() method).

We Need Your Help!

Help us increase our apps’ visibility in the app stores. Check out our apps and if there’s anything you like, download it on your phone and try it out. We appreciate your support, it truly makes a difference!

Also, don’t forget to follow us on X.