Google Play Billing Library release notes

This topic contains release notes for the Google Play Billing library.

Google Play Billing Library 2.0 Release (2019-05-07)

Version 2.0 of the Google Play Billing library is now available. This version contains the following changes.

Purchases must be acknowledged within three days

Google Play supports purchasing products from inside of your app (in-app) or outside of your app (out-of-app). In order for Google Play to ensure a consistent purchase experience regardless of where the user purchases your product, you must acknowledge all purchases received through the Google Play Billing Library as soon as possible after granting entitlement to the user. If you do not acknowledge a purchase within three days, the user automatically receives a refund, and Google Play revokes the purchase. For pending transactions (new in version 2.0), the three-day window starts when the purchase has moved to the SUCCESS state and does not apply while the purchase is in a PENDING state.

For subscriptions, you must acknowledge any purchase that has a new purchase token. This means that all initial purchases, plan changes, and re-signups need to be acknowledged, but you do not need to acknowledge subsequent renewals. To determine if a purchase needs acknowledgment, you can check the acknowledgement field in the purchase.

The Purchase object now includes an isAcknowledged() method that indicates whether a purchase has been acknowledged. In addition, the server-side API now includes acknowledgement boolean values for Product.purchases.get() and Product.subscriptions.get(). Before acknowledging a purchase, be sure to use these methods to determine if the purchase has already been acknowledged.

You can acknowledge a purchase by using one of the following methods:

• For consumable products, use consumeAsync(), found in the client API.
• For products that aren't consumed, use acknowledgePurchase(), found in the client API.
• A new acknowledge() method is also available in the Server API.

BillingFlowParams.setSku() has been removed

The previously-deprecated BillingFlowParams#setSku() method has been removed in this release. Before rendering products in a purchase flow, you must now call BillingClient.querySkuDetailsAsync(), passing the resulting SkuDetails object to BillingFlowParams.Builder.setSkuDetails().

For code examples, see Use the Google Play Billing Library.

Developer payload is supported

Version 2.0 of the Google Play Billing library adds support for developer payload—arbitrary strings that can be attached to purchases. You can attach a developer payload parameter to a purchase, but only when the purchase is acknowledged or consumed. This is unlike developer payload in AIDL, where the payload could be specified when launching the purchase flow. Because purchases can now be initiated from outside of your app, this change ensures that you always have an opportunity to add a payload to purchases.

To access the payload in the new library, Purchase objects now include a getDeveloperPayload() method.

Consistent offers

When you offer a discounted SKU, Google Play now returns the original price of the SKU so that you can show users that they are receiving a discount.

SkuDetails contains two new methods for retrieving the original SKU price:

• getOriginalPriceAmountMicros() - returns the unformatted original price of the SKU before discount.
• getOriginalPrice() - returns the original price with additional currency formatting.

Pending transactions

With version 2.0 of the Google Play Billing library, you must support purchases where additional action is required before granting entitlement. For example, a user might choose to purchase your in-app product at a physical store using cash. This means that the transaction is completed outside of your app. In this scenario, you should grant entitlement only after the user has completed the transaction.

To enable pending purchases, call enablePendingPurchases() as part of initializing your app.

Use Purchase.getState() to determine whether the purchase state is PURCHASED or PENDING. Note that you should grant entitlement only when the state is PURCHASED. You should check for Purchase status updates by doing the following:

1. When starting your app, call BillingClient.queryPurchases() to retrieve the list of unconsumed products associated with the user.
2. Call Purchase.getState() on each returned Purchase object.
3. Implement the onPurchasesUpdated() method to respond to changes to Purchase objects.

In addition to these changes, the server-side API now includes PENDING states for both Product.purchases.get() and Product.subscriptions.get().

This release also introduces a new real-time developer notification type, OneTimeProductNotification. This notification type contains a single message whose value is either INAPP_PURCHASED or INAPP_CANCELED. This notification type is sent only for purchases associated with delayed forms of payment, such as cash.

When acknowledging pending purchases, be sure to acknowledge only when the purchase state is SUCCESS and not PENDING.

