add pruning of inactive recipient_settings

Author: jbsession

app/src/main/java/org/session/libsession/avatars/AvatarCacheCleaner.kt

@@ -38,28 +38,15 @@ class AvatarCacheCleaner @Inject constructor(
     suspend fun cleanUpAvatars(): Int = withContext(Dispatchers.IO) {
         // 1) Build the set of still-wanted Avatars from:
         // -> Config
-        // -> RecipientSettingsDatabase
 
         // config
         val avatarsFromConfig: Set<RemoteFile> = recipientAvatarDownloadManager.getAllAvatars()
         // recipient_settings
-        val recipientAvatars : Map<Address, RemoteFile> = recipientSettingsDatabase.getAllReferencedAvatarFiles()
-        // mms and sms used to check for active references
-        val localActiveAddresses : Set<Address> = mmsSmsDatabase.getAllReferencedAddresses()
-        .mapTo(mutableSetOf()) { Address.fromSerialized(it) }
-
-        // 2) Keep only those recipient avatars whose address exists in a community/group
-        // Filter here since we don't delete rows from recipient_settings
-        val keepFromRecipients: Set<RemoteFile> =
-            recipientAvatars
-                .asSequence()
-                .filter { (address, _) -> address in localActiveAddresses }
-                .map { it.value }
-                .toSet()
+        val recipientAvatars : Set<RemoteFile> = recipientSettingsDatabase.getAllReferencedAvatarFiles()
 
         // 3) Union of everything we want to keep
         val filesToKeep: Set<RemoteFile> =
-            (avatarsFromConfig + keepFromRecipients).toSet()
+            (avatarsFromConfig + recipientAvatars).toSet()
 
         // 4) Map to actual files (same hashing/location as downloader)
         val wantedFiles: Set<File> = filesToKeep

app/src/main/java/org/thoughtcrime/securesms/configs/ConfigToDatabaseSync.kt

@@ -9,7 +9,6 @@ import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onStart
@@ -19,6 +18,7 @@ import network.loki.messenger.R
 import network.loki.messenger.libsession_util.ReadableGroupInfoConfig
 import network.loki.messenger.libsession_util.util.Conversation
 import network.loki.messenger.libsession_util.util.UserPic
+import org.session.libsession.avatars.AvatarCacheCleaner
 import org.session.libsession.database.StorageProtocol
 import org.session.libsession.messaging.sending_receiving.notifications.MessageNotifier
 import org.session.libsession.messaging.sending_receiving.notifications.PushRegistryV1
@@ -45,6 +45,7 @@ import org.thoughtcrime.securesms.database.LokiMessageDatabase
 import org.thoughtcrime.securesms.database.LokiThreadDatabase
 import org.thoughtcrime.securesms.database.MmsDatabase
 import org.thoughtcrime.securesms.database.MmsSmsDatabase
+import org.thoughtcrime.securesms.database.RecipientSettingsDatabase
 import org.thoughtcrime.securesms.database.SmsDatabase
 import org.thoughtcrime.securesms.database.ThreadDatabase
 import org.thoughtcrime.securesms.database.model.MmsMessageRecord
@@ -83,6 +84,8 @@ class ConfigToDatabaseSync @Inject constructor(
     private val mmsSmsDatabase: MmsSmsDatabase,
     private val lokiMessageDatabase: LokiMessageDatabase,
     private val messageNotifier: MessageNotifier,
+    private val recipientSettingsDatabase: RecipientSettingsDatabase,
+    private val avatarCacheCleaner: AvatarCacheCleaner,
     @param:ManagerScope private val scope: CoroutineScope,
 ) : OnAppStartupComponent {
     init {
@@ -148,6 +151,16 @@ class ConfigToDatabaseSync @Inject constructor(
                     }
                 }
             }
+
+            // Initiate cleanup in recipient_settings rows that no longer have any messages
+            val addressesToKeep = mmsSmsDatabase.getAllReferencedAddresses()
+                .mapTo(mutableSetOf()) { Address.fromSerialized(it) }
+
+            val removed = recipientSettingsDatabase.cleanupRecipientSettings(addressesToKeep)
+            Log.d(TAG, "Recipient settings pruned: $removed orphan rows")
+            if(removed > 0){
+                avatarCacheCleaner.launchAvatarCleanup()
+            }
         }
 
         // If we created threads, we need to update the thread database with the creation date.

app/src/main/java/org/thoughtcrime/securesms/database/RecipientSettingsDatabase.kt

@@ -157,31 +157,85 @@ class RecipientSettingsDatabase @Inject constructor(
     }
 
     /**
-     * This method returns all referenced profile picture URL.
+     * This method returns all profile pic url and key.
      * This will be used to identify which avatars are still being used  to exclude
      * them from the cleanup.
      */
-    fun getAllReferencedAvatarFiles(): Map<Address, RemoteFile.Encrypted> {
-        LinkedHashSet<RemoteFile.Encrypted>()
-
-        val sql =
+    fun getAllReferencedAvatarFiles(): Set<RemoteFile.Encrypted> {
+        val recipientAvatars = LinkedHashSet<RemoteFile.Encrypted>()
+        readableDatabase.rawQuery(
             """
         SELECT $COL_PROFILE_PIC_URL, $COL_PROFILE_PIC_KEY
         FROM $TABLE_NAME
         WHERE $COL_PROFILE_PIC_URL IS NOT NULL AND $COL_PROFILE_PIC_URL != ''
           AND $COL_PROFILE_PIC_KEY IS NOT NULL AND $COL_PROFILE_PIC_KEY != ''
-        """.trimIndent()
+        """.trimIndent(),
+            null
+        ).use { cursor ->
+            while (cursor.moveToNext()) {
+                val url = cursor.getString(0)
+                val keyB64 = cursor.getString(1)
+                runCatching {
+                    val keyBytes = Base64.decode(keyB64)
+                    recipientAvatars += RemoteFile.Encrypted(url = url, key = Bytes(keyBytes))
+                }.onFailure {
+                    // ignore bad rows
+                }
+            }
+        }
+        return recipientAvatars
+    }
 
-        return readableDatabase.rawQuery(sql, emptyArray()).use { cursor ->
-            buildMap {
+    fun getAllRecipientAddresses(): Set<Address> {
+        return readableDatabase.rawQuery(
+            "SELECT $COL_ADDRESS FROM $TABLE_NAME", emptyArray()
+        ).use { cursor ->
+            buildSet {
                 while (cursor.moveToNext()) {
-                    val address = Address.fromSerialized(cursor.getString(0))
-                    val url = cursor.getString(0)
-                    val key = Base64.decode(cursor.getString(1))
-                    put(address, RemoteFile.Encrypted(url = url, key = Bytes(key)))
+                    val raw = cursor.getString(0)
+                    if (!raw.isNullOrBlank()) add(Address.fromSerialized(raw))
+                }
+            }
+        }
+    }
+
+    /**
+     * Delete all rows whose address is NOT in [addressesToKeep].
+     * Returns the number of rows deleted.
+     */
+    fun cleanupRecipientSettings(addressesToKeep: Set<Address>): Int {
+        if (addressesToKeep.isEmpty()) return 0
+
+        // Build a temporary lookup of strings for SQL bind args
+        val keepSet = addressesToKeep.mapTo(hashSetOf()) { it.toString() }
+
+        // Collect all rows, figure out orphans in memory
+        val allRecipientAddresses = getAllRecipientAddresses()
+        val orphans = allRecipientAddresses.filter { it.toString() !in keepSet }
+
+        if (orphans.isEmpty()) return 0
+
+        var deleted = 0
+        val db = writableDatabase
+        db.beginTransaction()
+        try {
+            for (address in orphans) {
+                val rows = db.delete(
+                    TABLE_NAME,
+                    "$COL_ADDRESS = ?",
+                    arrayOf(address.toString())
+                )
+                if (rows > 0) {
+                    cache.remove(address)
+                    mutableChangeNotification.tryEmit(address)
+                    deleted += rows
                 }
             }
+            db.setTransactionSuccessful()
+        } finally {
+            db.endTransaction()
         }
+        return deleted
     }
 
     companion object {

app/src/main/java/org/thoughtcrime/securesms/groups/OpenGroupManager.kt

@@ -65,8 +65,6 @@ class OpenGroupManager @Inject constructor(
             configs.userGroups.eraseCommunity(server, room)
             configs.convoInfoVolatile.eraseCommunity(server, room)
         }
-
-        avatarCacheCleaner.launchAvatarCleanup()
     }
 
     suspend fun addOpenGroup(urlAsString: String) {