KlugBilling documentation

Introduction

KlugBilling sells one-time products and subscriptions from your AIR app. On iPhone and iPad it talks to the App Store through StoreKit, on Android to Google Play through the Google Play Billing Library 8.3.0, and your ActionScript code stays the same for both stores.

• Products: one-time products and auto-renewing subscriptions with localized titles, descriptions and prices straight from the store
• Subscriptions: billing periods, offers and pricing phases (free trials, introductory prices)
• Purchases: every transaction state as an event, and finishPurchase() to close a transaction once you have delivered
• Restore: restore earlier purchases on iOS, list owned purchases on Android
• Verification: the iOS app receipt, Google's signed purchase data, signature and purchase token for your server; on Android purchases are also checked on the device against your Play public key

Self-contained: no core library or dependency ANEs. One ANE is all you add. KlugBilling sells the subscriptions of our apps on iOS and Android.

Requirements

Add the extension

1 · Copy the ANE and declare it

Copy com.klug.billing.ane into your project's extension folder (the folder you pass to ADT with -extdir, or the one your IDE links as native extensions) and add the extension ID to the application descriptor:

<extensions>
    <extensionID>com.klug.billing</extensionID>
</extensions>

2 · Nothing else

No manifest entries, no activities and no Info.plist keys are needed. On Android the extension declares the Google Play Billing Library 8.3.0 as a Gradle dependency, so ADT adds it automatically when it packages your app, together with everything the library brings along. On iOS the extension links Apple's StoreKit framework.

Getting started

All calls go through InAppBilling.service. Every call returns at once; the results arrive as events on the service. Add your listeners first, then call setup(), so that no transaction that the store replays on start is missed.

import com.klug.billing.*;
import com.klug.billing.events.*;

private var store:InAppBillingService = InAppBilling.service;   // the single service: never call new InAppBillingService()

public function initStore():void
{
    if ( !InAppBilling.isSupported )                 // iOS and Android devices only
    {
        hideShop();                                  // your app function
        return;
    }
    store.addEventListener( InAppBillingEvent.SETUP_SUCCESS,  onSetup );
    store.addEventListener( InAppBillingEvent.SETUP_FAILURE,  onSetupFailed );
    store.addEventListener( ProductEvent.PRODUCTS_LOADED,     onProductsLoaded );
    store.addEventListener( PurchaseEvent.PURCHASES_UPDATED,  onPurchasesUpdated );   // before setup()
    store.addEventListener( PurchaseEvent.PURCHASE_FAILED,    onPurchaseFailed );

    store.setup( createBillingService() );           // see "Set up the store"
}

The guides below fill in each of these functions. Together they form a complete store: set up, check availability, load products, buy, verify, deliver and finish.

Guides

Set up the store

setup(service) connects to the store of the platform the app runs on and reports SETUP_SUCCESS or SETUP_FAILURE. Describe the store with a BillingService: the service type for the platform and, on Android, your Google Play public key.

// Play Console: your app > Monetization setup > Licensing (base64 RSA public key)
private static const PLAY_PUBLIC_KEY:String = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...";

private function createBillingService():BillingService
{
    if ( store.platform == "android" )
    {
        return new BillingService()
            .setServiceType( InAppBillingServiceTypes.GOOGLE_PLAY_INAPP_BILLING )
            .setGooglePlayPublicKey( PLAY_PUBLIC_KEY );
    }
    return new BillingService()
        .setServiceType( InAppBillingServiceTypes.APPLE_INAPP_PURCHASE );
}

private function onSetupFailed( e:InAppBillingEvent ):void
{
    trace( "store setup failed: " + e.errorCode + " " + e.message );
    hideShop();
}

setup() always uses the store of the current platform. The service type tells your code and isServiceSupported(type) which store you mean; isServiceSupported() is true for APPLE_INAPP_PURCHASE on iOS and for GOOGLE_PLAY_INAPP_BILLING on Android. dispose() disconnects from the store; you can call setup() again later.

The Android public key is used on the device: every purchase whose signature does not match is reported as failed with the message invalid purchase signature and is not delivered. Without a key the device check is skipped, and so it is when the key cannot be read (a warning is written to logcat under the tag KlugBilling). Your server should check the purchase as well; see Verify purchases on your server.

Check availability

After SETUP_SUCCESS, checkAvailability(callback) tells you whether purchases can be made. The result is one of the InAppBillingAvailability constants; it goes to the optional callback and arrives as AvailabilityEvent.COMPLETE as well.

