expo-iap 2.9.6 → 3.0.0

package/android/src/main/java/expo/modules/iap/ExpoIapModule.kt

@@ -2,745 +2,272 @@ package expo.modules.iap
 
 import android.content.Context
 import android.util.Log
-import com.android.billingclient.api.AcknowledgePurchaseParams
-import com.android.billingclient.api.BillingClient
-import com.android.billingclient.api.BillingClientStateListener
-import com.android.billingclient.api.BillingConfig
-import com.android.billingclient.api.BillingFlowParams
-import com.android.billingclient.api.BillingFlowParams.SubscriptionUpdateParams
-import com.android.billingclient.api.BillingConfigResponseListener
-import com.android.billingclient.api.BillingResult
-import com.android.billingclient.api.ConsumeParams
-import com.android.billingclient.api.GetBillingConfigParams
-import com.android.billingclient.api.PendingPurchasesParams
-import com.android.billingclient.api.ProductDetails
-import com.android.billingclient.api.ProductDetailsResult
-import com.android.billingclient.api.Purchase
-import com.android.billingclient.api.PurchasesUpdatedListener
-import com.android.billingclient.api.QueryProductDetailsParams
-import com.android.billingclient.api.QueryProductDetailsResult
-import com.android.billingclient.api.QueryPurchasesParams
-import com.google.android.gms.common.ConnectionResult
-import com.google.android.gms.common.GoogleApiAvailability
+import dev.hyo.openiap.OpenIapError
+import dev.hyo.openiap.OpenIapModule
+import dev.hyo.openiap.models.DeepLinkOptions
+import dev.hyo.openiap.models.ProductRequest
+import dev.hyo.openiap.models.RequestPurchaseAndroidProps
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-
-class ExpoIapModule :
-    Module(),
-    PurchasesUpdatedListener {
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.atomic.AtomicBoolean
+
+class ExpoIapModule : Module() {
     companion object {
         const val TAG = "ExpoIapModule"
+        private const val EVENT_PURCHASE_UPDATED = "purchase-updated"
+        private const val EVENT_PURCHASE_ERROR = "purchase-error"
+        private const val MAX_BUFFERED_EVENTS = 200
     }
 
-    private var billingClientCache: BillingClient? = null
-    private val skus: MutableMap<String, ProductDetails> = mutableMapOf()
+    private val job = Job()
+    private val scope = CoroutineScope(Dispatchers.Main + job)
     private val context: Context
         get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
     private val currentActivity
-        get() =
-            appContext.activityProvider?.currentActivity
-                ?: throw MissingCurrentActivityException()
+        get() = appContext.activityProvider?.currentActivity ?: throw Exceptions.MissingActivity()
+
+    private val openIap: OpenIapModule by lazy { OpenIapModule(context) }
+    private var listenersAttached = false
+    private val pendingEvents = ConcurrentLinkedQueue<Pair<String, Map<String, Any?>>>()
+    private val connectionReady = AtomicBoolean(false)
+    private val connectionMutex = Mutex()
 
-    override fun onPurchasesUpdated(
-        billingResult: BillingResult,
-        purchases: List<Purchase>?,
+    private fun emitOrQueue(
+        name: String,
+        payload: Map<String, Any?>,
     ) {
-        val responseCode = billingResult.responseCode
-        if (responseCode != BillingClient.BillingResponseCode.OK) {
-            val error =
-                mutableMapOf<String, Any?>(
-                    "responseCode" to responseCode,
-                    "debugMessage" to billingResult.debugMessage,
-                )
-            // Add sub-response code if available (v8.0.0+)
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
-                try {
-                    val subResponseCode = billingResult.javaClass.getMethod("getSubResponseCode").invoke(billingResult) as? Int
-                    if (subResponseCode != null && subResponseCode != 0) {
-                        error["subResponseCode"] = subResponseCode
-                        // Check for specific sub-response codes
-                        if (subResponseCode == 1) { // PAYMENT_DECLINED_DUE_TO_INSUFFICIENT_FUNDS
-                            error["subResponseMessage"] = "Payment declined due to insufficient funds"
-                        }
-                    }
-                } catch (e: Exception) {
-                    // Method doesn't exist in older versions, ignore
-                }
-            }
-            val errorData = PlayUtils.getBillingResponseData(responseCode)
-            error["code"] = errorData.code
-            error["message"] = errorData.message
-            try {
-                sendEvent(OpenIapEvent.PURCHASE_ERROR, error.toMap())
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to send PURCHASE_ERROR event: ${e.message}")
-            }
-            PromiseUtils.rejectPromisesForKey(IapConstants.PROMISE_BUY_ITEM, errorData.code, errorData.message, null)
+        if (connectionReady.get()) {
+            // Ensure event emission occurs on the main dispatcher
+            scope.launch { sendEvent(name, payload) }
             return
         }
-
-        if (purchases != null) {
-            val promiseItems = mutableListOf<Map<String, Any?>>()
-            purchases.forEach { purchase ->
-                val item =
-                    mutableMapOf<String, Any?>(
-                        "id" to purchase.orderId,
-                        "productId" to purchase.products.firstOrNull() as Any?,
-                        "ids" to purchase.products,
-                        "transactionId" to purchase.orderId, // @deprecated - use id instead
-                        "transactionDate" to purchase.purchaseTime.toDouble(),
-                        "transactionReceipt" to purchase.originalJson,
-                        "purchaseTokenAndroid" to purchase.purchaseToken,
-                        "purchaseToken" to purchase.purchaseToken,
-                        "dataAndroid" to purchase.originalJson,
-                        "signatureAndroid" to purchase.signature,
-                        "autoRenewingAndroid" to purchase.isAutoRenewing,
-                        "isAcknowledgedAndroid" to purchase.isAcknowledged,
-                        "purchaseStateAndroid" to purchase.purchaseState,
-                        "packageNameAndroid" to purchase.packageName,
-                        "developerPayloadAndroid" to purchase.developerPayload,
-                        "platform" to "android",
-                    )
-                purchase.accountIdentifiers?.let { accountIdentifiers ->
-                    item["obfuscatedAccountIdAndroid"] = accountIdentifiers.obfuscatedAccountId
-                    item["obfuscatedProfileIdAndroid"] = accountIdentifiers.obfuscatedProfileId
-                }
-                promiseItems.add(item.toMap())
-                try {
-                    sendEvent(OpenIapEvent.PURCHASE_UPDATED, item.toMap())
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to send PURCHASE_UPDATED event: ${e.message}")
-                }
-            }
-            PromiseUtils.resolvePromisesForKey(IapConstants.PROMISE_BUY_ITEM, promiseItems)
-        } else {
-            val result =
-                mutableMapOf<String, Any?>(
-                    "platform" to "android",
-                    "responseCode" to billingResult.responseCode,
-                    "debugMessage" to billingResult.debugMessage,
-                    "extraMessage" to
-                        "The purchases are null. This is a normal behavior if you have requested DEFERRED proration. If not please report an issue.",
-                )
-            try {
-                sendEvent(OpenIapEvent.PURCHASE_UPDATED, result.toMap())
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to send PURCHASE_UPDATED event: ${e.message}")
-            }
-            PromiseUtils.resolvePromisesForKey(IapConstants.PROMISE_BUY_ITEM, result)
+        // Bound the buffer to prevent unbounded growth if init stalls
+        if (pendingEvents.size >= MAX_BUFFERED_EVENTS) {
+            pendingEvents.poll()
+            Log.w(TAG, "pendingEvents overflow; dropping oldest")
         }
+        pendingEvents.add(name to payload)
     }
 
+    // Mapping helpers now provided by openiap-google (toJSON helpers)
+
     override fun definition() =
         ModuleDefinition {
             Name("ExpoIap")
 
             Constants(
-                "ERROR_CODES" to IapErrorCode.toMap()
+                "ERROR_CODES" to OpenIapError.getAllErrorCodes(),
             )
 
-            Events(OpenIapEvent.PURCHASE_UPDATED, OpenIapEvent.PURCHASE_ERROR)
+            Events(EVENT_PURCHASE_UPDATED, EVENT_PURCHASE_ERROR)
 
             AsyncFunction("initConnection") { promise: Promise ->
-                initBillingClient(promise) { promise.resolve(true) }
-            }
+                scope.launch {
+                    connectionMutex.withLock {
+                        try {
+                            // Activity may be unavailable in headless/background scenarios.
+                            // Attempt to set it, but do not fail init if missing.
+                            runCatching { openIap.setActivity(currentActivity) }
+                                .onFailure { Log.w(TAG, "initConnection: Activity missing; proceeding headless", it) }
+
+                            // If already connected, short-circuit
+                            if (connectionReady.get()) {
+                                promise.resolve(true)
+                                return@withLock
+                            }
 
-            AsyncFunction("endConnection") { promise: Promise ->
-                billingClientCache?.endConnection()
-                billingClientCache = null
-                skus.clear()
-                promise.resolve(true)
-            }
+                            // Attach listeners early to avoid races during init
+                            if (!listenersAttached) {
+                                listenersAttached = true
+                                openIap.addPurchaseUpdateListener { p ->
+                                    runCatching { emitOrQueue(EVENT_PURCHASE_UPDATED, p.toJSON()) }
+                                        .onFailure { Log.e(TAG, "Failed to buffer/send PURCHASE_UPDATED", it) }
+                                }
+                                openIap.addPurchaseErrorListener { e ->
+                                    runCatching { emitOrQueue(EVENT_PURCHASE_ERROR, e.toJSON()) }
+                                        .onFailure { Log.e(TAG, "Failed to buffer/send PURCHASE_ERROR", it) }
+                                }
+                            }
 
-            AsyncFunction("fetchProducts") { type: String, skuArr: Array<String>, promise: Promise ->
-                ensureConnection(promise) { billingClient ->
-                    val skuList =
-                        skuArr.map { sku ->
-                            QueryProductDetailsParams.Product
-                                .newBuilder()
-                                .setProductId(sku)
-                                .setProductType(type)
-                                .build()
-                        }
+                            val ok = openIap.initConnection()
 
-                    if (skuList.isEmpty()) {
-                        promise.reject(IapErrorCode.E_EMPTY_SKU_LIST, "The SKU list is empty.", null)
-                        return@ensureConnection
-                    }
+                            if (!ok) {
+                                // Clear any buffered events from a failed init
+                                pendingEvents.clear()
+                                promise.reject(OpenIapError.E_INIT_CONNECTION, "Failed to initialize connection", null)
+                                return@withLock
+                            }
 
-                    val params =
-                        QueryProductDetailsParams
-                            .newBuilder()
-                            .setProductList(skuList)
-                            .build()
+                            // Mark ready then flush any buffered events
+                            connectionReady.set(true)
+                            while (true) {
+                                val ev = pendingEvents.poll() ?: break
+                                // Already on main dispatcher here; emit directly
+                                runCatching { sendEvent(ev.first, ev.second) }
+                                    .onFailure { Log.e(TAG, "Failed to flush buffered event: ${ev.first}", it) }
+                            }
 
-                    billingClient.queryProductDetailsAsync(params) { billingResult: BillingResult, productDetailsResult: QueryProductDetailsResult ->
-                        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                            promise.reject(
-                                IapErrorCode.E_QUERY_PRODUCT,
-                                "Error querying product details: ${billingResult.debugMessage}",
-                                null,
-                            )
-                            return@queryProductDetailsAsync
+                            promise.resolve(true)
+                        } catch (e: Exception) {
+                            promise.reject(OpenIapError.E_INIT_CONNECTION, e.message, e)
                         }
-
-                        val productDetailsList = productDetailsResult.productDetailsList ?: emptyList()
-                        
-                        val items =
-                            productDetailsList.map { productDetails ->
-                                skus[productDetails.productId] = productDetails
-
-                                val currency = productDetails.oneTimePurchaseOfferDetails?.priceCurrencyCode
-                                    ?: productDetails.subscriptionOfferDetails?.firstOrNull()?.pricingPhases?.pricingPhaseList?.firstOrNull()?.priceCurrencyCode
-                                    ?: "Unknown"
-                                val displayPrice = productDetails.oneTimePurchaseOfferDetails?.formattedPrice
-                                    ?: productDetails.subscriptionOfferDetails?.firstOrNull()?.pricingPhases?.pricingPhaseList?.firstOrNull()?.formattedPrice
-                                    ?: "N/A"
-
-                                // Prepare reusable data
-                                val oneTimePurchaseData = productDetails.oneTimePurchaseOfferDetails?.let {
-                                    mapOf(
-                                        "priceCurrencyCode" to it.priceCurrencyCode,
-                                        "formattedPrice" to it.formattedPrice,
-                                        "priceAmountMicros" to it.priceAmountMicros.toString(),
-                                    )
-                                }
-                                
-                                val subscriptionOfferData = productDetails.subscriptionOfferDetails?.map { subscriptionOfferDetailsItem ->
-                                    mapOf(
-                                        "basePlanId" to subscriptionOfferDetailsItem.basePlanId,
-                                        "offerId" to subscriptionOfferDetailsItem.offerId,
-                                        "offerToken" to subscriptionOfferDetailsItem.offerToken,
-                                        "offerTags" to subscriptionOfferDetailsItem.offerTags,
-                                        "pricingPhases" to
-                                            mapOf(
-                                                "pricingPhaseList" to
-                                                    subscriptionOfferDetailsItem.pricingPhases.pricingPhaseList.map
-                                                        { pricingPhaseItem ->
-                                                            mapOf(
-                                                                "formattedPrice" to pricingPhaseItem.formattedPrice,
-                                                                "priceCurrencyCode" to pricingPhaseItem.priceCurrencyCode,
-                                                                "billingPeriod" to pricingPhaseItem.billingPeriod,
-                                                                "billingCycleCount" to pricingPhaseItem.billingCycleCount,
-                                                                "priceAmountMicros" to
-                                                                    pricingPhaseItem.priceAmountMicros.toString(),
-                                                                "recurrenceMode" to pricingPhaseItem.recurrenceMode,
-                                                            )
-                                                        },
-                                            ),
-                                    )
-                                }
-
-                                // Convert Android productType to our expected 'inapp' or 'subs'
-                                val productType = if (productDetails.productType == BillingClient.ProductType.SUBS) "subs" else "inapp"
-                                
-                                mapOf(
-                                    "id" to productDetails.productId,
-                                    "title" to productDetails.title,
-                                    "description" to productDetails.description,
-                                    "type" to productType,
-                                    // New field names with Android suffix
-                                    "nameAndroid" to productDetails.name,
-                                    "oneTimePurchaseOfferDetailsAndroid" to oneTimePurchaseData,
-                                    "subscriptionOfferDetailsAndroid" to subscriptionOfferData,
-                                    "platform" to "android",
-                                    "currency" to currency,
-                                    "displayPrice" to displayPrice,
-                                    // START: Deprecated - will be removed in v2.9.0
-                                    // Use nameAndroid instead of displayName
-                                    "displayName" to productDetails.name,
-                                    // Use nameAndroid instead of name
-                                    "name" to productDetails.name,
-                                    // Use oneTimePurchaseOfferDetailsAndroid instead of oneTimePurchaseOfferDetails
-                                    "oneTimePurchaseOfferDetails" to oneTimePurchaseData,
-                                    // Use subscriptionOfferDetailsAndroid instead of subscriptionOfferDetails
-                                    "subscriptionOfferDetails" to subscriptionOfferData,
-                                    // END: Deprecated - will be removed in v2.9.0
-                                )
-                            }
-                        promise.resolve(items)
                     }
                 }
             }
 
-            AsyncFunction("requestProducts") { type: String, skuArr: Array<String>, promise: Promise ->
-                Log.w("ExpoIap", "WARNING: requestProducts is deprecated. Use fetchProducts instead. The 'request' prefix should only be used for event-based operations. This method will be removed in version 3.0.0.")
-                
-                ensureConnection(promise) { billingClient ->
-                    val skuList =
-                        skuArr.map { sku ->
-                            QueryProductDetailsParams.Product
-                                .newBuilder()
-                                .setProductId(sku)
-                                .setProductType(type)
-                                .build()
-                        }
-
-                    if (skuList.isEmpty()) {
-                        promise.reject(IapErrorCode.E_EMPTY_SKU_LIST, "The SKU list is empty.", null)
-                        return@ensureConnection
+            AsyncFunction("endConnection") { promise: Promise ->
+                scope.launch {
+                    connectionMutex.withLock {
+                        runCatching { openIap.endConnection() }
+                        // Reset connection state and clear any buffered events
+                        connectionReady.set(false)
+                        pendingEvents.clear()
+                        promise.resolve(true)
                     }
+                }
+            }
 
-                    val params =
-                        QueryProductDetailsParams
-                            .newBuilder()
-                            .setProductList(skuList)
-                            .build()
-
-                    billingClient.queryProductDetailsAsync(params) { billingResult: BillingResult, productDetailsResult: QueryProductDetailsResult ->
-                        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                            promise.reject(
-                                IapErrorCode.E_QUERY_PRODUCT,
-                                "Error querying product details: ${billingResult.debugMessage}",
-                                null,
-                            )
-                            return@queryProductDetailsAsync
-                        }
-
-                        val productDetailsList = productDetailsResult.productDetailsList ?: emptyList()
-                        
-                        val items =
-                            productDetailsList.map { productDetails ->
-                                skus[productDetails.productId] = productDetails
-
-                                val currency = productDetails.oneTimePurchaseOfferDetails?.priceCurrencyCode
-                                    ?: productDetails.subscriptionOfferDetails?.firstOrNull()?.pricingPhases?.pricingPhaseList?.firstOrNull()?.priceCurrencyCode
-                                    ?: "Unknown"
-                                val displayPrice = productDetails.oneTimePurchaseOfferDetails?.formattedPrice
-                                    ?: productDetails.subscriptionOfferDetails?.firstOrNull()?.pricingPhases?.pricingPhaseList?.firstOrNull()?.formattedPrice
-                                    ?: "N/A"
-
-                                // Prepare reusable data
-                                val oneTimePurchaseData = productDetails.oneTimePurchaseOfferDetails?.let {
-                                    mapOf(
-                                        "priceCurrencyCode" to it.priceCurrencyCode,
-                                        "formattedPrice" to it.formattedPrice,
-                                        "priceAmountMicros" to it.priceAmountMicros.toString(),
-                                    )
-                                }
-                                
-                                val subscriptionOfferData = productDetails.subscriptionOfferDetails?.map { subscriptionOfferDetailsItem ->
-                                    mapOf(
-                                        "basePlanId" to subscriptionOfferDetailsItem.basePlanId,
-                                        "offerId" to subscriptionOfferDetailsItem.offerId,
-                                        "offerToken" to subscriptionOfferDetailsItem.offerToken,
-                                        "offerTags" to subscriptionOfferDetailsItem.offerTags,
-                                        "pricingPhases" to
-                                            mapOf(
-                                                "pricingPhaseList" to
-                                                    subscriptionOfferDetailsItem.pricingPhases.pricingPhaseList.map
-                                                        { pricingPhaseItem ->
-                                                            mapOf(
-                                                                "formattedPrice" to pricingPhaseItem.formattedPrice,
-                                                                "priceCurrencyCode" to pricingPhaseItem.priceCurrencyCode,
-                                                                "billingPeriod" to pricingPhaseItem.billingPeriod,
-                                                                "billingCycleCount" to pricingPhaseItem.billingCycleCount,
-                                                                "priceAmountMicros" to
-                                                                    pricingPhaseItem.priceAmountMicros.toString(),
-                                                                "recurrenceMode" to pricingPhaseItem.recurrenceMode,
-                                                            )
-                                                        },
-                                            ),
-                                    )
-                                }
+            AsyncFunction("fetchProducts") { type: String, skuArr: Array<String>, promise: Promise ->
+                scope.launch {
+                    try {
+                        val reqType = ProductRequest.ProductRequestType.fromString(type)
+                        val products = openIap.fetchProducts(ProductRequest(skuArr.toList(), reqType))
+                        promise.resolve(products.map { it.toJSON() })
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_QUERY_PRODUCT, e.message, null)
+                    }
+                }
+            }
 
-                                // Convert Android productType to our expected 'inapp' or 'subs'
-                                val productType = if (productDetails.productType == BillingClient.ProductType.SUBS) "subs" else "inapp"
-                                
-                                mapOf(
-                                    "id" to productDetails.productId,
-                                    "title" to productDetails.title,
-                                    "description" to productDetails.description,
-                                    "type" to productType,
-                                    // New field names with Android suffix
-                                    "nameAndroid" to productDetails.name,
-                                    "oneTimePurchaseOfferDetailsAndroid" to oneTimePurchaseData,
-                                    "subscriptionOfferDetailsAndroid" to subscriptionOfferData,
-                                    "platform" to "android",
-                                    "currency" to currency,
-                                    "displayPrice" to displayPrice,
-                                    // START: Deprecated - will be removed in v2.9.0
-                                    // Use nameAndroid instead of displayName
-                                    "displayName" to productDetails.name,
-                                    // Use nameAndroid instead of name
-                                    "name" to productDetails.name,
-                                    // Use oneTimePurchaseOfferDetailsAndroid instead of oneTimePurchaseOfferDetails
-                                    "oneTimePurchaseOfferDetails" to oneTimePurchaseData,
-                                    // Use subscriptionOfferDetailsAndroid instead of subscriptionOfferDetails
-                                    "subscriptionOfferDetails" to subscriptionOfferData,
-                                    // END: Deprecated - will be removed in v2.9.0
-                                )
-                            }
-                        promise.resolve(items)
+            AsyncFunction("getAvailableItems") { promise: Promise ->
+                scope.launch {
+                    try {
+                        val purchases = openIap.getAvailablePurchases(null)
+                        promise.resolve(purchases.map { it.toJSON() })
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_SERVICE_ERROR, e.message, null)
                     }
                 }
             }
 
-            AsyncFunction("getAvailableItemsByType") { type: String, promise: Promise ->
-                ensureConnection(promise) { billingClient ->
-                    val items = mutableListOf<Map<String, Any?>>()
-                    billingClient.queryPurchasesAsync(
-                        QueryPurchasesParams
-                            .newBuilder()
-                            .setProductType(
-                                if (type == "subs") BillingClient.ProductType.SUBS else BillingClient.ProductType.INAPP,
-                            ).build(),
-                    ) { billingResult: BillingResult, purchases: List<Purchase>? ->
-                        if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
-                        purchases?.forEach { purchase ->
-                            val item =
-                                mutableMapOf<String, Any?>(
-                                    "id" to purchase.orderId,
-                                    "productId" to purchase.products.firstOrNull() as Any?,
-                                    "ids" to purchase.products,
-                                    "transactionId" to purchase.orderId, // @deprecated - use id instead
-                                    "transactionDate" to purchase.purchaseTime.toDouble(),
-                                    "transactionReceipt" to purchase.originalJson,
-                                    "orderId" to purchase.orderId,
-                                    "purchaseTokenAndroid" to purchase.purchaseToken,
-                                    "purchaseToken" to purchase.purchaseToken,
-                                    "developerPayloadAndroid" to purchase.developerPayload,
-                                    "signatureAndroid" to purchase.signature,
-                                    "purchaseStateAndroid" to purchase.purchaseState,
-                                    "isAcknowledgedAndroid" to purchase.isAcknowledged,
-                                    "packageNameAndroid" to purchase.packageName,
-                                    "obfuscatedAccountIdAndroid" to purchase.accountIdentifiers?.obfuscatedAccountId,
-                                    "obfuscatedProfileIdAndroid" to purchase.accountIdentifiers?.obfuscatedProfileId,
-                                    "platform" to "android",
-                                )
-                            if (type == BillingClient.ProductType.SUBS) {
-                                item["autoRenewingAndroid"] = purchase.isAutoRenewing
-                            }
-                            items.add(item)
-                        }
-                        promise.resolve(items)
+            // Deep link to Manage Subscriptions screen (Android)
+            AsyncFunction("deepLinkToSubscriptionsAndroid") { params: Map<String, Any?>, promise: Promise ->
+                val sku = (params["sku"] ?: params["skuAndroid"]) as? String
+                val packageName = (params["packageName"] ?: params["packageNameAndroid"]) as? String
+                scope.launch {
+                    try {
+                        openIap.deepLinkToSubscriptions(DeepLinkOptions(sku, packageName))
+                        promise.resolve(null)
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_SERVICE_ERROR, e.message, null)
                     }
                 }
             }
 
-            // getPurchaseHistoryByType removed in Google Play Billing Library v8
-            // Use getAvailableItemsByType instead to get active purchases
+            // Get Google Play storefront country code (Android)
+            AsyncFunction("getStorefrontAndroid") { promise: Promise ->
+                scope.launch {
+                    try {
+                        val code = openIap.getStorefront()
+                        promise.resolve(code)
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_SERVICE_ERROR, e.message, e)
+                    }
+                }
+            }
 
             AsyncFunction("requestPurchase") { params: Map<String, Any?>, promise: Promise ->
                 val type = params["type"] as String
-                val skuArr =
-                    (params["skuArr"] as? List<*>)?.filterIsInstance<String>()?.toTypedArray()
-                        ?: emptyArray()
-                val purchaseToken = params["purchaseToken"] as? String
-                val replacementMode = (params["replacementMode"] as? Double)?.toInt() ?: -1
-                val obfuscatedAccountId = params["obfuscatedAccountId"] as? String
-                val obfuscatedProfileId = params["obfuscatedProfileId"] as? String
-                val offerTokenArr =
-                    (params["offerTokenArr"] as? List<*>)
-                        ?.filterIsInstance<String>()
-                        ?.toTypedArray() ?: emptyArray()
+                val skus: List<String> =
+                    (params["skus"] as? List<*>)?.filterIsInstance<String>()
+                        ?: (params["skuArr"] as? List<*>)?.filterIsInstance<String>()
+                        ?: emptyList()
+                val obfuscatedAccountId =
+                    (params["obfuscatedAccountIdAndroid"] ?: params["obfuscatedAccountId"]) as? String
+                val obfuscatedProfileId =
+                    (params["obfuscatedProfileIdAndroid"] ?: params["obfuscatedProfileId"]) as? String
                 val isOfferPersonalized = params["isOfferPersonalized"] as? Boolean ?: false
 
-                if (currentActivity == null) {
-                    promise.reject(IapErrorCode.E_UNKNOWN, "getCurrentActivity returned null", null)
-                    return@AsyncFunction
-                }
-
-                ensureConnection(promise) { billingClient ->
-                    PromiseUtils.addPromiseForKey(IapConstants.PROMISE_BUY_ITEM, promise)
-
-                    if (type == BillingClient.ProductType.SUBS && skuArr.size != offerTokenArr.size) {
-                        val debugMessage = "The number of skus (${skuArr.size}) must match: the number of offerTokens (${offerTokenArr.size}) for Subscriptions"
-                        try {
-                            sendEvent(
-                                OpenIapEvent.PURCHASE_ERROR,
-                                mapOf(
-                                    "debugMessage" to debugMessage,
-                                    "code" to IapErrorCode.E_SKU_OFFER_MISMATCH,
-                                    "message" to debugMessage,
-                                )
+                PromiseUtils.addPromiseForKey(PromiseUtils.PROMISE_BUY_ITEM, promise)
+                scope.launch {
+                    try {
+                        openIap.setActivity(currentActivity)
+                        val reqType = ProductRequest.ProductRequestType.fromString(type)
+                        val result =
+                            openIap.requestPurchase(
+                                RequestPurchaseAndroidProps(
+                                    skus = skus,
+                                    obfuscatedAccountIdAndroid = obfuscatedAccountId,
+                                    obfuscatedProfileIdAndroid = obfuscatedProfileId,
+                                    isOfferPersonalized = isOfferPersonalized,
+                                ),
+                                reqType,
                             )
-                        } catch (e: Exception) {
-                            Log.e(TAG, "Failed to send PURCHASE_ERROR event: ${e.message}")
-                        }
-                        promise.reject(IapErrorCode.E_SKU_OFFER_MISMATCH, debugMessage, null)
-                        return@ensureConnection
-                    }
-
-                    val productParamsList =
-                        skuArr.mapIndexed { index, sku ->
-                            val selectedSku = skus[sku]
-                            if (selectedSku == null) {
-                                val debugMessage =
-                                    "The sku was not found. Please fetch products first by calling getItems"
-                                try {
-                                    sendEvent(
-                                        OpenIapEvent.PURCHASE_ERROR,
-                                        mapOf(
-                                            "debugMessage" to debugMessage,
-                                            "code" to IapErrorCode.E_SKU_NOT_FOUND,
-                                            "message" to debugMessage,
-                                            "productId" to sku,
-                                        ),
-                                    )
-                                } catch (e: Exception) {
-                                    Log.e(TAG, "Failed to send PURCHASE_ERROR event: ${e.message}")
-                                }
-                                promise.reject(IapErrorCode.E_SKU_NOT_FOUND, debugMessage, null)
-                                return@ensureConnection
-                            }
-
-                            val productDetailParams =
-                                BillingFlowParams.ProductDetailsParams
-                                    .newBuilder()
-                                    .setProductDetails(selectedSku)
-
-                            if (type == BillingClient.ProductType.SUBS) {
-                                productDetailParams.setOfferToken(offerTokenArr[index])
+                        result.forEach { p ->
+                            try {
+                                emitOrQueue(EVENT_PURCHASE_UPDATED, p.toJSON())
+                            } catch (ex: Exception) {
+                                Log.e(TAG, "Failed to send PURCHASE_UPDATED event (requestPurchase)", ex)
                             }
-
-                            productDetailParams.build()
-                        }
-
-                    val builder =
-                        BillingFlowParams
-                            .newBuilder()
-                            .setProductDetailsParamsList(productParamsList)
-                            .setIsOfferPersonalized(isOfferPersonalized)
-
-                    if (purchaseToken != null) {
-                        val subscriptionUpdateParams =
-                            SubscriptionUpdateParams
-                                .newBuilder()
-                                .setOldPurchaseToken(purchaseToken)
-
-                        if (type == BillingClient.ProductType.SUBS && replacementMode != -1) {
-                            val mode =
-                                when (replacementMode) {
-                                    SubscriptionUpdateParams.ReplacementMode.CHARGE_PRORATED_PRICE ->
-                                        SubscriptionUpdateParams.ReplacementMode.CHARGE_PRORATED_PRICE
-                                    SubscriptionUpdateParams.ReplacementMode.WITHOUT_PRORATION ->
-                                        SubscriptionUpdateParams.ReplacementMode.WITHOUT_PRORATION
-                                    SubscriptionUpdateParams.ReplacementMode.DEFERRED ->
-                                        SubscriptionUpdateParams.ReplacementMode.DEFERRED
-                                    SubscriptionUpdateParams.ReplacementMode.WITH_TIME_PRORATION ->
-                                        SubscriptionUpdateParams.ReplacementMode.WITH_TIME_PRORATION
-                                    SubscriptionUpdateParams.ReplacementMode.CHARGE_FULL_PRICE ->
-                                        SubscriptionUpdateParams.ReplacementMode.CHARGE_FULL_PRICE
-                                    else -> SubscriptionUpdateParams.ReplacementMode.UNKNOWN_REPLACEMENT_MODE
-                                }
-                            subscriptionUpdateParams.setSubscriptionReplacementMode(mode)
                         }
-                        builder.setSubscriptionUpdateParams(subscriptionUpdateParams.build())
-                    }
-
-                    obfuscatedAccountId?.let { builder.setObfuscatedAccountId(it) }
-                    obfuscatedProfileId?.let { builder.setObfuscatedProfileId(it) }
-
-                    val flowParams = builder.build()
-                    val billingResult = billingClient.launchBillingFlow(currentActivity, flowParams)
-
-                    if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                        val errorData = PlayUtils.getBillingResponseData(billingResult.responseCode)
-                        var errorMessage = billingResult.debugMessage ?: errorData.message
-                        var subResponseCode: Int? = null
-                        
-                        // Check for sub-response codes (v8.0.0+)
+                        PromiseUtils.resolvePromisesForKey(PromiseUtils.PROMISE_BUY_ITEM, result.map { it.toJSON() })
+                    } catch (e: Exception) {
+                        val errorMap =
+                            mapOf(
+                                "code" to OpenIapError.E_PURCHASE_ERROR,
+                                "message" to (e.message ?: "Purchase failed"),
+                                "platform" to "android",
+                            )
                         try {
-                            subResponseCode = billingResult.javaClass.getMethod("getSubResponseCode").invoke(billingResult) as? Int
-                            if (subResponseCode != null && subResponseCode != 0) {
-                                if (subResponseCode == 1) { // PAYMENT_DECLINED_DUE_TO_INSUFFICIENT_FUNDS
-                                    errorMessage = "$errorMessage (Payment declined due to insufficient funds)"
-                                } else {
-                                    errorMessage = "$errorMessage (Sub-response code: $subResponseCode)"
-                                }
-                            }
-                        } catch (e: Exception) {
-                            // Method doesn't exist in older versions, ignore
+                            emitOrQueue(EVENT_PURCHASE_ERROR, errorMap)
+                        } catch (ex: Exception) {
+                            Log.e(TAG, "Failed to send PURCHASE_ERROR event (requestPurchase)", ex)
                         }
-                        
-                        // Send error event to match iOS behavior
-                        val errorMap = mutableMapOf<String, Any?>(
-                            "responseCode" to billingResult.responseCode,
-                            "debugMessage" to billingResult.debugMessage,
-                            "code" to errorData.code,
-                            "message" to errorMessage
+                        // Reject and clear any pending promises for this purchase flow
+                        PromiseUtils.rejectPromisesForKey(
+                            PromiseUtils.PROMISE_BUY_ITEM,
+                            OpenIapError.E_PURCHASE_ERROR,
+                            e.message,
+                            null,
                         )
-                        
-                        // Add product ID if available
-                        if (skuArr.isNotEmpty()) {
-                            errorMap["productId"] = skuArr.first()
-                        }
-                        
-                        // Add sub-response code if available
-                        subResponseCode?.let {
-                            if (it != 0) {
-                                errorMap["subResponseCode"] = it
-                            }
-                        }
-                        
-                        try {
-                            sendEvent(OpenIapEvent.PURCHASE_ERROR, errorMap.toMap())
-                        } catch (e: Exception) {
-                            Log.e(TAG, "Failed to send PURCHASE_ERROR event: ${e.message}")
-                        }
-                        
-                        promise.reject(errorData.code, errorMessage, null)
-                        return@ensureConnection
                     }
                 }
             }
 
-            AsyncFunction("acknowledgePurchaseAndroid") {
-                    token: String,
-                    promise: Promise,
-                ->
-
-                ensureConnection(promise) { billingClient ->
-                    val acknowledgePurchaseParams =
-                        AcknowledgePurchaseParams
-                            .newBuilder()
-                            .setPurchaseToken(token)
-                            .build()
-
-                    billingClient.acknowledgePurchase(acknowledgePurchaseParams) { billingResult: BillingResult ->
-                        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                            PlayUtils.rejectPromiseWithBillingError(
-                                promise,
-                                billingResult.responseCode,
-                            )
-                            return@acknowledgePurchase
-                        }
-
-                        val map = mutableMapOf<String, Any?>()
-                        map["responseCode"] = billingResult.responseCode
-                        map["debugMessage"] = billingResult.debugMessage
-                        val errorData = PlayUtils.getBillingResponseData(billingResult.responseCode)
-                        map["code"] = errorData.code
-                        map["message"] = errorData.message
-                        promise.resolve(map)
+            AsyncFunction("acknowledgePurchaseAndroid") { token: String, promise: Promise ->
+                scope.launch {
+                    try {
+                        openIap.acknowledgePurchaseAndroid(token)
+                        promise.resolve(mapOf("responseCode" to 0))
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_SERVICE_ERROR, e.message, null)
                     }
                 }
             }
 
-            AsyncFunction("consumeProductAndroid") {
-                    token: String,
-                    promise: Promise,
-                ->
-
-                val params = ConsumeParams.newBuilder().setPurchaseToken(token).build()
-
-                ensureConnection(promise) { billingClient ->
-                    billingClient.consumeAsync(params) { billingResult: BillingResult, purchaseToken: String? ->
-                        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                            PlayUtils.rejectPromiseWithBillingError(
-                                promise,
-                                billingResult.responseCode,
-                            )
-                            return@consumeAsync
-                        }
-
-                        val map = mutableMapOf<String, Any?>()
-                        map["responseCode"] = billingResult.responseCode
-                        map["debugMessage"] = billingResult.debugMessage
-                        val errorData = PlayUtils.getBillingResponseData(billingResult.responseCode)
-                        map["code"] = errorData.code
-                        map["message"] = errorData.message
-                        map["purchaseTokenAndroid"] = purchaseToken
-                        promise.resolve(map)
+            // New name: consumePurchaseAndroid
+            AsyncFunction("consumePurchaseAndroid") { token: String, promise: Promise ->
+                scope.launch {
+                    try {
+                        openIap.consumePurchaseAndroid(token)
+                        promise.resolve(mapOf("responseCode" to 0, "purchaseToken" to token))
+                    } catch (e: Exception) {
+                        promise.reject(OpenIapError.E_SERVICE_ERROR, e.message, null)
                     }
                 }
             }
 
-
-            AsyncFunction("getStorefront") {
-                    promise: Promise,
-                ->
-                ensureConnection(promise) { billingClient ->
-                    billingClient.getBillingConfigAsync(
-                        GetBillingConfigParams.newBuilder().build(),
-                        BillingConfigResponseListener { result: BillingResult, config: BillingConfig? ->
-                            if (result.responseCode == BillingClient.BillingResponseCode.OK) {
-                                promise.safeResolve(config?.countryCode.orEmpty())
-                            } else {
-                                val debugMessage = result.debugMessage.orEmpty()
-                                promise.safeReject(result.responseCode.toString(), debugMessage)
-                            }
-                        },
-                    )
-                }
+            OnDestroy {
+                job.cancel()
             }
         }
-
-    /**
-     * Rejects promise with billing code if BillingResult is not OK
-     */
-    private fun isValidResult(
-        billingResult: BillingResult,
-        promise: Promise,
-    ): Boolean {
-        Log.d(TAG, "responseCode: " + billingResult.responseCode)
-        if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-            PlayUtils.rejectPromiseWithBillingError(promise, billingResult.responseCode)
-            return false
-        }
-        return true
-    }
-
-    private fun ensureConnection(
-        promise: Promise,
-        callback: (billingClient: BillingClient) -> Unit,
-    ) {
-        // With auto-reconnection enabled, we only need to check if billing client exists
-        // The service will automatically reconnect when needed
-        if (billingClientCache != null) {
-            callback(billingClientCache!!)
-            return
-        }
-
-        initBillingClient(promise, callback)
-    }
-
-    private fun initBillingClient(
-        promise: Promise,
-        callback: (billingClient: BillingClient) -> Unit,
-    ) {
-        if (GoogleApiAvailability
-                .getInstance()
-                .isGooglePlayServicesAvailable(context) != ConnectionResult.SUCCESS
-        ) {
-            Log.i(TAG, "Google Play Services are not available on this device")
-            promise.reject(
-                IapErrorCode.E_NOT_PREPARED,
-                "Google Play Services are not available on this device",
-                null,
-            )
-            return
-        }
-
-        billingClientCache =
-            BillingClient
-                .newBuilder(context)
-                .setListener(this)
-                .enablePendingPurchases(PendingPurchasesParams.newBuilder().enableOneTimeProducts().build())
-                .enableAutoServiceReconnection() // Automatically handle service disconnections
-                .build()
-
-        billingClientCache?.startConnection(
-            object : BillingClientStateListener {
-                override fun onBillingSetupFinished(billingResult: BillingResult) {
-                    if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                        promise.reject(
-                            IapErrorCode.E_INIT_CONNECTION,
-                            "Billing setup finished with error: ${billingResult.debugMessage}",
-                            null,
-                        )
-                        return
-                    }
-                    callback(billingClientCache!!)
-                }
-
-                override fun onBillingServiceDisconnected() {
-                    Log.i(TAG, "Billing service disconnected")
-                }
-            },
-        )
-    }
 }