Merge branch 'dev' into fix/SES-4464-reply-mesasge-details

Author: ThomasSession

app/build.gradle.kts

@@ -386,9 +386,6 @@ dependencies {
     implementation(libs.subsampling.scale.image.view) {
         exclude(group = "com.android.support", module = "support-annotations")
     }
-    implementation(libs.tooltips) {
-        exclude(group = "com.android.support", module = "appcompat-v7")
-    }
     implementation(libs.stream)
     implementation(libs.androidx.sqlite.ktx)
     implementation(libs.sqlcipher.android)

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

@@ -0,0 +1,69 @@
+package org.session.libsession.avatars
+
+import android.app.Application
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.session.libsession.utilities.recipients.RemoteFile
+import org.session.libsignal.utilities.Log
+import org.thoughtcrime.securesms.attachments.RemoteFileDownloadWorker
+import org.thoughtcrime.securesms.database.RecipientSettingsDatabase
+import org.thoughtcrime.securesms.dependencies.ManagerScope
+import org.thoughtcrime.securesms.glide.RecipientAvatarDownloadManager
+import java.io.File
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AvatarCacheCleaner @Inject constructor(
+    private val application: Application,
+    private val recipientAvatarDownloadManager: RecipientAvatarDownloadManager,
+    private val recipientSettingsDatabase: RecipientSettingsDatabase,
+    @param:ManagerScope private val coroutineScope: CoroutineScope
+) {
+
+    companion object {
+        const val TAG = "AvatarCacheCleaner"
+    }
+
+    /**
+     * Deletes avatar files under cache/remote_files that are no longer referenced
+     * in the current config. Returns number of files deleted.
+     */
+    private suspend fun cleanUpAvatars(): Int = withContext(Dispatchers.IO) {
+        // 1) Build the set of still-wanted Avatars from:
+        // -> Config
+        // -> Recipient Settings DB
+
+        // config
+        val avatarsFromConfig: Set<RemoteFile> = recipientAvatarDownloadManager.getAllAvatars()
+        // recipient_settings
+        val recipientAvatars : Set<RemoteFile> = recipientSettingsDatabase.getAllReferencedAvatarFiles()
+
+        // 3) Union of everything we want to keep
+        val filesToKeep: Set<RemoteFile> =
+            (avatarsFromConfig + recipientAvatars).toSet()
+
+        // 4) Map to actual files (same hashing/location as downloader)
+        val wantedFiles: Set<File> = filesToKeep
+            .map { RemoteFileDownloadWorker.computeFileName(application, it) }
+            .toSet()
+
+        // 5) Delete everything not wanted in cache/remote_files
+        val files = RemoteFileDownloadWorker.listDownloadedFiles(application)
+        var deleted = 0
+        for (file in files) {
+            if (file !in wantedFiles && file.delete()) deleted++
+        }
+
+        deleted
+    }
+
+    fun launchAvatarCleanup() {
+        coroutineScope.launch(Dispatchers.IO) {
+            val deleted = cleanUpAvatars()
+            Log.d(TAG, "Avatar cache removed: $deleted files")
+        }
+    }
+}

app/src/main/java/org/session/libsession/utilities/ConfigFactoryProtocol.kt

@@ -151,6 +151,52 @@ fun ConfigFactoryProtocol.userConfigsChanged(
             }
         }
 