private function onSetup( e:InAppBillingEvent ):void
{
    store.checkAvailability( function( result:String ):void {
        switch ( result )
        {
            case InAppBillingAvailability.AVAILABLE:
                loadProducts();
                break;
            case InAppBillingAvailability.STORE_UPGRADE_REQUIRED:
                showMessage( "Please update the Google Play Store app to subscribe." );   // your app
                break;
            default:
                hideShop();
        }
    });
}

On iOS the callback and the event come right away, within the call. On Android the callback is called within the call and the event follows asynchronously. The property canMakePayments answers the same question directly: on iOS whether the device allows payments, on Android whether the connection to Google Play is up.

Load products and subscriptions

getProducts(productIds, subscriptionIds) loads the store data of your products. Put one-time products in the first array and subscriptions in the second. Google Play queries the two kinds separately, so a subscription in the first array (or a one-time product in the second) is reported as unknown on Android; on iOS the split makes no difference. Use the same product IDs in App Store Connect and in the Play Console, such as com.example.pro.yearly, and one code path serves both stores.

private function loadProducts():void
{
    store.addEventListener( ProductEvent.INVALID_PRODUCT, onInvalidProducts );
    store.addEventListener( ProductEvent.PRODUCTS_FAILED, onProductsFailed );
    store.getProducts(
        [ "com.example.removeads" ],                                // one-time products
        [ "com.example.pro.monthly", "com.example.pro.yearly" ] );   // subscriptions
}

private function onProductsLoaded( e:ProductEvent ):void
{
    for each ( var p:Product in e.products )
    {
        // localized by the store, e.g. "Pro Yearly · 19,99 € / 1 year"
        var label:String = p.title + " · " + p.priceString;
        if ( p.type == Product.TYPE_SUBSCRIPTION && p.subscriptionPeriod != null )
            label += " / " + p.subscriptionPeriod.toString();
        addShopButton( p.id, label );                                  // your app function
    }
}

private function onInvalidProducts( e:ProductEvent ):void
{
    trace( "unknown product ids: " + e.data.join( ", " ) );
}

private function onProductsFailed( e:ProductEvent ):void
{
    trace( "products failed: " + e.errorCode + " " + e.message );
}

Show priceString as it is: it is formatted by the store in the user's currency and language. price (a Number) and currencyCode (ISO 4217, such as EUR) are there for your own calculations, for example a monthly price of a yearly plan.

Subscription periods, offers and pricing phases

A subscription Product carries subscriptionOffers, an Array of SubscriptionOffer. subscriptionOffers[0] is always the regular price. Each offer has an id, tags and pricingPhases: the SubscriptionPhase objects in the order the customer goes through them, for example a free week, then the regular yearly price.

private function describeOffers( p:Product ):void
{
    for each ( var offer:SubscriptionOffer in p.subscriptionOffers )
    {
        var parts:Array = [];
        for each ( var phase:SubscriptionPhase in offer.pricingPhases )
        {
            var period:String = phase.subscriptionPeriod ? phase.subscriptionPeriod.toString() : "";
            if ( phase.recurrenceMode == SubscriptionPhase.INFINITE_RECURRING )
                parts.push( phase.priceString + " every " + period );
            else if ( phase.recurrenceMode == SubscriptionPhase.FINITE_RECURRING )
                parts.push( phase.priceString + " every " + period + " for " + phase.numberOfPeriods + " period(s)" );
            else
                parts.push( phase.priceString + " once for " + period );
        }
        // e.g. "offer 'introductory' [free-trial]: 0,00 € every 1 week for 1 period(s), then 19,99 € every 1 year"
        trace( "offer '" + offer.id + "' [" + offer.tags.join( "," ) + "]: " + parts.join( ", then " ) );
    }
}

Buy, deliver, finish

Load the product first: makePurchase() only works for products from a PRODUCTS_LOADED event. checkPurchaseRequestValid(request) is true when the product was loaded and canMakePayments is true. makePurchase(request) opens the store's purchase sheet and returns true; it returns false when the product was not loaded or (iOS) payments are not allowed.

public function buy( productId:String ):void
{
    var request:PurchaseRequest = new PurchaseRequest().setProductId( productId );
    if ( !store.checkPurchaseRequestValid( request ) || !store.makePurchase( request ) )
        showMessage( "The store is not available right now." );
}

From then on every step of the transaction arrives as PurchaseEvent.PURCHASES_UPDATED. e.data is an Array of Purchase; check transactionState of each one:

