react-native-iap 8.2.0 → 8.3.0

package/RNIap.podspec

@@ -11,6 +11,11 @@ Pod::Spec.new do |s|
   s.platforms     = { :ios => "9.0", :tvos => "9.0" }
   s.source        = { :git => "https://github.com/dooboolab/react-native-iap.git", :tag => "#{s.version}" }
   s.source_files  = "ios/*.{h,m,swift}"
+  s.script_phase = {
+    :name => 'Copy Swift Header',
+    :script => 'ditto "${DERIVED_SOURCES_DIR}/${PRODUCT_MODULE_NAME}-Swift.h" "${PODS_ROOT}/Headers/Public/${PRODUCT_MODULE_NAME}/${PRODUCT_MODULE_NAME}-Swift.h"',
+    :execution_position => :after_compile 
+  }
   s.swift_version = "4.2"
   s.requires_arc  = true
 

package/android/build.gradle

@@ -66,7 +66,7 @@ repositories {
 
 dependencies {
   implementation 'com.facebook.react:react-native:+'
-  testImplementation 'junit:junit:4.12'
+  testImplementation 'junit:junit:4.13.1'
   testImplementation "io.mockk:mockk:1.12.4"
   playImplementation 'com.android.billingclient:billing:4.0.0'
   def playServicesVersion = safeExtGet('playServicesVersion', DEFAULT_PLAY_SERVICES_VERSION)

package/android/src/amazon/java/com/dooboolab/RNIap/RNIapAmazonModule.kt

@@ -2,6 +2,7 @@ package com.dooboolab.RNIap
 
 import com.amazon.device.iap.PurchasingService
 import com.amazon.device.iap.model.FulfillmentResult
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -10,9 +11,8 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableNativeArray
 import java.util.HashSet
 
-class RNIapAmazonModule(reactContext: ReactApplicationContext?) :
+class RNIapAmazonModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
-    val TAG = "RNIapAmazonModule"
     override fun getName(): String {
         return TAG
     }
@@ -127,5 +127,23 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext?) :
         const val PROMISE_QUERY_PURCHASES = "PROMISE_QUERY_PURCHASES"
         const val PROMISE_QUERY_AVAILABLE_ITEMS = "PROMISE_QUERY_AVAILABLE_ITEMS"
         const val PROMISE_GET_USER_DATA = "PROMISE_GET_USER_DATA"
+
+        const val TAG = "RNIapAmazonModule"
+    }
+    init {
+        val lifecycleEventListener: LifecycleEventListener = object : LifecycleEventListener {
+            /**
+             * From https://developer.amazon.com/docs/in-app-purchasing/iap-implement-iap.html#getpurchaseupdates-responses
+             * We should fetch updates on resume
+             */
+            override fun onHostResume() {
+                PurchasingService.getUserData()
+                PurchasingService.getPurchaseUpdates(false)
+            }
+            override fun onHostPause() {}
+            override fun onHostDestroy() {
+            }
+        }
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
     }
 }

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

