Merge branch 'dev' into release/1.25.2

Author: SessionHero01

.github/workflows/build_and_test.yml

@@ -37,7 +37,7 @@ jobs:
         with:
           submodules: 'recursive'
       - name: Set up JDK 21
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'

app/src/main/AndroidManifest.xml

@@ -53,6 +53,7 @@
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO"/>
     <uses-permission android:name="android.permission.READ_MEDIA_IMAGES"/>
     <uses-permission android:name="android.permission.READ_MEDIA_VIDEO"/>
+    <uses-permission android:name="android.permission.READ_MEDIA_VISUAL_USER_SELECTED"/>
     <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
@@ -279,7 +280,6 @@
         <activity
             android:name="org.thoughtcrime.securesms.MediaPreviewActivity"
             android:configChanges="touchscreen|keyboard|keyboardHidden|orientation|screenLayout|screenSize"
-            android:screenOrientation="portrait"
             android:theme="@style/Theme.Session.DayNight.NoActionBar"
             android:launchMode="singleTask"
             android:windowSoftInputMode="stateHidden" />
@@ -382,7 +382,7 @@
             android:exported="false" />
 
         <provider
-            android:name="org.thoughtcrime.securesms.providers.PartProvider"
+            android:name="org.thoughtcrime.securesms.providers.PartAndBlobProvider"
             android:authorities="network.loki.provider.securesms"
             android:exported="false"
             android:grantUriPermissions="true" />

app/src/main/java/org/session/libsession/database/CallDataProvider.kt

@@ -11,7 +11,6 @@ import org.session.libsession.messaging.jobs.Job
 import org.session.libsession.messaging.jobs.MessageSendJob
 import org.session.libsession.messaging.messages.ExpirationConfiguration
 import org.session.libsession.messaging.messages.Message
-import org.session.libsession.messaging.messages.control.ConfigurationMessage
 import org.session.libsession.messaging.messages.control.GroupUpdated
 import org.session.libsession.messaging.messages.control.MessageRequestResponse
 import org.session.libsession.messaging.messages.visible.Attachment
@@ -37,6 +36,7 @@ import org.session.libsignal.messages.SignalServiceGroup
 import org.session.libsignal.utilities.AccountId
 import org.thoughtcrime.securesms.database.model.MessageId
 import org.thoughtcrime.securesms.database.model.MessageRecord
+import org.thoughtcrime.securesms.database.model.ReactionRecord
 import network.loki.messenger.libsession_util.util.Contact as LibSessionContact
 import network.loki.messenger.libsession_util.util.GroupMember as LibSessionGroupMember
 
@@ -159,16 +159,17 @@ interface StorageProtocol {
     // Closed Groups
     fun getMembers(groupPublicKey: String): List<LibSessionGroupMember>
     fun getClosedGroupDisplayInfo(groupAccountId: String): GroupDisplayInfo?
-    fun insertGroupInfoChange(message: GroupUpdated, closedGroup: AccountId): Long?
-    fun insertGroupInfoLeaving(closedGroup: AccountId): Long?
-    fun insertGroupInfoErrorQuit(closedGroup: AccountId): Long?
+    fun insertGroupInfoChange(message: GroupUpdated, closedGroup: AccountId)
+    fun insertGroupInfoLeaving(closedGroup: AccountId)
+    fun insertGroupInfoErrorQuit(closedGroup: AccountId)
     fun insertGroupInviteControlMessage(
         sentTimestamp: Long,
         senderPublicKey: String,
         senderName: String?,
         closedGroup: AccountId,
         groupName: String
-    ): Long?
+    )
+
     fun updateGroupInfoChange(messageId: Long, newType: UpdateMessageData.Kind)
     fun deleteGroupInfoMessages(groupId: AccountId, kind: Class<out UpdateMessageData.Kind>)
 