private function onPurchasesUpdated( e:PurchaseEvent ):void
{
    for each ( var p:Purchase in e.data )
        handlePurchase( p );
}

private function handlePurchase( p:Purchase ):void
{
    switch ( p.transactionState )
    {
        case Purchase.STATE_PURCHASING:
            showSpinner();                                   // your app
            break;

        case Purchase.STATE_DEFERRED:
            hideSpinner();
            showMessage( "Your purchase is waiting for approval." );
            break;

        case Purchase.STATE_PURCHASED:
        case Purchase.STATE_RESTORED:
            verifyOnServer( p, function( valid:Boolean ):void {   // see "Verify purchases"
                hideSpinner();
                if ( valid ) unlock( p.productId );           // your app
                store.finishPurchase( p );                    // close it, or the store sends it again
            });
            break;

        case Purchase.STATE_FAILED:
        case Purchase.STATE_CANCELLED:
            hideSpinner();
            store.finishPurchase( p );
            break;
    }
}

When to call finishPurchase()

finishPurchase(purchase) closes a transaction. Call it once for every PURCHASED, RESTORED, FAILED and CANCELLED transaction, and never for PURCHASING or DEFERRED. Call it only after the product has been delivered, that is after your server confirmed the purchase and your app saved the unlock: once a transaction is finished, the store does not send it again.

Use the Purchase objects from the events of the current app session. Transactions from earlier sessions are delivered again after setup(); finish those new objects.

Failed and cancelled purchases

A failed or cancelled purchase arrives twice: first in PURCHASES_UPDATED with STATE_FAILED or STATE_CANCELLED (finish it there, as above), then as PurchaseEvent.PURCHASE_FAILED with errorCode, message and the purchase in e.data. Use PURCHASE_FAILED to tell the user. One exception on Android: ITEM_ALREADY_OWNED arrives only as PURCHASE_FAILED, with an empty e.data.

private function onPurchaseFailed( e:PurchaseEvent ):void
{
    hideSpinner();
    switch ( e.errorCode )
    {
        case ErrorCodes.USER_CANCELLED:
            break;                                           // the user decided; say nothing
        case ErrorCodes.ITEM_ALREADY_OWNED:                   // Android: already bought
            restore();                                       // see "Restore purchases"
            break;
        case ErrorCodes.NOT_ALLOWED:                          // iOS: payments disabled on this device
            showMessage( "Purchases are not allowed on this device." );
            break;
        case ErrorCodes.NETWORK_ERROR:
        case ErrorCodes.SERVICE_UNAVAILABLE:
            showMessage( "The store cannot be reached. Please try again later." );
            break;
        default:
            showMessage( "The purchase did not go through. " + e.message );
    }
}

Deferred purchases

A deferred purchase is neither paid nor failed yet. On iOS this is Ask to Buy: a family organiser has to approve the purchase. On Android it is a pending purchase: the user chose a payment method that completes later, such as cash at a shop; Google Play allows this for one-time products. In both cases the purchase arrives with STATE_DEFERRED. Do not unlock and do not finish. When the purchase completes, it arrives again: while your app runs through PURCHASES_UPDATED, otherwise after the next setup(), as STATE_PURCHASED (or, on iOS, STATE_FAILED if it was declined).

Buy a subscription with an offer

To buy a subscription with a specific offer, wrap the SubscriptionOffer in a SubscriptionOfferRequest and attach it to the PurchaseRequest. Without an offer request the regular price is bought.

// e.g. buyWithOffer( "com.example.pro.yearly", "free-trial" )
public function buyWithOffer( productId:String, tag:String ):void
{
    var product:Product = store.getProduct( productId );
    if ( product == null || product.subscriptionOffers == null ) return;

    var chosen:SubscriptionOffer = product.subscriptionOffers[ 0 ];   // the regular price
    for each ( var offer:SubscriptionOffer in product.subscriptionOffers )
    {
        if ( offer.tags.indexOf( tag ) >= 0 ) { chosen = offer; break; }
    }

    store.makePurchase( new PurchaseRequest()
        .setProductId( productId )
        .setSubscriptionOfferRequest( new SubscriptionOfferRequest().setSubscriptionOffer( chosen ) ) );
}

On Android, tag your offers in the Play Console (for example free-trial) so the same code finds them on both platforms; on iOS KlugBilling sets the tag free-trial or introductory itself.

Restore purchases

Apps that sell non-consumable products or subscriptions should offer a way to restore them, for example a "Restore Purchases" button. The two stores work differently here, and isGetPurchasesSupported tells you which way to go:

On Android, restorePurchases() only reports RESTORE_PURCHASES_SUCCESS or RESTORE_PURCHASES_FAILED and delivers no purchases, and on iOS getPurchases() returns false. Use the right call per platform:

public function restore():void
{
    if ( store.isGetPurchasesSupported )                  // Android
    {
        store.addEventListener( PurchaseEvent.GET_PURCHASES_COMPLETE, onOwnedPurchases );
        store.addEventListener( PurchaseEvent.GET_PURCHASES_FAILED,   onRestoreFailed );
        store.getPurchases();
    }
    else                                                  // iOS: STATE_RESTORED arrives in handlePurchase()
    {
        store.addEventListener( PurchaseEvent.RESTORE_PURCHASES_SUCCESS, onRestoreDone );
        store.addEventListener( PurchaseEvent.RESTORE_PURCHASES_FAILED,  onRestoreFailed );
        store.restorePurchases();
    }
}

private function onOwnedPurchases( e:PurchaseEvent ):void
{
    for each ( var p:Purchase in e.data )
    {
        // verify, unlock, finish: acknowledges a purchase that is still open,
        // and returns at once for one that is already acknowledged
        if ( p.transactionState == Purchase.STATE_PURCHASED ) handlePurchase( p );
    }
    showMessage( "Purchases restored." );
}

private function onRestoreDone( e:PurchaseEvent ):void
{
    showMessage( "Purchases restored." );
}

private function onRestoreFailed( e:PurchaseEvent ):void
{
    showMessage( "Restoring failed. " + e.message );
}

Subscriptions do not have to be restored for your app to know about them: your server can check their state with the receipt or purchase token at any time. Restoring is for the user who reinstalled the app or uses a new device.

Pending purchases at startup

A purchase can be paid while your app is not running or before it could finish it: the app crashed after payment, the network was down during verification, an Ask to Buy request was approved, or (iOS) a subscription renewed or a purchase was started from your App Store page. KlugBilling hands these over after setup(), as ordinary PURCHASES_UPDATED events, so handlePurchase() from above covers them. That is why the listener must be added before setup().

getPendingPurchases() returns, without an event, the transactions that are still open. On iOS these are all unfinished transactions in the StoreKit queue except those still in STATE_PURCHASING; call it after setup(). On Android these are the purchases delivered in this session that are not yet acknowledged. Use it to avoid a second purchase while one is still open, not to deliver: the delivery runs through PURCHASES_UPDATED.

private function hasOpenTransaction( productId:String ):Boolean
{
    for each ( var p:Purchase in store.getPendingPurchases() )
    {
        if ( p.productId == productId ) return true;
    }
    return false;
}

Verify purchases on your server

Before you unlock anything of value, let your server confirm the purchase with Apple or Google. Each Purchase carries what the server needs:

import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;

// done( valid ) is called only when the server answered. Without an answer the purchase
// stays unfinished and is delivered again after the next setup().
private function verifyOnServer( p:Purchase, done:Function ):void
{
    var body:Object = { platform: store.platform, productId: p.productId, transactionId: p.transactionId };
    if ( store.platform == "ios" )
    {
        body.receipt = p.transactionReceipt;                 // app receipt, base64
        body.originalTransactionId = p.originalTransactionId;
    }
    else
    {
        body.purchaseToken = p.transactionId;               // for the Google Play Developer API
        body.purchaseData  = p.originalMessage;             // signed JSON
        body.signature     = p.signature;
    }

    var request:URLRequest = new URLRequest( "https://api.example.com/verify-purchase" );
    request.method = URLRequestMethod.POST;
    request.contentType = "application/json";
    request.data = JSON.stringify( body );

    var loader:URLLoader = new URLLoader();
    loader.addEventListener( Event.COMPLETE, function( ev:Event ):void {
        var answer:Object = JSON.parse( String( loader.data ) );
        done( answer.valid == true );
    });
    loader.addEventListener( IOErrorEvent.IO_ERROR, function( ev:IOErrorEvent ):void {
        hideSpinner();                                       // try again at the next start
    });
    loader.load( request );
}

On iOS you can also read the app receipt at any time with applicationReceipt.getAppReceipt(), for example to send it to your server at login. It returns "" when there is no receipt on the device yet, which is normal for development builds before the first sandbox purchase. applicationReceipt.refresh() asks the App Store for a fresh one and may show an Apple ID sign-in; the result arrives as ApplicationReceiptEvent on the applicationReceipt object, not on the service. On Android applicationReceipt.isSupported is false.

