Complete Guide to iOS In-App Purchases in Flutter

import 'dart:async';
import 'dart:developer';
import 'package:in_app_purchase/in_app_purchase.dart';

class InAppPurchaseService {
  InAppPurchaseService._();
  static final InAppPurchaseService instance = InAppPurchaseService._();

  static final InAppPurchase _iap = InAppPurchase.instance;
  StreamSubscription>? _subscription;

  // Cache to track processed IDs and avoid redundant backend calls
  final Set _handledPurchaseIds = {};

  static const Set iapSubscriptionIds = {
    'monthly_subscription',
    'quarterly_subscription',
    'half_year_subscription',
    'yearly_subscription',
  };

  /// Initializes the IAP connection and checks if the store is available.
  Future initialize() async {
    final available = await _iap.isAvailable();
    log('IAP Availability: $available');
    return available;
  }

  /// Queries App Store Connect for product information based on defined IDs.
  Future> fetchProducts() async {
    final response = await _iap.queryProductDetails(iapSubscriptionIds);

    if (response.error != null) {
      throw Exception('Product Query Error: ${response.error!.message}');
    }

    if (response.productDetails.isEmpty) {
      log('No products found. Ensure products are "Ready to Submit" in App Store Connect.');
    }

    return response.productDetails;
  }

  /// Launches the native iOS payment sheet for a specific product.
  Future buySubscription(ProductDetails product) async {
    final param = PurchaseParam(productDetails: product);
    await _iap.buyNonConsumable(purchaseParam: param);
  }

  /// Sets up the stream listener to handle purchase updates (purchased, restored, etc).
  void listenToPurchases({
    required void Function(PurchaseDetails purchase) onVerified,
    required void Function(PurchaseDetails purchase) onError,
  }) {
    _subscription ??= _iap.purchaseStream.listen(
      (purchases) async {
        for (final purchase in purchases) {
          final purchaseId = purchase.purchaseID ?? '';

          // Skip if this specific transaction instance was already handled
          if (_handledPurchaseIds.contains(purchaseId)) continue;

          switch (purchase.status) {
            case PurchaseStatus.purchased:
            case PurchaseStatus.restored:
              _handledPurchaseIds.add(purchaseId);
              // Complete the transaction with Apple before notifying the UI
              await _complete(purchase);
              onVerified(purchase);
              break;

            case PurchaseStatus.pending:
              log('Purchase Status: Pending');
              break;

            case PurchaseStatus.error:
              onError(purchase);
              break;

            case PurchaseStatus.canceled:
              log('Purchase Status: Canceled');
              break;
          }
        }
      },
      onError: (e) => log('Purchase Stream Error: $e'),
    );
  }

  /// Signals to the App Store that the delivery of the product is successful.
  Future _complete(PurchaseDetails purchase) async {
    if (purchase.pendingCompletePurchase) {
      await _iap.completePurchase(purchase);
    }
  }

  /// Triggers the native Apple restore flow for existing subscriptions.
  Future restorePurchases() async {
    await _iap.restorePurchases();
  }

  /// Clears the local cache of handled IDs. Useful for local testing.
  void clearHandledPurchases() {
    _handledPurchaseIds.clear();
  }

  /// Cancels the stream subscription when the service is no longer needed.
  void dispose() {
    _subscription?.cancel();
    _subscription = null;
    _handledPurchaseIds.clear();
  }
}