expo-iap 1.0.4 → 2.0.0-rc.2

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

@@ -1,356 +0,0 @@
-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
-import com.amazon.device.iap.model.PurchaseUpdatesResponse
-import com.amazon.device.iap.model.Receipt
-import com.amazon.device.iap.model.UserData
-import com.amazon.device.iap.model.UserDataResponse
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
-import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import java.lang.NumberFormatException
-import java.util.ArrayList
-
-class RNIapAmazonListener(private val reactContext: ReactContext) : PurchasingListener {
-    val TAG = "RNIapAmazonListener"
-    private val skus: MutableList<Product>
-    private var availableItems: WritableNativeArray
-    private var availableItemsType: String?
-    fun getPurchaseUpdatesByType(type: String?) {
-        availableItemsType = type
-        PurchasingService.getPurchaseUpdates(true)
-    }
-
-    override fun onProductDataResponse(response: ProductDataResponse) {
-        val status = response.requestStatus
-        val requestId = response.requestId.toString()
-        when (status) {
-            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)
-                    }
-                    val productType = product.productType
-                    val productTypeString =
-                        if (productType == ProductType.ENTITLED || productType == ProductType.CONSUMABLE) "inapp" else "subs"
-                    var priceNumber: Number = 0.00
-                    val priceString = product.price
-                    try {
-                        if (priceString != null && !priceString.isEmpty()) {
-                            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", productTypeString)
-                    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)
-                }
-                DoobooUtils.instance
-                    .resolvePromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_GET_PRODUCT_DATA,
-                        items
-                    )
-            }
-            ProductDataResponse.RequestStatus.FAILED ->
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_GET_PRODUCT_DATA,
-                        E_PRODUCT_DATA_RESPONSE_FAILED,
-                        null,
-                        null
-                    )
-            ProductDataResponse.RequestStatus.NOT_SUPPORTED ->
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_GET_PRODUCT_DATA,
-                        E_PRODUCT_DATA_RESPONSE_NOT_SUPPORTED,
-                        null,
-                        null
-                    )
-        }
-    }
-
-    override fun onPurchaseUpdatesResponse(response: PurchaseUpdatesResponse) {
-        // Info for potential error reporting
-        var debugMessage: String? = null
-        var errorCode = DoobooUtils.E_UNKNOWN
-        val error = Arguments.createMap()
-        val status = response.requestStatus
-        when (status) {
-            PurchaseUpdatesResponse.RequestStatus.SUCCESSFUL -> {
-                val userData = response.userData
-                var promiseItem: WritableMap? = null
-                val purchases = response.receipts
-                for (receipt in purchases) {
-                    val item = receiptToMap(userData, receipt)
-                    promiseItem = WritableNativeMap()
-                    promiseItem.merge(item)
-                    sendEvent(reactContext, "purchase-updated", item)
-                    val productType = receipt.productType
-                    val productTypeString =
-                        if (productType == ProductType.ENTITLED || productType == ProductType.CONSUMABLE) "inapp" else "subs"
-                    if (productTypeString == availableItemsType) {
-                        availableItems.pushMap(promiseItem)
-                    }
-                }
-                if (response.hasMore()) {
-                    PurchasingService.getPurchaseUpdates(false)
-                } else {
-                    if (purchases.size > 0 && promiseItem != null) {
-                        DoobooUtils.instance
-                            .resolvePromisesForKey(
-                                RNIapAmazonModule.Companion.PROMISE_BUY_ITEM,
-                                promiseItem
-                            )
-                    }
-                    DoobooUtils.instance
-                        .resolvePromisesForKey(
-                            RNIapAmazonModule.Companion.PROMISE_QUERY_PURCHASES,
-                            true
-                        )
-                    DoobooUtils.instance
-                        .resolvePromisesForKey(
-                            RNIapAmazonModule.Companion.PROMISE_QUERY_AVAILABLE_ITEMS,
-                            availableItems
-                        )
-                    availableItems = WritableNativeArray()
-                    availableItemsType = null
-                }
-            }
-            PurchaseUpdatesResponse.RequestStatus.FAILED -> {
-                debugMessage = "An unknown or unexpected error has occured. Please try again later."
-                errorCode = DoobooUtils.E_UNKNOWN
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_QUERY_PURCHASES,
-                        errorCode,
-                        debugMessage,
-                        null
-                    )
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_QUERY_AVAILABLE_ITEMS,
-                        errorCode,
-                        debugMessage,
-                        null
-                    )
-                availableItems = WritableNativeArray()
-                availableItemsType = null
-            }
-            PurchaseUpdatesResponse.RequestStatus.NOT_SUPPORTED -> {
-                debugMessage = "This feature is not available on your device."
-                errorCode = DoobooUtils.E_SERVICE_ERROR
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_QUERY_PURCHASES,
-                        errorCode,
-                        debugMessage,
-                        null
-                    )
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_QUERY_AVAILABLE_ITEMS,
-                        errorCode,
-                        debugMessage,
-                        null
-                    )
-                availableItems = WritableNativeArray()
-                availableItemsType = null
-            }
-        }
-    }
-
-    private fun receiptToMap(userData: UserData, receipt: Receipt): WritableMap {
-        val item = Arguments.createMap()
-        item.putString("productId", receipt.sku)
-        item.putDouble("transactionDate", receipt.purchaseDate.time.toDouble())
-        item.putString("purchaseToken", receipt.receiptId)
-        item.putString("transactionReceipt", receipt.toJSON().toString())
-        item.putString("userIdAmazon", userData.userId)
-        item.putString("userMarketplaceAmazon", userData.marketplace)
-        item.putString("userJsonAmazon", userData.toJSON().toString())
-        item.putBoolean("isCanceledAmazon", receipt.isCanceled)
-        return item
-    }
-
-    override fun onPurchaseResponse(response: PurchaseResponse) {
-        val requestId = response.requestId.toString()
-        val userId = response.userData.userId
-        val status = response.requestStatus
-
-        // Info for potential error reporting
-        var debugMessage: String? = null
-        var errorCode = DoobooUtils.E_UNKNOWN
-        val error = Arguments.createMap()
-        when (status) {
-            PurchaseResponse.RequestStatus.SUCCESSFUL -> {
-                val receipt = response.receipt
-                val userData = response.userData
-                val item = receiptToMap(userData, receipt)
-                val promiseItem: WritableMap = WritableNativeMap()
-                promiseItem.merge(item)
-                sendEvent(reactContext, "purchase-updated", item)
-                DoobooUtils.instance
-                    .resolvePromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_BUY_ITEM,
-                        promiseItem
-                    )
-            }
-            PurchaseResponse.RequestStatus.ALREADY_PURCHASED -> {
-                debugMessage = "You already own this item."
-                errorCode = DoobooUtils.E_ALREADY_OWNED
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_BUY_ITEM, errorCode, debugMessage, null
-                    )
-            }
-            PurchaseResponse.RequestStatus.FAILED -> {
-                debugMessage =
-                    "An unknown or unexpected error has occurred. Please try again later."
-                errorCode = DoobooUtils.E_UNKNOWN
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_BUY_ITEM, errorCode, debugMessage, null
-                    )
-            }
-            PurchaseResponse.RequestStatus.INVALID_SKU -> {
-                debugMessage = "That item is unavailable."
-                errorCode = DoobooUtils.E_ITEM_UNAVAILABLE
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_BUY_ITEM, errorCode, debugMessage, null
-                    )
-            }
-            PurchaseResponse.RequestStatus.NOT_SUPPORTED -> {
-                debugMessage = "This feature is not available on your device."
-                errorCode = DoobooUtils.E_SERVICE_ERROR
-                error.putInt("responseCode", 0)
-                error.putString("debugMessage", debugMessage)
-                error.putString("code", errorCode)
-                error.putString("message", debugMessage)
-                sendEvent(reactContext, "purchase-error", error)
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_BUY_ITEM, errorCode, debugMessage, null
-                    )
-            }
-        }
-    }
-
-    override fun onUserDataResponse(response: UserDataResponse) {
-        val status = response.requestStatus
-        when (status) {
-            UserDataResponse.RequestStatus.SUCCESSFUL -> {
-                val userData = response.userData
-                val item = Arguments.createMap()
-                item.putString("userIdAmazon", userData.userId)
-                item.putString("userMarketplaceAmazon", userData.marketplace)
-                item.putString("userJsonAmazon", userData.toJSON().toString())
-                DoobooUtils.instance
-                    .resolvePromisesForKey(RNIapAmazonModule.Companion.PROMISE_GET_USER_DATA, item)
-            }
-            UserDataResponse.RequestStatus.NOT_SUPPORTED ->
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_GET_USER_DATA,
-                        E_USER_DATA_RESPONSE_NOT_SUPPORTED,
-                        null,
-                        null
-                    )
-            UserDataResponse.RequestStatus.FAILED ->
-                DoobooUtils.instance
-                    .rejectPromisesForKey(
-                        RNIapAmazonModule.Companion.PROMISE_GET_USER_DATA,
-                        E_USER_DATA_RESPONSE_FAILED,
-                        null,
-                        null
-                    )
-        }
-    }
-
-    private fun sendEvent(
-        reactContext: ReactContext,
-        eventName: String,
-        params: WritableMap?
-    ) {
-        reactContext
-            .getJSModule(RCTDeviceEventEmitter::class.java)
-            .emit(eventName, params)
-    }
-
-    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"
-    }
-
-    init {
-        skus = ArrayList()
-        availableItems = WritableNativeArray()
-        availableItemsType = null
-    }
-}

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

