Android Billing

AppDNA.configure(
    context = applicationContext,
    apiKey = "adn_live_xxx",
    environment = Environment.PRODUCTION,
    // `billingProvider` is a field on AppDNAOptions, not a direct argument.
    // Optional — defaults to BillingProvider.StoreKit2 (Google Play Billing on Android)
    options = AppDNAOptions(billingProvider = BillingProvider.StoreKit2),
)

val billing = AppDNA.billing

import androidx.lifecycle.lifecycleScope

lifecycleScope.launch {
    val products = AppDNA.billing.getProducts(listOf("premium_monthly", "premium_yearly"))
    // Returns List<ProductInfo>
    for (product in products) {
        Log.d("Billing", "${product.name}: ${product.formattedPrice}")
    }
}

import androidx.lifecycle.lifecycleScope

lifecycleScope.launch {
    try {
        val transaction = AppDNA.billing.purchase(
            activity = this@MyActivity,
            productId = "premium_monthly",
        )
        Log.d("Billing", "Purchased: ${transaction.productId}")
    } catch (e: Exception) {
        Log.e("Billing", "Purchase failed", e)
    }
}

import ai.appdna.sdk.billing.PurchaseOptions

lifecycleScope.launch {
    val products = AppDNA.billing.getProducts(listOf("premium_monthly"))
    val product = products.firstOrNull() ?: return@launch
    val offerToken = product.offerToken

    val transaction = AppDNA.billing.purchase(
        activity = this@MyActivity,
        productId = "premium_monthly",
        options = PurchaseOptions(offerToken = offerToken),
    )
}

lifecycleScope.launch {
    val restoredProductIds = AppDNA.billing.restorePurchases()
    Log.d("Billing", "Restored ${restoredProductIds.size} products")
}

lifecycleScope.launch {
    val entitlements = AppDNA.billing.getEntitlements()
    for (entitlement in entitlements) {
        Log.d("Billing", "${entitlement.productId}: status=${entitlement.status}")
    }
}

val hasSubscription = AppDNA.billing.hasActiveSubscription()

if (hasSubscription) {
    // Unlock premium features
}

AppDNA.billing.onEntitlementsChanged { entitlements ->
    val activeIds = entitlements
        .filter { it.status == "active" }
        .map { it.productId }
    Log.d("Billing", "Active entitlements: $activeIds")
}

import ai.appdna.sdk.AppDNABillingDelegate
import ai.appdna.sdk.TransactionInfo
import ai.appdna.sdk.billing.Entitlement
// purchase() takes the foreground Activity directly — actual signature is
// `suspend fun purchase(activity: Activity, productId: String, options: PurchaseOptions? = null): TransactionInfo`

interface AppDNABillingDelegate {
    fun onPurchaseCompleted(productId: String, transaction: TransactionInfo) {}
    fun onPurchaseFailed(productId: String, error: Throwable) {}
    fun onEntitlementsChanged(entitlements: List<Entitlement>) {}
    fun onRestoreCompleted(restoredProducts: List<String>) {}

    /**
     * Fires once when the SDK gives up on connecting to Play Billing (Play
     * Services missing or permanently broken on this device). Hide paywalls
     * / disable purchase UI when this fires so users don't tap a dead button.
     */
    fun onBillingUnavailable() {}
}

AppDNA.billing.setDelegate(delegate, deliversPurchases = false)

class BillingHandler : AppDNABillingDelegate {

    override fun onPurchaseCompleted(productId: String, transaction: TransactionInfo) {
        Log.d("Billing", "Purchase completed: $productId")
        // Update UI, unlock features
    }

    override fun onPurchaseFailed(productId: String, error: Throwable) {
        Log.e("Billing", "Purchase failed: $productId — ${error.message}", error)
        // Show error to user
    }

    override fun onEntitlementsChanged(entitlements: List<Entitlement>) {
        val active = entitlements.filter { it.status == "active" }
        Log.d("Billing", "Entitlements updated: ${active.size} active")
    }

    override fun onRestoreCompleted(restoredProducts: List<String>) {
        Log.d("Billing", "Restored ${restoredProducts.size} products")
    }

    override fun onBillingUnavailable() {
        Log.w("Billing", "Play Billing unavailable — hide purchase UI")
        // Hide paywalls, disable purchase buttons
    }
}

import ai.appdna.sdk.AppDNA
import ai.appdna.sdk.AppDNABillingDelegate
import ai.appdna.sdk.TransactionInfo
import ai.appdna.sdk.billing.Entitlement
import kotlinx.coroutines.runBlocking

class SubscriptionManager : AppDNABillingDelegate {

    suspend fun loadProducts() {
        try {
            val products = AppDNA.billing.getProducts(
                listOf("premium_monthly", "premium_annual")
            )
            // Display products in UI
            updateUi(products)
        } catch (e: Exception) {
            Log.e("Billing", "Failed to load products", e)
        }
    }

    suspend fun purchaseMonthly(activity: Activity) {
        try {
            val transaction = AppDNA.billing.purchase(
                activity = activity,
                productId = "premium_monthly",
            )
            unlockPremiumFeatures()
            Log.d("Billing", "Purchased ${transaction.productId}")
        } catch (e: Exception) {
            showError(e)
        }
    }

    suspend fun checkAccess() {
        if (AppDNA.billing.hasActiveSubscription()) {
            unlockPremiumFeatures()
        }
    }

    // AppDNABillingDelegate

    override fun onPurchaseCompleted(productId: String, transaction: TransactionInfo) {
        unlockPremiumFeatures()
    }

    override fun onPurchaseFailed(productId: String, error: Throwable) {
        showError(error)
    }

    override fun onBillingUnavailable() {
        // Play Billing unavailable — hide premium upsells
    }

    override fun onEntitlementsChanged(entitlements: List<Entitlement>) {
        refreshAccessState(entitlements)
    }

    override fun onRestoreCompleted(restoredProducts: List<String>) {
        showRestoredAlert(restoredProducts.size)
    }

    private fun updateUi(products: List<Any>) { /* ... */ }
    private fun unlockPremiumFeatures() { /* ... */ }
    private fun showError(error: Throwable) { /* ... */ }
    private fun refreshAccessState(entitlements: List<Entitlement>) { /* ... */ }
    private fun showRestoredAlert(count: Int) { /* ... */ }
}

AppDNA.reportPayingUser(productId = "pro_monthly", priceCents = 999, currency = "USD")