@namiml/expo-nami-iap 3.4.0-dev.202605060437

package/android/src/google/java/ml/nami/expo/iap/google/PlayBillingConnection.kt

@@ -0,0 +1,104 @@
+package ml.nami.expo.iap.google
+
+import android.content.Context
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.PendingPurchasesParams
+import com.android.billingclient.api.PurchasesUpdatedListener
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+/**
+ * Wraps [BillingClient] construction and connection lifecycle.
+ *
+ * [ensureConnected] suspends until the client is connected. If the client
+ * disconnects with [BillingClient.BillingResponseCode.SERVICE_DISCONNECTED],
+ * it retries the connection once automatically.
+ */
+internal class PlayBillingConnection(
+    context: Context,
+    builder: BillingClient.Builder,
+) {
+    /**
+     * Convenience constructor that builds a default [BillingClient.Builder].
+     */
+    constructor(
+        context: Context,
+        purchasesUpdatedListener: PurchasesUpdatedListener,
+    ) : this(
+        context,
+        BillingClient
+            .newBuilder(context)
+            .setListener(purchasesUpdatedListener)
+            .enablePendingPurchases(
+                PendingPurchasesParams
+                    .newBuilder()
+                    .enableOneTimeProducts()
+                    .build(),
+            ),
+    )
+
+    internal val billingClient: BillingClient = builder.build()
+
+    /** Whether we have already spent our single automatic retry. */
+    private var hasRetried = false
+
+    /**
+     * Suspend until the [BillingClient] is connected and ready.
+     *
+     * If the client is already ready, returns immediately.
+     * On [BillingClient.BillingResponseCode.SERVICE_DISCONNECTED], retries once.
+     *
+     * @return the connected [BillingClient] instance.
+     * @throws IllegalStateException if the connection fails after retry.
+     */
+    suspend fun ensureConnected(): BillingClient {
+        if (billingClient.isReady) return billingClient
+        return connect()
+    }
+
+    /**
+     * Disconnect the underlying [BillingClient] and release resources.
+     */
+    fun close() {
+        billingClient.endConnection()
+    }
+
+    // ── Internals ──────────────────────────────────────────────────────
+
+    private suspend fun connect(): BillingClient =
+        suspendCancellableCoroutine { cont ->
+            billingClient.startConnection(
+                object : BillingClientStateListener {
+                    override fun onBillingSetupFinished(result: BillingResult) {
+                        if (result.responseCode == BillingClient.BillingResponseCode.OK) {
+                            if (cont.isActive) cont.resume(billingClient)
+                        } else if (
+                            result.responseCode ==
+                            BillingClient.BillingResponseCode.SERVICE_DISCONNECTED &&
+                            !hasRetried
+                        ) {
+                            // Retry once
+                            hasRetried = true
+                            billingClient.startConnection(this)
+                        } else {
+                            if (cont.isActive) {
+                                cont.resumeWithException(
+                                    IllegalStateException(
+                                        "BillingClient connection failed: " +
+                                            "${result.responseCode} ${result.debugMessage}",
+                                    ),
+                                )
+                            }
+                        }
+                    }
+
+                    override fun onBillingServiceDisconnected() {
+                        // No-op: reconnection is handled by ensureConnected on next call
+                    }
+                },
+            )
+        }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest />

package/android/src/main/java/ml/nami/expo/iap/Errors.kt

@@ -0,0 +1,94 @@
+package ml.nami.expo.iap
+
+import com.android.billingclient.api.BillingClient.BillingResponseCode
+
+/**
+ * Maps Google Play Billing `BillingResponseCode` integers to normalized error
+ * codes that match the cross-platform `ExpoNamiIapException` hierarchy defined
+ * in [IapBackend.kt].
+ *
+ * Two projections are provided:
+ * - [billingResponseToCode]: normalized code string (`"user_cancelled"`, `"network"`, etc.)
+ * - [billingResponseToNativeCode]: the Play Billing constant name (e.g. `"USER_CANCELED"`)
+ */
+object Errors {
+    // ── Normalized code mapping ─────────────────────────────────────────
+
+    /**
+     * Convert a `BillingResponseCode` integer to a normalized string code.
+     *
+     * | Normalized code    | BillingResponseCode constants                            |
+     * |--------------------|----------------------------------------------------------|
+     * | user_cancelled     | USER_CANCELED                                            |
+     * | network            | SERVICE_DISCONNECTED, SERVICE_UNAVAILABLE, NETWORK_ERROR |
+     * | item_unavailable   | ITEM_UNAVAILABLE                                         |
+     * | already_owned      | ITEM_ALREADY_OWNED                                       |
+     * | not_allowed        | FEATURE_NOT_SUPPORTED, DEVELOPER_ERROR, BILLING_UNAVAILABLE |
+     * | unknown            | ERROR, ITEM_NOT_OWNED, anything else                     |
+     */
+    fun billingResponseToCode(code: Int): String =
+        when (code) {
+            BillingResponseCode.USER_CANCELED -> "user_cancelled"
+            BillingResponseCode.SERVICE_DISCONNECTED,
+            BillingResponseCode.SERVICE_UNAVAILABLE,
+            BillingResponseCode.NETWORK_ERROR,
+            -> "network"
+            BillingResponseCode.ITEM_UNAVAILABLE -> "item_unavailable"
+            BillingResponseCode.ITEM_ALREADY_OWNED -> "already_owned"
+            BillingResponseCode.FEATURE_NOT_SUPPORTED,
+            BillingResponseCode.DEVELOPER_ERROR,
+            BillingResponseCode.BILLING_UNAVAILABLE,
+            -> "not_allowed"
+            else -> "unknown"
+        }
+
+    // ── Native code (constant name) mapping ─────────────────────────────
+
+    /**
+     * Map from `BillingResponseCode` integer to the constant name.
+     * Used to populate `nativeCode` in `ExpoNamiIapException`.
+     */
+    private val nativeCodeMap: Map<Int, String> =
+        mapOf(
+            BillingResponseCode.OK to "OK",
+            BillingResponseCode.USER_CANCELED to "USER_CANCELED",
+            BillingResponseCode.SERVICE_UNAVAILABLE to "SERVICE_UNAVAILABLE",
+            BillingResponseCode.BILLING_UNAVAILABLE to "BILLING_UNAVAILABLE",
+            BillingResponseCode.ITEM_UNAVAILABLE to "ITEM_UNAVAILABLE",
+            BillingResponseCode.DEVELOPER_ERROR to "DEVELOPER_ERROR",
+            BillingResponseCode.ERROR to "ERROR",
+            BillingResponseCode.ITEM_ALREADY_OWNED to "ITEM_ALREADY_OWNED",
+            BillingResponseCode.ITEM_NOT_OWNED to "ITEM_NOT_OWNED",
+            BillingResponseCode.SERVICE_DISCONNECTED to "SERVICE_DISCONNECTED",
+            BillingResponseCode.FEATURE_NOT_SUPPORTED to "FEATURE_NOT_SUPPORTED",
+            BillingResponseCode.NETWORK_ERROR to "NETWORK_ERROR",
+        )
+
+    /**
+     * Return the constant name for a `BillingResponseCode` integer.
+     * Falls back to `"UNKNOWN(<code>)"` for unmapped values.
+     */
+    fun billingResponseToNativeCode(code: Int): String = nativeCodeMap[code] ?: "UNKNOWN($code)"
+
+    // ── Factory helper ──────────────────────────────────────────────────
+
+    /**
+     * Convert a `BillingResponseCode` integer into the appropriate
+     * [ExpoNamiIapException] subclass.
+     */
+    fun toException(
+        code: Int,
+        message: String? = null,
+    ): ExpoNamiIapException {
+        val nativeCode = billingResponseToNativeCode(code)
+        val msg = message ?: "Billing error: $nativeCode"
+        return when (billingResponseToCode(code)) {
+            "user_cancelled" -> ExpoNamiIapException.UserCancelled(nativeCode)
+            "network" -> ExpoNamiIapException.Network(msg, nativeCode)
+            "item_unavailable" -> ExpoNamiIapException.ItemUnavailable(msg, nativeCode)
+            "already_owned" -> ExpoNamiIapException.AlreadyOwned(nativeCode)
+            "not_allowed" -> ExpoNamiIapException.NotAllowed(msg, nativeCode)
+            else -> ExpoNamiIapException.Unknown(msg, nativeCode)
+        }
+    }
+}

package/android/src/main/java/ml/nami/expo/iap/ExpoNamiIapModule.kt

@@ -0,0 +1,56 @@
+package ml.nami.expo.iap
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class ExpoNamiIapModule : Module() {
+    internal val backend: IapBackend by lazy { buildBackend() }
+
+    override fun definition() =
+        ModuleDefinition {
+            Name("ExpoNamiIapModule")
+            Events("onTransactionUpdate", "onError")
+
+            OnCreate {
+                backend.onTransactionUpdate { dict ->
+                    sendEvent("onTransactionUpdate", dict)
+                }
+                backend.onError { dict ->
+                    sendEvent("onError", dict)
+                }
+            }
+
+            Function("configure") { options: Map<String, Any?> -> backend.configure(options) }
+
+            AsyncFunction("initConnection") {
+                backend.initConnection(appContext.reactContext ?: error("No React context"))
+            }
+            AsyncFunction("endConnection") { backend.endConnection() }
+            AsyncFunction("getProducts") { skuIds: List<String> -> backend.getProducts(skuIds) }
+            AsyncFunction("checkEligibility") { skuIds: List<String> -> backend.checkEligibility(skuIds) }
+            AsyncFunction("purchase") { options: Map<String, Any?> ->
+                val skuId = options["skuId"] as String
+                val activity = appContext.currentActivity ?: error("No current activity")
+                backend.purchase(
+                    activity,
+                    skuId,
+                    options["offerId"] as String?,
+                    options["offerSignature"] as String?,
+                    options["appAccountToken"] as String?,
+                )
+            }
+            AsyncFunction("restorePurchases") { backend.restorePurchases() }
+            AsyncFunction("finishTransaction") { id: String -> backend.finishTransaction(id) }
+        }
+
+    internal fun buildBackend(): IapBackend {
+        // Flavor-specific implementation resolved by classpath
+        val cls =
+            try {
+                Class.forName("ml.nami.expo.iap.google.PlayBillingBackend")
+            } catch (_: ClassNotFoundException) {
+                Class.forName("ml.nami.expo.iap.amazon.AmazonIapBackend")
+            }
+        return cls.getDeclaredConstructor().newInstance() as IapBackend
+    }
+}

package/android/src/main/java/ml/nami/expo/iap/IapBackend.kt

@@ -0,0 +1,72 @@
+package ml.nami.expo.iap
+
+import android.app.Activity
+import android.content.Context
+
+interface IapBackend {
+    suspend fun initConnection(context: Context)
+
+    suspend fun endConnection()
+
+    suspend fun getProducts(skuIds: List<String>): List<Map<String, Any?>>
+
+    suspend fun checkEligibility(skuIds: List<String>): List<Map<String, Any?>>
+
+    suspend fun purchase(
+        activity: Activity,
+        skuId: String,
+        offerId: String?,
+        offerSignature: String?,
+        appAccountToken: String?,
+    ): Map<String, Any?>
+
+    suspend fun restorePurchases(): List<Map<String, Any?>>
+
+    suspend fun finishTransaction(transactionId: String)
+
+    fun onTransactionUpdate(callback: (Map<String, Any?>) -> Unit)
+
+    fun onError(callback: (Map<String, Any?>) -> Unit)
+
+    /**
+     * Apply store-specific configuration options.
+     *
+     * Called from `ExpoNamiIapModule.configure(...)`. The default
+     * implementation is a no-op; store backends override as needed.
+     */
+    fun configure(options: Map<String, Any?>) {}
+}
+
+sealed class ExpoNamiIapException(
+    message: String,
+    val code: String,
+    val nativeCode: String?,
+) : Exception(message) {
+    class UserCancelled(
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException("User cancelled", "user_cancelled", nativeCode)
+
+    class Network(
+        msg: String,
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException(msg, "network", nativeCode)
+
+    class ItemUnavailable(
+        msg: String,
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException(msg, "item_unavailable", nativeCode)
+
+    class AlreadyOwned(
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException("Already owned", "already_owned", nativeCode)
+
+    class NotAllowed(
+        msg: String,
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException(msg, "not_allowed", nativeCode)
+
+    class Unknown(
+        msg: String,
+        nativeCode: String? = null,
+    ) : ExpoNamiIapException(msg, "unknown", nativeCode)
+}

package/android/src/main/java/ml/nami/expo/iap/ProductMapper.kt

@@ -0,0 +1,191 @@
+package ml.nami.expo.iap
+
+import com.android.billingclient.api.BillingClient.ProductType
+import com.android.billingclient.api.ProductDetails
+
+/**
+ * Maps a Google Play Billing [ProductDetails] into a [Map] matching the
+ * `NamiProductDetails` / `ExpoNamiIapProduct` TypeScript type.
+ *
+ * Output keys:
+ * - `product_ref_id` (String)
+ * - `name` (String)
+ * - `description` (String)
+ * - `product_type` (`"one_time_purchase"` | `"subscription"`)
+ * - `offers` (List<Map<String, Any?>>)
+ * - `subscription_period` (Map<String, Any>) — only for subscriptions
+ */
+object ProductMapper {
+    /**
+     * Convert a [ProductDetails] to a dictionary suitable for bridging to TypeScript.
+     */
+    fun toMap(pd: ProductDetails): Map<String, Any?> {
+        val result =
+            mutableMapOf<String, Any?>(
+                "product_ref_id" to pd.productId,
+                "name" to pd.name,
+                "description" to pd.description,
+                "product_type" to mapProductType(pd),
+                "offers" to buildOffers(pd),
+            )
+
+        // subscription_period — only for subscriptions
+        if (pd.productType == ProductType.SUBS) {
+            basePlanPeriod(pd)?.let { result["subscription_period"] = it }
+        }
+
+        return result
+    }
+
+    // ── Product type ────────────────────────────────────────────────────
+
+    private fun mapProductType(pd: ProductDetails): String =
+        when (pd.productType) {
+            ProductType.INAPP -> "one_time_purchase"
+            ProductType.SUBS -> "subscription"
+            else -> "unknown"
+        }
+
+    // ── Offers ──────────────────────────────────────────────────────────
+
+    private fun buildOffers(pd: ProductDetails): List<Map<String, Any?>> {
+        val offers = mutableListOf<Map<String, Any?>>()
+
+        // INAPP — single default offer from OneTimePurchaseOfferDetails
+        pd.oneTimePurchaseOfferDetails?.let { otp ->
+            offers.add(
+                mapOf(
+                    "offer_type" to "default",
+                    "price" to (otp.priceAmountMicros / 1_000_000.0),
+                    "currency" to otp.priceCurrencyCode,
+                ),
+            )
+        }
+
+        // SUBS — derive default + promotional offers from SubscriptionOfferDetails
+        pd.subscriptionOfferDetails?.let { subOffers ->
+            // The base plan is the entry without an offerId
+            val basePlan = subOffers.firstOrNull { it.offerId == null }
+            val basePricingPhase =
+                basePlan
+                    ?.pricingPhases
+                    ?.pricingPhaseList
+                    ?.firstOrNull { it.priceAmountMicros > 0 }
+
+            // Default offer from base plan
+            if (basePricingPhase != null) {
+                offers.add(
+                    mapOf(
+                        "offer_type" to "default",
+                        "price" to (basePricingPhase.priceAmountMicros / 1_000_000.0),
+                        "currency" to basePricingPhase.priceCurrencyCode,
+                    ),
+                )
+            }
+
+            // Promotional / intro / free-trial offers from other subscription offers
+            for (subOffer in subOffers) {
+                if (subOffer.offerId == null) continue // skip the base plan
+                for (phase in subOffer.pricingPhases.pricingPhaseList) {
+                    if (phase.priceAmountMicros == 0L) {
+                        // Free trial phase
+                        offers.add(
+                            buildTrialOffer(phase, subOffer.offerId),
+                        )
+                    } else if (isIntroPhase(phase, basePricingPhase)) {
+                        // Intro price phase (lower than base price)
+                        offers.add(
+                            buildIntroOffer(phase, subOffer.offerId),
+                        )
+                    }
+                }
+            }
+        }
+
+        return offers
+    }
+
+    private fun buildTrialOffer(
+        phase: ProductDetails.PricingPhase,
+        offerId: String?,
+    ): Map<String, Any?> =
+        mapOf(
+            "offer_type" to "free_trial",
+            "offer_ref_id" to offerId,
+            "price" to 0.0,
+            "currency" to phase.priceCurrencyCode,
+            "promo_period" to parsePeriod(phase.billingPeriod),
+        )
+
+    private fun buildIntroOffer(
+        phase: ProductDetails.PricingPhase,
+        offerId: String?,
+    ): Map<String, Any?> =
+        mapOf(
+            "offer_type" to "intro",
+            "offer_ref_id" to offerId,
+            "price" to (phase.priceAmountMicros / 1_000_000.0),
+            "currency" to phase.priceCurrencyCode,
+            "promo_period" to parsePeriod(phase.billingPeriod),
+            "promo_price" to
+                mapOf(
+                    "price" to (phase.priceAmountMicros / 1_000_000.0),
+                    "currency" to phase.priceCurrencyCode,
+                ),
+        )
+
+    /**
+     * Determine whether a pricing phase is an intro (discounted) phase.
+     * An intro phase has a price > 0 but lower than the base plan price.
+     */
+    private fun isIntroPhase(
+        phase: ProductDetails.PricingPhase,
+        basePricingPhase: ProductDetails.PricingPhase?,
+    ): Boolean {
+        if (basePricingPhase == null) return false
+        return phase.priceAmountMicros in 1 until basePricingPhase.priceAmountMicros
+    }
+
+    // ── Period parsing ──────────────────────────────────────────────────
+
+    /**
+     * The base plan's billing period, derived from the first non-free pricing
+     * phase of the base-plan subscription offer (the entry with offerId == null).
+     */
+    private fun basePlanPeriod(pd: ProductDetails): Map<String, Any>? {
+        val basePlan =
+            pd.subscriptionOfferDetails
+                ?.firstOrNull { it.offerId == null }
+        val phase =
+            basePlan
+                ?.pricingPhases
+                ?.pricingPhaseList
+                ?.firstOrNull { it.priceAmountMicros > 0 }
+        return phase?.let { parsePeriod(it.billingPeriod) }
+    }
+
+    /**
+     * Parse an ISO 8601 duration string from Play Billing into a period dict.
+     *
+     * Play Billing uses simplified durations: `P1D`, `P1W`, `P1M`, `P3M`, `P1Y`.
+     *
+     * Returns `{ "type": "month", "count": 1 }` etc.
+     */
+    internal fun parsePeriod(iso8601: String): Map<String, Any> {
+        val match =
+            PERIOD_REGEX.find(iso8601)
+                ?: return mapOf("type" to "unknown", "count" to 0)
+        val count = match.groupValues[1].toIntOrNull() ?: 0
+        val unit =
+            when (match.groupValues[2]) {
+                "D" -> "day"
+                "W" -> "week"
+                "M" -> "month"
+                "Y" -> "year"
+                else -> "unknown"
+            }
+        return mapOf("type" to unit, "count" to count)
+    }
+
+    private val PERIOD_REGEX = Regex("""P(\d+)([DWMY])""")
+}