react-native-iap 12.4.3 → 12.4.4

package/android/build.gradle

@@ -70,6 +70,9 @@ android {
   }
 
   testOptions {
+    unitTests.all {
+      jvmArgs '-noverify'
+    }
     unitTests.returnDefaultValues = true
   }
 }

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

@@ -0,0 +1,20 @@
+package com.dooboolab.RNIap
+
+import android.content.Context
+import com.amazon.device.iap.PurchasingListener
+import com.amazon.device.iap.model.FulfillmentResult
+import com.amazon.device.iap.model.RequestId
+
+interface PurchasingServiceProxy {
+    fun registerListener(var0: Context?, var1: PurchasingListener?)
+
+    fun getUserData(): RequestId
+
+    fun purchase(var0: String?): RequestId
+
+    fun getProductData(var0: Set<String?>?): RequestId
+
+    fun getPurchaseUpdates(var0: Boolean): RequestId
+
+    fun notifyFulfillment(var0: String?, var1: FulfillmentResult?)
+}

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

@@ -0,0 +1,33 @@
+package com.dooboolab.RNIap
+
+import android.content.Context
+import com.amazon.device.iap.PurchasingListener
+import com.amazon.device.iap.PurchasingService
+import com.amazon.device.iap.model.FulfillmentResult
+import com.amazon.device.iap.model.RequestId
+
+class PurchasingServiceProxyAmazonImpl : PurchasingServiceProxy {
+    override fun registerListener(var0: Context?, var1: PurchasingListener?) {
+        return PurchasingService.registerListener(var0, var1)
+    }
+
+    override fun getUserData(): RequestId {
+        return PurchasingService.getUserData()
+    }
+
+    override fun purchase(var0: String?): RequestId {
+        return PurchasingService.purchase(var0)
+    }
+
+    override fun getProductData(var0: Set<String?>?): RequestId {
+        return PurchasingService.getProductData(var0)
+    }
+
+    override fun getPurchaseUpdates(var0: Boolean): RequestId {
+        return PurchasingService.getPurchaseUpdates(var0)
+    }
+
+    override fun notifyFulfillment(var0: String?, var1: FulfillmentResult?) {
+        return PurchasingService.notifyFulfillment(var0, var1)
+    }
+}

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

@@ -2,8 +2,6 @@ package com.dooboolab.RNIap
 
 import android.util.Log
 import com.amazon.device.iap.PurchasingListener
-import com.amazon.device.iap.PurchasingService
-import com.amazon.device.iap.model.Product
 import com.amazon.device.iap.model.ProductDataResponse
 import com.amazon.device.iap.model.ProductType
 import com.amazon.device.iap.model.PurchaseResponse
@@ -18,26 +16,21 @@ import com.facebook.react.bridge.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
 import java.lang.NumberFormatException
-import java.util.ArrayList
 
 val ProductType.typeString: String
     get() = if (this == ProductType.ENTITLED || this == ProductType.CONSUMABLE) "inapp" else "subs"
 