+/** All addresses that exist in config and therefore must be kept. */
+fun ConfigFactoryProtocol.allConfigAddresses(): Set<Address> {
+    val (contacts, blinded, groups) = withUserConfigs { config ->
+        Triple(config.contacts.all(), config.contacts.allBlinded(), config.userGroups.all())
+    }
+
+    val contactsAddress : Set<Address> =
+        contacts.asSequence().map { Address.fromSerialized(it.id) }.toSet()
+    val blindedAddress : Set<Address> =
+        blinded.asSequence().map { Address.fromSerialized(it.id) }.toSet()
+
+    val closedIds = mutableListOf<AccountId>()
+    val groupAddresses: Set<Address> = buildSet {
+        groups.forEach { groupInfo ->
+            when (groupInfo) {
+                is GroupInfo.LegacyGroupInfo -> {
+                    add(Address.LegacyGroup(groupInfo.accountId))
+                    groupInfo.members.keys.forEach { add(Address.fromSerialized(it)) }
+                }
+                is GroupInfo.ClosedGroupInfo -> {
+                    val groupId = AccountId(groupInfo.groupAccountId)
+                    closedIds += groupId
+                    add(Address.Group(groupId))
+                }
+                is GroupInfo.CommunityGroupInfo -> {
+                    add(Address.Community(groupInfo.community.baseUrl, groupInfo.community.room))
+                }
+            }
+        }
+    }
+
+    val closedMemberAddresses: Set<Address> = buildSet {
+        closedIds.forEach { groupId ->
+            withGroupConfigs(groupId) { config ->
+                config.groupMembers.all().forEach { add(Address.fromSerialized(it.accountId())) }
+            }
+        }
+    }
+
+    return buildSet {
+        addAll(contactsAddress)
+        addAll(blindedAddress)
+        addAll(groupAddresses)
+        addAll(closedMemberAddresses)
+    }
+}
 
 /**
  * Wait until all configs of given group are pushed to the server.

app/src/main/java/org/thoughtcrime/securesms/attachments/RemoteFileDownloadWorker.kt

@@ -261,6 +261,8 @@ class RemoteFileDownloadWorker @AssistedInject constructor(
         private const val ARG_COMMUNITY_ROOM_ID = "community_room_id"
         private const val ARG_COMMUNITY_FILE_ID = "community_file_id"
 
+        private const val SUBDIRECTORY = "remote_files"
+
         private fun RemoteFile.sha256Hash(): String {
             val hash = MessageDigest.getInstance("SHA-256")
             when (this) {
@@ -278,9 +280,12 @@ class RemoteFileDownloadWorker @AssistedInject constructor(
             return hash.digest().toHexString()
         }
 
+        private fun downloadsDirectory(context: Context): File =
+            File(context.cacheDir, SUBDIRECTORY)
+
         // Deterministically get the file path for the given remote file.
         fun computeFileName(context: Context, remote: RemoteFile): File {
-            return File(context.cacheDir, "remote_files/${remote.sha256Hash()}")
+            return File(downloadsDirectory(context), remote.sha256Hash())
         }
 
         fun cancelAll(context: Context) {
@@ -297,6 +302,12 @@ class RemoteFileDownloadWorker @AssistedInject constructor(
             )
         }
 
+        /** Returns all currently downloaded files (may be empty). */
+        fun listDownloadedFiles(context: Context): List<File> {
+            val directory = downloadsDirectory(context)
+            return directory.listFiles()?.toList().orEmpty()
+        }
+
         /**
          * @param isOldAvatarOf used to indicate that this file is an avatar of a specific address. This
          * information is optional and only used for migration purposes (to move the avatar from

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
@@ -30,6 +30,7 @@ import org.session.libsession.utilities.Address.Companion.fromSerialized
 import org.session.libsession.utilities.ConfigFactoryProtocol
 import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsession.utilities.UserConfigType
+import org.session.libsession.utilities.allConfigAddresses
 import org.session.libsession.utilities.getGroup
 import org.session.libsession.utilities.userConfigsChanged
 import org.session.libsignal.crypto.ecc.DjbECPrivateKey
@@ -45,6 +46,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 +85,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 +152,9 @@ class ConfigToDatabaseSync @Inject constructor(
                     }
                 }
             }
+
+            // Initiate cleanup in recipient_settings
+            pruneRecipientSettingsAndAvatars()
         }
 
         // If we created threads, we need to update the thread database with the creation date.
@@ -167,6 +174,20 @@ class ConfigToDatabaseSync @Inject constructor(
         }
     }
 
+    private fun pruneRecipientSettingsAndAvatars() {
+        val addressesToKeep: Set<Address> = buildSet {
+            addAll(configFactory.allConfigAddresses())
+            addAll(mmsSmsDatabase.getAllReferencedAddresses())
+        }
+
+        val removed = recipientSettingsDatabase.cleanupRecipientSettings(addressesToKeep)
+        Log.d(TAG, "Recipient settings pruned: $removed orphan rows")
+
+        if (removed > 0) {
+            avatarCacheCleaner.launchAvatarCleanup()
+        }
+    }
+
     private fun deleteGroupData(address: Address.Group) {
         lokiAPIDatabase.clearLastMessageHashes(address.accountId.hexString)
         lokiAPIDatabase.clearReceivedMessageHashValues(address.accountId.hexString)

app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationActivityV2.kt

@@ -356,7 +356,6 @@ class ConversationActivityV2 : ScreenLockActionBarActivity(), InputBarDelegate,
     private val adapter by lazy {
         val adapter = ConversationAdapter(
             this,
-            null,
             storage.getLastSeen(viewModel.threadId),
             false,
             onItemPress = { message, position, view, event ->
@@ -367,7 +366,7 @@ class ConversationActivityV2 : ScreenLockActionBarActivity(), InputBarDelegate,
             },
             onItemLongPress = { message, position, view ->
                 // long pressing message for blocked users should show unblock dialog
-                if (viewModel.recipient.blocked == true) unblock()
+                if (viewModel.recipient.blocked) unblock()
                 else {
                     if (!viewModel.isMessageRequestThread) {
                         showConversationReaction(message, view)
@@ -384,6 +383,7 @@ class ConversationActivityV2 : ScreenLockActionBarActivity(), InputBarDelegate,
             downloadPendingAttachment = viewModel::downloadPendingAttachment,
             retryFailedAttachments = viewModel::retryFailedAttachments,
             glide = glide,
+            threadRecipientProvider = viewModel::recipient,
         )
         adapter.visibleMessageViewDelegate = this
         adapter