clevertap-react-native 2.2.1 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 Change Log
 ==========
+
+Version 3.0.0 *(8 October 2024)*
+-------------------------------------------
+**What's new**
+
+* **[Android Platform]**
+  * Supports [CleverTap Android SDK v7.0.1](https://github.com/CleverTap/clevertap-android-sdk/blob/master/docs/CTCORECHANGELOG.md#version-701-september-2-2024).
+  * Removes character limit of maximum 3 lines from `AppInbox` messages.
+  * Deprecates `CleverTapModule.setInitialUri()` in favour of `CleverTapRnAPI.setInitialUri()`. Refer to [step 4](docs/integration.md#step4)
+
+* **[iOS Platform]**
+  * Supports [CleverTap iOS SDK v7.0.1](https://github.com/CleverTap/clevertap-ios-sdk/blob/master/CHANGELOG.md#version-701-august-22-2024).
+
+* **[Android and iOS Platform]**
+  * Adds support for triggering InApps based on user attribute changes.
+  * Migrates the bridge to a backwards-compatible [New Architecture Turbo Module](docs/integration.md).
+    * The CleverTap ReactNative SDK continues to be compatible with both the Old and the New Architecture.
+
+**Breaking Changes**
+* **[Android Platform]**
+  * Ensure that your custom `Application` class, extends the `CleverTapApplication` or calls `CleverTapRnAPI.initReactNativeIntegration(this);` to enable the functionality of `ClevertapPushNotificationClicked` and few other callbacks linked to killed state. Refer to [step 3](docs/integration.md#step3a)
+
+**Bug Fixes**
+* **[Android Platform]**
+  * Fixes an ANR caused by extremely old InApp campaigns.
+  * Fixes an issue where incorrect callbacks were sent for InApps when the phone was rotated.
+  * Fixes an issue where an InApp was displayed even after all the campaigns were stopped.
+  * Fixes an issue where the InApp image was not shown when the phone was rotated to landscape.
+  * Fixes an issue where certain URLs loaded incorrectly in custom HTML InApp templates.
+
 Version 2.2.1 *(12 April 2024)*
 -------------------------------------------
 **What's new**

package/README.md

@@ -30,6 +30,12 @@ To get started, sign up [here](https://clevertap.com/live-product-demo/).
 CleverTap Push Templates SDK helps you engage with your users using fancy push notification templates built specifically to work with [CleverTap Push Templates SDK](https://github.com/CleverTap/CTNotificationContent).
 Find the integration steps for the CleverTap Push Templates SDK [here](./docs/iospushtemplates.md)
 
+## ℹ️ Version Support
+| CleverTap RN SDK | React Native | Supports New Architecture? |
+|------------------|--------------|----------------------------|
+| 3.0.0+           | >=0.65       | ✅ (>=0.71)                 |
+| <=2.2.1          | >=0.49.5     | ❌                          |
+
 ## 📑 Documentation & Example
 
 - [See the CleverTap React Native Usage Documentation](/docs/usage.md)

package/android/.gradle/config.properties

@@ -1,2 +1,2 @@
-#Tue Mar 05 15:18:18 IST 2024
-java.home=/Users/anush/Applications/Android Studio.app/Contents/jbr/Contents/Home
+#Mon Sep 02 11:39:00 IST 2024
+java.home=/Applications/Android Studio.app/Contents/jbr/Contents/Home

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,2 @@
+connection.project.dir=../../../android
+eclipse.preferences.version=1

package/android/build.gradle

@@ -1,55 +1,63 @@
 apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+def isNewArchitectureEnabled() {
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+
+if (isNewArchitectureEnabled()) {
+    react {
+        jsRootDir = file("../src/")
+        libraryName = "clevertap-react-native"
+        codegenJavaPackageName = "com.clevertap.react"
+    }
+}
 
 buildscript {
+    ext {
+        kotlin_version = '1.9.0'
+    }
     repositories {
         mavenCentral()
-        maven {
-            url 'https://maven.google.com/'
-            name 'Google'
-        }
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:8.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
 
 android {
-    compileSdkVersion 34
+    compileSdk 34
     buildToolsVersion '34.0.0'
-
     defaultConfig {
         minSdkVersion 19
         targetSdkVersion 34
-        versionCode 221
-        versionName "2.2.1"
+        versionCode 300
+        versionName "3.0.0"
+        buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString())
     }
 
-    namespace 'com.clevertap.react'
-    buildTypes {
-        release {
-            minifyEnabled false
+    sourceSets {
+        main {
+            if (isNewArchitectureEnabled()) {
+                java.srcDirs += ['src/newarch']
+            } else {
+                java.srcDirs += ['src/oldarch']
+            }
         }
     }
+
+    namespace 'com.clevertap.react'
 }
 
 dependencies {
-    repositories {
-        mavenCentral()
-        mavenLocal()
-        maven { url "https://maven.google.com" }
-        maven { url "$rootDir/../node_modules/react-native/android" }
-    }
-
-    api 'com.clevertap.android:clevertap-android-sdk:6.2.1'
+    api 'com.clevertap.android:clevertap-android-sdk:7.0.1'
     implementation 'com.android.installreferrer:installreferrer:2.2'
     //compile 'com.android.support:appcompat-v7:28.0.0'
     implementation 'com.facebook.react:react-native:+'
+    implementation 'androidx.core:core-ktx:1.9.0'
     compileOnly 'androidx.annotation:annotation:1.2.0'
 }
-
-repositories {
-    maven {
-        url 'https://maven.google.com/'
-        name 'Google'
-    }
-}

package/android/src/main/java/com/clevertap/react/CleverTapApplication.kt

@@ -0,0 +1,12 @@
+package com.clevertap.react
+
+import com.clevertap.android.sdk.ActivityLifecycleCallback
+import com.clevertap.android.sdk.Application
+
+open class CleverTapApplication : Application() {
+    override fun onCreate() {
+        ActivityLifecycleCallback.register(this)
+        super.onCreate()
+        CleverTapRnAPI.initReactNativeIntegration(this)
+    }
+}

package/android/src/main/java/com/clevertap/react/CleverTapEvent.kt

@@ -0,0 +1,35 @@
+package com.clevertap.react
+
+enum class CleverTapEvent(val eventName: String, val bufferable: Boolean = false) {
+
+    CLEVERTAP_PROFILE_DID_INITIALIZE("CleverTapProfileDidInitialize", bufferable = true),
+    CLEVERTAP_PROFILE_SYNC("CleverTapProfileSync"),
+    CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED("CleverTapInAppNotificationDismissed", bufferable = true),
+    CLEVERTAP_IN_APP_NOTIFICATION_SHOWED("CleverTapInAppNotificationShowed", bufferable = true),
+    CLEVERTAP_INBOX_DID_INITIALIZE("CleverTapInboxDidInitialize", bufferable = true),
+    CLEVERTAP_INBOX_MESSAGES_DID_UPDATE("CleverTapInboxMessagesDidUpdate"),
+    CLEVERTAP_ON_INBOX_BUTTON_CLICK("CleverTapInboxMessageButtonTapped"),
+    CLEVERTAP_ON_INBOX_MESSAGE_CLICK("CleverTapInboxMessageTapped"),
+    CLEVERTAP_ON_INAPP_BUTTON_CLICK("CleverTapInAppNotificationButtonTapped", bufferable = true),
+    CLEVERTAP_ON_DISPLAY_UNITS_LOADED("CleverTapDisplayUnitsLoaded", bufferable = true),
+    CLEVERTAP_FEATURE_FLAGS_DID_UPDATE("CleverTapFeatureFlagsDidUpdate"),
+    CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE("CleverTapProductConfigDidInitialize", bufferable = true),
+    CLEVERTAP_PRODUCT_CONFIG_DID_FETCH("CleverTapProductConfigDidFetch"),
+    CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE("CleverTapProductConfigDidActivate"),
+    CLEVERTAP_PUSH_NOTIFICATION_CLICKED("CleverTapPushNotificationClicked", bufferable = true),
+    CLEVERTAP_ON_PUSH_PERMISSION_RESPONSE("CleverTapPushPermissionResponseReceived"),
+    CLEVERTAP_ON_VARIABLES_CHANGED("CleverTapOnVariablesChanged"),
+    CLEVERTAP_ON_VALUE_CHANGED("CleverTapOnValueChanged");
+
+    override fun toString(): String {
+        return eventName
+    }
+
+    companion object {
+
+        @JvmStatic
+        fun fromName(eventName: String): CleverTapEvent? {
+            return values().find { it.eventName == eventName }
+        }
+    }
+}

package/android/src/main/java/com/clevertap/react/CleverTapEventEmitter.kt

@@ -0,0 +1,126 @@
+package com.clevertap.react
+
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.LinkedList
+import java.util.Queue
+
+/**
+ * CleverTapEventEmitter is responsible for emitting events to the React Native JavaScript layer.
+ * It manages event buffers and allows events to be queued which is useful when needing to send an
+ * event while the ReactContext of the application is not yet initialized. Only events specified as
+ * [CleverTapEvent.bufferable] will be considered for buffering, all other events will be emitted
+ * immediately.
+ */
+object CleverTapEventEmitter {
+    private const val LOG_TAG = "CleverTapEventEmitter"
+
+    var reactContext: ReactContext? = null
+
+    private var eventsBuffers: Map<CleverTapEvent, Buffer> = createBuffersMap(enableBuffers = true)
+
+    /**
+     * Enable buffering for the specified event. While enabled, all events which should be emitted
+     * will be added to the buffer. Only buffers for events specified as [CleverTapEvent.bufferable]
+     * can be enabled.
+     *
+     * @see [disableBuffer]
+     */
+    fun enableBuffer(event: CleverTapEvent) {
+        eventsBuffers[event]?.enabled = true
+    }
+
+    /**
+     * Disable buffering for the specified event. This will only have effect for events specified as
+     * [CleverTapEvent.bufferable].
+     *
+     * @see [enableBuffer]
+     */
+    fun disableBuffer(event: CleverTapEvent) {
+        eventsBuffers[event]?.enabled = false
+    }
+
+    /**
+     * Clear all the buffered events from all buffers and set whether all buffers should be enabled
+     * after that.
+     *
+     * @param enableBuffers enable/disable all buffers after they are cleared
+     */
+    fun resetAllBuffers(enableBuffers: Boolean) {
+        eventsBuffers = createBuffersMap(enableBuffers)
+        Log.i(LOG_TAG, "Buffers reset and enabled: $enableBuffers")
+    }
+
+    /**
+     * Emit all currently buffered events for the specified event name.
+     */
+    fun flushBuffer(event: CleverTapEvent) {
+        val buffer = eventsBuffers[event] ?: return
+        while (buffer.size() > 0) {
+            val params = buffer.remove()
+            sendEvent(event, params)
+        }
+    }
+
+    /**
+     * Emit an event with specified params. It will be buffered if buffering for the event is enabled or
+     * it will be send immediately otherwise.
+     *
+     * @param event The event to be emitted
+     * @param params Optional event parameters
+     *
+     * @see [enableBuffer]
+     * @see [disableBuffer]
+     */
+    fun emit(event: CleverTapEvent, params: Any?) {
+        if (eventsBuffers[event]?.enabled == true) {
+            addToBuffer(event, params)
+        } else {
+            sendEvent(event, params)
+        }
+    }
+
+    /**
+     * Adds an event to the buffer for future emission.
+     * Events will remain in the buffer until [flushBuffer] for the same event name is called.
+     *
+     * @param event The event to be buffered.
+     * @param params Optional event parameters to be sent when the event is emitted.
+     */
+    private fun addToBuffer(event: CleverTapEvent, params: Any?) {
+        val buffer = eventsBuffers[event] ?: return
+        buffer.add(params)
+        Log.i(LOG_TAG, "Event $event added to buffer.")
+    }
+
+    private fun sendEvent(event: CleverTapEvent, params: Any?) {
+        val context = reactContext
+        if (context == null) {
+            Log.e(LOG_TAG, "Sending event $event failed. ReactContext is null")
+            return
+        }
+
+        try {
+            context.getJSModule(
+                DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+            ).emit(event.eventName, params)
+            Log.i(LOG_TAG, "Sending event $event")
+        } catch (t: Throwable) {
+            Log.e(LOG_TAG, "Sending event $event failed", t)
+        }
+    }
+
+    private fun createBuffersMap(enableBuffers: Boolean) =
+        CleverTapEvent.values().filter { it.bufferable }.associateWith {
+            Buffer(enabled = enableBuffers)
+        }
+
+    private class Buffer(var enabled: Boolean) {
+        private val items: Queue<Any?> by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { LinkedList() }
+
+        fun add(item: Any?) = items.add(item)
+        fun remove(): Any? = items.remove()
+        fun size(): Int = items.size
+    }
+}

package/android/src/main/java/com/clevertap/react/CleverTapListenerProxy.kt

@@ -0,0 +1,225 @@
+package com.clevertap.react
+
+import android.util.Log
+import com.clevertap.android.sdk.CTFeatureFlagsListener
+import com.clevertap.android.sdk.CTInboxListener
+import com.clevertap.android.sdk.CleverTapAPI
+import com.clevertap.android.sdk.InAppNotificationButtonListener
+import com.clevertap.android.sdk.InAppNotificationListener
+import com.clevertap.android.sdk.InboxMessageButtonListener
+import com.clevertap.android.sdk.InboxMessageListener
+import com.clevertap.android.sdk.PushPermissionResponseListener
+import com.clevertap.android.sdk.SyncListener
+import com.clevertap.android.sdk.displayunits.DisplayUnitListener
+import com.clevertap.android.sdk.displayunits.model.CleverTapDisplayUnit
+import com.clevertap.android.sdk.inapp.CTInAppNotification
+import com.clevertap.android.sdk.inbox.CTInboxMessage
+import com.clevertap.android.sdk.product_config.CTProductConfigListener
+import com.clevertap.android.sdk.pushnotification.CTPushNotificationListener
+import com.facebook.react.bridge.Arguments
+import org.json.JSONException
+import org.json.JSONObject
+
+object CleverTapListenerProxy : SyncListener, InAppNotificationListener, CTInboxListener,
+    InboxMessageButtonListener, InboxMessageListener, InAppNotificationButtonListener,
+    DisplayUnitListener, CTProductConfigListener, CTFeatureFlagsListener,
+    CTPushNotificationListener, PushPermissionResponseListener {
+
+    private const val LOG_TAG = Constants.REACT_MODULE_NAME
+
+    fun attachToInstance(instance: CleverTapAPI) {
+        instance.unregisterPushPermissionNotificationResponseListener(this)
+        instance.registerPushPermissionNotificationResponseListener(this)
+        instance.ctPushNotificationListener = this
+        instance.inAppNotificationListener = this
+        instance.syncListener = this
+        instance.ctNotificationInboxListener = this
+        instance.setInboxMessageButtonListener(this)
+        instance.setCTInboxMessageListener(this)
+        instance.setInAppNotificationButtonListener(this)
+        instance.setDisplayUnitListener(this)
+        instance.setCTProductConfigListener(this)
+        instance.setCTFeatureFlagsListener(this)
+    }
+
+    // SyncListener
+    override fun profileDataUpdated(updates: JSONObject?) {
+        if (updates == null) {
+            return
+        }
+
+        val updateParams = Arguments.createMap()
+        val keys: Iterator<String> = updates.keys()
+
+        while (keys.hasNext()) {
+            val key = keys.next()
+            try {
+                val arr = updates.getJSONArray(key)
+                val writableArray = Arguments.createArray()
+                for (n in 0 until arr.length()) {
+                    val update = arr.getJSONObject(n)
+                    writableArray.pushString(update.toString())
+                }
+                updateParams.putArray(key, writableArray)
+            } catch (je: JSONException) {
+                try {
+                    val value = updates[key]
+                    updateParams.putString(key, value.toString())
+                } catch (e: Exception) {
+                    Log.e(LOG_TAG, "Failed sending profile update event", e)
+                }
+            }
+        }
+
+        val params = Arguments.createMap()
+        params.putMap("updates", updateParams)
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_PROFILE_SYNC, params)
+    }
+
+    // SyncListener
+    override fun profileDidInitialize(cleverTapID: String?) {
+        if (cleverTapID == null) {
+            Log.d(LOG_TAG, "profileDidInitialize called with cleverTapID=null")
+            return
+        }
+        val params = Arguments.createMap()
+        params.putString("CleverTapID", cleverTapID)
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_PROFILE_DID_INITIALIZE, params)
+    }
+
+    // InAppNotificationListener
+    override fun beforeShow(extras: MutableMap<String, Any>?): Boolean {
+        return true
+    }
+
+    // InAppNotificationListener
+    override fun onShow(ctInAppNotification: CTInAppNotification) {
+        val params = Arguments.createMap()
+        val data = ctInAppNotification.jsonDescription
+        if (data != null) {
+            params.putMap("data", CleverTapUtils.convertObjectToWritableMap(data))
+        }
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_IN_APP_NOTIFICATION_SHOWED, params)
+    }
+
+    // InAppNotificationListener
+    override fun onDismissed(
+        extras: MutableMap<String, Any>?, actionExtras: MutableMap<String, Any>?
+    ) {
+        val extrasParams = CleverTapUtils.getWritableMapFromMap(extras)
+        val actionExtrasParams = CleverTapUtils.getWritableMapFromMap(actionExtras)
+
+        val params = Arguments.createMap()
+        params.putMap("extras", extrasParams)
+        params.putMap("actionExtras", actionExtrasParams)
+
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_IN_APP_NOTIFICATION_DISMISSED, params)
+    }
+
+    // CTInboxListener
+    override fun inboxDidInitialize() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_INBOX_DID_INITIALIZE,
+            Arguments.createMap()
+        )
+    }
+
+    // CTInboxListener
+    override fun inboxMessagesDidUpdate() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_INBOX_MESSAGES_DID_UPDATE,
+            Arguments.createMap()
+        )
+    }
+
+    // CTInboxListener
+    override fun onInboxButtonClick(payload: HashMap<String, String>?) {
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_ON_INBOX_BUTTON_CLICK,
+            CleverTapUtils.getWritableMapFromMap(payload)
+        )
+    }
+
+    // CTInboxListener
+    override fun onInboxItemClicked(
+        message: CTInboxMessage?, contentPageIndex: Int, buttonIndex: Int
+    ) {
+        val params = Arguments.createMap()
+        val data = message?.data
+        params.putMap("data",
+            data?.let { CleverTapUtils.convertObjectToWritableMap(it) } ?: Arguments.createMap())
+        params.putInt("contentPageIndex", contentPageIndex)
+        params.putInt("buttonIndex", buttonIndex)
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_ON_INBOX_MESSAGE_CLICK, params)
+    }
+
+    // InAppNotificationButtonListener
+    override fun onInAppButtonClick(payload: HashMap<String, String>?) {
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_ON_INAPP_BUTTON_CLICK,
+            CleverTapUtils.getWritableMapFromMap(payload)
+        )
+    }
+
+    // DisplayUnitListener
+    override fun onDisplayUnitsLoaded(units: ArrayList<CleverTapDisplayUnit>?) {
+        val params = Arguments.createMap()
+        params.putArray("displayUnits", CleverTapUtils.getWritableArrayFromDisplayUnitList(units))
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_ON_DISPLAY_UNITS_LOADED, params)
+    }
+
+    // CTProductConfigListener
+    override fun onActivated() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_PRODUCT_CONFIG_DID_ACTIVATE,
+            Arguments.createMap()
+        )
+    }
+
+    // CTProductConfigListener
+    override fun onFetched() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_PRODUCT_CONFIG_DID_FETCH,
+            Arguments.createMap()
+        )
+    }
+
+    // CTProductConfigListener
+    override fun onInit() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_PRODUCT_CONFIG_DID_INITIALIZE,
+            Arguments.createMap()
+        )
+    }
+
+    override fun featureFlagsUpdated() {
+        // passing an empty map
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_FEATURE_FLAGS_DID_UPDATE,
+            Arguments.createMap()
+        )
+    }
+
+    // CTPushNotificationListener
+    override fun onNotificationClickedPayloadReceived(payload: HashMap<String, Any>?) {
+        CleverTapEventEmitter.emit(
+            CleverTapEvent.CLEVERTAP_PUSH_NOTIFICATION_CLICKED,
+            CleverTapUtils.getWritableMapFromMap(payload)
+        )
+    }
+
+    // PushPermissionResponseListener
+    override fun onPushPermissionResponse(accepted: Boolean) {
+        Log.i(
+            LOG_TAG, "onPushPermissionResponse result: $accepted"
+        )
+        val params = Arguments.createMap()
+        params.putBoolean("accepted", accepted)
+        CleverTapEventEmitter.emit(CleverTapEvent.CLEVERTAP_ON_PUSH_PERMISSION_RESPONSE, params)
+    }
+}