react-native-nami-sdk 2.0.5 → 3.0.8

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

@@ -33,31 +33,31 @@ class NamiEmitter(reactContext: ReactApplicationContext) :
     }
 
     override fun initialize() {
-        NamiPaywallManager.registerSignInListener { _, _, developerPaywallID ->
-            Log.i(LOG_TAG, "Sign in clicked with developerPaywallID $developerPaywallID")
-
-            emitSignInActivated(developerPaywallID)
-        }
+//        NamiPaywallManager.registerSignInListener { _, _, developerPaywallID ->
+//            Log.i(LOG_TAG, "Sign in clicked with developerPaywallID $developerPaywallID")
+//
+//            emitSignInActivated(developerPaywallID)
+//        }
 
         Log.i(LOG_TAG, "In Emitter Initialize()")
 
-        NamiPaywallManager.registerPaywallRaiseListener { _, paywallData, products, developerPaywallId ->
-            Log.i(
-                LOG_TAG,
-                "Products from registerPaywallRaiseListener callback are $products"
-            )
-
-            val sendProducts: List<NamiSKU> = products ?: ArrayList<NamiSKU>()
-            emitPaywallRaise(paywallData, sendProducts, developerPaywallId)
-        }
-
-        NamiPurchaseManager.registerPurchasesChangedListener { list, namiPurchaseState, s ->
-            emitPurchaseMade(list, namiPurchaseState, s)
-        }
-
-        NamiCustomerManager.registerCustomerJourneyChangedListener {
-            emitCustomerJourneyChanged(it)
-        }
+//        NamiPaywallManager.registerPaywallRaiseListener { _, paywallData, products, developerPaywallId ->
+//            Log.i(
+//                LOG_TAG,
+//                "Products from registerPaywallRaiseListener callback are $products"
+//            )
+//
+//            val sendProducts: List<NamiSKU> = products ?: ArrayList<NamiSKU>()
+//            emitPaywallRaise(paywallData, sendProducts, developerPaywallId)
+//        }
+
+//        NamiPurchaseManager.registerPurchasesChangedListener { list, namiPurchaseState, s ->
+//            emitPurchaseMade(list, namiPurchaseState, s)
+//        }
+//
+//        NamiCustomerManager.registerCustomerJourneyChangedListener {
+//            emitCustomerJourneyChanged(it)
+//        }
     }
 
     private fun emitCustomerJourneyChanged(customerJourneyState: CustomerJourneyState) {
@@ -126,8 +126,8 @@ class NamiEmitter(reactContext: ReactApplicationContext) :
         }
 
         // Populate paywall metadata map
-        val paywallMap: WritableMap = namiPaywall.toNamiPaywallDict()
-        map.putMap("paywallMetadata", paywallMap)
+        // val paywallMap: WritableMap = namiPaywall.toNamiPaywallDict()
+        // map.putMap("paywallMetadata", paywallMap)
 
         // Populate SKU details
         val skusArray: WritableArray = Arguments.createArray()

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

@@ -1,167 +1,68 @@
 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.ReadableMap
-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 com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.namiml.entitlement.NamiEntitlement
 import com.namiml.entitlement.NamiEntitlementManager
-import com.namiml.entitlement.NamiEntitlementSetter
+//import com.namiml.entitlement.NamiEntitlementSetter
 import com.namiml.entitlement.NamiPlatformType
 import java.util.ArrayList
 import java.util.Date
+import com.facebook.react.bridge.Callback
 
 class NamiEntitlementManagerBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