public function sendReceiptToServer():void
{
    var receipt:ApplicationReceipt = store.applicationReceipt;
    if ( !receipt.isSupported ) return;                 // iOS only

    var data:String = receipt.getAppReceipt();
    if ( data != "" )
    {
        uploadReceipt( data );                               // your server call
        return;
    }
    receipt.addEventListener( ApplicationReceiptEvent.REFRESH_SUCCESS, function( e:ApplicationReceiptEvent ):void {
        uploadReceipt( receipt.getAppReceipt() );
    });
    receipt.addEventListener( ApplicationReceiptEvent.REFRESH_FAILED, function( e:ApplicationReceiptEvent ):void {
        trace( "receipt refresh failed: " + e.message );
    });
    receipt.refresh();
}

Testing

App Store. Test on a device; the iOS Simulator uses the fallback where isSupported is false.

• Create the products in App Store Connect with complete metadata, and make sure the Paid Applications agreement is active. Until then getProducts() reports your IDs as INVALID_PRODUCT.
• Development and ad-hoc builds buy in the App Store sandbox. Create a sandbox Apple Account in App Store Connect (Users and Access, Sandbox) and sign in with it when the purchase sheet asks, or in the sandbox account section of the device's settings. Nothing is charged.
• TestFlight builds also buy in the sandbox, with the tester's own Apple Account, free of charge.
• Sandbox subscriptions renew at an accelerated rate (minutes instead of months), so renewals and expiry can be tested in one session.
• Sandbox receipts must be verified against Apple's sandbox environment; production receipts against production.

Google Play. Test on a device or emulator with the Google Play Store and a signed-in Google account.

• Upload a build to a testing track (internal testing is fastest), and create and activate your products and subscriptions in the Play Console.
• Add the testers' Google accounts as license testers (Play Console, Settings, License testing) and to the testing track. Install the app from the track's opt-in link; the application ID of the build must match the app in the Play Console.
• License testers pay with test payment methods: a test card that always approves, one that always declines, and slow test cards that approve or decline after a few minutes. A slow card is the easiest way to test STATE_DEFERRED.
• Test subscriptions renew within minutes. Test purchases are not charged.
• KlugBilling writes warnings to logcat under the tag KlugBilling: adb logcat -s KlugBilling.

Error handling

Errors arrive in the errorCode of InAppBillingEvent, ProductEvent and PurchaseEvent, and in Purchase.errorCode of failed purchases, always as one of the ErrorCodes constants. message (or Purchase.errorMessage) adds the store's own text, which is meant for your logs, not for users.

API reference

All classes are in the package com.klug.billing; the events are in com.klug.billing.events.

InAppBilling

Static entry point. Everything is static; apps may extend the class, for example for a purchase helper.

InAppBillingService

Extends flash.events.EventDispatcher. Use it through InAppBilling.service; do not create further instances. All results are dispatched on this object, except ApplicationReceiptEvent.

BillingService

Describes the store for setup(). Builder style: the setters return the object.

InAppBillingServiceTypes

InAppBillingAvailability

Product

A product as the store reports it, with localized texts and prices.

Purchase

A store transaction. Finish it with finishPurchase() once delivered.

PurchaseRequest

What to buy. Builder style.

SubscriptionOffer

A way to buy a subscription. Product.subscriptionOffers[0] is always the regular price.

SubscriptionOfferRequest

Chooses the offer for a subscription purchase. Builder style.

SubscriptionPeriod

Length of a subscription or pricing phase, e.g. 3 x UNIT_MONTH.

SubscriptionPhase

One pricing phase of a subscription offer.

ApplicationReceipt

Extends flash.events.EventDispatcher. The iOS app receipt, the signed record of everything this Apple ID bought in the app. Get it through InAppBilling.service.applicationReceipt.

ErrorCodes

When each code occurs is described in Error handling.

Events

All event classes are in com.klug.billing.events, extend flash.events.Event, do not bubble and cannot be cancelled. They are dispatched on InAppBilling.service, except ApplicationReceiptEvent, which is dispatched on InAppBilling.service.applicationReceipt. Each class implements clone().

InAppBillingEvent

InAppBillingEvent(type:String, errorCode:String = "", message:String = "", data:Array = null). Fields: errorCode:String, message:String, data:Array (not filled in 1.0.0).

ProductEvent