API changes

Version 2.0 of the Google Play Billing library contains several API changes to support new features and clarify existing functionality.

consumeAsync

consumeAsync() now takes a ConsumeParams object instead of a purchaseToken. ConsumeParams contains the purchaseToken as well as an optional developer payload.

The previous version of consumeAsync() has been removed in this release.

queryPurchaseHistoryAsync

To minimize confusion, queryPurchaseHistoryAsync() now returns a PurchaseHistory object instead of a Purchase object. The PurchaseHistory object is the same as a Purchase object, except that it reflects only the values returned by queryPurchaseHistoryAsync() and does not contain the autoRenewing, orderId, and packageName fields. Note that nothing has changed with the returned data—queryPurchaseHistoryAsync() returns the same data as before.

BillingResult return values

APIs that previously returned a BillingResponse integer value now return a BillingResult object. BillingResult contains the BillingResponse integer as well as a debug string that you can use to diagnose errors. The debug string uses an en-US locale and is not meant to be shown to end users.

Bug fixes

• SkuDetails.getIntroductoryPriceAmountMicros() now returns a long instead of a String.

Google Play Billing Library 1.2.2 Release (2019-03-07)

Version 1.2.2 of the Google Play Billing library is now available. This version contains the following changes.

Bug fixes

• Fixed a threading issue introduced in v1.2.1. Background calls no longer block the main thread.

Other changes

• Although using the main thread is still recommended, you can now instantiate the Google Play Billing Library from a background thread.
• Instantiation has been fully migrated to the background thread to reduce the chance of causing ANRs.

Play Billing Library 1.2.1 Release (2019-03-04)

Version 1.2.1 of the Google Play Billing library is now available. This version contains the following changes.

Major changes

• Added support for rewarded products. For more information on monetization options, see Add rewarded-product-specific features.

Other changes

• Added public constructors for PurchasesResult and SkuDetailsResult to make testing easier.
• SkuDetails objects can use a new method, getOriginalJson().
• All AIDL service calls are now handled by background threads.

Bug fixes

• Null callback listeners are no longer passed into public APIs.

Google Play Billing Library 1.2 Release (2018-10-18)

Version 1.2 of the Google Play Billing library is now available. This version contains the following changes.

Summary of changes

• The Google Play Billing Library is now licensed under the Android Software Development Kit License Agreement.
• Added the launchPriceChangeConfirmationFlow API, which prompts users to review a pending change to a subscription price.
• Added support for a new proration mode, DEFERRED, when upgrading or downgrading a user's subscription.
• In the BillingFlowParams class, replaced setSku() with setSkuDetails().
• Minor bug fixes and code optimizations.

Price change confirmation

You can now change the price of a subscription in Google Play Console and prompt users to review and accept the new price when they enter your app.

To use this API, create a PriceChangeFlowParams object by using the skuDetails of the subscription product, and then call launchPriceChangeConfirmationFlow(). Implement the PriceChangeConfirmationListener to handle the result when the price change confirmation flow finishes, as shown in the following code snippet:

val priceChangeFlowParams = PriceChangeFlowParams.newBuilder()
    .setSkuDetails(skuDetailsOfThePriceChangedSubscription)
    .build()

billingClient.launchPriceChangeConfirmationFlow(activity,
        priceChangeFlowParams,
        object : PriceChangeConfirmationListener() {
            override fun onPriceChangeConfirmationResult(responseCode: Int) {
                // Handle the result.
            }
        })

PriceChangeFlowParams priceChangeFlowParams =
        PriceChangeFlowParams.newBuilder()
    .setSkuDetails(skuDetailsOfThePriceChangedSubscription)
    .build();

billingClient.launchPriceChangeConfirmationFlow(activity,
        priceChangeFlowParams,
        new PriceChangeConfirmationListener() {
            @Override
            public void onPriceChangeConfirmationResult(int responseCode) {
                // Handle the result.
            }
        });

The price change confirmation flow displays a dialog containing the new pricing information, asking users to accept the new price. This flow returns a response code of type BillingClient.BillingResponse.

