react-native-nami-sdk 2.0.4 → 3.0.8

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

@@ -1,42 +1,111 @@
 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.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.namiml.campaign.NamiCampaignManager
 import com.namiml.customer.CustomerJourneyState
 import com.namiml.customer.NamiCustomerManager
 
+
 class NamiCustomerManagerBridgeModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
 
     override fun getName(): String {
-        return "NamiCustomerManagerBridge"
+        return "RNNamiCustomerManager"
     }
 
-    init {
-        NamiCustomerManager.registerCustomerJourneyChangedListener { customerJourneyState ->
-            emitCustomerJourneyChanged(customerJourneyState)
-        }
+    private fun journeyStateToReadableMap(journeyState: CustomerJourneyState): ReadableMap {
+        val readableMap = Arguments.createMap()
+        readableMap.putBoolean("formerSubscriber", journeyState.formerSubscriber)
+        readableMap.putBoolean("inGracePeriodl", journeyState.inGracePeriod)
+        readableMap.putBoolean("inTrialPeriod", journeyState.inTrialPeriod)
+        readableMap.putBoolean("inIntroOfferPeriod", journeyState.inIntroOfferPeriod)
+        readableMap.putBoolean("isCancelled", journeyState.isCancelled)
+        readableMap.putBoolean("inPause", journeyState.inPause)
+        readableMap.putBoolean("inAccountHold", journeyState.inAccountHold)
+        return readableMap
+    }
+    @ReactMethod
+    fun setCustomerAttribute(key: String, value: String){
+        NamiCustomerManager.setCustomerAttribute(key, value)
+    }
+
+    @ReactMethod
+    fun getCustomerAttribute(key: String, promise: Promise){
+        val customerAttribute = NamiCustomerManager.getCustomerAttribute(key)
+        promise.resolve(customerAttribute)
+    }
+
+    @ReactMethod
+    fun clearCustomerAttribute(key: String){
+        NamiCustomerManager.clearCustomerAttribute(key)
+    }
+
+    @ReactMethod
+    fun clearAllCustomerAttributes(){
+        NamiCustomerManager.clearAllCustomerAttributes()
+    }
+
+    @ReactMethod
+   fun journeyState(promise: Promise){
+     val journeyState = NamiCustomerManager.journeyState()
+       if (journeyState != null) {
+           val handledJourneyState = journeyStateToReadableMap(journeyState)
+           promise.resolve(handledJourneyState)
+       } else {
+           promise.resolve(null)
+       }
+   }
+
+    @ReactMethod
+    fun isLoggedIn(promise: Promise){
+        val isLoggedIn = NamiCustomerManager.isLoggedIn()
+        promise.resolve(isLoggedIn)
+    }
+
+    @ReactMethod
+    fun loggedInId(promise: Promise){
+        val id = NamiCustomerManager.loggedInId()
+        promise.resolve(id)
+    }
+
+    @ReactMethod
+    fun deviceId(promise: Promise){
+        val id = NamiCustomerManager.deviceId()
+        promise.resolve(id)
     }
 
-    private fun emitCustomerJourneyChanged(customerJourneyState: CustomerJourneyState) {
-        Log.i(LOG_TAG, "Emitting CustomerJourneyState changed")
-        try {
+    @ReactMethod
+    fun login(customerId: String){
+        NamiCustomerManager.login(customerId)
+    }
+
+    @ReactMethod
+    fun logout() {
+        NamiCustomerManager.logout()
+    }
+
+    @ReactMethod
+    fun registerJourneyStateHandler() {
+        NamiCustomerManager.registerJourneyStateHandler { journeyState ->
+            val handledJourneyState = journeyStateToReadableMap(journeyState)
             reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("CustomerJourneyStateChanged", customerJourneyState.toDict())
-        } catch (e: Exception) {
-            Log.e(LOG_TAG, "Caught Exception: " + e.message)
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("JourneyStateChanged", handledJourneyState)
         }
     }
 
     @ReactMethod
-    fun currentCustomerJourneyState(resultsCallback: Callback) {
-        reactApplicationContext.runOnUiQueueThread {
-            resultsCallback.invoke(NamiCustomerManager.currentCustomerJourneyState().toDict())
+    fun registerAccountStateHandler() {
+        NamiCustomerManager.registerAccountStateHandler { action, success, error ->
+            val body = Arguments.createMap()
+            body.putString("action", action.toString())
+            body.putBoolean("success", success)
+            body.putString("error", error.toString())
+            reactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("AccountStateChanged", body)
         }
     }
-}
+}

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()
@@ -160,4 +160,4 @@ class NamiEmitter(reactContext: ReactApplicationContext) :
             Log.e(LOG_TAG, "Caught Exception: " + e.message)
         }
     }
-}
+}

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/NamiMLManagerBridgeModule.kt

@@ -47,4 +47,4 @@ class NamiMLManagerBridgeModule(reactContext: ReactApplicationContext) :
             NamiMLManager.coreAction(label)
         }
     }
-}
+}

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