react-native-iap 13.0.4 → 14.0.0-rc.2

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

@@ -1,325 +0,0 @@
-package com.dooboolab.rniap
-
-import android.util.Log
-import com.amazon.device.iap.PurchasingListener
-import com.amazon.device.iap.model.ProductDataResponse
-import com.amazon.device.iap.model.ProductType
-import com.amazon.device.iap.model.PurchaseResponse
-import com.amazon.device.iap.model.PurchaseUpdatesResponse
-import com.amazon.device.iap.model.UserDataResponse
-import com.dooboolab.rniap.utils.toMap
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
-import java.lang.NumberFormatException
-
-val ProductType.typeString: String
-    get() = if (this == ProductType.ENTITLED || this == ProductType.CONSUMABLE) "inapp" else "subs"
-
-class RNIapAmazonListener(
-    var eventSender: EventSender?,
-    var purchasingService: PurchasingServiceProxy?,
-) : PurchasingListener {
-    override fun onProductDataResponse(response: ProductDataResponse) {
-        when (response.requestStatus) {
-            ProductDataResponse.RequestStatus.SUCCESSFUL -> {
-                val productData = response.productData
-                val items = WritableNativeArray()
-                for ((_, product) in productData) {
-                    var priceNumber: Number = 0.00
-                    val priceString = product.price
-                    try {
-                        if (priceString?.isNotEmpty() == true) {
-                            priceNumber = priceString.replace("[^\\d.,]+".toRegex(), "").toDouble()
-                        }
-                    } catch (e: NumberFormatException) {
-                        Log.w(
-                            TAG,
-                            "onProductDataResponse: Failed to parse price for product: " + product.sku,
-                        )
-                    }
-                    val item = Arguments.createMap()
-                    val coinsReward = product.coinsReward
-                    item.putString("productId", product.sku)
-                    item.putString("price", priceNumber.toString())
-                    item.putString("type", product.productType.typeString)
-                    item.putString("localizedPrice", priceString)
-                    item.putString("title", product.title)
-                    item.putString("description", product.description)
-                    item.putString("iconUrl", product.smallIconUrl)
-                    item.putString("originalJson", product.toString())
-                    item.putString("originalPrice", priceString)
-                    // item.putString("userMarketplaceAmazon", marketplace);
-                    if (coinsReward != null) {
-                        item.putInt("coinsRewardAmountAmazon", coinsReward.amount)
-                    }
-                    items.pushMap(item)
-                }
-                PromiseUtils
-                    .resolvePromisesForKey(
-                        RNIapAmazonModule.PROMISE_GET_PRODUCT_DATA,
-                        items,
-                    )
-            }
-            ProductDataResponse.RequestStatus.FAILED ->
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_GET_PRODUCT_DATA,
-                        E_PRODUCT_DATA_RESPONSE_FAILED,
-                        null,
-                        null,
-                    )
-            ProductDataResponse.RequestStatus.NOT_SUPPORTED ->
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_GET_PRODUCT_DATA,
-                        E_PRODUCT_DATA_RESPONSE_NOT_SUPPORTED,
-                        null,
-                        null,
-                    )
-        }
-    }
-
-    override fun onPurchaseUpdatesResponse(response: PurchaseUpdatesResponse) {
-        when (response.requestStatus) {
-            PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL -> {
-                val availableItems = Arguments.createArray()
-                val userData = response.userData
-                var promiseItem: WritableMap? = null
-                val purchases = response.receipts
-                for (receipt in purchases) {
-                    val item = receipt.toMap(userData)
-                    promiseItem = WritableNativeMap()
-                    promiseItem.merge(item)
-                    eventSender?.sendEvent("purchase-updated", item)
-                    availableItems.pushMap(promiseItem)
-                }
-                if (response.hasMore()) {
-                    purchasingService?.getPurchaseUpdates(false)
-                } else {
-                    if (purchases.size > 0 && promiseItem != null) {
-                        PromiseUtils
-                            .resolvePromisesForKey(
-                                RNIapAmazonModule.PROMISE_BUY_ITEM,
-                                promiseItem,
-                            )
-                    }
-                    PromiseUtils
-                        .resolvePromisesForKey(
-                            RNIapAmazonModule.PROMISE_QUERY_PURCHASES,
-                            true,
-                        )
-                    PromiseUtils
-                        .resolvePromisesForKey(
-                            RNIapAmazonModule.PROMISE_QUERY_AVAILABLE_ITEMS,
-                            availableItems,
-                        )
-                }
-            }
-            PurchaseUpdatesResponse.RequestStatus.FAILED -> {
-                val error = Arguments.createMap()
-                val debugMessage = "An unknown or unexpected error has occured. Please try again later."
-                val errorCode = PromiseUtils.E_UNKNOWN
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_QUERY_PURCHASES,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_QUERY_AVAILABLE_ITEMS,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-            PurchaseUpdatesResponse.RequestStatus.NOT_SUPPORTED -> {
-                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)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_QUERY_PURCHASES,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_QUERY_AVAILABLE_ITEMS,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-        }
-    }
-
-    override fun onPurchaseResponse(response: PurchaseResponse) {
-        val requestId = response.requestId.toString()
-        val userId = response.userData.userId
-
-        when (response.requestStatus) {
-            PurchaseResponse.RequestStatus.SUCCESSFUL -> {
-                val receipt = response.receipt
-                val userData = response.userData
-                val item = receipt.toMap(userData)
-                val promiseItem: WritableMap = Arguments.createMap()
-                promiseItem.merge(item)
-                eventSender?.sendEvent("purchase-updated", item)
-                PromiseUtils
-                    .resolvePromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        promiseItem,
-                    )
-            }
-            PurchaseResponse.RequestStatus.ALREADY_PURCHASED -> {
-                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)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-            PurchaseResponse.RequestStatus.FAILED -> {
-                val error = Arguments.createMap()
-                val debugMessage =
-                    "An unknown or unexpected error has occurred. Please try again later."
-                val errorCode = PromiseUtils.E_UNKNOWN
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-            PurchaseResponse.RequestStatus.INVALID_SKU -> {
-                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)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-            PurchaseResponse.RequestStatus.PENDING -> {
-                val error = Arguments.createMap()
-                val debugMessage = "Purchase is pending. Please wait for the transaction to complete."
-                val errorCode = PromiseUtils.E_PENDING
-                error.putInt("responseCode", 0)
-                error.putString("code", errorCode)
-                error.putString("debugMessage", debugMessage)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-            PurchaseResponse.RequestStatus.NOT_SUPPORTED -> {
-                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)
-                error.putString("message", debugMessage)
-                eventSender?.sendEvent("purchase-error", error)
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-        }
-    }
-
-    override fun onUserDataResponse(response: UserDataResponse) {
-        when (response.requestStatus) {
-            UserDataResponse.RequestStatus.SUCCESSFUL -> {
-                val userData = response.userData
-                val item = Arguments.createMap()
-                item.putString("userIdAmazon", userData.userId)
-                item.putString("userMarketplaceAmazon", userData.marketplace)
-                item.putString("userCountryCode", userData.countryCode)
-                item.putString("userJsonAmazon", userData.toJSON().toString())
-                PromiseUtils
-                    .resolvePromisesForKey(RNIapAmazonModule.PROMISE_GET_USER_DATA, item)
-            }
-            UserDataResponse.RequestStatus.NOT_SUPPORTED ->
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_GET_USER_DATA,
-                        E_USER_DATA_RESPONSE_NOT_SUPPORTED,
-                        null,
-                        null,
-                    )
-            UserDataResponse.RequestStatus.FAILED ->
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_GET_USER_DATA,
-                        E_USER_DATA_RESPONSE_FAILED,
-                        null,
-                        null,
-                    )
-        }
-    }
-
-    companion object {
-        private const val E_PRODUCT_DATA_RESPONSE_FAILED = "E_PRODUCT_DATA_RESPONSE_FAILED"
-        private const val E_PRODUCT_DATA_RESPONSE_NOT_SUPPORTED =
-            "E_PRODUCT_DATA_RESPONSE_NOT_SUPPORTED"
-        private const val E_PURCHASE_UPDATES_RESPONSE_FAILED = "E_PURCHASE_UPDATES_RESPONSE_FAILED"
-        private const val E_PURCHASE_UPDATES_RESPONSE_NOT_SUPPORTED =
-            "E_PURCHASE_UPDATES_RESPONSE_NOT_SUPPORTED"
-        private const val E_PURCHASE_RESPONSE_FAILED = "E_PURCHASE_RESPONSE_FAILED"
-        private const val E_PURCHASE_RESPONSE_ALREADY_PURCHASED =
-            "E_PURCHASE_RESPONSE_ALREADY_PURCHASED"
-        private const val E_PURCHASE_RESPONSE_NOT_SUPPORTED = "E_PURCHASE_RESPONSE_NOT_SUPPORTED"
-        private const val E_PURCHASE_RESPONSE_INVALID_SKU = "E_PURCHASE_RESPONSE_INVALID_SKU"
-        private const val E_USER_DATA_RESPONSE_FAILED = "E_USER_DATA_RESPONSE_FAILED"
-        private const val E_USER_DATA_RESPONSE_NOT_SUPPORTED = "E_USER_DATA_RESPONSE_NOT_SUPPORTED"
-        const val TAG = "RNIapAmazonListener"
-    }
-}

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

