aptoide_iap_android #

license: MIT

Flutter plugin for the Aptoide Android Billing SDK.
Integrates in-app purchases (consumables & non-consumables) and subscriptions (including free trials) for apps distributed via Aptoide Connect.

Platform support #

Android	iOS	Web
✅	—	—

Minimum Android SDK: 21

Installation #

# pubspec.yaml
dependencies:
  aptoide_iap_android: ^0.1.0

flutter pub get

Android project setup #

In your project-level build.gradle, add the JitPack repository:

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url "https://jitpack.io" }  // required by Aptoide Billing SDK
    }
}

The plugin automatically adds the Aptoide Billing SDK dependency to your app.
No additional build.gradle changes are needed in your app module.

Setup #

1. Get your public key #

2. Initialize once at app startup #

Initialize before any UI interaction, ideally in main() or your root widget's initState.
Subscribe to streams before calling initialize to avoid missing the first events.

import 'package:aptoide_iap_android/aptoide_iap_android.dart';

const _publicKey = 'YOUR_APTOIDE_CONNECT_PUBLIC_KEY';

Future<void> setupBilling() async {
  // Subscribe to real-time purchase updates first
  AptoideIapAndroid.purchasesUpdatedStream.listen((event) async {
    if (event.billingResult.isOk) {
      for (final purchase in event.purchases) {
        await _handlePurchase(purchase);
      }
    } else {
      print('Purchase error: ${event.billingResult.debugMessage}');
    }
  });

  // Connect
  final result = await AptoideIapAndroid.initialize(publicKey: _publicKey);

  if (result.isOk) {
    // Check for purchases that weren't processed in a previous session
    await _checkPendingConsumables();
    await _checkActiveSubscriptions();
  }
}

The 4-step integration #

Step 1 — Connection #

// Connect
final BillingResult result = await AptoideIapAndroid.initialize(
  publicKey: 'YOUR_KEY',
);

// Check readiness before making purchases
final bool ready = await AptoideIapAndroid.isReady;

// Disconnect when done (e.g. app shutdown)
await AptoideIapAndroid.endConnection();

Listen to connection state changes:

AptoideIapAndroid.billingStateStream.listen((event) {
  if (event.state == BillingConnectionState.connected) {
    print('Billing ready');
  } else {
    print('Billing disconnected');
  }
});

Step 2 — Query products #

Always fetch product details from Aptoide Connect and use the returned prices in your UI.
This is mandatory for app review.

// One-time in-app products
final QueryProductDetailsResult result =
    await AptoideIapAndroid.queryProductDetails(
  productIds: ['coins_100', 'remove_ads'],
  productType: ProductType.inapp,
);

for (final product in result.productDetailsList) {
  final price = product.oneTimePurchaseOfferDetails?.formattedPrice ?? '';
  print('${product.title} — $price');
}

// Subscriptions
final QueryProductDetailsResult subResult =
    await AptoideIapAndroid.queryProductDetails(
  productIds: ['premium_monthly'],
  productType: ProductType.subs,
);

for (final product in subResult.productDetailsList) {
  final phase =
      product.subscriptionOfferDetails?.first.pricingPhases.first;
  print('${product.title} — ${phase?.formattedPrice}/${phase?.billingPeriod}');
}

// Handle products that failed to load
for (final unfetched in result.unfetchedProductList) {
  print('Failed to load ${unfetched.productId}: ${unfetched.responseCode}');
}

Step 3 — Launch a purchase #

// One-time purchase
await AptoideIapAndroid.launchBillingFlow(
  productId: 'coins_100',
  productType: ProductType.inapp,
  obfuscatedAccountId: currentUserId,   // optional, but recommended
  developerPayload: 'order-ref-abc123', // optional, for your own tracking
);

// Subscription with free trial
final freeTrialSupported =
    await AptoideIapAndroid.isFeatureSupported(FeatureType.freeTrials) == 0;

await AptoideIapAndroid.launchBillingFlow(
  productId: 'premium_monthly',
  productType: ProductType.subs,
  obfuscatedAccountId: currentUserId, // required for free trials
  freeTrial: freeTrialSupported,
);

The purchase result is delivered via purchasesUpdatedStream (not from the launchBillingFlow return value).

Step 4 — Process & consume purchases #

Future<void> _handlePurchase(Purchase purchase) async {
  // 1. Validate server-side (strongly recommended)
  //    https://docs.catappult.io/docs/iap-validators-server-to-server-check-client
  final valid = await myServer.validatePurchase(
    purchaseToken: purchase.purchaseToken,
    packageName: purchase.packageName,
  );
  if (!valid) return;

  // 2. Deliver the item to the user
  await myStore.grantItem(purchase.products.first);

  // 3. Consume to allow re-purchase (consumables) or activate (subscriptions)
  final ConsumeResult result = await AptoideIapAndroid.consumePurchase(
    purchaseToken: purchase.purchaseToken,
  );

  if (!result.billingResult.isOk) {
    print('Consume failed: ${result.billingResult.debugMessage}');
  }
}

Handle purchases from previous sessions on startup:

Future<void> _checkPendingConsumables() async {
  final result = await AptoideIapAndroid.queryPurchases(ProductType.inapp);
  for (final purchase in result.purchases) {
    await _handlePurchase(purchase);
  }
}

Future<void> _checkActiveSubscriptions() async {
  final result = await AptoideIapAndroid.queryPurchases(ProductType.subs);
  // purchases present = active or pending subscriptions
  // purchases absent  = subscription expired; revoke access
  final activeIds = result.purchases.map((p) => p.products).expand((i) => i).toSet();
  await myStore.syncSubscriptions(activeIds);
}

Complete API reference #