Merge pull request #879 from CleverTap/develop

Release Core 7.5.2

Author: CTLalit

CHANGELOG.md

@@ -1,4 +1,7 @@
 ## CHANGE LOG.
+### September 11, 2025
+* [CleverTap Android SDK v7.5.2](docs/CTCORECHANGELOG.md)
+
 ### August 28, 2025
 * [CleverTap Android SDK v7.5.1](docs/CTCORECHANGELOG.md)
 

README.md

@@ -26,15 +26,15 @@ We publish the SDK to `mavenCentral` as an `AAR` file. Just declare it as depend
 
 ```groovy
     dependencies {      
-         implementation "com.clevertap.android:clevertap-android-sdk:7.5.1"
+         implementation "com.clevertap.android:clevertap-android-sdk:7.5.2"
     }
 ```
 
 Alternatively, you can download and add the AAR file included in this repo in your Module libs directory and tell gradle to install it like this:
 
  ```groovy
     dependencies {      
-        implementation (name: "clevertap-android-sdk-7.5.1", ext: 'aar')
+        implementation (name: "clevertap-android-sdk-7.5.2", ext: 'aar')
     }
 ```
 
@@ -46,7 +46,7 @@ Add the Firebase Messaging library and Android Support Library v4 as dependencie
 
 ```groovy
      dependencies {      
-         implementation "com.clevertap.android:clevertap-android-sdk:7.5.1"
+         implementation "com.clevertap.android:clevertap-android-sdk:7.5.2"
          implementation "androidx.core:core:1.13.0"
          implementation "com.google.firebase:firebase-messaging:24.0.0"
          implementation "com.google.android.gms:play-services-ads:23.6.0" // Required only if you enable Google ADID collection in the SDK (turned off by default).

clevertap-core/src/main/java/com/clevertap/android/sdk/CTXtensions.kt

@@ -190,7 +190,7 @@ fun JSONArray?.orEmptyArray(): JSONArray {
  * @return A List of elements of type [T] extracted from the JSONArray.
  * @reified T The expected type of elements in the list.
  */
-inline fun <reified T> JSONArray.toList(): List<T> {
+inline fun <reified T> JSONArray.toList(): MutableList<T> {
     val list = mutableListOf<T>()
     for (index in 0 until length()) {
         val element = get(index)

clevertap-core/src/main/java/com/clevertap/android/sdk/CleverTapFactory.kt

@@ -435,10 +435,9 @@ internal object CleverTapFactory {
         )
         controllerManager.inAppController = inAppController
 
+        val batchListener = CompositeBatchListener()
         val appLaunchListener = AppLaunchListener()
         appLaunchListener.addListener(inAppController.onAppLaunchEventSent)
-
-        val batchListener = CompositeBatchListener()
         batchListener.addListener(appLaunchListener)
         batchListener.addListener(FetchInAppListener(callbackManager))
         callbackManager.batchListener = batchListener

clevertap-core/src/main/java/com/clevertap/android/sdk/db/BaseDatabaseManager.kt

@@ -10,20 +10,46 @@ internal interface BaseDatabaseManager {
 
     fun clearQueues(context: Context)
 
+    /**
+     * Gets queued events from the database
+     * @param context Android context
+     * @param batchSize Number of events to fetch (typically 50)
+     * @param eventGroup Type of events to fetch
+     * @return QueueData containing events and their IDs for cleanup
+     */
     fun getQueuedEvents(
         context: Context,
         batchSize: Int,
-        previousQueue: QueueData?,
         eventGroup: EventGroup
     ): QueueData
 
-    fun getQueuedDBEvents(context: Context, batchSize: Int, previousQueue: QueueData?): QueueData
-
-    fun getQueue(context: Context, table: Table, batchSize: Int, previousQueue: QueueData?): QueueData
+    /**
+     * Fetches a combined batch of events from both events and profileEvents tables
+     * Returns QueueData with events data and ids, also if there are more events to fetch
+     */
+    fun getCombinedQueuedEvents(context: Context, batchSize: Int): QueueData
 
     fun queueEventToDB(context: Context, event: JSONObject, type: Int)
 
     fun queuePushNotificationViewedEventToDB(context: Context, event: JSONObject)
 
-    fun getPushNotificationViewedQueuedEvents(context: Context, batchSize: Int, previousQueue: QueueData?): QueueData
+    fun getPushNotificationViewedQueuedEvents(context: Context, batchSize: Int): QueueData
+
+    /**
+     * Cleans up successfully sent events from the database
+     * @param context Android context
+     * @param eventIds List of event IDs to clean up from events table
+     * @param profileEventIds List of event IDs to clean up from profileEvents table
+     * @return true if cleanup successful, false otherwise
+     */
+    fun cleanupSentEvents(
+        context: Context,
+        eventIds: List<String>,
+        profileEventIds: List<String>
+    ) : Boolean
+
+    fun cleanupPushNotificationEvents(
+        context: Context,
+        ids: List<String>
+    ) : Boolean
 }

clevertap-core/src/main/java/com/clevertap/android/sdk/db/DBAdapter.kt

@@ -452,24 +452,6 @@ internal class DBAdapter(context: Context, config: CleverTapInstanceConfig) {
         cleanInternal(PUSH_NOTIFICATIONS, 0)
     }
 
-    /**
-     * Removes sent events with an _id <= last_id from table
-     *
-     * @param lastId the last id to delete
-     * @param table  the table to remove events
-     */
-    @WorkerThread
-    @Synchronized
-    fun cleanupEventsFromLastId(lastId: String, table: Table) {
-        val tName = table.tableName
-        try {
-            dbHelper.writableDatabase.delete(tName, "${Column.ID} <= ?", arrayOf(lastId))
-        } catch (e: SQLiteException) {
-            logger.verbose("Error removing sent data from table $tName Recreating DB")
-            deleteDB()
-        }
-    }
-
     @Synchronized
     fun storePushNotificationId(id: String?, ttl: Long) {
         if (id == null) {
@@ -517,39 +499,146 @@ internal class DBAdapter(context: Context, config: CleverTapInstanceConfig) {
      * @return JSONObject containing the max row ID and a JSONArray of the JSONObject events or null
      */
     @Synchronized
-    fun fetchEvents(table: Table, limit: Int): JSONObject? {
+    fun fetchEvents(table: Table, limit: Int): QueueData {
+        val queueData = QueueData()
+
         val tName = table.tableName
-        var lastId: String? = null
-        val events = JSONArray()
         try {
             dbHelper.readableDatabase.query(
-                tName, null, null, null, null, null, "${Column.CREATED_AT} ASC", limit.toString()
+                tName,
+                arrayOf(Column.ID, Column.DATA, Column.CREATED_AT),
+                null, null, null, null,
+                "${Column.CREATED_AT} ASC",
+                (limit + 1).toString()
             )?.use { cursor ->
+                val rowCount = cursor.count
+                queueData.hasMore = rowCount > limit
+
+                var pos = 0
                 while (cursor.moveToNext()) {
-                    if (cursor.isLast) {
-                        lastId = cursor.getString(cursor.getColumnIndexOrThrow(Column.ID))
+                    if (pos == limit) {
+                        break
                     }
+                    val id = cursor.getString(cursor.getColumnIndexOrThrow(Column.ID))
+                    val eventData = cursor.getString(cursor.getColumnIndexOrThrow(Column.DATA))
+
                     try {
-                        val j = JSONObject(cursor.getString(cursor.getColumnIndexOrThrow(Column.DATA)))
-                        events.put(j)
+                        val jsonEvent = JSONObject(eventData)
+                        queueData.data.put(jsonEvent)
+
+                        if (table == Table.PROFILE_EVENTS) {
+                            queueData.profileEventIds.add(id)
+                        } else {
+                            queueData.eventIds.add(id)
+                        }
+
                     } catch (e: JSONException) {
-                        // Ignore
+                        logger.verbose("Error parsing event data for id: $id from table: $tName", e)
                     }
+                    pos++
                 }
             }
-        } catch (e: Exception) { // SQLiteException | IllegalArgumentException
-            logger.verbose("Could not fetch records out of database $tName.", e)
-            lastId = null
+        } catch (e: Exception) {
+            logger.verbose("Could not fetch records from table $tName", e)
         }
 
-        return lastId?.let {
-            try {
-                val ret = JSONObject()
-                ret.put(it, events)
-                ret
-            } catch (e: JSONException) {
-                null
+        val size = if (table == Table.PROFILE_EVENTS) {
+            queueData.profileEventIds.size
+        } else {
+            queueData.eventIds.size
+        }
+        logger.verbose("Fetched $size events from $tName")
+        return queueData
+    }
+
+    /**
+     * Fetches a combined batch of events from both events and profileEvents tables
+     * Prioritizes profileEvents table first, then fills remaining slots from events
+     *
+     * @param batchSize The maximum number of events to fetch (typically 50)
+     * @return QueueData containing the events and their IDs for cleanup
+     */
+    @Synchronized
+    fun fetchCombinedEvents(batchSize: Int): QueueData {
+        val combinedQueueData = QueueData()
+
+        // First priority: Fetch from profileEvents table using the base fetchEvents method
+        val profileData = fetchEvents(Table.PROFILE_EVENTS, batchSize)
+
+        // Add profile events to combined data
+            for (i in 0 until profileData.data.length()) {
+                combinedQueueData.data.put(profileData.data.getJSONObject(i))
+            }
+            combinedQueueData.profileEventIds.addAll(profileData.profileEventIds)
+            combinedQueueData.hasMore = profileData.hasMore
+
+        // Calculate remaining slots for normal events
+        val eventsNeeded = batchSize - combinedQueueData.profileEventIds.size
+
+        // Second priority: Fill remaining slots from events table
+        if (eventsNeeded > 0 || combinedQueueData.hasMore.not()) {
+            val eventsData = fetchEvents(Table.EVENTS, eventsNeeded)
+
+            // Add events to combined data
+                for (i in 0 until eventsData.data.length()) {
+                    combinedQueueData.data.put(eventsData.data.getJSONObject(i))
+                }
+                combinedQueueData.eventIds.addAll(eventsData.eventIds)
+            combinedQueueData.hasMore = eventsData.hasMore
+        }
+
+        logger.verbose("Fetched combined batch: ${combinedQueueData.profileEventIds.size} profile events, ${combinedQueueData.eventIds.size} events")
+
+        return combinedQueueData
+    }
+
+    /**
+     * Removes sent events with an _id <= last_id from table
+     *
+     * @param lastId the last id to delete
+     * @param table  the table to remove events
+     */
+    @WorkerThread
+    @Synchronized
+    fun cleanupEventsFromLastId(lastId: String, table: Table) {
+        val tName = table.tableName
+        try {
+            dbHelper.writableDatabase.delete(tName, "${Column.ID} <= ?", arrayOf(lastId))
+        } catch (e: SQLiteException) {
+            logger.verbose("Error removing sent data from table $tName Recreating DB")
+            deleteDB()
+        }
+    }
+
+    /**
+     * Cleans up events from the profileEvents table by their IDs
+     *
+     * @param events List of profile event IDs to delete
+     */
+    @WorkerThread
+    @Synchronized
+    fun cleanupEventsByIds(table: Table, events: List<String>) {
+        if (events.isEmpty()) {
+            return
+        }
+
+        val tName = table.tableName
+
+        try {
+            // Process in chunks if the list is too large
+            val chunkSize = 100
+            events.chunked(chunkSize).forEach { chunk ->
+                val placeholders = chunk.joinToString(",") { "?" }
+                val deletedCount = dbHelper.writableDatabase.delete(
+                    tName,
+                    "${Column.ID} IN ($placeholders)",
+                    chunk.toTypedArray()
+                )
+                logger.verbose("Deleted $deletedCount events from $tName")
             }
+        } catch (e: SQLiteException) {
+            logger.verbose("Error removing events from $tName", e)
+            deleteDB()
         }
     }