@@ -7,7 +7,7 @@ import com.facebook.react.bridge.Promise
 class PlayUtils {
     fun rejectPromiseWithBillingError(promise: Promise, responseCode: Int) {
         val errorData = getBillingResponseData(responseCode)
-        promise.reject(errorData[0], errorData[1])
+        promise.safeReject(errorData[0], errorData[1])
     }
 
     fun getBillingResponseData(responseCode: Int): Array<String?> {

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

@@ -0,0 +1,33 @@
+package com.dooboolab.RNIap
+
+import android.util.Log
+import com.facebook.react.bridge.ObjectAlreadyConsumedException
+import com.facebook.react.bridge.Promise
+
+/**
+ * Extension functions used to simplify promise handling since we don't
+ * want to crash in the case of it being resolved/rejected more than once
+ */
+
+fun Promise.safeResolve(value: Any) {
+    try {
+        this.resolve(value)
+    } catch (oce: ObjectAlreadyConsumedException) {
+        Log.d(RNIapModule.TAG, "Already consumed ${oce.message}")
+    }
+}
+
+fun Promise.safeReject(message: String) = this.safeReject(message, null, null)
+
+fun Promise.safeReject(code: String?, message: String?) = this.safeReject(code, message, null)
+
+fun Promise.safeReject(code: String?, throwable: Throwable?) =
+    this.safeReject(code, null, throwable)
+
+fun Promise.safeReject(code: String?, message: String?, throwable: Throwable?) {
+    try {
+        this.reject(code, message, throwable)
+    } catch (oce: ObjectAlreadyConsumedException) {
+        Log.d(RNIapModule.TAG, "Already consumed ${oce.message}")
+    }
+}

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

@@ -15,7 +15,6 @@ import com.android.billingclient.api.SkuDetails
 import com.android.billingclient.api.SkuDetailsParams
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.ObjectAlreadyConsumedException
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.PromiseImpl
 import com.facebook.react.bridge.ReactApplicationContext
@@ -23,6 +22,7 @@ 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
@@ -40,28 +40,37 @@ class RNIapModule(
     ReactContextBaseJavaModule(reactContext),
     PurchasesUpdatedListener {
 
-    private var billingClient: BillingClient = builder.setListener(this).build()
+    private var billingClientCache: BillingClient? = null
     private val skus: MutableMap<String, SkuDetails> = mutableMapOf()
     override fun getName(): String {
-        return "RNIapModule"
+        return TAG
     }
 
-    private 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")
                     }
                 },
                 {
                     if (it.size > 1 && it[0] is String && it[1] is String) {
-                        promise.reject(
+                        promise.safeReject(
                             it[0] as String, it[1] as String
                         )
                     } else {
@@ -75,50 +84,44 @@ 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.resolve(true)
-            return
-        }
         if (googleApiAvailability.isGooglePlayServicesAvailable(reactContext)
             != ConnectionResult.SUCCESS
         ) {
             Log.i(TAG, "Google Play Services are not available on this device")
-            promise.reject(DoobooUtils.E_NOT_PREPARED, "Google Play Services are not available on this device")
+            promise.safeReject(DoobooUtils.E_NOT_PREPARED, "Google Play Services are not available on this device")
             return
         }
 
-        billingClient = builder.setListener(this).build()
+        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
 
-        billingClient.startConnection(
-            object : BillingClientStateListener {
-                override fun onBillingSetupFinished(billingResult: BillingResult) {
-                    val responseCode = billingResult.responseCode
-                    try {
-                        if (responseCode == BillingClient.BillingResponseCode.OK) {
-                            promise.resolve(true)
-                        } else {
-                            PlayUtils.instance
-                                .rejectPromiseWithBillingError(promise, responseCode)
-                        }
-                    } catch (oce: ObjectAlreadyConsumedException) {
-                        Log.e(TAG, oce.message!!)
+                        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()
-        promise.resolve(true)
+        billingClientCache?.endConnection()
+        billingClientCache = null
+        promise.safeResolve(true)
     }
 
     private fun consumeItems(
@@ -129,7 +132,7 @@ class RNIapModule(
         for (purchase in purchases) {
             ensureConnection(
                 promise
-            ) {
+            ) { billingClient ->
                 val consumeParams =
                     ConsumeParams.newBuilder().setPurchaseToken(purchase.purchaseToken)
                         .build()
@@ -143,11 +146,8 @@ class RNIapModule(
                                 )
                             return@ConsumeResponseListener
                         }
-                        try {
-                            promise.resolve(true)
-                        } catch (oce: ObjectAlreadyConsumedException) {
-                            promise.reject(oce.message)
-                        }
+
+                        promise.safeResolve(true)
                     }
                 billingClient.consumeAsync(consumeParams, listener)
             }
@@ -158,13 +158,14 @@ class RNIapModule(
     fun flushFailedPurchasesCachedAsPending(promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             billingClient.queryPurchasesAsync(
                 BillingClient.SkuType.INAPP
-            ) { _: BillingResult?, list: List<Purchase>? ->
+            ) { billingResult: BillingResult, list: List<Purchase>? ->
+                if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
                 if (list == null) {
                     // No purchases found
-                    promise.resolve(false)
+                    promise.safeResolve(false)
                     return@queryPurchasesAsync
                 }
                 // we only want to try to consume PENDING items, in order to force cache-refresh
@@ -172,7 +173,7 @@ class RNIapModule(
                 val pendingPurchases = list.filter { it.purchaseState == Purchase.PurchaseState.PENDING }
 
                 if (pendingPurchases.isEmpty()) {
-                    promise.resolve(false)
+                    promise.safeResolve(false)
                     return@queryPurchasesAsync
                 }
                 consumeItems(
@@ -185,101 +186,109 @@ class RNIapModule(
     }
 
     @ReactMethod
-    fun getItemsByType(type: String?, skuArr: ReadableArray, promise: Promise) {
+    fun getItemsByType(type: String, skuArr: ReadableArray, promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val skuList = ArrayList<String>()
             for (i in 0 until skuArr.size()) {
-                val sku = skuArr.getString(i)
-                if (sku is String) {
+                if (skuArr.getType(i) == ReadableType.String) {
+                    val sku = skuArr.getString(i)
                     skuList.add(sku)
                 }
             }
             val params = SkuDetailsParams.newBuilder()
-            params.setSkusList(skuList).setType(type!!)
+            params.setSkusList(skuList).setType(type)
             billingClient.querySkuDetailsAsync(
                 params.build()
             ) { billingResult: BillingResult, skuDetailsList: List<SkuDetails>? ->
-                Log.d(TAG, "responseCode: " + billingResult.responseCode)
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                    return@querySkuDetailsAsync
-                }
+                if (!isValidResult(billingResult, promise)) return@querySkuDetailsAsync
+
+                val items = Arguments.createArray()
                 if (skuDetailsList != null) {
-                    for (sku in skuDetailsList) {
-                        skus[sku.sku] = sku
+                    for (skuDetails in skuDetailsList) {
+                        skus[skuDetails.sku] = 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("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)
+                        items.pushMap(item)
                     }
                 }
-                val items = WritableNativeArray()
-                for (skuDetails in skuDetailsList!!) {
-                    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("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)
-                    items.pushMap(item)
-                }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
 
+    /**
+     * 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.instance
+                .rejectPromiseWithBillingError(promise, billingResult.responseCode)
+            return false
+        }
+        return true
+    }
+
     @ReactMethod
     fun getAvailableItemsByType(type: String, promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val items = WritableNativeArray()
             billingClient.queryPurchasesAsync(
                 if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
-            ) { billingResult: BillingResult?, purchases: List<Purchase>? ->
+            ) { billingResult: BillingResult, purchases: List<Purchase>? ->
+                if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
                 if (purchases != null) {
                     for (i in purchases.indices) {
                         val purchase = purchases[i]
@@ -297,11 +306,11 @@ 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) {
                             item.putBoolean("autoRenewingAndroid", purchase.isAutoRenewing)
@@ -309,11 +318,7 @@ class RNIapModule(
                         items.pushMap(item)
                     }
                 }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
@@ -322,20 +327,16 @@ class RNIapModule(
     fun getPurchaseHistoryByType(type: String, promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             billingClient.queryPurchaseHistoryAsync(
                 if (type == "subs") BillingClient.SkuType.SUBS else BillingClient.SkuType.INAPP
             ) { billingResult, purchaseHistoryRecordList ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                    return@queryPurchaseHistoryAsync
-                }
+                if (!isValidResult(billingResult, promise)) return@queryPurchaseHistoryAsync
+
                 Log.d(TAG, purchaseHistoryRecordList.toString())
                 val items = Arguments.createArray()
-                for (i in purchaseHistoryRecordList!!.indices) {
+                purchaseHistoryRecordList?.forEach { purchase ->
                     val item = Arguments.createMap()
-                    val purchase = purchaseHistoryRecordList[i]
                     item.putString("productId", purchase.skus[0])
                     item.putDouble("transactionDate", purchase.purchaseTime.toDouble())
                     item.putString("transactionReceipt", purchase.originalJson)
@@ -345,11 +346,7 @@ class RNIapModule(
                     item.putString("developerPayload", purchase.developerPayload)
                     items.pushMap(item)
                 }
-                try {
-                    promise.resolve(items)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                promise.safeResolve(items)
             }
         }
     }
@@ -366,12 +363,12 @@ class RNIapModule(
     ) {
         val activity = currentActivity
         if (activity == null) {
-            promise.reject(DoobooUtils.E_UNKNOWN, "getCurrentActivity returned null")
+            promise.safeReject(DoobooUtils.E_UNKNOWN, "getCurrentActivity returned null")
             return
         }
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             DoobooUtils.instance.addPromiseForKey(
                 PROMISE_BUY_ITEM, promise
             )
@@ -386,7 +383,7 @@ class RNIapModule(
                 error.putString("message", debugMessage)
                 error.putString("productId", sku)
                 sendEvent(reactContext, "purchase-error", error)
-                promise.reject(PROMISE_BUY_ITEM, debugMessage)
+                promise.safeReject(PROMISE_BUY_ITEM, debugMessage)
                 return@ensureConnection
             }
             builder.setSkuDetails(selectedSku)
@@ -419,7 +416,7 @@ class RNIapModule(
                         error.putString("message", debugMessage)
                         error.putString("productId", sku)
                         sendEvent(reactContext, "purchase-error", error)
-                        promise.reject(PROMISE_BUY_ITEM, debugMessage)
+                        promise.safeReject(PROMISE_BUY_ITEM, debugMessage)
                         return@ensureConnection
                     }
                 } else if (prorationMode
@@ -455,77 +452,71 @@ class RNIapModule(
                 builder.setSubscriptionUpdateParams(subscriptionUpdateParams)
             }
             val flowParams = builder.build()
-            val billingResult = billingClient.launchBillingFlow(activity, flowParams)
-            val errorData: Array<String?> =
-                PlayUtils.instance.getBillingResponseData(billingResult.responseCode)
+            val billingResultCode = billingClient.launchBillingFlow(activity, flowParams)?.responseCode ?: BillingClient.BillingResponseCode.ERROR
+            if (billingResultCode == BillingClient.BillingResponseCode.OK) {
+                promise.safeResolve(true)
+                return@ensureConnection
+            } else {
+                val errorData: Array<String?> =
+                    PlayUtils.instance.getBillingResponseData(billingResultCode)
+                promise.safeReject(errorData[0], errorData[1])
+            }
         }
     }
 
     @ReactMethod
     fun acknowledgePurchase(
-        token: String?,
+        token: String,
         developerPayLoad: String?,
         promise: Promise
     ) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val acknowledgePurchaseParams =
                 AcknowledgePurchaseParams.newBuilder().setPurchaseToken(
-                    token!!
+                    token
                 ).build()
             billingClient.acknowledgePurchase(
                 acknowledgePurchaseParams
             ) { billingResult: BillingResult ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                }
-                try {
-                    val map = Arguments.createMap()
-                    map.putInt("responseCode", billingResult.responseCode)
-                    map.putString("debugMessage", billingResult.debugMessage)
-                    val errorData: Array<String?> = PlayUtils.instance
-                        .getBillingResponseData(billingResult.responseCode)
-                    map.putString("code", errorData[0])
-                    map.putString("message", errorData[1])
-                    promise.resolve(map)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    Log.e(TAG, oce.message!!)
-                }
+                if (!isValidResult(billingResult, promise)) return@acknowledgePurchase
+
+                val map = Arguments.createMap()
+                map.putInt("responseCode", billingResult.responseCode)
+                map.putString("debugMessage", billingResult.debugMessage)
+                val errorData: Array<String?> = PlayUtils.instance
+                    .getBillingResponseData(billingResult.responseCode)
+                map.putString("code", errorData[0])
+                map.putString("message", errorData[1])
+                promise.safeResolve(map)
             }
         }
     }
 
     @ReactMethod
     fun consumeProduct(
-        token: String?,
+        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? ->
-                if (billingResult.responseCode != BillingClient.BillingResponseCode.OK) {
-                    PlayUtils.instance
-                        .rejectPromiseWithBillingError(promise, billingResult.responseCode)
-                }
-                try {
-                    val map = Arguments.createMap()
-                    map.putInt("responseCode", billingResult.responseCode)
-                    map.putString("debugMessage", billingResult.debugMessage)
-                    val errorData: Array<String?> = PlayUtils.instance
-                        .getBillingResponseData(billingResult.responseCode)
-                    map.putString("code", errorData[0])
-                    map.putString("message", errorData[1])
-                    promise.resolve(map)
-                } catch (oce: ObjectAlreadyConsumedException) {
-                    promise.reject(oce.message)
-                }
+                if (!isValidResult(billingResult, promise)) return@consumeAsync
+
+                val map = Arguments.createMap()
+                map.putInt("responseCode", billingResult.responseCode)
+                map.putString("debugMessage", billingResult.debugMessage)
+                val errorData: Array<String?> = PlayUtils.instance
+                    .getBillingResponseData(billingResult.responseCode)
+                map.putString("code", errorData[0])
+                map.putString("message", errorData[1])
+                promise.safeResolve(map)
             }
         }
     }
@@ -596,23 +587,19 @@ class RNIapModule(
     private fun sendUnconsumedPurchases(promise: Promise) {
         ensureConnection(
             promise
-        ) {
+        ) { billingClient ->
             val types = arrayOf(BillingClient.SkuType.INAPP, BillingClient.SkuType.SUBS)
             for (type in types) {
                 billingClient.queryPurchasesAsync(
                     type
-                ) { billingResult: BillingResult, list: List<Purchase>? ->
-                    val unacknowledgedPurchases = ArrayList<Purchase>()
+                ) { billingResult: BillingResult, list: List<Purchase> ->
+                    if (!isValidResult(billingResult, promise)) return@queryPurchasesAsync
 
-                    for (purchase in list!!) {
-                        if (!purchase.isAcknowledged) {
-                            unacknowledgedPurchases.add(purchase)
-                        }
-                    }
+                    val unacknowledgedPurchases = list.filter { !it.isAcknowledged }
                     onPurchasesUpdated(billingResult, unacknowledgedPurchases)
                 }
             }
-            promise.resolve(true)
+            promise.safeResolve(true)
         }
     }
 
@@ -631,9 +618,8 @@ class RNIapModule(
         // Keep: Required for RN built-in Event Emitter Calls.
     }
 
-    @get:ReactMethod
-    val packageName: String
-        get() = reactApplicationContext.packageName
+    @ReactMethod
+    fun getPackageName(promise: Promise) = promise.resolve(reactApplicationContext.packageName)
 
     private fun sendEvent(
         reactContext: ReactContext,
@@ -655,7 +641,7 @@ class RNIapModule(
             override fun onHostResume() {}
             override fun onHostPause() {}
             override fun onHostDestroy() {
-                billingClient.endConnection()
+                billingClientCache?.endConnection()
             }
         }
         reactContext.addLifecycleEventListener(lifecycleEventListener)

package/android/src/testPlay/java/com/dooboolab/RNIap/RNIapModuleTest.kt

@@ -3,17 +3,30 @@ package com.dooboolab.RNIap
 import com.android.billingclient.api.BillingClient
 import com.android.billingclient.api.BillingClientStateListener
 import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.ConsumeResponseListener
+import com.android.billingclient.api.Purchase
 import com.android.billingclient.api.PurchasesResponseListener
+import com.android.billingclient.api.SkuDetailsResponseListener
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
 import com.google.android.gms.common.ConnectionResult
 import com.google.android.gms.common.GoogleApiAvailability
 import io.mockk.MockKAnnotations
 import io.mockk.every
 import io.mockk.impl.annotations.MockK
+import io.mockk.just
 import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.runs
 import io.mockk.slot
 import io.mockk.verify
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 
@@ -21,10 +34,13 @@ class RNIapModuleTest {
 
     @MockK
     lateinit var context: ReactApplicationContext
+
     @MockK
     lateinit var builder: BillingClient.Builder
+
     @MockK
     lateinit var billingClient: BillingClient
+
     @MockK
     lateinit var availability: GoogleApiAvailability
 
@@ -40,9 +56,13 @@ class RNIapModuleTest {
 
     @Test
     fun `initConnection Already connected should resolve to true`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        module.initConnection(mockk())
+
         every { billingClient.isReady } returns true
-        val promise = mockk<Promise>(relaxed = true)
 
+        val promise = mockk<Promise>(relaxed = true)
+        // Already connected
         module.initConnection(promise)
         verify(exactly = 0) { promise.reject(any(), any<String>()) }
         verify { promise.resolve(true) }
@@ -55,7 +75,7 @@ class RNIapModuleTest {
         val promise = mockk<Promise>(relaxed = true)
 
         module.initConnection(promise)
-        verify { promise.reject(any(), any<String>()) }
+        verify { promise.safeReject(any(), any<String>()) }
         verify(exactly = 0) { promise.resolve(any()) }
     }
 
@@ -64,7 +84,10 @@ class RNIapModuleTest {
         every { billingClient.isReady } returns false
         val listener = slot<BillingClientStateListener>()
         every { billingClient.startConnection(capture(listener)) } answers {
-            listener.captured.onBillingSetupFinished(BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.OK).build())
+            listener.captured.onBillingSetupFinished(
+                BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.OK)
+                    .build()
+            )
         }
         every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
         val promise = mockk<Promise>(relaxed = true)
@@ -79,20 +102,25 @@ class RNIapModuleTest {
         every { billingClient.isReady } returns false
         val listener = slot<BillingClientStateListener>()
         every { billingClient.startConnection(capture(listener)) } answers {
-            listener.captured.onBillingSetupFinished(BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.ERROR).build())
+            listener.captured.onBillingSetupFinished(
+                BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.ERROR)
+                    .build()
+            )
         }
         every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
         val promise = mockk<Promise>(relaxed = true)
 
         module.initConnection(promise)
-        verify { promise.reject(any(), any<String>()) }
+        verify { promise.safeReject(any(), any<String>()) }
         verify(exactly = 0) { promise.resolve(any()) }
     }
 
     @Test
     fun `endConnection resolves`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
         val promise = mockk<Promise>(relaxed = true)
 
+        module.initConnection(mockk())
         module.endConnection(promise)
 
         verify { billingClient.endConnection() }
@@ -102,20 +130,131 @@ class RNIapModuleTest {
 
     @Test
     fun `flushFailedPurchasesCachedAsPending resolves to false if no pending purchases`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
         every { billingClient.isReady } returns true
         val promise = mockk<Promise>(relaxed = true)
         val listener = slot<PurchasesResponseListener>()
         every { billingClient.queryPurchasesAsync(any(), capture(listener)) } answers {
             listener.captured.onQueryPurchasesResponse(BillingResult.newBuilder().build(), listOf())
         }
+        module.initConnection(mockk())
         module.flushFailedPurchasesCachedAsPending(promise)
 
         verify(exactly = 0) { promise.reject(any(), any<String>()) }
         verify { promise.resolve(false) } // empty list
     }
 
+    @Test
+    fun `flushFailedPurchasesCachedAsPending resolves to true if pending purchases`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        every { billingClient.isReady } returns true
+        val promise = mockk<Promise>(relaxed = true)
+        val listener = slot<PurchasesResponseListener>()
+        every { billingClient.queryPurchasesAsync(any(), capture(listener)) } answers {
+            listener.captured.onQueryPurchasesResponse(
+                BillingResult.newBuilder().build(),
+                listOf(
+                    // 4 = Pending
+                    mockk<Purchase> {
+                        every { purchaseState } returns 2
+                        every { purchaseToken } returns "token"
+                    },
+                    Purchase("", "1")
+                )
+            )
+        }
+        val consumeListener = slot<ConsumeResponseListener>()
+        every { billingClient.consumeAsync(any(), capture(consumeListener)) } answers {
+            consumeListener.captured.onConsumeResponse(
+                BillingResult.newBuilder()
+                    .setResponseCode(BillingClient.BillingResponseCode.ITEM_NOT_OWNED).build(),
+                ""
+            )
+        }
+        module.initConnection(mockk())
+        module.flushFailedPurchasesCachedAsPending(promise)
+
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(true) } // at least one pending transactions
+    }
+
+    @Test
+    fun `ensureConnection should attempt to reconnect, if not in ready state`() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        val promise = mockk<Promise>(relaxed = true)
+        var isCallbackCalled = false
+        val callback = { _: BillingClient ->
+            isCallbackCalled = true
+            promise.resolve(true)
+        }
+
+        every { billingClient.isReady } returns true
+        val listener = slot<BillingClientStateListener>()
+        every { billingClient.startConnection(capture(listener)) } answers {
+            listener.captured.onBillingSetupFinished(
+                BillingResult.newBuilder().setResponseCode(BillingClient.BillingResponseCode.OK)
+                    .build()
+            )
+        }
+
+        module.ensureConnection(promise, callback)
+        verify { promise.resolve(true) } // at least one pending transactions
+        assertTrue("Should call callback", isCallbackCalled)
+    }
+
     @Test
     fun getItemsByType() {
+        every { availability.isGooglePlayServicesAvailable(any()) } returns ConnectionResult.SUCCESS
+        every { billingClient.isReady } returns true
+        val promise = mockk<Promise>(relaxed = true)
+        val listener = slot<SkuDetailsResponseListener>()
+        every { billingClient.querySkuDetailsAsync(any(), capture(listener)) } answers {
+            listener.captured.onSkuDetailsResponse(
+                BillingResult.newBuilder().build(),
+                listOf(
+                    mockk {
+                        every { sku } returns "sku1"
+                        every { introductoryPriceAmountMicros } returns 0
+                        every { priceAmountMicros } returns 1
+                        every { priceCurrencyCode } returns "USD"
+                        every { type } returns "sub"
+                        every { price } returns "$10.0"
+                        every { title } returns "My product"
+                        every { description } returns "My desc"
+                        every { introductoryPrice } returns "$5.0"
+                        every { zzc() } returns "com.mypackage"
+                        every { originalPrice } returns "$13.0"
+                        every { subscriptionPeriod } returns "3 months"
+                        every { freeTrialPeriod } returns "1 week"
+                        every { introductoryPriceCycles } returns 1
+                        every { introductoryPricePeriod } returns "1"
+                        every { iconUrl } returns "http://myicon.com/icon"
+                        every { originalJson } returns "{}"
+                        every { originalPriceAmountMicros } returns 2
+                    }
+                )
+            )
+        }
+        val skus = mockk<ReadableArray>() {
+            every { size() } returns 1
+            every { getString(0) } returns "sku0"
+            every { getType(0) } returns ReadableType.String
+        }
+        mockkStatic(Arguments::class)
+
+        val itemsMap = mockk<WritableMap>()
+        val itemsArr = mockk<WritableArray>()
+        every { Arguments.createMap() } returns itemsMap
+        every { Arguments.createArray() } returns itemsArr
+        every { itemsMap.putString(any(), any()) } just runs
+        var itemsSize = 0
+        every { itemsArr.pushMap(any()) } answers {
+            itemsSize++
+        }
+        module.initConnection(mockk())
+        module.getItemsByType("subs", skus, promise)
+        verify { promise.resolve(any()) }
+        assertEquals(itemsSize, 1)
     }
 
     @Test

package/ios/RNIapQueue.swift

@@ -10,12 +10,13 @@ import StoreKit
 
 // Temporarily stores payment information since it is sent by the OS before RN instantiates the RNModule
 @objc(RNIapQueue)
-class RNIapQueue: NSObject, SKPaymentTransactionObserver {
-    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
+public class RNIapQueue: NSObject, SKPaymentTransactionObserver {
+    public func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
         //No-op
     }
     
-    static let shared = RNIapQueue()
+    @objc
+    public static let shared = RNIapQueue()
     
     var queue: SKPaymentQueue? = nil;
     var payment: SKPayment? = nil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-iap",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "packageManager": "yarn@3.2.0",
   "description": "React Native In App Purchase Module.",
   "main": "index.js",

package/src/iap.js

@@ -400,10 +400,19 @@ export var acknowledgePurchaseAndroid = function (token, developerPayload) {
  * @param {string} sku The product's SKU (on Android)
  * @returns {Promise<void>}
  */
-export var deepLinkToSubscriptionsAndroid = function (sku) {
-    checkNativeAndroidAvailable();
-    return Linking.openURL("https://play.google.com/store/account/subscriptions?package=".concat(RNIapModule.getPackageName(), "&sku=").concat(sku));
-};
+export var deepLinkToSubscriptionsAndroid = function (sku) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                checkNativeAndroidAvailable();
+                _b = (_a = Linking).openURL;
+                _c = "https://play.google.com/store/account/subscriptions?package=".concat;
+                return [4 /*yield*/, RNIapModule.getPackageName()];
+            case 1: return [2 /*return*/, _b.apply(_a, [_c.apply("https://play.google.com/store/account/subscriptions?package=", [_d.sent(), "&sku="]).concat(sku)])];
+        }
+    });
+}); };
 /**
  * Should Add Store Payment (iOS only)
  *   Indicates the the App Store purchase should continue from the app instead of the App Store.