@@ -1,128 +0,0 @@
-package com.dooboolab.RNIap
-
-import com.amazon.device.iap.PurchasingService
-import com.amazon.device.iap.model.FulfillmentResult
-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.WritableNativeArray
-import java.util.HashSet
-
-class RNIapAmazonModule(reactContext: ReactApplicationContext?) :
-    ReactContextBaseJavaModule(reactContext) {
-    val TAG = "RNIapAmazonModule"
-    override fun getName(): String {
-        return TAG
-    }
-
-    @ReactMethod
-    fun initConnection(promise: Promise) {
-        val context = reactApplicationContext
-        PurchasingService.registerListener(context, RNIapAmazonListener(context))
-        // Prefetch user and purchases as per Amazon SDK documentation:
-        PurchasingService.getUserData()
-        PurchasingService.getPurchaseUpdates(false)
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun endConnection(promise: Promise) {
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun getUser(promise: Promise) {
-        val requestId = PurchasingService.getUserData()
-        DoobooUtils.instance.addPromiseForKey(PROMISE_GET_USER_DATA, promise)
-    }
-
-    @ReactMethod
-    fun flushFailedPurchasesCachedAsPending(promise: Promise) {
-        // No-op
-        val items = WritableNativeArray()
-        promise.resolve(items)
-    }
-
-    @ReactMethod
-    fun getItemsByType(type: String?, skuArr: ReadableArray, promise: Promise) {
-        val productSkus: MutableSet<String> = HashSet()
-        var ii = 0
-        val skuSize = skuArr.size()
-        while (ii < skuSize) {
-            productSkus.add(skuArr.getString(ii))
-            ii++
-        }
-        DoobooUtils.instance.addPromiseForKey(PROMISE_GET_PRODUCT_DATA, promise)
-        val requestId = PurchasingService.getProductData(productSkus)
-    }
-
-    @ReactMethod
-    fun getAvailableItems(promise: Promise) {
-        DoobooUtils.instance.addPromiseForKey(PROMISE_QUERY_AVAILABLE_ITEMS, promise)
-        PurchasingService.getPurchaseUpdates(true)
-    }
-
-    @ReactMethod
-    fun buyItemByType(
-        type: String?,
-        sku: String?,
-        purchaseToken: String?,
-        prorationMode: Int?,
-        obfuscatedAccountId: String?,
-        obfuscatedProfileId: String?,
-        promise: Promise
-    ) {
-        DoobooUtils.instance.addPromiseForKey(PROMISE_BUY_ITEM, promise)
-        val requestId = 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) {
-        PurchasingService.getPurchaseUpdates(false)
-        DoobooUtils.instance.addPromiseForKey(PROMISE_QUERY_PURCHASES, promise)
-    }
-
-    @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"
-    }
-}

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

@@ -1,20 +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<*, *>> {
-        return emptyList()
-    }
-
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        val modules: MutableList<NativeModule> = ArrayList()
-        modules.add(RNIapAmazonModule(reactContext))
-        return modules
-    }
-}

