expo-iap 1.0.3 → 2.0.0-rc.1

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()
-    }
-}

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

@@ -1,77 +0,0 @@
-package com.dooboolab.RNIap
-
-import android.util.Log
-import com.android.billingclient.api.BillingClient
-import com.facebook.react.bridge.Promise
-
-class PlayUtils {
-    fun rejectPromiseWithBillingError(promise: Promise, responseCode: Int) {
-        val errorData = getBillingResponseData(responseCode)
-        promise.reject(errorData[0], errorData[1])
-    }
-
-    fun getBillingResponseData(responseCode: Int): Array<String?> {
-        val errorData = arrayOfNulls<String>(2)
-        when (responseCode) {
-            BillingClient.BillingResponseCode.FEATURE_NOT_SUPPORTED -> {
-                errorData[0] = DoobooUtils.E_SERVICE_ERROR
-                errorData[1] = "This feature is not available on your device."
-            }
-            BillingClient.BillingResponseCode.SERVICE_DISCONNECTED -> {
-                errorData[0] = DoobooUtils.E_NETWORK_ERROR
-                errorData[1] = "The service is disconnected (check your internet connection.)"
-            }
-            BillingClient.BillingResponseCode.OK -> {
-                errorData[0] = "OK"
-                errorData[1] = ""
-            }
-            BillingClient.BillingResponseCode.USER_CANCELED -> {
-                errorData[0] = DoobooUtils.E_USER_CANCELLED
-                errorData[1] = "Payment is Cancelled."
-            }
-            BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE -> {
-                errorData[0] = DoobooUtils.E_SERVICE_ERROR
-                errorData[1] =
-                    "The service is unreachable. This may be your internet connection, or the Play Store may be down."
-            }
-            BillingClient.BillingResponseCode.BILLING_UNAVAILABLE -> {
-                errorData[0] = DoobooUtils.E_SERVICE_ERROR
-                errorData[1] =
-                    "Billing is unavailable. This may be a problem with your device, or the Play Store may be down."
-            }
-            BillingClient.BillingResponseCode.ITEM_UNAVAILABLE -> {
-                errorData[0] = DoobooUtils.E_ITEM_UNAVAILABLE
-                errorData[1] = "That item is unavailable."
-            }
-            BillingClient.BillingResponseCode.DEVELOPER_ERROR -> {
-                errorData[0] = DoobooUtils.E_DEVELOPER_ERROR
-                errorData[1] = "Google is indicating that we have some issue connecting to payment."
-            }
-            BillingClient.BillingResponseCode.ERROR -> {
-                errorData[0] = DoobooUtils.E_UNKNOWN
-                errorData[1] = "An unknown or unexpected error has occured. Please try again later."
-            }
-            BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> {
-                errorData[0] = DoobooUtils.E_ALREADY_OWNED
-                errorData[1] = "You already own this item."
-            }
-            else -> {
-                errorData[0] = DoobooUtils.E_UNKNOWN
-                errorData[1] = "Purchase failed with code: $responseCode"
-            }
-        }
-        Log.e(TAG, "Error Code : $responseCode")
-        return errorData
-    }
-
-    fun rejectPromisesWithBillingError(key: String, responseCode: Int) {
-        val errorData = getBillingResponseData(responseCode)
-        DoobooUtils.instance.rejectPromisesForKey(key, errorData[0], errorData[1], null)
-    }
-
-    companion object {
-        private const val TAG = "PlayUtils"
-        const val E_PLAY_SERVICES_UNAVAILABLE = "E_PLAY_SERVICES_UNAVAILABLE"
-        val instance = PlayUtils()
-    }
-}