-class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingListener {
-    private val skus: MutableList<Product>
+class RNIapAmazonListener(
+    private val reactContext: ReactContext,
+    private val purchasingService: PurchasingServiceProxy
+) : PurchasingListener {
 
     override fun onProductDataResponse(response: ProductDataResponse) {
-        val requestId = response.requestId.toString()
         when (response.requestStatus) {
             ProductDataResponse.RequestStatus.SUCCESSFUL -> {
                 val productData = response.productData
-                val unavailableSkus = response.unavailableSkus
                 val items = WritableNativeArray()
                 for ((_, product) in productData) {
-                    if (!skus.contains(product)) {
-                        skus.add(product)
-                    }
-
                     var priceNumber: Number = 0.00
                     val priceString = product.price
                     try {
@@ -107,7 +100,7 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     availableItems.pushMap(promiseItem)
                 }
                 if (response.hasMore()) {
-                    PurchasingService.getPurchaseUpdates(false)
+                    purchasingService.getPurchaseUpdates(false)
                 } else {
                     if (purchases.size > 0 && promiseItem != null) {
                         PromiseUtils
@@ -197,13 +190,8 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
     override fun onPurchaseResponse(response: PurchaseResponse) {
         val requestId = response.requestId.toString()
         val userId = response.userData.userId
-        val status = response.requestStatus
 
-        // Info for potential error reporting
-        val debugMessage: String?
-        var errorCode = PromiseUtils.E_UNKNOWN
-        val error = Arguments.createMap()
-        when (status) {
+        when (response.requestStatus) {
             PurchaseResponse.RequestStatus.SUCCESSFUL -> {
                 val receipt = response.receipt
                 val userData = response.userData
@@ -218,8 +206,9 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     )
             }
             PurchaseResponse.RequestStatus.ALREADY_PURCHASED -> {
-                debugMessage = "You already own this item."
-                errorCode = PromiseUtils.E_ALREADY_OWNED
+                val error = Arguments.createMap()
+                val debugMessage = "You already own this item."
+                val errorCode = PromiseUtils.E_ALREADY_OWNED
                 error.putInt("responseCode", 0)
                 error.putString("debugMessage", debugMessage)
                 error.putString("code", errorCode)
@@ -234,9 +223,10 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     )
             }
             PurchaseResponse.RequestStatus.FAILED -> {
-                debugMessage =
+                val error = Arguments.createMap()
+                val debugMessage =
                     "An unknown or unexpected error has occurred. Please try again later."
-                errorCode = PromiseUtils.E_UNKNOWN
+                val errorCode = PromiseUtils.E_UNKNOWN
                 error.putInt("responseCode", 0)
                 error.putString("debugMessage", debugMessage)
                 error.putString("code", errorCode)
@@ -251,8 +241,9 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     )
             }
             PurchaseResponse.RequestStatus.INVALID_SKU -> {
-                debugMessage = "That item is unavailable."
-                errorCode = PromiseUtils.E_ITEM_UNAVAILABLE
+                val error = Arguments.createMap()
+                val debugMessage = "That item is unavailable."
+                val errorCode = PromiseUtils.E_ITEM_UNAVAILABLE
                 error.putInt("responseCode", 0)
                 error.putString("debugMessage", debugMessage)
                 error.putString("code", errorCode)
@@ -267,8 +258,9 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     )
             }
             PurchaseResponse.RequestStatus.NOT_SUPPORTED -> {
-                debugMessage = "This feature is not available on your device."
-                errorCode = PromiseUtils.E_SERVICE_ERROR
+                val error = Arguments.createMap()
+                val debugMessage = "This feature is not available on your device."
+                val errorCode = PromiseUtils.E_SERVICE_ERROR
                 error.putInt("responseCode", 0)
                 error.putString("debugMessage", debugMessage)
                 error.putString("code", errorCode)
@@ -314,11 +306,8 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
                     )
         }
     }
-    fun clear() {
-        skus.clear()
-    }
 
-    private fun sendEvent(
+    fun sendEvent(
         reactContext: ReactContext,
         eventName: String,
         params: WritableMap?
@@ -344,8 +333,4 @@ class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingLi
         private const val E_USER_DATA_RESPONSE_NOT_SUPPORTED = "E_USER_DATA_RESPONSE_NOT_SUPPORTED"
         const val TAG = "RNIapAmazonListener"
     }
-
-    init {
-        skus = ArrayList()
-    }
 }

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

@@ -1,9 +1,11 @@
 package com.dooboolab.RNIap
 
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
 import com.amazon.device.drm.LicensingService
 import com.amazon.device.drm.model.LicenseResponse
-import com.amazon.device.iap.PurchasingService
+import com.amazon.device.iap.PurchasingListener
 import com.amazon.device.iap.model.FulfillmentResult
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
@@ -11,14 +13,17 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.module.annotations.ReactModule
 
 @ReactModule(name = RNIapAmazonModule.TAG)
-class RNIapAmazonModule(reactContext: ReactApplicationContext) :
+class RNIapAmazonModule(
+    reactContext: ReactApplicationContext,
+    private val purchasingService: PurchasingServiceProxy = PurchasingServiceProxyAmazonImpl(),
+    private val handler: Handler = Handler(Looper.getMainLooper()),
+    private val amazonListener: PurchasingListener = RNIapAmazonListener(reactContext, purchasingService)
+) :
     ReactContextBaseJavaModule(reactContext) {
     var hasListener = false
-    private var amazonListener: RNIapAmazonListener? = null
     override fun getName(): String {
         return TAG
     }
@@ -26,20 +31,19 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     fun initConnection(promise: Promise) {
         val context = reactApplicationContext
-        val amazonListener = RNIapAmazonListener(context)
-        this.amazonListener = amazonListener
-        UiThreadUtil.runOnUiThread {
+
+        handler.postDelayed({
             try {
-                PurchasingService.registerListener(context.applicationContext, amazonListener)
+                purchasingService.registerListener(context.applicationContext, amazonListener)
                 hasListener = true
                 // Prefetch user and purchases as per Amazon SDK documentation:
-                PurchasingService.getUserData()
-                PurchasingService.getPurchaseUpdates(false)
+                purchasingService.getUserData()
+                purchasingService.getPurchaseUpdates(false)
                 promise.safeResolve(true)
             } catch (e: Exception) {
                 promise.safeReject("Error initializing Amazon appstore sdk", e)
             }
-        }
+        }, 0L)
     }
 
     @ReactMethod
@@ -84,14 +88,13 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     fun endConnection(promise: Promise) {
         PromiseUtils.rejectAllPendingPromises()
-        amazonListener?.clear()
         hasListener = false
         promise.resolve(true)
     }
 
     @ReactMethod
     fun getUser(promise: Promise) {
-        val requestId = PurchasingService.getUserData()
+        val requestId = purchasingService.getUserData()
         PromiseUtils.addPromiseForKey(PROMISE_GET_USER_DATA, promise)
     }
 
@@ -114,13 +117,13 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
             ii++
         }
         PromiseUtils.addPromiseForKey(PROMISE_GET_PRODUCT_DATA, promise)
-        val requestId = PurchasingService.getProductData(productSkus)
+        val requestId = purchasingService.getProductData(productSkus)
     }
 
     @ReactMethod
     fun getAvailableItems(promise: Promise) {
         PromiseUtils.addPromiseForKey(PROMISE_QUERY_AVAILABLE_ITEMS, promise)
-        PurchasingService.getPurchaseUpdates(true)
+        purchasingService.getPurchaseUpdates(true)
     }
 
     @ReactMethod
@@ -129,7 +132,7 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
         promise: Promise
     ) {
         PromiseUtils.addPromiseForKey(PROMISE_BUY_ITEM, promise)
-        val requestId = PurchasingService.purchase(sku)
+        val requestId = purchasingService.purchase(sku)
     }
 
     @ReactMethod
@@ -138,7 +141,7 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
         developerPayLoad: String?,
         promise: Promise
     ) {
-        PurchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
+        purchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
         promise.resolve(true)
     }
 
@@ -148,13 +151,13 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
         developerPayLoad: String?,
         promise: Promise
     ) {
-        PurchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
+        purchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
         promise.resolve(true)
     }
 
     private fun sendUnconsumedPurchases(promise: Promise) {
         PromiseUtils.addPromiseForKey(PROMISE_QUERY_PURCHASES, promise)
-        PurchasingService.getPurchaseUpdates(false)
+        purchasingService.getPurchaseUpdates(false)
     }
 
     @ReactMethod
@@ -189,8 +192,8 @@ class RNIapAmazonModule(reactContext: ReactApplicationContext) :
              */
             override fun onHostResume() {
                 if (hasListener) {
-                    PurchasingService.getUserData()
-                    PurchasingService.getPurchaseUpdates(false)
+                    purchasingService.getUserData()
+                    purchasingService.getPurchaseUpdates(false)
                 }
             }
             override fun onHostPause() {}

package/android/src/testAmazon/java/com/dooboolab/RNIap/RNIapAmazonModuleTest.kt

@@ -0,0 +1,151 @@
+package com.dooboolab.RNIap
+
+import android.os.Handler
+import com.amazon.device.iap.model.PurchaseResponse
+import com.amazon.device.iap.model.Receipt
+import com.amazon.device.iap.model.RequestId
+import com.amazon.device.iap.model.UserData
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import io.mockk.MockKAnnotations
+import io.mockk.Runs
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.spyk
+import io.mockk.verify
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import java.util.*
+
+class RNIapAmazonModuleTest {
+
+    @MockK
+    lateinit var context: ReactApplicationContext
+
+    @RelaxedMockK
+    lateinit var purchasingServiceProxy: PurchasingServiceProxy
+
+    @MockK
+    lateinit var mainThreadHandler: Handler
+
+    private lateinit var listener: RNIapAmazonListener
+
+    private lateinit var module: RNIapAmazonModule
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this, relaxUnitFun = true)
+        listener = spyk(RNIapAmazonListener(context, purchasingServiceProxy))
+        module = RNIapAmazonModule(context, purchasingServiceProxy, mainThreadHandler, listener)
+    }
+
+    @Test
+    fun `initConnection should resolve to true`() {
+        every { context.applicationContext } returns mockk()
+
+        val promise = mockk<Promise>(relaxed = true)
+        val slot = slot<Runnable>()
+        every { mainThreadHandler.postDelayed(capture(slot), any()) } answers { slot.captured.run(); true }
+        module.initConnection(promise)
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        verify { promise.resolve(true) }
+        verify { purchasingServiceProxy.registerListener(any(), any()) }
+    }
+
+    @Test
+    fun `Purchase Item`() {
+        val purchaseResponse = mockk<PurchaseResponse>() {
+            every { requestId } returns RequestId.fromString("0")
+
+            every { requestStatus } returns PurchaseResponse.RequestStatus.SUCCESSFUL
+            val mReceipt = mockk<Receipt>(relaxed = true) {
+                every { sku } returns "mySku"
+                every { purchaseDate } returns Date()
+                every { receiptId } returns "rId"
+            }
+            every { receipt } returns mReceipt
+            val mUserData = mockk<UserData>(relaxed = true) {
+                every { userId } returns "uid1"
+            }
+            every { userData } returns mUserData
+        }
+
+        every { listener.sendEvent(any(), any(), any()) } just Runs
+
+        every { purchasingServiceProxy.purchase(any()) } answers {
+            listener.onPurchaseResponse(
+                purchaseResponse
+            ); RequestId.fromString("0")
+        }
+
+        val itemsMap = mockk<WritableMap>(relaxed = true) {
+            every { getString("productId") } returns "mySku"
+        }
+        mockkStatic(Arguments::class)
+
+        every { Arguments.createMap() } returns itemsMap
+
+        val promise = mockk<Promise>(relaxed = true)
+
+        module.buyItemByType("mySku", promise)
+        verify(exactly = 0) { promise.reject(any(), any<String>()) }
+        val response = slot<WritableMap>()
+        verify { promise.resolve(capture(response)) }
+        assertEquals("mySku", response.captured.getString("productId"))
+        verify { listener.sendEvent(any(), "purchase-updated", any()) }
+        verify(exactly = 0) { purchasingServiceProxy.getPurchaseUpdates(false) }
+    }
+
+//    @Test
+//    fun `initConnection Play Services not available on device should reject`() {
+//    }
+//
+//    @Test
+//    fun `initConnection start new connection fails`() {
+//    }
+//
+//    @Test
+//    fun `endConnection resolves`() {
+//    }
+//
+//    @Test
+//    fun `flushFailedPurchasesCachedAsPending resolves to false if no pending purchases`() {
+//    }
+//
+//    @Test
+//    fun `flushFailedPurchasesCachedAsPending resolves to true if pending purchases`() {
+//    }
+//
+//    @Test
+//    fun getItemsByType() {
+//    }
+//
+//    @Test
+//    fun getAvailableItemsByType() {
+//    }
+//
+//    @Test
+//    fun getPurchaseHistoryByType() {
+//    }
+//
+//
+//    @Test
+//    fun acknowledgePurchase() {
+//    }
+//
+//    @Test
+//    fun consumeProduct() {
+//    }
+//
+//    @Test
+//    fun onPurchasesUpdated() {
+//    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-iap",
-  "version": "12.4.3",
+  "version": "12.4.4",
   "description": "React Native In App Purchase Module.",
   "repository": "https://github.com/dooboolab/react-native-iap",
   "author": "dooboolab <support@dooboolab.com> (https://github.com/dooboolab)",