package/android/src/main/java/com/dooboolab/RNIap/DoobooUtils.kt

@@ -1,180 +0,0 @@
-package com.dooboolab.RNIap
-
-import android.util.Log
-import com.facebook.react.bridge.ObjectAlreadyConsumedException
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableType
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
-import org.json.JSONArray
-import org.json.JSONException
-import org.json.JSONObject
-import java.lang.Exception
-import java.util.ArrayList
-import java.util.HashMap
-import kotlin.Throws
-
-class DoobooUtils {
-    private val promises = HashMap<String, ArrayList<Promise>>()
-    fun addPromiseForKey(key: String, promise: Promise) {
-        try {
-            val list: ArrayList<Promise>
-            if (promises.containsKey(key)) {
-                list = promises[key]!!
-            } else {
-                list = ArrayList()
-            }
-            list.add(promise)
-            promises[key] = list
-        } catch (oce: ObjectAlreadyConsumedException) {
-            Log.e(TAG, oce.message!!)
-        }
-    }
-
-    fun resolvePromisesForKey(key: String, value: Any?) {
-        try {
-            if (promises.containsKey(key)) {
-                val list = promises[key]!!
-                for (promise in list) {
-                    promise.resolve(value)
-                }
-                promises.remove(key)
-            }
-        } catch (oce: ObjectAlreadyConsumedException) {
-            Log.e(TAG, oce.message!!)
-        }
-    }
-
-    fun rejectPromisesForKey(
-        key: String,
-        code: String?,
-        message: String?,
-        err: Exception?
-    ) {
-        try {
-            if (promises.containsKey(key)) {
-                val list = promises[key]!!
-                for (promise in list) {
-                    promise.reject(code, message, err)
-                }
-                promises.remove(key)
-            }
-        } catch (oce: ObjectAlreadyConsumedException) {
-            Log.e(TAG, oce.message!!)
-        }
-    }
-
-    @Throws(JSONException::class)
-    fun convertJsonToMap(jsonObject: JSONObject): WritableMap {
-        val map: WritableMap = WritableNativeMap()
-        val iterator = jsonObject.keys()
-        while (iterator.hasNext()) {
-            val key = iterator.next()
-            val value = jsonObject[key]
-            if (value is JSONObject) {
-                map.putMap(key, convertJsonToMap(value))
-            } else if (value is JSONArray) {
-                map.putArray(key, convertJsonToArray(value))
-            } else if (value is Boolean) {
-                map.putBoolean(key, value)
-            } else if (value is Int) {
-                map.putInt(key, value)
-            } else if (value is Double) {
-                map.putDouble(key, value)
-            } else if (value is String) {
-                map.putString(key, value)
-            } else {
-                map.putString(key, value.toString())
-            }
-        }
-        return map
-    }
-
-    @Throws(JSONException::class)
-    fun convertJsonToArray(jsonArray: JSONArray): WritableArray {
-        val array: WritableArray = WritableNativeArray()
-        for (i in 0 until jsonArray.length()) {
-            val value = jsonArray[i]
-            if (value is JSONObject) {
-                array.pushMap(convertJsonToMap(value))
-            } else if (value is JSONArray) {
-                array.pushArray(convertJsonToArray(value))
-            } else if (value is Boolean) {
-                array.pushBoolean(value)
-            } else if (value is Int) {
-                array.pushInt(value)
-            } else if (value is Double) {
-                array.pushDouble(value)
-            } else if (value is String) {
-                array.pushString(value)
-            } else {
-                array.pushString(value.toString())
-            }
-        }
-        return array
-    }
-
-    @Throws(JSONException::class)
-    fun convertMapToJson(readableMap: ReadableMap?): JSONObject {
-        val `object` = JSONObject()
-        val iterator = readableMap?.keySetIterator()
-        iterator?.let {
-            while (iterator.hasNextKey()) {
-                val key = iterator.nextKey()
-                when (readableMap.getType(key)) {
-                    ReadableType.Null -> `object`.put(key, JSONObject.NULL)
-                    ReadableType.Boolean -> `object`.put(key, readableMap.getBoolean(key))
-                    ReadableType.Number -> `object`.put(key, readableMap.getDouble(key))
-                    ReadableType.String -> `object`.put(key, readableMap.getString(key))
-                    ReadableType.Map -> `object`.put(key, convertMapToJson(readableMap.getMap(key)))
-                    ReadableType.Array -> `object`.put(
-                        key,
-                        convertArrayToJson(readableMap.getArray(key))
-                    )
-                }
-            }
-        }
-        return `object`
-    }
-
-    @Throws(JSONException::class)
-    fun convertArrayToJson(readableArray: ReadableArray?): JSONArray {
-        val array = JSONArray()
-        readableArray?.let {
-            for (i in 0 until readableArray.size()) {
-                when (readableArray.getType(i)) {
-                    ReadableType.Null -> {
-                    }
-                    ReadableType.Boolean -> array.put(readableArray.getBoolean(i))
-                    ReadableType.Number -> array.put(readableArray.getDouble(i))
-                    ReadableType.String -> array.put(readableArray.getString(i))
-                    ReadableType.Map -> array.put(convertMapToJson(readableArray.getMap(i)))
-                    ReadableType.Array -> array.put(convertArrayToJson(readableArray.getArray(i)))
-                }
-            }
-        }
-        return array
-    }
-
-    companion object {
-        private const val TAG = "DoobooUtils"
-        const val E_UNKNOWN = "E_UNKNOWN"
-        const val E_NOT_PREPARED = "E_NOT_PREPARED"
-        const val E_ALREADY_PREPARED = "E_ALREADY_PREPARED"
-        const val E_NOT_ENDED = "E_NOT_ENDED"
-        const val E_USER_CANCELLED = "E_USER_CANCELLED"
-        const val E_ITEM_UNAVAILABLE = "E_ITEM_UNAVAILABLE"
-        const val E_NETWORK_ERROR = "E_NETWORK_ERROR"
-        const val E_SERVICE_ERROR = "E_SERVICE_ERROR"
-        const val E_ALREADY_OWNED = "E_ALREADY_OWNED"
-        const val E_REMOTE_ERROR = "E_REMOTE_ERROR"
-        const val E_USER_ERROR = "E_USER_ERROR"
-        const val E_DEVELOPER_ERROR = "E_DEVELOPER_ERROR"
-        const val E_BILLING_RESPONSE_JSON_PARSE_ERROR = "E_BILLING_RESPONSE_JSON_PARSE_ERROR"
-        val instance = DoobooUtils()
-    }
-}