-    init {
-        NamiEntitlementManager.registerEntitlementChangeListener {
-            emitEntitlementsChanged(it)
-        }
+    override fun getName(): String {
+        return "RNNamiEntitlementManager"
     }
 
-    private fun emitEntitlementsChanged(activeEntitlements: List<NamiEntitlement>) {
-        val map: WritableMap = WritableNativeMap()
+    @ReactMethod
+    fun isEntitlementActive(referenceId: String, promise: Promise){
+        val isEntitlementActive = NamiEntitlementManager.isEntitlementActive(referenceId)
+        promise.resolve(isEntitlementActive)
+    }
 
+    @ReactMethod
+    fun active(promise: Promise){
+        val nativeEntitlements = NamiEntitlementManager.active()
         val resultArray: WritableArray = WritableNativeArray()
-        for (entitlement in activeEntitlements) {
+        for (entitlement in nativeEntitlements) {
             entitlement.toEntitlementDict()?.let { entitlementDict ->
                 resultArray.pushMap(entitlementDict)
-            }
-        }
-
-        map.putArray("activeEntitlements", resultArray)
-        try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("EntitlementsChanged", map)
-        } catch (e: Exception) {
-            Log.e(LOG_TAG, "Caught Exception: " + e.message)
+           }
         }
-    }
-
-    override fun getName(): String {
-        return "NamiEntitlementManagerBridge"
+        promise.resolve(resultArray)
     }
 
     @ReactMethod
-    fun isEntitlementActive(entitlementRefID: String, resultsCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            val isActive = NamiEntitlementManager.isEntitlementActive(entitlementRefID)
-
-            Log.i(
-                LOG_TAG,
-                "Checking for $entitlementRefID entitlement active, result was $isActive"
-            )
-            resultsCallback.invoke(isActive)
-        }
-    }
-
-    @ReactMethod
-    fun activeEntitlements(resultsCallback: Callback) {
-
-        reactApplicationContext.runOnUiQueueThread {
-            val nativeEntitlements = NamiEntitlementManager.activeEntitlements()
-
+    fun refresh(callback: Callback){
+        NamiEntitlementManager.refresh { activeNativeEntitlements ->
             val resultArray: WritableArray = WritableNativeArray()
-            for (entitlement in nativeEntitlements) {
-                entitlement.toEntitlementDict()?.let { entitlementDict ->
-                    resultArray.pushMap(entitlementDict)
+            if (activeNativeEntitlements != null) {
+                for (entitlement in activeNativeEntitlements) {
+                    entitlement.toEntitlementDict()?.let { entitlementDict ->
+                        resultArray.pushMap(entitlementDict)
+                    }
                 }
             }
-            resultsCallback.invoke(resultArray)
+            callback.invoke(resultArray)
         }
     }
 
     @ReactMethod
-    fun getEntitlements(resultsCallback: Callback) {
-
-        reactApplicationContext.runOnUiQueueThread {
-            val nativeEntitlements = NamiEntitlementManager.getEntitlements()
-
-            Log.i(LOG_TAG, "getEntitlements result is $nativeEntitlements")
-
+    fun registerActiveEntitlementsHandler() {
+        NamiEntitlementManager.registerActiveEntitlementsHandler { activeNativeEntitlements ->
             val resultArray: WritableArray = WritableNativeArray()
-            for (entitlement in nativeEntitlements) {
+            for (entitlement in activeNativeEntitlements) {
                 entitlement.toEntitlementDict()?.let { entitlementDict ->
                     resultArray.pushMap(entitlementDict)
                 }
             }
-            resultsCallback.invoke(resultArray)
-        }
-    }
-
-    @ReactMethod
-    fun setEntitlements(entitlements: ReadableArray) {
-        val entitlementsToSet = ArrayList<NamiEntitlementSetter>()
-
-        val size = entitlements.size()
-        var index = 0
-        while (index < size) {
-            val setterMap: ReadableMap? = entitlements.getMap(index)
-            setterMap?.let {
-                val entitlementSetter = entitlementSetterFromSetterMap(setterMap)
-                entitlementSetter?.let {
-                    entitlementsToSet.add(entitlementSetter)
-                }
-            }
-            index += 1
-        }
-
-        reactApplicationContext.runOnUiQueueThread {
-            NamiEntitlementManager.setEntitlements(entitlementsToSet)
-        }
-    }
-
-    @ReactMethod
-    fun clearAllEntitlements() {
-        reactApplicationContext.runOnUiQueueThread {
-            NamiEntitlementManager.clearAllEntitlements()
-        }
-    }
-
-    private fun entitlementSetterFromSetterMap(entitlementSetterMap: ReadableMap): NamiEntitlementSetter? {
-        if (entitlementSetterMap.hasKey("referenceID")) {
-            val referenceID = entitlementSetterMap.getString("referenceID").orEmpty()
-            if (referenceID.isNotEmpty()) {
-                val expires: Date? = null
-
-                var purchasedSKUid: String? = null
-                if (entitlementSetterMap.hasKey("purchasedSKUID")) {
-                    purchasedSKUid = entitlementSetterMap.getString("purchasedSKUid")
-                }
-
-                var platform: NamiPlatformType = NamiPlatformType.OTHER
-                if (entitlementSetterMap.hasKey("platform")) {
-                    platform = when (entitlementSetterMap.getString("platform")) {
-                        "other" -> NamiPlatformType.OTHER
-
-                        "android" -> NamiPlatformType.ANDROID
-
-                        "apple" -> NamiPlatformType.APPLE
-
-                        "roku" -> NamiPlatformType.ROKU
-
-                        "web" -> NamiPlatformType.WEB
-
-                        else -> NamiPlatformType.OTHER
-                    }
-                }
-
-                //referenceId: kotlin.String, purchasedSKUid: kotlin.String?, expires: java.util.Date?, platform: com.namiml.entitlement.NamiPlatformType
-                return NamiEntitlementSetter(referenceID, platform, purchasedSKUid, expires)
-            }
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("EntitlementsChanged", resultArray)
         }
-        Log.e(LOG_TAG, "Attempted to set entitlement with no referenceID $entitlementSetterMap")
-
-        return null
     }
 }

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

@@ -3,13 +3,8 @@ 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
@@ -19,18 +14,41 @@ class NamiPaywallManagerBridgeModule(reactContext: ReactApplicationContext) :
 
     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(purchase: WritableMap, skuRefId: String) {
+//        NamiPaywallManager.buySkuComplete(currentActivity!!, purchase, skuRefId)
+    }
+
+
+    @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()
+            }
         }
-        reactContext.addActivityEventListener(this)
     }
 
-    override fun getName(): String {
-        return "NamiPaywallManagerBridge"
+    @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 +82,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)
-        }
-    }
-
-    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())
-        }
+//    @ReactMethod
+//    fun blockRaisePaywall(blockRaise: Boolean) {
+//        blockRaisePaywall = blockRaise
+//    }
 
-        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)
+
+
+            }
+        }
+    }
 }