@@ -208,7 +209,6 @@ interface StorageProtocol {
     fun getRecipientSettings(address: Address): RecipientSettings?
     fun syncLibSessionContacts(contacts: List<LibSessionContact>, timestamp: Long?)
     fun hasAutoDownloadFlagBeenSet(recipient: Recipient): Boolean
-    fun addContacts(contacts: List<ConfigurationMessage.Contact>)
     fun shouldAutoDownloadAttachments(recipient: Recipient): Boolean
     fun setAutoDownloadAttachments(recipient: Recipient, shouldAutoDownloadAttachments: Boolean)
 
@@ -259,12 +259,17 @@ interface StorageProtocol {
      * Add reaction to a specific message. This is preferable to the timestamp lookup.
      */
     fun addReaction(messageId: MessageId, reaction: Reaction, messageSender: String, notifyUnread: Boolean)
+
+    /**
+     * Add reactions into the database. If [replaceAll] is true,
+     * it will remove all existing reactions that belongs to the same message(s).
+     */
+    fun addReactions(reactions: Map<MessageId, List<ReactionRecord>>, replaceAll: Boolean, notifyUnread: Boolean)
     fun removeReaction(emoji: String, messageTimestamp: Long, threadId: Long, author: String, notifyUnread: Boolean)
     fun updateReactionIfNeeded(message: Message, sender: String, openGroupSentTimestamp: Long)
     fun deleteReactions(messageId: MessageId)
     fun deleteReactions(messageIds: List<Long>, mms: Boolean)
     fun setBlocked(recipients: Iterable<Recipient>, isBlocked: Boolean, fromConfigUpdate: Boolean = false)
-    fun setRecipientHash(recipient: Recipient, recipientHash: String?)
     fun blockedContacts(): List<Recipient>
     fun getExpirationConfiguration(threadId: Long): ExpirationConfiguration?
     fun setExpirationConfiguration(config: ExpirationConfiguration)

app/src/main/java/org/session/libsession/database/StorageProtocol.kt

@@ -12,6 +12,7 @@ import org.session.libsession.utilities.Device
 import org.session.libsession.utilities.TextSecurePreferences
 import org.session.libsession.utilities.Toaster
 import org.session.libsession.utilities.UsernameUtils
+import org.thoughtcrime.securesms.pro.ProStatusManager
 
 class MessagingModuleConfiguration(
     val context: Context,
@@ -25,7 +26,8 @@ class MessagingModuleConfiguration(
     val clock: SnodeClock,
     val preferences: TextSecurePreferences,
     val deprecationManager: LegacyGroupDeprecationManager,
-    val usernameUtils: UsernameUtils
+    val usernameUtils: UsernameUtils,
+    val proStatusManager: ProStatusManager
 ) {
 
     companion object {

app/src/main/java/org/session/libsession/messaging/MessagingModuleConfiguration.kt

@@ -6,38 +6,34 @@ import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import network.loki.messenger.libsession_util.ConfigBase
-import network.loki.messenger.libsession_util.util.BlindKeyAPI
 import org.session.libsession.messaging.MessagingModuleConfiguration
 import org.session.libsession.messaging.messages.Destination
 import org.session.libsession.messaging.messages.Message
 import org.session.libsession.messaging.messages.Message.Companion.senderOrSync
 import org.session.libsession.messaging.messages.control.CallMessage
-import org.session.libsession.messaging.messages.control.LegacyGroupControlMessage
-import org.session.libsession.messaging.messages.control.ConfigurationMessage
 import org.session.libsession.messaging.messages.control.DataExtractionNotification
 import org.session.libsession.messaging.messages.control.ExpirationTimerUpdate
 import org.session.libsession.messaging.messages.control.MessageRequestResponse
 import org.session.libsession.messaging.messages.control.ReadReceipt
-import org.session.libsession.messaging.messages.control.SharedConfigurationMessage
 import org.session.libsession.messaging.messages.control.TypingIndicator
 import org.session.libsession.messaging.messages.control.UnsendRequest
 import org.session.libsession.messaging.messages.visible.ParsedMessage
 import org.session.libsession.messaging.messages.visible.VisibleMessage
 import org.session.libsession.messaging.open_groups.OpenGroupApi
 import org.session.libsession.messaging.sending_receiving.MessageReceiver
+import org.session.libsession.messaging.sending_receiving.VisibleMessageHandlerContext
+import org.session.libsession.messaging.sending_receiving.constructReactionRecords
 import org.session.libsession.messaging.sending_receiving.handle
-import org.session.libsession.messaging.sending_receiving.handleOpenGroupReactions
 import org.session.libsession.messaging.sending_receiving.handleUnsendRequest
 import org.session.libsession.messaging.sending_receiving.handleVisibleMessage
 import org.session.libsession.messaging.utilities.Data
 import org.session.libsession.utilities.SSKEnvironment
 import org.session.libsession.utilities.UserConfigType
 import org.session.libsignal.protos.UtilProtos
 import org.session.libsignal.utilities.AccountId
-import org.session.libsignal.utilities.Hex
-import org.session.libsignal.utilities.IdPrefix
 import org.session.libsignal.utilities.Log
 import org.thoughtcrime.securesms.database.model.MessageId
+import org.thoughtcrime.securesms.database.model.ReactionRecord
 import kotlin.math.max
 
 data class MessageReceiveParameters(
@@ -83,12 +79,9 @@ class BatchMessageReceiveJob(
         if (message is VisibleMessage) return true
         else { // message is control message otherwise
             return when(message) {
-                is SharedConfigurationMessage -> false
-                is LegacyGroupControlMessage -> false // message.kind is ClosedGroupControlMessage.Kind.New && !message.isSenderSelf
                 is DataExtractionNotification -> false
                 is MessageRequestResponse -> false
                 is ExpirationTimerUpdate -> false
-                is ConfigurationMessage -> false
                 is TypingIndicator -> false
                 is UnsendRequest -> false
                 is ReadReceipt -> false
@@ -175,45 +168,51 @@ class BatchMessageReceiveJob(
         }
 
         // iterate over threads and persist them (persistence is the longest constant in the batch process operation)
-        fun processMessages(threadId: Long, messages: List<ParsedMessage>) {
+        suspend fun processMessages(threadId: Long, messages: List<ParsedMessage>) {
             // The LinkedHashMap should preserve insertion order
             val messageIds = linkedMapOf<MessageId, Pair<Boolean, Boolean>>()
             val myLastSeen = storage.getLastSeen(threadId)
-            var newLastSeen = myLastSeen.takeUnless { it == -1L } ?: 0
+            var updatedLastSeen = myLastSeen.takeUnless { it == -1L } ?: 0
+            val handlerContext = VisibleMessageHandlerContext(
+                module = MessagingModuleConfiguration.shared,
+                threadId = threadId,
+                openGroupID = openGroupID,
+            )
+
+            val communityReactions = mutableMapOf<MessageId, MutableList<ReactionRecord>>()
+
             messages.forEach { (parameters, message, proto) ->
                 try {
                     when (message) {
                         is VisibleMessage -> {
                             val isUserBlindedSender =
-                                message.sender == serverPublicKey?.let {
-                                    BlindKeyAPI.blind15KeyPairOrNull(
-                                        ed25519SecretKey = storage.getUserED25519KeyPair()!!
-                                            .secretKey.data,
-                                        serverPubKey = Hex.fromStringCondensed(it),
-                                    )
-                                }?.let {
-                                    AccountId(IdPrefix.BLINDED, it.pubKey.data).hexString
-                                }
+                                message.sender == handlerContext.userBlindedKey
+
                             if (message.sender == localUserPublicKey || isUserBlindedSender) {
                                 // use sent timestamp here since that is technically the last one we have
-                                newLastSeen = max(newLastSeen, message.sentTimestamp!!)
+                                updatedLastSeen = max(updatedLastSeen, message.sentTimestamp!!)
                             }
-                            val messageId = MessageReceiver.handleVisibleMessage(message, proto, openGroupID,
-                                threadId,
+                            val messageId = MessageReceiver.handleVisibleMessage(
+                                message = message,
+                                proto = proto,
+                                context = handlerContext,
                                 runThreadUpdate = false,
-                                runProfileUpdate = true)
+                                runProfileUpdate = true
+                            )
 
                             if (messageId != null && message.reaction == null) {
                                 messageIds[messageId] = Pair(
                                     (message.sender == localUserPublicKey || isUserBlindedSender),
                                     message.hasMention
                                 )
                             }
+
                             parameters.openGroupMessageServerID?.let {
-                                MessageReceiver.handleOpenGroupReactions(
-                                    threadId,
-                                    it,
-                                    parameters.reactions
+                                constructReactionRecords(
+                                    openGroupMessageServerID = it,
+                                    context = handlerContext,
+                                    reactions = parameters.reactions,
+                                    out = communityReactions
                                 )
                             }
                         }
@@ -248,13 +247,20 @@ class BatchMessageReceiveJob(
             // increment unreads, notify, and update thread
             // last seen will be the current last seen if not changed (re-computes the read counts for thread record)
             // might have been updated from a different thread at this point
-            val currentLastSeen = storage.getLastSeen(threadId).let { if (it == -1L) 0 else it }
-            newLastSeen = max(newLastSeen, currentLastSeen)
-            if (newLastSeen > 0 || currentLastSeen == 0L) {
-                storage.markConversationAsRead(threadId, newLastSeen, force = true)
+            val storedLastSeen = storage.getLastSeen(threadId).let { if (it == -1L) 0 else it }
+            updatedLastSeen = max(updatedLastSeen, storedLastSeen)
+            // Only call markConversationAsRead() when lastSeen actually advanced (we sent a message).
+            // For incoming-only batches (like reactions), skip this to preserve REACTIONS_UNREAD flags
+            // so the notification system can detect them. Thread updates happen separately below.
+            if (updatedLastSeen > storedLastSeen) {
+                storage.markConversationAsRead(threadId, updatedLastSeen, force = true)
             }
             storage.updateThread(threadId, true)
             SSKEnvironment.shared.notificationManager.updateNotification(context, threadId)
+
+            if (communityReactions.isNotEmpty()) {
+                storage.addReactions(communityReactions, replaceAll = true, notifyUnread = false)
+            }
         }
 
         coroutineScope {