react-native-nami-sdk 2.0.5 → 3.0.9

package/android/src/main/java/com/nami/reactlibrary/NamiPaywallManagerBridgeModule.kt

@@ -3,34 +3,147 @@ package com.nami.reactlibrary
 import android.app.Activity
 import android.content.Intent
 import android.util.Log
-import com.facebook.react.bridge.ActivityEventListener
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Callback
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.WritableNativeMap
+import com.android.billingclient.api.Purchase
+import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.namiml.paywall.NamiPaywallManager
-import com.namiml.paywall.PreparePaywallResult
+import com.namiml.paywall.*
+import com.namiml.paywall.model.NamiPurchaseSuccess
+import java.text.SimpleDateFormat
+import java.util.Date
 
 class NamiPaywallManagerBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext), ActivityEventListener {
 
     private var blockRaisePaywall: Boolean = false
 
-    init {
-        NamiPaywallManager.registerApplicationAutoRaisePaywallBlocker {
-            Log.i(LOG_TAG, "Nami flag for blocking paywall raise is $blockRaisePaywall")
-            blockRaisePaywall
+    override fun getName(): String {
+        return "RNNamiPaywallManager"
+    }
+
+    @ReactMethod
+    fun buySkuComplete(dict: ReadableMap, storeType: String) {
+        var product = dict.getMap("product")
+        var name = product?.getString("name")
+        var featured = product?.getBoolean("featured")
+        var productId = product?.getString("id")
+        var skuId = product?.getString("skuId")
+        var typeInt = product?.getInt("type")
+        var purchaseSourceString = dict.getString("purchaseSource")
+        var purchaseDateInt = dict.getInt("purchaseDate")
+        var expiresDateInt = dict.getInt("expiresDate")
+        val type = when (typeInt) {
+            0 -> {
+                NamiSKUType.UNKNOWN
+            }
+            1 -> {
+                NamiSKUType.SUBSCRIPTION
+            }
+            2 -> {
+                NamiSKUType.ONE_TIME_PURCHASE
+            }
+            else -> {
+                NamiSKUType.UNKNOWN
+            }
+        }
+
+        val purchaseSource = when (purchaseSourceString) {
+            "CAMPAIGN" -> {
+                NamiPurchaseSource.CAMPAIGN
+            }
+            "MARKETPLACE" -> {
+                NamiPurchaseSource.MARKETPLACE
+            }
+            "UNKNOWN" -> {
+                NamiPurchaseSource.UNKNOWN
+            }
+            else -> {
+                NamiPurchaseSource.UNKNOWN
+            }
+        }
+
+        if (name != null && skuId != null && featured != null) {
+            val namiSku = NamiSKU(
+                    skuId = skuId,
+                    skuDetails = null,
+                    amazonProduct = null,
+                    id = productId,
+                    type = type,
+                    name = name,
+                    featured = featured,
+                    rawDisplayText = null,
+                    rawSubDisplayText = null,
+                    entitlements = emptyList(),
+                    variables = null
+            )
+            val purchaseDate = Date(purchaseDateInt * 1000L)
+            var expiresDate = Date(expiresDateInt * 1000L )
+            var purchaseSuccess: NamiPurchaseSuccess? = null;
+            if (storeType == "GooglePlay") {
+                var purchaseToken = dict.getString("purchaseToken")
+                var orderId = dict.getString("orderId")
+                if (purchaseToken != null && orderId != null) {
+                    purchaseSuccess = NamiPurchaseSuccess.GooglePlay(
+                            product = namiSku,
+                            expiresDate = expiresDate,
+                            purchaseDate = purchaseDate,
+                            purchaseSource = purchaseSource,
+                            description = null,
+                            orderId = orderId,
+                            purchaseToken = purchaseToken,
+                    )
+                }
+            } else if (storeType == "Amazon") {
+                var receiptId = dict.getString("receiptId")
+                var localizedPrice = dict.getString("localizedPrice")
+                var userId = dict.getString("userId")
+                var marketplace = dict.getString("marketplace")
+                if (receiptId != null && localizedPrice != null && userId != null && marketplace != null) {
+                    purchaseSuccess = NamiPurchaseSuccess.Amazon(
+                            product = namiSku,
+                            expiresDate = expiresDate,
+                            purchaseDate = purchaseDate,
+                            purchaseSource = purchaseSource,
+                            description = null,
+                            receiptId = receiptId,
+                            localizedPrice = localizedPrice,
+                            userId = userId,
+                            marketplace = marketplace,
+                    )
+                }
+            }
+
+            if (purchaseSuccess != null) {
+                NamiPaywallManager.buySkuComplete(currentActivity!!, purchaseSuccess)
+            }
         }
-        reactContext.addActivityEventListener(this)
     }
 
-    override fun getName(): String {
-        return "NamiPaywallManagerBridge"
+
+    @ReactMethod
+    fun registerCloseHandler(blockDismiss: Boolean) {
+        NamiPaywallManager.registerCloseHandler { activity ->
+            val resultMap = Arguments.createMap()
+            resultMap.putBoolean("blockingPaywallClosed", true)
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("BlockingPaywallClosed", resultMap)
+            if (!blockDismiss) {
+                activity.finish()
+            }
+        }
+    }
+
+    @ReactMethod
+    fun registerBuySkuHandler() {
+        NamiPaywallManager.registerBuySkuHandler { activity, sku ->
+            val dictionary = sku.toSkuDict()
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("RegisterBuySKU", dictionary)
+        }
     }
 
+
     override fun onActivityResult(
         activity: Activity?,
         requestCode: Int,
@@ -64,138 +177,9 @@ class NamiPaywallManagerBridgeModule(reactContext: ReactApplicationContext) :
         // do nothing
     }
 
-    @ReactMethod
-    fun raisePaywall() {
-        reactApplicationContext.runOnUiQueueThread {
-            raisePaywall(currentActivity, null)
-        }
-    }
-
-    @ReactMethod
-    fun raisePaywallByDeveloperPaywallId(developerPaywallID: String) {
-        reactApplicationContext.runOnUiQueueThread {
-            raisePaywall(currentActivity, developerPaywallID)
-        }
-    }
+//    @ReactMethod
+//    fun blockRaisePaywall(blockRaise: Boolean) {
+//        blockRaisePaywall = blockRaise
+//    }
 
-    private fun raisePaywall(activity: Activity?, developerPaywallID: String?) {
-        if (NamiPaywallManager.canRaisePaywall()) {
-            Log.d(LOG_TAG, "About to raise Paywall ")
-            if (activity != null) {
-                Log.i(LOG_TAG, "Nami Activity to raise paywall is $activity")
-                if (developerPaywallID == null) {
-                    Log.i(LOG_TAG, "Raising Paywall: ")
-                    NamiPaywallManager.raisePaywall(activity)
-                } else {
-                    Log.i(LOG_TAG, "Raising Paywall by Id: $developerPaywallID")
-                    NamiPaywallManager.raisePaywall(developerPaywallID, activity)
-                }
-            } else {
-                Log.w(LOG_TAG, "Activity from react getCurrentActivity was null.")
-            }
-        } else {
-            Log.w(LOG_TAG, "Paywall not raised, SDK says paywall cannot be raised at this time.")
-        }
-    }
-
-    @ReactMethod
-    fun canRaisePaywall(successCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            val canRaiseResult = NamiPaywallManager.canRaisePaywall()
-            successCallback.invoke(canRaiseResult)
-        }
-    }
-
-    @ReactMethod
-    fun blockRaisePaywall(blockRaise: Boolean) {
-        blockRaisePaywall = blockRaise
-    }
-
-    @ReactMethod
-    fun fetchCustomMetadataForDeveloperID(paywallDeveloperID: String, successCallback: Callback) {
-        val sendDict = WritableNativeMap()
-        //TODO: Android SDK needs fetchCustomMetadataForDeveloperID
-        successCallback(sendDict)
-    }
-
-    @ReactMethod
-    fun paywallImpression(developerPaywallID: String) {
-        // TODO: Android SDK paywall impression call.
-    }
-
-    @ReactMethod
-    fun preparePaywallForDisplay(backgroundImageRequired: Boolean, imageFetchTimeout: Double) {
-        val imageFetchTimeoutConvertedToLong: Long = imageFetchTimeout.toLong()
-        reactApplicationContext.runOnUiQueueThread {
-
-            NamiPaywallManager.preparePaywallForDisplay(
-                backgroundImageRequired,
-                imageFetchTimeoutConvertedToLong
-            ) { result ->
-                when (result) {
-                    is PreparePaywallResult.Success -> {
-                        emitPreparePaywallFinished(true, null, null)
-                    }
-                    is PreparePaywallResult.Failure -> {
-                        emitPreparePaywallFinished(false, null, result.error)
-                    }
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun preparePaywallForDisplayByDeveloperPaywallId(
-        developerPaywallID: String,
-        backgroundImageRequired: Boolean,
-        imageFetchTimeout: Double
-    ) {
-        val imageFetchTimeoutConvertedToLong: Long = imageFetchTimeout.toLong()
-        reactApplicationContext.runOnUiQueueThread {
-            NamiPaywallManager.preparePaywallForDisplay(
-                developerPaywallID,
-                backgroundImageRequired,
-                imageFetchTimeoutConvertedToLong
-            ) { result ->
-                when (result) {
-                    is PreparePaywallResult.Success -> {
-                        emitPreparePaywallFinished(true, developerPaywallID, null)
-                    }
-                    is PreparePaywallResult.Failure -> {
-                        emitPreparePaywallFinished(false, developerPaywallID, result.error)
-                    }
-                }
-            }
-        }
-    }
-
-    private fun emitPreparePaywallFinished(
-        success: Boolean,
-        developerPaywallID: String?,
-        error: com.namiml.paywall.PreparePaywallError?
-    ) {
-        val prepareContentMap = Arguments.createMap()
-        prepareContentMap.putBoolean("success", success)
-
-        if (developerPaywallID != null) {
-            prepareContentMap.putString("developerPaywallID", developerPaywallID)
-        }
-
-        if (error != null) {
-            prepareContentMap.putInt("errorCode", error.ordinal)
-            prepareContentMap.putString("errorMessage", error.toString())
-        }
-
-        Log.i(
-            LOG_TAG,
-            "Emitting preparePaywallForDisplay finished with result " + success + "error: " + error.toString()
-        )
-        try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("PreparePaywallFinished", prepareContentMap)
-        } catch (e: Exception) {
-            Log.e(LOG_TAG, "Caught Exception: " + e.message)
-        }
-    }
 }

package/android/src/main/java/com/nami/reactlibrary/NamiPurchaseManagerBridge.kt

@@ -1,22 +1,16 @@
 package com.nami.reactlibrary
 
 import android.util.Log
-import com.facebook.react.bridge.Callback
-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.ReadableType
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.namiml.billing.NamiPurchaseManager
+import com.namiml.paywall.NamiPaywallManager
 
 class NamiPurchaseManagerBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     override fun getName(): String {
-        return "NamiPurchaseManagerBridge"
+        return "RNNamiPurchaseManager"
     }
 
     @ReactMethod
@@ -26,26 +20,6 @@ class NamiPurchaseManagerBridgeModule(reactContext: ReactApplicationContext) :
         }
     }
 
-    @ReactMethod
-    fun buySKU(skuPlatformID: String, developerPaywallID: String, resultsCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            currentActivity?.let {
-                NamiPurchaseManager.buySKU(it, skuPlatformID) {
-
-                    val result: Boolean
-                    if (NamiPurchaseManager.isSKUIDPurchased(skuPlatformID)) {
-                        result = true
-                        Log.i(LOG_TAG, "Purchase complete, result is PURCHASED.")
-                    } else {
-                        result = false
-                        Log.i(LOG_TAG, "Purchase complete, product not purchased.")
-                    }
-                    resultsCallback.invoke(result)
-                }
-            }
-        }
-    }
-
     @ReactMethod
     fun purchases(resultsCallback: Callback) {
         reactApplicationContext.runOnUiQueueThread {
@@ -63,22 +37,20 @@ class NamiPurchaseManagerBridgeModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun isSKUIDPurchased(skuID: String, resultsCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            val isPurchased = NamiPurchaseManager.isSKUIDPurchased(skuID)
-            resultsCallback.invoke(isPurchased)
-        }
+    fun skuPurchased(skuID: String, promise: Promise) {
+        val isPurchased = NamiPurchaseManager.isSKUIDPurchased(skuID)
+        promise.resolve(isPurchased)
     }
 
     @ReactMethod
-    fun consumePurchasedSKU(skuRefId: String) {
+    fun consumePurchasedSku(skuRefId: String) {
         reactApplicationContext.runOnUiQueueThread {
             NamiPurchaseManager.consumePurchasedSKU(skuRefId)
         }
     }
 
     @ReactMethod
-    fun anySKUIDPurchased(skuIDs: ReadableArray, resultsCallback: Callback) {
+    fun anySkuPurchased(skuIDs: ReadableArray, promise: Promise) {
         reactApplicationContext.runOnUiQueueThread {
             val checkArray: MutableList<String> = mutableListOf()
             for (x in 0 until skuIDs.size()) {
@@ -92,7 +64,7 @@ class NamiPurchaseManagerBridgeModule(reactContext: ReactApplicationContext) :
 
             val anyPurchased = NamiPurchaseManager.anySKUIDPurchased(checkArray)
 
-            resultsCallback.invoke(anyPurchased)
+            promise.resolve(anyPurchased)
         }
     }
 
@@ -109,4 +81,30 @@ class NamiPurchaseManagerBridgeModule(reactContext: ReactApplicationContext) :
         }
         resultsCallback.invoke(resultMap)
     }
+
+    @ReactMethod
+    fun registerPurchasesChangedHandler() {
+        NamiPurchaseManager.registerPurchasesChangedHandler{purchases, purchaseState, error ->
+            run {
+                val resultPurchases: WritableArray = WritableNativeArray()
+
+                for (purchase in purchases) {
+                    resultPurchases.pushMap(purchase.toPurchaseDict())
+                }
+
+                val stateString = purchaseState.toString()
+
+                val payload = Arguments.createMap()
+                payload.putArray("purchases", resultPurchases)
+                payload.putString("purchaseState", stateString)
+                payload.putString("error", error)
+
+                reactApplicationContext
+                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit("PurchasesChanged", payload)
+
+
+            }
+        }
+    }
 }