Flutter Billing

await AppDNA.configure(
  apiKey: 'adn_live_xxx',
  env: AppDNAEnvironment.production,
  options: AppDNAOptions(billingProvider: AppDNABillingProvider.storeKit2),
);

class MyPaywallDelegate extends AppDNAPaywallDelegate {
  @override
  void onPaywallPurchaseFailed(
      String paywallId, Object error, String errorType, String? productId) {
    if (errorType == 'providerNotAvailable' && productId != null) {
      // RevenueCat owns purchases: buy the tapped plan with RevenueCat.
      startRevenueCatPurchase(productId); // e.g. Purchases.purchaseStoreProduct(...)
    }
  }
  // ... other callbacks
}

final billing = AppDNA.billing;

final products = await AppDNA.billing.getProducts(["premium_monthly"]);

for (final product in products) {
  print("${product.name}: ${product.displayPrice}");
}

final result = await AppDNA.billing.purchase(
  "premium_monthly",
  offerToken: "offer-xxx",
);

switch (result.status) {
  case 'purchased':
    print("Purchase successful!");
    if (result.entitlement != null) {
      print("Entitlement: ${result.entitlement!.productId}");
    }
    break;
  case 'cancelled':
    print("User cancelled");
    break;
  case 'pending':
    print("Purchase pending approval");
    break;
  default:
    print("Unknown status: ${result.status}");
}

try {
  await AppDNA.billing.purchase('premium_monthly');
} on PlatformException catch (e) {
  if (e.code == 'PURCHASE_ERROR') {
    final errorType = (e.details as Map?)?['errorType'] as String? ?? 'unknown';
    switch (errorType) {
      case 'userCancelled':
        break; // nothing to show
      case 'providerNotAvailable':
        // billingProvider is revenueCat / adapty / none: buy through your provider instead.
        break;
      case 'networkError':
      case 'serverError':
        // offer a retry
        break;
      default:
        // show a generic error
    }
  }
}

// Inside onPurchaseCompleted:
final txnId = transaction['transactionId'] as String;
final purchasedAt = DateTime.fromMillisecondsSinceEpoch(
  int.parse(transaction['purchaseDate'] as String),
);

final entitlements = await AppDNA.billing.restorePurchases();

for (final ent in entitlements) {
  print("Restored: ${ent.productId} (${ent.status})");
}

try {
  await AppDNA.billing.restorePurchases();
} on PlatformException catch (e) {
  final errorType = (e.details as Map?)?['errorType'] as String? ?? 'unknown';
  if (errorType == 'providerNotAvailable') {
    // restore through your billing provider instead
  } else {
    // show a retry
  }
}

final active = await AppDNA.billing.hasActiveSubscription();

if (active) {
  // Unlock premium features
}

final ents = await AppDNA.billing.getEntitlements();

for (final ent in ents) {
  print("${ent.productId}: ${ent.status}, trial: ${ent.isTrial}");
}

AppDNA.billing.onEntitlementsChanged.listen((List<Entitlement> entitlements) {
  print("Entitlements changed: ${entitlements.length} active");
  // Update UI to reflect new entitlement state
});

AppDNA.billing.onEntitlementsChangedCallback((List<Entitlement> entitlements) {
  print("Entitlements updated");
});

abstract class AppDNABillingDelegate {
  void onPurchaseCompleted(String productId, Map<String, dynamic> transaction);
  void onPurchaseFailed(String productId, Object error);
  void onEntitlementsChanged(List<Map<String, dynamic>> entitlements);
  void onRestoreCompleted(List<String> restoredProductIds);
  void onBillingUnavailable() {}
}

class MyBillingHandler extends AppDNABillingDelegate {
  @override
  void onPurchaseCompleted(String productId, Map<String, dynamic> transaction) {
    print("Purchased: $productId");
    // Unlock premium features
  }

  @override
  void onPurchaseFailed(String productId, Object error) {
    // `error` is a typed Object -- usually a Map<String, dynamic> from native
    // ({ "message": "...", "type": "..." }) or a raw String. Stringify when displaying.
    print("Purchase failed: $productId -- $error");
    // Show error message to user
  }

  @override
  void onEntitlementsChanged(List<Map<String, dynamic>> entitlements) {
    // Each entry is an Entitlement-shaped map: productId/store/status/expiresAt/isTrial/offerType.
    final productIds = entitlements.map((e) => e["productId"]).join(', ');
    print("Entitlement product IDs: $productIds");
    // For strongly-typed entitlement objects, parse each map:
    //   final ents = entitlements.map(Entitlement.fromMap).toList();
  }

  @override
  void onRestoreCompleted(List<String> restoredProductIds) {
    print("Restored ${restoredProductIds.length} products");
  }

  @override
  void onBillingUnavailable() {
    // Android-only: billing permanently unavailable (Play Services missing/broken).
    print("Billing unavailable -- hiding purchase UI");
  }
}

import 'package:appdna_sdk/appdna_sdk.dart';
import 'package:flutter/material.dart';

class SubscriptionPage extends StatefulWidget {
  const SubscriptionPage({super.key});

  @override
  State<SubscriptionPage> createState() => _SubscriptionPageState();
}

class _SubscriptionPageState extends State<SubscriptionPage> {
  List<ProductInfo> _products = [];
  bool _isSubscribed = false;

  @override
  void initState() {
    super.initState();
    _loadProducts();
    _checkSubscription();

    // Listen for entitlement changes
    AppDNA.billing.onEntitlementsChanged.listen((entitlements) {
      setState(() {
        _isSubscribed = entitlements.any((e) => e.status == "active");
      });
    });
  }

  Future<void> _loadProducts() async {
    final products = await AppDNA.billing.getProducts([
      "premium_monthly",
      "premium_yearly",
    ]);
    setState(() => _products = products);
  }

  Future<void> _checkSubscription() async {
    final active = await AppDNA.billing.hasActiveSubscription();
    setState(() => _isSubscribed = active);
  }

  Future<void> _purchase(ProductInfo product) async {
    final result = await AppDNA.billing.purchase(
      product.id,
      offerToken: product.offerToken,
    );
    if (result.status == 'purchased') {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text("Purchase successful!")),
      );
    }
  }

  Future<void> _restore() async {
    final restored = await AppDNA.billing.restorePurchases();
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(content: Text("Restored ${restored.length} purchases")),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text("Subscription"),
        actions: [
          TextButton(
            onPressed: _restore,
            child: const Text("Restore"),
          ),
        ],
      ),
      body: ListView(
        children: _products.map((product) {
          return ListTile(
            title: Text(product.name),
            subtitle: Text(product.description),
            trailing: Text(product.displayPrice),
            onTap: () => _purchase(product),
          );
        }).toList(),
      ),
    );
  }
}

await AppDNA.reportPayingUser(
  productId: 'pro_monthly',
  priceCents: 999,
  currency: 'USD',
);