New proration mode

When upgrading or downgrading a user's subscription, you can use a new proration mode, DEFERRED. This mode updates the user's subscription when it next renews. To learn more about how to set this proration mode, see Set proration mode.

New method for setting SKU details

In the BillingFlowParams class, the setSku() method has been deprecated. This change serves to optimize the Google Play Billing flow.

When constructing a new instance of BillingFlowParams in your in-app billing client, we recommend that you instead work with the JSON object directly using setSkuDetails(), as shown in the following code snippet:

In the BillingFlowParams Builder class, the setSku() method has been deprecated. Instead, use the setSkuDetails() method, as shown in the following code snippet. The object passed into setSkuDetails() object comes from the querySkuDetailsAsync() method.

private lateinit var mBillingClient: BillingClient
private val mSkuDetailsMap = HashMap<String, SkuDetails>()

private fun querySkuDetails() {
    val skuDetailsParamsBuilder = SkuDetailsParams.newBuilder()
    mBillingClient.querySkuDetailsAsync(skuDetailsParamsBuilder.build()
    ) { responseCode, skuDetailsList ->
        if (responseCode == 0) {
            for (skuDetails in skuDetailsList) {
                mSkuDetailsMap[skuDetails.sku] = skuDetails
            }
        }
    }
}

private fun startPurchase(skuId: String) {
    val billingFlowParams = BillingFlowParams.newBuilder()
    .setSkuDetails(mSkuDetailsMap[skuId])
    .build()
}

private BillingClient mBillingClient;
private Map<String, SkuDetails> mSkuDetailsMap = new HashMap<>();

private void querySkuDetails() {
    SkuDetailsParams.Builder skuDetailsParamsBuilder
            = SkuDetailsParams.newBuilder();
    mBillingClient.querySkuDetailsAsync(skuDetailsParamsBuilder.build(),
            new SkuDetailsResponseListener() {
                @Override
                public void onSkuDetailsResponse(int responseCode,
                        List<SkuDetails> skuDetailsList) {
                    if (responseCode == 0) {
                        for (SkuDetails skuDetails : skuDetailsList) {
                            mSkuDetailsMap.put(skuDetails.getSku(), skuDetails);
                        }
                    }
                }
            });
}

private void startPurchase(String skuId) {
    BillingFlowParams billingFlowParams = BillingFlowParams.newBuilder()
            .setSkuDetails(mSkuDetailsMap.get(skuId))
            .build();
}

Play Billing Library 1.1 Release (2018-05-07)

Version 1.1 of the Google Play Billing library is now available. This version contains the following changes.

Summary of changes

• Added support to specify a proration mode in BillingFlowParams when upgrading/downgrading an existing subscription.
• The replaceSkusProration boolean flag in BillingFlowParams is no longer supported. Use replaceSkusProrationMode instead.
• launchBillingFlow() now triggers a callback for failed responses.

Behavior changes

Version 1.1 of the Google Play Billing library contains the following behavior changes.

Developers can set replaceSkusProrationMode in BillingFlowParams class

A ProrationMode provides further details on the type of proration when upgrading or downgrading a user's subscription.

BillingFlowParams.newBuilder()
    .setSku(skuId)
    .setType(billingType)
    .setOldSku(oldSku)
    .setReplaceSkusProrationMode(replaceSkusProrationMode)
    .build()

BillingFlowParams.newBuilder()
    .setSku(skuId)
    .setType(billingType)
    .setOldSku(oldSku)
    .setReplaceSkusProrationMode(replaceSkusProrationMode)
    .build();

Currently, Google Play supports following proration modes:

replaceSkusProration is no longer supported in BillingFlowParams class

Developers used to be able to set a boolean flag to charge a prorated amount for a subscription upgrade request. Given that we are supporting ProrationMode, which contains more detailed proration instruction, this boolean flag is no longer supported.

launchBillingFlow() now triggers a callback for failed responses

The Billing Library will always trigger the PurhcasesUpdatedListener callback and return a BillingResponse asynchronously. The synchronous return value of BillingResponse is kept as well.