@@ -1,244 +0,0 @@
-package com.dooboolab.rniap
-
-import android.content.Intent
-import android.net.Uri
-import android.util.Log
-import androidx.core.content.ContextCompat.startActivity
-import com.amazon.device.drm.LicensingService
-import com.amazon.device.drm.model.LicenseResponse
-import com.amazon.device.iap.model.FulfillmentResult
-import com.amazon.device.iap.model.ProrationMode
-import com.facebook.react.bridge.LifecycleEventListener
-import com.facebook.react.bridge.Promise
-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.WritableMap
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.modules.core.DeviceEventManagerModule
-
-@ReactModule(name = RNIapAmazonModule.TAG)
-class RNIapAmazonModule(
-    private val reactContext: ReactApplicationContext,
-    private val purchasingService: PurchasingServiceProxy = PurchasingServiceProxyAmazonImpl(),
-    private var eventSender: EventSender? = null,
-) : ReactContextBaseJavaModule(reactContext) {
-    override fun getName(): String = TAG
-
-    @ReactMethod
-    fun initConnection(promise: Promise) {
-        if (RNIapActivityListener.amazonListener == null) {
-            promise.safeReject(
-                PromiseUtils.E_DEVELOPER_ERROR,
-                Exception("RNIapActivityListener is not registered in your MainActivity.onCreate"),
-            )
-            return
-        }
-        if (eventSender == null) {
-            eventSender =
-                object : EventSender {
-                    private val rctDeviceEventEmitter =
-                        reactContext
-                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-
-                    override fun sendEvent(
-                        eventName: String,
-                        params: WritableMap?,
-                    ) {
-                        rctDeviceEventEmitter
-                            .emit(eventName, params)
-                    }
-                }
-        }
-        RNIapActivityListener.initListeners(eventSender, purchasingService)
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun verifyLicense(promise: Promise) {
-        if (!BuildConfig.IS_AMAZON_DRM_ENABLED) {
-            Log.d(TAG, "Amazon's DRM is disabled")
-            promise.resolve("NOT_LICENSED")
-            return
-        }
-
-        Log.d(TAG, "Amazon's DRM is enabled")
-        try {
-            LicensingService.verifyLicense(reactApplicationContext) { licenseResponse ->
-                val status = licenseResponse.requestStatus.also {
-                    Log.d(TAG, "LicenseResponse status: $it")
-                }
-                when (status) {
-                    LicenseResponse.RequestStatus.LICENSED -> "LICENSED"
-                    LicenseResponse.RequestStatus.NOT_LICENSED -> "NOT_LICENSED"
-                    LicenseResponse.RequestStatus.EXPIRED -> "EXPIRED"
-                    LicenseResponse.RequestStatus.ERROR_VERIFICATION -> "ERROR_VERIFICATION"
-                    LicenseResponse.RequestStatus.ERROR_INVALID_LICENSING_KEYS -> "ERROR_INVALID_LICENSING_KEYS"
-                    LicenseResponse.RequestStatus.UNKNOWN_ERROR -> "UNKNOWN_ERROR"
-                    else -> null
-                }?.let { promise.resolve(it) }
-            }
-        } catch (exception: Exception) {
-            promise.reject("Error while attempting to check for License", exception)
-        }
-    }
-
-    @ReactMethod
-    fun endConnection(promise: Promise) {
-        PromiseUtils.rejectAllPendingPromises()
-        RNIapActivityListener.hasListener = false
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun getUser(promise: Promise) {
-        val requestId = purchasingService.getUserData()
-        PromiseUtils.addPromiseForKey(PROMISE_GET_USER_DATA, promise)
-    }
-
-    @ReactMethod
-    fun flushFailedPurchasesCachedAsPending(promise: Promise) {
-        // No-op
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun getItemsByType(
-        type: String?,
-        skuArr: ReadableArray,
-        promise: Promise,
-    ) {
-        val productSkus: MutableSet<String> = HashSet()
-        var ii = 0
-        val skuSize = skuArr.size()
-        while (ii < skuSize) {
-            skuArr.getString(ii)?.let { sku ->
-                productSkus.add(sku)
-            }
-            ii++
-        }
-        PromiseUtils.addPromiseForKey(PROMISE_GET_PRODUCT_DATA, promise)
-        val requestId = purchasingService.getProductData(productSkus)
-    }
-
-    @ReactMethod
-    fun getAvailableItems(promise: Promise) {
-        PromiseUtils.addPromiseForKey(PROMISE_QUERY_AVAILABLE_ITEMS, promise)
-        purchasingService.getPurchaseUpdates(true)
-    }
-
-    @ReactMethod
-    fun buyItemByType(
-        sku: String?,
-        proration: String?,
-        promise: Promise,
-    ) {
-        PromiseUtils.addPromiseForKey(PROMISE_BUY_ITEM, promise)
-        val requestId = if (!proration.isNullOrEmpty()) {
-            purchasingService.modifySubscription(
-                sku,
-                if (proration == "DEFERRED") ProrationMode.DEFERRED else ProrationMode.IMMEDIATE,
-            )
-        } else {
-            purchasingService.purchase(sku)
-        }
-    }
-
-    @ReactMethod
-    fun acknowledgePurchase(
-        token: String?,
-        developerPayLoad: String?,
-        promise: Promise,
-    ) {
-        purchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun consumeProduct(
-        token: String?,
-        developerPayLoad: String?,
-        promise: Promise,
-    ) {
-        purchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED)
-        promise.resolve(true)
-    }
-
-    private fun sendUnconsumedPurchases(promise: Promise) {
-        PromiseUtils.addPromiseForKey(PROMISE_QUERY_PURCHASES, promise)
-        purchasingService.getPurchaseUpdates(false)
-    }
-
-    /**
-     * Redirects user to a screen where they can manage their subscriptions.
-     * on Amazon devices it will use the system dialog whereas on Android devices that install the Amazon app store, it'll use the browser.
-     * This based on provided parameter `isAmazonDevice`
-     * From https://amazon.developer.forums.answerhub.com/questions/175720/how-to-open-store-subscription-screen-directly-use.html?childToView=179402#answer-179402
-     */
-    @ReactMethod
-    fun deepLinkToSubscriptions(
-        isAmazonDevice: Boolean,
-        promise: Promise,
-    ) {
-        if (isAmazonDevice) {
-            val intent =
-                Intent("android.intent.action.VIEW", Uri.parse("amzn://apps/library/subscriptions"))
-            startActivity(reactContext, intent, null)
-        } else {
-            val uri =
-                Uri.parse("https://www.amazon.com/gp/mas/your-account/myapps/yoursubscriptions/ref=mas_ya_subs")
-            val launchIntent = Intent(Intent.ACTION_VIEW, uri)
-            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            startActivity(reactContext, launchIntent, null)
-        }
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun startListening(promise: Promise) {
-        sendUnconsumedPurchases(promise)
-    }
-
-    @ReactMethod
-    fun addListener(eventName: String) {
-        // Keep: Required for RN built-in Event Emitter Calls.
-    }
-
-    @ReactMethod
-    fun removeListeners(count: Double) {
-        // Keep: Required for RN built-in Event Emitter Calls.
-    }
-
-    companion object {
-        const val PROMISE_BUY_ITEM = "PROMISE_BUY_ITEM"
-        const val PROMISE_GET_PRODUCT_DATA = "PROMISE_GET_PRODUCT_DATA"
-        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() {
-                    if (RNIapActivityListener.hasListener) {
-                        purchasingService.getUserData()
-                        purchasingService.getPurchaseUpdates(false)
-                    }
-                }
-
-                override fun onHostPause() {}
-
-                override fun onHostDestroy() {
-                }
-            }
-        reactContext.addLifecycleEventListener(lifecycleEventListener)
-    }
-}

package/android/src/amazon/java/com/dooboolab/rniap/RNIapPackage.kt

@@ -1,17 +0,0 @@
-package com.dooboolab.rniap
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-import java.util.ArrayList
-
-class RNIapPackage : ReactPackage {
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
-
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        val modules: MutableList<NativeModule> = ArrayList()
-        modules.add(RNIapAmazonModule(reactContext))
-        return modules
-    }
-}

package/android/src/amazon/java/com/dooboolab/rniap/modifysubscription/RNIapAmazonModifySubscriptionListener.kt

@@ -1,88 +0,0 @@
-package com.dooboolab.rniap.modifysubscription
-
-import android.util.Log
-import com.amazon.device.iap.ModifySubscriptionListener
-import com.amazon.device.iap.model.ModifySubscriptionResponse
-import com.dooboolab.rniap.EventSender
-import com.dooboolab.rniap.PromiseUtils
-import com.dooboolab.rniap.RNIapAmazonModule
-import com.dooboolab.rniap.utils.toMap
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableMap
-
-class RNIapAmazonModifySubscriptionListener(
-    var eventSender: EventSender?,
-) : ModifySubscriptionListener {
-
-    companion object {
-        private const val TAG = "AmazonModifySbnListener"
-    }
-
-    override fun onModifySubscriptionResponse(response: ModifySubscriptionResponse) {
-        Log.d(TAG, "onModifySubscriptionResponse ${response.requestStatus}")
-
-        when (response.requestStatus) {
-            ModifySubscriptionResponse.RequestStatus.SUCCESSFUL -> {
-                response.receipts.map { receipt ->
-                    val item = receipt.toMap(response.userData)
-                    val promiseItem: WritableMap = Arguments.createMap()
-                    promiseItem.merge(item)
-                    eventSender?.sendEvent("purchase-updated", item)
-                    PromiseUtils
-                        .resolvePromisesForKey(
-                            RNIapAmazonModule.PROMISE_BUY_ITEM,
-                            promiseItem,
-                        )
-                }
-            }
-
-            else -> {
-                val messageAndCode = when (response.requestStatus) {
-                    ModifySubscriptionResponse.RequestStatus.FAILED -> Pair(
-                        "An unknown or unexpected error has occurred. Please try again later.",
-                        PromiseUtils.E_UNKNOWN,
-                    )
-
-                    ModifySubscriptionResponse.RequestStatus.INVALID_SKU -> Pair(
-                        "That item is unavailable.",
-                        PromiseUtils.E_ITEM_UNAVAILABLE,
-                    )
-
-                    ModifySubscriptionResponse.RequestStatus.NOT_SUPPORTED -> Pair(
-                        "This feature is not available on your device.",
-                        PromiseUtils.E_SERVICE_ERROR,
-                    )
-
-                    else -> null
-                }
-
-                if (messageAndCode == null) {
-                    Log.d(
-                        TAG,
-                        "onModifySubscriptionResponse: ${response.requestStatus} is not handled",
-                    )
-                    return
-                }
-
-                val debugMessage = messageAndCode.first
-                val errorCode = messageAndCode.second
-
-                Arguments.createMap().also {
-                    it.putInt("responseCode", 0)
-                    it.putString("debugMessage", debugMessage)
-                    it.putString("code", errorCode)
-                    it.putString("message", debugMessage)
-                    eventSender?.sendEvent("purchase-error", it)
-                }
-
-                PromiseUtils
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.PROMISE_BUY_ITEM,
-                        errorCode,
-                        debugMessage,
-                        null,
-                    )
-            }
-        }
-    }
-}