ProductEvent(type:String, products:Array = null, data:Array = null, errorCode:String = "", message:String = ""). Fields: products:Array (of Product), data:Array (of product ID strings), errorCode:String, message:String.

PurchaseEvent

PurchaseEvent(type:String, data:Array = null, errorCode:String = "", message:String = ""). Fields: data:Array (of Purchase), errorCode:String, message:String.

AvailabilityEvent

AvailabilityEvent(type:String, availability:String = ""). Field: availability:String, one of InAppBillingAvailability.

ApplicationReceiptEvent

ApplicationReceiptEvent(type:String, message:String = ""). Field: message:String. Dispatched on applicationReceipt.

Troubleshooting

isSupported is false on iOS

The native part is built for iOS devices. In the iOS Simulator the fallback is used. Test on a device.

setup() returns false on iOS and no setup event arrives

The BillingService carries a googlePlayPublicKey. Set the key only in the Android branch, as in Set up the store.

SETUP_FAILURE on Android

Google Play is not available on the device: no Play Store, no Google account signed in to it, or an outdated Play Store. Emulators need a system image with Google Play. errorCode and message carry Google's reason.

PRODUCTS_LOADED is empty, or my IDs come back in INVALID_PRODUCT

Check that the IDs are exactly the ones in App Store Connect or the Play Console. iOS: the products need complete metadata and an active Paid Applications agreement. Android: subscriptions belong in the second array of getProducts(), one-time products in the first; the products must be active, and the app must be uploaded to a testing track and installed by a tester account.

makePurchase() returns false

The product was not loaded with getProducts() in this session, or (iOS) the device does not allow payments. Use checkPurchaseRequestValid() first.

checkPurchaseRequestValid() is false on Android after a long time in the background

The connection to Google Play was lost, so canMakePayments is false. Call setup() again and buy after SETUP_SUCCESS.

The same purchase arrives at every app start

It was never finished. Call finishPurchase() after delivery, also for failed and cancelled transactions, and watch for FINISH_FAILED.

Google Play refunded purchases after three days

The purchases were not acknowledged. On Android finishPurchase() is the acknowledgement. Keep the PURCHASES_UPDATED listener in place before setup() so that purchases replayed at start are finished as well.

ITEM_ALREADY_OWNED on Android

The Google account owns the product. Call getPurchases() and deliver what it lists. Version 1.0.0 does not consume one-time products on Google Play, so they cannot be bought a second time.

Every Android purchase fails with "invalid purchase signature"

The public key does not belong to this app. Copy it again from the Play Console of exactly this app (Monetization setup). A key that cannot be read at all is skipped with a logcat warning under the tag KlugBilling.

FINISH_FAILED with "unknown or already finished transaction"

The purchase was finished before, it is still PURCHASING or DEFERRED, or the Purchase object is from an earlier app session. Finish each purchase once, with the object from the current session's events.

restorePurchases() delivers nothing on Android

On Android it only reports success or failure. Use getPurchases(); isGetPurchasesSupported tells you which call to use.

getAppReceipt() returns an empty string

Development builds have no receipt until the first sandbox purchase. Call applicationReceipt.refresh() and read it again after REFRESH_SUCCESS.

iOS shows the introductory offer to a user who already used it

The App Store reports the introductory offer without eligibility, and StoreKit charges the regular price when the user is not eligible. If you want to hide the offer, decide on your server from the receipt whether the user had a trial before. Google Play returns only offers the user is eligible for.

The product title on Android contains my app name

Google Play adds the app name in brackets to product titles. Show your own label, or cut the part in brackets.

The quantity is ignored on Android

PurchaseRequest.quantity is used on iOS only. On Google Play the user picks the quantity in the purchase sheet when multi-quantity purchases are enabled for the product; Purchase.quantity reports it.

The Android build fails to resolve the billing library

The Google Play Billing Library is fetched through Gradle when ADT packages the app. Make sure the build machine can reach Google's Maven repository, or that the library is in the local Gradle cache.

Changelog

1.0.0

• First release for iOS (StoreKit) and Android (Google Play Billing Library 8.3.0, added by Gradle at packaging)
• One-time products and auto-renewing subscriptions with localized prices, billing periods, offers and pricing phases
• All transaction states as events; finishPurchase() finishes iOS transactions and acknowledges Google Play purchases
• Open transactions and unacknowledged Google Play purchases delivered again after setup(); purchases started from the App Store page accepted
• Restore on iOS, owned purchases on Android, the iOS app receipt with refresh
• Android: signature check of every purchase against the Play public key