Bug fixes

• Properly exits early in async methods when service is disconnected.
• Builder param objects no longer mutates built objects.
• Issue 68087141: launchBillingFlow() now trigger callback for failed responses.

Google Play Billing Library 1.0 Release (2017-09-19, Announcement)

Version 1.0 of the Google Play Billing library is now available. This version contains the following changes.

Important changes

• Embedded billing permission inside library’s manifest. It's not necessary to add the com.android.vending.BILLING permission inside Android manifest anymore.
• New builder added to BillingClient.Builder class.
• Introduced builder pattern for SkuDetailsParams class to be used on methods to query SKUs.
• Several API methods were updated for consistency (the same return argument names and order).

Behavior changes

Version 1.0 of the Google Play Billing library contains the following behavior changes.

BillingClient.Builder class

BillingClient.Builder is now initialized via the newBuilder pattern:

billingClient = BillingClient.newBuilder(context).setListener(this).build()

billingClient = BillingClient.newBuilder(context).setListener(this).build();

launchBillingFlow method is now called using a BillingFlowParams class

To initiate the billing flow for a purchase or subscription, the launchBillingFlow() method receives a BillingFlowParams instance initialized with parameters specific to the request:

BillingFlowParams.newBuilder().setSku(skuId)
        .setType(billingType)
        .setOldSku(oldSku)
        .build()

// Then, use the BillingFlowParams to start the purchase flow
val responseCode = billingClient.launchBillingFlow(builder.build())

BillingFlowParams.newBuilder().setSku(skuId)
                              .setType(billingType)
                              .setOldSku(oldSku)
                              .build();

// Then, use the BillingFlowParams to start the purchase flow
int responseCode = billingClient.launchBillingFlow(builder.build());

New way to query available products

Arguments for queryPurchaseHistoryAsync() and querySkuDetailsAsync() methods were wrapped into a Builder pattern:

val params = SkuDetailsParams.newBuilder()
params.setSkusList(skuList)
        .setType(itemType)
billingClient.querySkuDetailsAsync(params.build(), object : SkuDetailsResponseListener() {
    ...
})

SkuDetailsParams.Builder params = SkuDetailsParams.newBuilder();
params.setSkusList(skuList)
        .setType(itemType);
billingClient.querySkuDetailsAsync(params.build(), new SkuDetailsResponseListener() {...})

The result is now returned via result code and a list of SkuDetails objects instead of previous wrapper class for your convenience and to be consistent across our API:

fun onSkuDetailsResponse(@BillingResponse responseCode: Int, skuDetailsList: List<SkuDetails>)

public void onSkuDetailsResponse(@BillingResponse int responseCode, List<SkuDetails> skuDetailsList)

Parameters order changed on onConsumeResponse() method

The order of arguments for onConsumeResponse from the ConsumeResponseListener interface has changed to be consistent across our API:

fun onConsumeResponse(@BillingResponse responseCode: Int, outToken: String)

public void onConsumeResponse(@BillingResponse int responseCode, String outToken)

Unwrapped PurchaseResult object

PurchaseResult has been unwraped to be consistent across our API:

fun onPurchaseHistoryResponse(@BillingResponse responseCode: Int, purchasesList: List<Purchase>)

void onPurchaseHistoryResponse(@BillingResponse int responseCode, List<Purchase> purchasesList)

Bug fixes

• No response code in PURCHASES_UPDATED Bundle
• Fix ProxyBillingActivity and PurchasesUpdatedListener issues during device rotation

Developer Preview 1 Release (2017-06-12, Announcement)

Developer preview launched, aimed to simplify the development process when it comes to billing, allowing developers to focus their efforts on implementing logic specific to the Android app, such as application architecture and navigation structure.

The library includes several convenient classes and features for you to use when integrating your Android apps with the Google Play Billing API. The library also provides an abstraction layer on top of the Android Interface Definition Language (AIDL) service, making it easier for developers to define the interface between the app and the Google Play Billing API.