react-native-nami-sdk 2.0.5 → 3.0.9

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

@@ -1,42 +1,121 @@
 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"
+    }
+
+    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)
     }
 
-    init {
-        NamiCustomerManager.registerCustomerJourneyChangedListener { customerJourneyState ->
-            emitCustomerJourneyChanged(customerJourneyState)
+    @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 clearCustomerDataPlatformId(){
+        NamiCustomerManager.clearCustomerDataPlatformId()
+    }
+
+    @ReactMethod
+    fun setCustomerDataPlatformId(cdpId: String){
+        NamiCustomerManager.setCustomerDataPlatformId(cdpId)
+    }
+
+    @ReactMethod
+   fun journeyState(promise: Promise){
+     val journeyState = NamiCustomerManager.journeyState()
+        if (journeyState == null) {
+            promise.resolve(null)
+        } else {
+            val handledJourneyState = journeyStateToReadableMap(journeyState)
+            promise.resolve(handledJourneyState)
         }
+   }
+
+    @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()

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