react-native-iap 8.2.2 → 9.0.0-beta

package/android/src/play/java/com/dooboolab/RNIap/RNIapModule.kt

@@ -9,10 +9,13 @@ import com.android.billingclient.api.BillingFlowParams.SubscriptionUpdateParams
 import com.android.billingclient.api.BillingResult
 import com.android.billingclient.api.ConsumeParams
 import com.android.billingclient.api.ConsumeResponseListener
+import com.android.billingclient.api.ProductDetails
 import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchaseHistoryRecord
 import com.android.billingclient.api.PurchasesUpdatedListener
-import com.android.billingclient.api.SkuDetails
-import com.android.billingclient.api.SkuDetailsParams
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchaseHistoryParams
+import com.android.billingclient.api.QueryPurchasesParams
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
@@ -22,13 +25,13 @@ import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
 import com.google.android.gms.common.ConnectionResult
 import com.google.android.gms.common.GoogleApiAvailability
-import java.math.BigDecimal
 import java.util.ArrayList
 
 class RNIapModule(
@@ -37,23 +40,33 @@ class RNIapModule(
     private val googleApiAvailability: GoogleApiAvailability = GoogleApiAvailability.getInstance()
 ) :
     ReactContextBaseJavaModule(reactContext),
-    PurchasesUpdatedListener {
+    PurchasesUpdatedListener,
+    RNIapModuleInterface {
 
-    private var billingClient: BillingClient = builder.setListener(this).build()
-    private val skus: MutableMap<String, SkuDetails> = mutableMapOf()
+    private var billingClientCache: BillingClient? = null
+    private val skus: MutableMap<String, ProductDetails> = mutableMapOf()
     override fun getName(): String {
         return TAG
     }
 
-    internal fun ensureConnection(promise: Promise, callback: () -> Unit) {
-        if (billingClient.isReady) {
-            callback()
+    internal fun ensureConnection(
+        promise: Promise,
+        callback: (billingClient: BillingClient) -> Unit
+    ) {
+        val billingClient = billingClientCache
+        if (billingClient?.isReady == true) {
+            callback(billingClient)
             return
         } else {
             val nested = PromiseImpl(
                 {
                     if (it.isNotEmpty() && it[0] is Boolean && it[0] as Boolean) {
-                        callback()
+                        val connectedBillingClient = billingClientCache
+                        if (connectedBillingClient?.isReady == true) {
+                            callback(connectedBillingClient)
+                        } else {
+                            promise.safeReject(DoobooUtils.E_NOT_PREPARED, "Unable to auto-initialize connection")
+                        }
                     } else {
                         Log.i(TAG, "Incorrect parameter in resolve")
                     }
@@ -61,7 +74,8 @@ class RNIapModule(
                 {
                     if (it.size > 1 && it[0] is String && it[1] is String) {
                         promise.safeReject(
-                            it[0] as String, it[1] as String
+                            it[0] as String,
+                            it[1] as String
                         )
                     } else {
                         Log.i(TAG, "Incorrect parameters in reject")
@@ -73,15 +87,7 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun initConnection(promise: Promise) {
-        if (billingClient.isReady) {
-            Log.i(
-                TAG,
-                "Already initialized, you should only call initConnection() once when your app starts"
-            )
-            promise.safeResolve(true)
-            return
-        }
+    override fun initConnection(promise: Promise) {
         if (googleApiAvailability.isGooglePlayServicesAvailable(reactContext)
             != ConnectionResult.SUCCESS
         ) {
@@ -90,25 +96,36 @@ class RNIapModule(
             return
         }
 
-        billingClient = builder.setListener(this).build()
-
-        billingClient.startConnection(
-            object : BillingClientStateListener {
-                override fun onBillingSetupFinished(billingResult: BillingResult) {
-                    if (!isValidResult(billingResult, promise)) return
+        if (billingClientCache?.isReady == true) {
+            Log.i(
+                TAG,
+                "Already initialized, you should only call initConnection() once when your app starts"
+            )
+            promise.safeResolve(true)
+            return
+        }
+        builder.setListener(this).build().also {
+            billingClientCache = it
+            it.startConnection(
+                object : BillingClientStateListener {
+                    override fun onBillingSetupFinished(billingResult: BillingResult) {
+                        if (!isValidResult(billingResult, promise)) return
 
-                    promise.safeResolve(true)
-                }
+                        promise.safeResolve(true)
+                    }
 
-                override fun onBillingServiceDisconnected() {
-                    Log.i(TAG, "Billing service disconnected")
+                    override fun onBillingServiceDisconnected() {
+                        Log.i(TAG, "Billing service disconnected")
+                    }
                 }
-            })
+            )
+        }
     }
 
     @ReactMethod
-    fun endConnection(promise: Promise) {
-        billingClient.endConnection()
+    override fun endConnection(promise: Promise) {
+        billingClientCache?.endConnection()
+        billingClientCache = null
         promise.safeResolve(true)
     }
 
@@ -120,7 +137,7 @@ class RNIapModule(
         for (purchase in purchases) {
             ensureConnection(
                 promise
-            ) {
+            ) { billingClient ->
                 val consumeParams =
                     ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
                         .build()
@@ -143,12 +160,14 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun flushFailedPurchasesCachedAsPending(promise: Promise) {
+    override fun flushFailedPurchasesCachedAsPending(promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             billingClient.queryPurchasesAsync(
-                BillingClient.SkuType.INAPP
+                QueryPurchasesParams.newBuilder().setProductType(
+                    BillingClient.ProductType.INAPP
+                ).build()
             ) { billingResult: BillingResult, list: List<Purchase>? ->
                 if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
                 if (list == null) {
@@ -174,77 +193,93 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun getItemsByType(type: String, skuArr: ReadableArray, promise: Promise) {
+    override fun getItemsByType(type: String, skuArr: ReadableArray, promise: Promise) {
         ensureConnection(
             promise
-        ) {
-            val skuList = ArrayList<String>()
+        ) { billingClient ->
+            val skuList = ArrayList<QueryProductDetailsParams.Product>()
             for (i in 0 until skuArr.size()) {
-                val sku = skuArr.getString(i)
-                if (sku is String) {
-                    skuList.add(sku)
+                if (skuArr.getType(i) == ReadableType.String) {
+                    val sku = skuArr.getString(i)
+                    skuList.add(
+                        QueryProductDetailsParams.Product.newBuilder().setProductId(sku)
+                            .setProductType(type).build()
+                    )
                 }
             }
-            val params = SkuDetailsParams.newBuilder()
-            params.setSkusList(skuList).setType(type)
-            billingClient.querySkuDetailsAsync(
+            val params = QueryProductDetailsParams.newBuilder().setProductList(skuList)
+            billingClient.queryProductDetailsAsync(
                 params.build()
-            ) { billingResult: BillingResult, skuDetailsList: List<SkuDetails>? ->
-                if (!isValidResult(billingResult, promise)) return@querySkuDetailsAsync
+            ) { billingResult: BillingResult, skuDetailsList: List<ProductDetails> ->
+                if (!isValidResult(billingResult, promise)) return@queryProductDetailsAsync
 
-                if (skuDetailsList != null) {
-                    for (sku in skuDetailsList) {
-                        skus[sku.sku] = sku
-                    }
-                }
                 val items = Arguments.createArray()
-                for (skuDetails in skuDetailsList!!) {
+                for (skuDetails in skuDetailsList) {
+                    skus[skuDetails.productId] = skuDetails
+
                     val item = Arguments.createMap()
-                    item.putString("productId", skuDetails.sku)
-                    val introductoryPriceMicros = skuDetails.introductoryPriceAmountMicros
-                    val priceAmountMicros = skuDetails.priceAmountMicros
-                    // Use valueOf instead of constructors.
-                    // See:
-                    // https://www.javaworld.com/article/2073176/caution--double-to-bigdecimal-in-java.html
-                    val priceAmount = BigDecimal.valueOf(priceAmountMicros)
-                    val introductoryPriceAmount =
-                        BigDecimal.valueOf(introductoryPriceMicros)
-                    val microUnitsDivisor = BigDecimal.valueOf(1000000)
-                    val price = priceAmount.divide(microUnitsDivisor).toString()
-                    val introductoryPriceAsAmountAndroid =
-                        introductoryPriceAmount.divide(microUnitsDivisor).toString()
-                    item.putString("price", price)
-                    item.putString("currency", skuDetails.priceCurrencyCode)
-                    item.putString("type", skuDetails.type)
-                    item.putString("localizedPrice", skuDetails.price)
+                    item.putString("productId", skuDetails.productId)
                     item.putString("title", skuDetails.title)
                     item.putString("description", skuDetails.description)
-                    item.putString("introductoryPrice", skuDetails.introductoryPrice)
-                    item.putString("typeAndroid", skuDetails.type)
-                    item.putString("packageNameAndroid", skuDetails.zzc())
-                    item.putString("originalPriceAndroid", skuDetails.originalPrice)
-                    item.putString(
-                        "subscriptionPeriodAndroid",
-                        skuDetails.subscriptionPeriod
-                    )
-                    item.putString("freeTrialPeriodAndroid", skuDetails.freeTrialPeriod)
-                    item.putString(
-                        "introductoryPriceCyclesAndroid",
-                        skuDetails.introductoryPriceCycles.toString()
-                    )
-                    item.putString(
-                        "introductoryPricePeriodAndroid", skuDetails.introductoryPricePeriod
-                    )
-                    item.putString(
-                        "introductoryPriceAsAmountAndroid", introductoryPriceAsAmountAndroid
-                    )
-                    item.putString("iconUrl", skuDetails.iconUrl)
-                    item.putString("originalJson", skuDetails.originalJson)
-                    val originalPriceAmountMicros =
-                        BigDecimal.valueOf(skuDetails.originalPriceAmountMicros)
-                    val originalPrice =
-                        originalPriceAmountMicros.divide(microUnitsDivisor).toString()
-                    item.putString("originalPrice", originalPrice)
+                    item.putString("productType", skuDetails.productType)
+                    item.putString("name", skuDetails.name)
+                    val oneTimePurchaseOfferDetails = Arguments.createMap()
+                    skuDetails.oneTimePurchaseOfferDetails?.let {
+                        oneTimePurchaseOfferDetails.putString(
+                            "priceCurrencyCode",
+                            it.priceCurrencyCode
+                        )
+                        oneTimePurchaseOfferDetails.putString("formattedPrice", it.formattedPrice)
+                        oneTimePurchaseOfferDetails.putString(
+                            "priceAmountMicros",
+                            it.priceAmountMicros.toString()
+                        )
+                    }
+                    item.putMap("oneTimePurchaseOfferDetails", oneTimePurchaseOfferDetails)
+
+                    val subscriptionOfferDetails = Arguments.createArray()
+                    skuDetails.subscriptionOfferDetails?.forEach { subscriptionOfferDetailsItem ->
+                        val offerDetails = Arguments.createMap()
+                        offerDetails.putString(
+                            "offerToken",
+                            subscriptionOfferDetailsItem.offerToken
+                        )
+                        val offerTags = Arguments.createArray()
+                        subscriptionOfferDetailsItem.offerTags.forEach { offerTag ->
+                            offerTags.pushString(offerTag)
+                        }
+                        offerDetails.putArray("offerTags", offerTags)
+
+                        val pricingPhasesList = Arguments.createArray()
+                        subscriptionOfferDetailsItem.pricingPhases.pricingPhaseList.forEach { pricingPhaseItem ->
+                            val pricingPhase = Arguments.createMap()
+                            pricingPhase.putString(
+                                "formattedPrice",
+                                pricingPhaseItem.formattedPrice
+                            )
+                            pricingPhase.putString(
+                                "priceCurrencyCode",
+                                pricingPhaseItem.priceCurrencyCode
+                            )
+                            pricingPhase.putString("billingPeriod", pricingPhaseItem.billingPeriod)
+                            pricingPhase.putInt(
+                                "billingCycleCount",
+                                pricingPhaseItem.billingCycleCount
+                            )
+                            pricingPhase.putString(
+                                "priceAmountMicros",
+                                pricingPhaseItem.priceAmountMicros.toString()
+                            )
+                            pricingPhase.putInt("recurrenceMode", pricingPhaseItem.recurrenceMode)
+
+                            pricingPhasesList.pushMap(pricingPhase)
+                        }
+                        val pricingPhases = Arguments.createMap()
+                        pricingPhases.putArray("pricingPhaseList", pricingPhasesList)
+                        offerDetails.putMap("pricingPhases", pricingPhases)
+                        subscriptionOfferDetails.pushMap(offerDetails)
+                    }
+                    item.putArray("subscriptionOfferDetails", subscriptionOfferDetails)
                     items.pushMap(item)
                 }
                 promise.safeResolve(items)
@@ -269,20 +304,22 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun getAvailableItemsByType(type: String, promise: Promise) {
+    override fun getAvailableItemsByType(type: String, promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val items = WritableNativeArray()
             billingClient.queryPurchasesAsync(
-                if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
+                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
                 if (purchases != null) {
                     for (i in purchases.indices) {
                         val purchase = purchases[i]
                         val item = WritableNativeMap()
-                        item.putString("productId", purchase.skus[0])
+                        item.putString("productId", purchase.products[0]) // TODO: should be a list
                         item.putString("transactionId", purchase.orderId)
                         item.putDouble("transactionDate", purchase.purchaseTime.toDouble())
                         item.putString("transactionReceipt", purchase.originalJson)
@@ -295,13 +332,13 @@ class RNIapModule(
                         item.putString("packageNameAndroid", purchase.packageName)
                         item.putString(
                             "obfuscatedAccountIdAndroid",
-                            purchase.accountIdentifiers!!.obfuscatedAccountId
+                            purchase.accountIdentifiers?.obfuscatedAccountId
                         )
                         item.putString(
                             "obfuscatedProfileIdAndroid",
-                            purchase.accountIdentifiers!!.obfuscatedProfileId
+                            purchase.accountIdentifiers?.obfuscatedProfileId
                         )
-                        if (type == BillingClient.SkuType.SUBS) {
+                        if (type == BillingClient.ProductType.SUBS) {
                             item.putBoolean("autoRenewingAndroid", purchase.isAutoRenewing)
                         }
                         items.pushMap(item)
@@ -313,20 +350,24 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun getPurchaseHistoryByType(type: String, promise: Promise) {
+    override fun getPurchaseHistoryByType(type: String, promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             billingClient.queryPurchaseHistoryAsync(
-                if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
-            ) { billingResult, purchaseHistoryRecordList ->
+                QueryPurchaseHistoryParams.newBuilder().setProductType(
+                    if (type == "subs") BillingClient.ProductType.SUBS else BillingClient.ProductType.INAPP
+                ).build()
+            ) {
+                    billingResult: BillingResult, purchaseHistoryRecordList: MutableList<PurchaseHistoryRecord>? ->
+
                 if (!isValidResult(billingResult, promise)) return@queryPurchaseHistoryAsync
 
                 Log.d(TAG, purchaseHistoryRecordList.toString())
                 val items = Arguments.createArray()
                 purchaseHistoryRecordList?.forEach { purchase ->
                     val item = Arguments.createMap()
-                    item.putString("productId", purchase.skus[0])
+                    item.putString("productId", purchase.products[0])
                     item.putDouble("transactionDate", purchase.purchaseTime.toDouble())
                     item.putString("transactionReceipt", purchase.originalJson)
                     item.putString("purchaseToken", purchase.purchaseToken)
@@ -341,13 +382,14 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun buyItemByType(
+    override fun buyItemByType(
         type: String,
-        sku: String,
+        sku: String, // TODO: should this now be an array?
         purchaseToken: String?,
         prorationMode: Int?,
         obfuscatedAccountId: String?,
         obfuscatedProfileId: String?,
+        selectedOfferIndex: Int?, // New optional parameter in V5, TODO: should it be an array?
         promise: Promise
     ) {
         val activity = currentActivity
@@ -357,12 +399,13 @@ class RNIapModule(
         }
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             DoobooUtils.instance.addPromiseForKey(
-                PROMISE_BUY_ITEM, promise
+                PROMISE_BUY_ITEM,
+                promise
             )
             val builder = BillingFlowParams.newBuilder()
-            val selectedSku: SkuDetails? = skus[sku]
+            val selectedSku: ProductDetails? = skus[sku]
             if (selectedSku == null) {
                 val debugMessage =
                     "The sku was not found. Please fetch products first by calling getItems"
@@ -375,10 +418,21 @@ class RNIapModule(
                 promise.safeReject(PROMISE_BUY_ITEM, debugMessage)
                 return@ensureConnection
             }
-            builder.setSkuDetails(selectedSku)
+            var productParams = BillingFlowParams.ProductDetailsParams.newBuilder().setProductDetails(selectedSku)
+            if (selectedOfferIndex != null && (
+                selectedSku.subscriptionOfferDetails?.size
+                    ?: 0
+                ) > selectedOfferIndex
+            ) {
+                val offerToken =
+                    selectedSku.subscriptionOfferDetails?.get(selectedOfferIndex)?.offerToken
+                offerToken?.let { productParams = productParams.setOfferToken(offerToken) }
+            }
+
+            builder.setProductDetailsParamsList(listOf(productParams.build()))
             val subscriptionUpdateParamsBuilder = SubscriptionUpdateParams.newBuilder()
             if (purchaseToken != null) {
-                subscriptionUpdateParamsBuilder.setOldSkuPurchaseToken(purchaseToken)
+                subscriptionUpdateParamsBuilder.setOldPurchaseToken(purchaseToken)
             }
             if (obfuscatedAccountId != null) {
                 builder.setObfuscatedAccountId(obfuscatedAccountId)
@@ -390,7 +444,7 @@ class RNIapModule(
                 if (prorationMode
                     == BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_PRORATED_PRICE
                 ) {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_PRORATED_PRICE
                     )
                     if (type != BillingClient.SkuType.SUBS) {
@@ -411,27 +465,27 @@ class RNIapModule(
                 } else if (prorationMode
                     == BillingFlowParams.ProrationMode.IMMEDIATE_WITHOUT_PRORATION
                 ) {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.IMMEDIATE_WITHOUT_PRORATION
                     )
                 } else if (prorationMode == BillingFlowParams.ProrationMode.DEFERRED) {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.DEFERRED
                     )
                 } else if (prorationMode
                     == BillingFlowParams.ProrationMode.IMMEDIATE_WITH_TIME_PRORATION
                 ) {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.IMMEDIATE_WITHOUT_PRORATION
                     )
                 } else if (prorationMode
                     == BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_FULL_PRICE
                 ) {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_FULL_PRICE
                     )
                 } else {
-                    subscriptionUpdateParamsBuilder.setReplaceSkusProrationMode(
+                    subscriptionUpdateParamsBuilder.setReplaceProrationMode(
                         BillingFlowParams.ProrationMode.UNKNOWN_SUBSCRIPTION_UPGRADE_DOWNGRADE_POLICY
                     )
                 }
@@ -441,30 +495,30 @@ class RNIapModule(
                 builder.setSubscriptionUpdateParams(subscriptionUpdateParams)
             }
             val flowParams = builder.build()
-            val billingResult = billingClient.launchBillingFlow(activity, flowParams)
-            if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
+            val billingResultCode = billingClient.launchBillingFlow(activity, flowParams).responseCode
+            if (billingResultCode == BillingClient.BillingResponseCode.OK) {
                 promise.safeResolve(true)
                 return@ensureConnection
             } else {
                 val errorData: Array<String?> =
-                    PlayUtils.instance.getBillingResponseData(billingResult.responseCode)
+                    PlayUtils.instance.getBillingResponseData(billingResultCode)
                 promise.safeReject(errorData[0], errorData[1])
             }
         }
     }
 
     @ReactMethod
-    fun acknowledgePurchase(
-        token: String?,
+    override fun acknowledgePurchase(
+        token: String,
         developerPayLoad: String?,
         promise: Promise
     ) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val acknowledgePurchaseParams =
                 AcknowledgePurchaseParams.newBuilder().setPurchaseToken(
-                    token!!
+                    token
                 ).build()
             billingClient.acknowledgePurchase(
                 acknowledgePurchaseParams
@@ -484,15 +538,15 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun consumeProduct(
-        token: String?,
+    override fun consumeProduct(
+        token: String,
         developerPayLoad: String?,
         promise: Promise
     ) {
-        val params = ConsumeParams.newBuilder().setPurchaseToken(token!!).build()
+        val params = ConsumeParams.newBuilder().setPurchaseToken(token).build()
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             billingClient.consumeAsync(
                 params
             ) { billingResult: BillingResult, purchaseToken: String? ->
@@ -529,7 +583,7 @@ class RNIapModule(
             for (i in purchases.indices) {
                 val item = Arguments.createMap()
                 val purchase = purchases[i]
-                item.putString("productId", purchase.skus[0])
+                item.putString("productId", purchase.products[0])
                 item.putString("transactionId", purchase.orderId)
                 item.putDouble("transactionDate", purchase.purchaseTime.toDouble())
                 item.putString("transactionReceipt", purchase.originalJson)
@@ -576,11 +630,13 @@ class RNIapModule(
     private fun sendUnconsumedPurchases(promise: Promise) {
         ensureConnection(
             promise
-        ) {
-            val types = arrayOf(BillingClient.SkuType.INAPP, BillingClient.SkuType.SUBS)
+        ) { billingClient ->
+            val types = arrayOf(BillingClient.ProductType.INAPP, BillingClient.ProductType.SUBS)
             for (type in types) {
                 billingClient.queryPurchasesAsync(
-                    type
+                    QueryPurchasesParams.newBuilder().setProductType(
+                        type
+                    ).build()
                 ) { billingResult: BillingResult, list: List<Purchase> ->
                     if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
 
@@ -593,23 +649,22 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun startListening(promise: Promise) {
+    override fun startListening(promise: Promise) {
         sendUnconsumedPurchases(promise)
     }
 
     @ReactMethod
-    fun addListener(eventName: String) {
+    override fun addListener(eventName: String) {
         // Keep: Required for RN built-in Event Emitter Calls.
     }
 
     @ReactMethod
-    fun removeListeners(count: Double) {
+    override fun removeListeners(count: Double) {
         // Keep: Required for RN built-in Event Emitter Calls.
     }
 
-    @get:ReactMethod
-    val packageName: String
-        get() = reactApplicationContext.packageName
+    @ReactMethod
+    override fun getPackageName(promise: Promise) = promise.resolve(reactApplicationContext.packageName)
 
     private fun sendEvent(
         reactContext: ReactContext,
@@ -631,7 +686,7 @@ class RNIapModule(
             override fun onHostResume() {}
             override fun onHostPause() {}
             override fun onHostDestroy() {
-                billingClient.endConnection()
+                billingClientCache?.endConnection()
             }
         }
         reactContext.addLifecycleEventListener(lifecycleEventListener)

package/android/src/play/java/com/dooboolab/RNIap/RNIapModuleInterface.kt

@@ -0,0 +1,44 @@
+package com.dooboolab.RNIap
+
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.Purchase
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+
+/**
+ * Common interface for consistency
+ */
+interface RNIapModuleInterface {
+    fun getName(): String
+    fun initConnection(promise: Promise)
+    fun endConnection(promise: Promise)
+    fun flushFailedPurchasesCachedAsPending(promise: Promise)
+    fun getItemsByType(type: String, skuArr: ReadableArray, promise: Promise)
+    fun getAvailableItemsByType(type: String, promise: Promise)
+    fun getPurchaseHistoryByType(type: String, promise: Promise)
+    fun buyItemByType(
+        type: String,
+        sku: String,
+        purchaseToken: String?,
+        prorationMode: Int?,
+        obfuscatedAccountId: String?,
+        obfuscatedProfileId: String?,
+        selectedOfferIndex: Int?, // New optional parameter in V5 (added to maintain interface consistency)
+        promise: Promise
+    )
+    fun acknowledgePurchase(
+        token: String,
+        developerPayLoad: String?,
+        promise: Promise
+    )
+    fun consumeProduct(
+        token: String,
+        developerPayLoad: String?,
+        promise: Promise
+    )
+    fun onPurchasesUpdated(billingResult: BillingResult, purchases: List<Purchase>?)
+    fun startListening(promise: Promise)
+    fun addListener(eventName: String)
+    fun removeListeners(count: Double)
+    fun getPackageName(promise: Promise)
+}