Merge pull request #2005 from session-foundation/release/1.32.1

ThomasSession · web-flow · commit b8b04668f9cc · 2026-02-26T14:07:24.000+11:00
Prepare for release 1.32.1
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -26,8 +26,8 @@ configurations.configureEach {
     exclude(module = "commons-logging")
 }
 
-val canonicalVersionCode = 443
-val canonicalVersionName = "1.32.0"
+val canonicalVersionCode = 444
+val canonicalVersionName = "1.32.1"
 
 val postFixSize = 10
 val abiPostFix = mapOf(
diff --git a/app/src/main/java/org/thoughtcrime/securesms/api/batch/BatchApiExecutor.kt b/app/src/main/java/org/thoughtcrime/securesms/api/batch/BatchApiExecutor.kt
@@ -4,13 +4,19 @@ import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.channels.SendChannel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withTimeoutOrNull
+import kotlinx.coroutines.selects.onTimeout
+import kotlinx.coroutines.selects.select
 import org.session.libsignal.utilities.Log
 import org.thoughtcrime.securesms.api.ApiExecutor
 import org.thoughtcrime.securesms.api.ApiExecutorContext
-import java.time.Instant
+import kotlin.time.ComparableTimeMark
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.TimeSource
 
 /**
  * An [ApiExecutor] that batches requests together based on a [Batcher.batchKey].
@@ -37,73 +43,87 @@ class BatchApiExecutor<Req, Res, T>(
         batchCommandSender = channel
 
         scope.launch {
+            val timeSource: TimeSource.WithComparableMarks = TimeSource.Monotonic
+
             val pendingRequests = linkedMapOf<Any, BatchInfo<Req, Res>>()
-            var nextDeadline: Instant? = null
-
-            while (true) {
-                val command: BatchCommand<Req, Res>? = if (nextDeadline == null) {
-                    channel.receive()
-                } else {
-                    val now = Instant.now()
-                    if (nextDeadline > now) {
-                        withTimeoutOrNull(nextDeadline.toEpochMilli() - now.toEpochMilli()) {
-                            channel.receive()
-                        }
+            var nextDeadline: ComparableTimeMark? = null
+
+            while (isActive) {
+                try {
+                    val command: BatchCommand<Req, Res>? = if (nextDeadline == null) {
+                        channel.receive()
                     } else {
-                        // Deadline already reached
-                        null
+                        val now = timeSource.markNow()
+                        if (nextDeadline > now) {
+                            select {
+                                channel.onReceive { it }
+                                onTimeout(nextDeadline - now) { null }
+                            }
+                        } else {
+                            // Deadline already reached
+                            null
+                        }
                     }
-                }
 
-                var calculateNextDeadline = false
+                    var calculateNextDeadline = false
 
-                when (command) {
-                    is BatchCommand.Send<Req, Res> -> {
-                        val existingBatch = pendingRequests[command.batchKey]
-                        if (existingBatch == null) {
-                            pendingRequests[command.batchKey] = BatchInfo(
-                                requests = arrayListOf(command),
-                                deadline = Instant.now().plusMillis(100L),
-                            )
+                    when (command) {
+                        is BatchCommand.Send<Req, Res> -> {
+                            val existingBatch = pendingRequests[command.batchKey]
+                            if (existingBatch == null) {
+                                pendingRequests[command.batchKey] = BatchInfo(
+                                    requests = arrayListOf(command),
+                                    deadline = timeSource.markNow() + 100.milliseconds
+                                )
 
-                            calculateNextDeadline = true
-                        } else {
-                            existingBatch.requests.add(command)
+                                calculateNextDeadline = true
+                            } else {
+                                existingBatch.requests.add(command)
+                            }
                         }
-                    }
 
-                    is BatchCommand.Cancel<Req, Res> -> {
-                        val existingBatch = pendingRequests[command.batchKey]
-                        if (existingBatch != null) {
-                            existingBatch.requests.removeIf { it.req == command.req }
-                            if (existingBatch.requests.isEmpty()) {
-                                pendingRequests.remove(command.batchKey)
-                                calculateNextDeadline = true
+                        is BatchCommand.Cancel<Req, Res> -> {
+                            val existingBatch = pendingRequests[command.batchKey]
+                            if (existingBatch != null) {
+                                existingBatch.requests.removeIf { it.req == command.req }
+                                if (existingBatch.requests.isEmpty()) {
+                                    pendingRequests.remove(command.batchKey)
+                                    calculateNextDeadline = true
+                                }
                             }
                         }
-                    }
 
-                    null -> {
-                        // Deadline reached: it will be the first batch in the queue
-                        executeBatch(pendingRequests.removeFirst())
-                        calculateNextDeadline = true
+                        null -> {
+                            // Deadline reached: it will be the first batch in the queue
+                            executeBatch(pendingRequests.removeFirst())
+                            calculateNextDeadline = true
+                        }
                     }
-                }
 
-                if (calculateNextDeadline) {
-                    nextDeadline = if (pendingRequests.isEmpty()) {
-                        null
-                    } else {
-                        pendingRequests.values.first().deadline
+                    if (calculateNextDeadline) {
+                        nextDeadline = if (pendingRequests.isEmpty()) {
+                            null
+                        } else {
+                            pendingRequests.values.first().deadline
+                        }
                     }
+                } catch (e: CancellationException) {
+                    Log.i(TAG, "Main loop cancelled")
+                    throw e
+                } catch (e: ClosedReceiveChannelException) {
+                    Log.e(TAG, "Channel no longer open. Stopping batch handling", e)
+                    break
+                } catch (e: Throwable) {
+                    Log.e(TAG, "Error in main loop. Retrying in 1s", e)
+                    delay(1000)
                 }
             }
         }
     }
 
     private class BatchInfo<Req, Res>(
         val requests: ArrayList<BatchCommand.Send<Req, Res>>,
-        val deadline: Instant,
+        val deadline: ComparableTimeMark,
     ) {
         init {
             check(requests.isNotEmpty()) {
@@ -123,8 +143,11 @@ class BatchApiExecutor<Req, Res, T>(
                 }
 
                 if (transformed.isFailure) {
+                    Log.d(TAG, "Transformation of request failed", transformed.exceptionOrNull())
                     // Notify individual request of failure
-                    r.callback.send(Result.failure(transformed.exceptionOrNull()!!))
+                    if (!r.callback.trySend(Result.failure(transformed.exceptionOrNull()!!)).isSuccess) {
+                        Log.w(TAG, "Unable to send transform result back")
+                    }
                     continue
                 }
 
@@ -150,22 +173,27 @@ class BatchApiExecutor<Req, Res, T>(
                     response = resp
                 )
 
-                check(responses.size == batch.requests.size) {
-                    "Batch response size ${responses.size} does not match request size ${batch.requests.size}"
+                check(responses.size == requestsToSend.size) {
+                    "Batch response size ${responses.size} does not match request size ${requestsToSend.size}"
                 }
 
-                for (i in batch.requests.indices) {
-                    val request = batch.requests[i]
+                for (i in requestsToSend.indices) {
+                    val (request, _) = requestsToSend[i]
                     val response = responses[i]
-                    request.callback.send(response)
+
+                    if (!request.callback.trySend(response).isSuccess) {
+                        Log.w(TAG, "Unable to send result back to individual request")
+                    }
                 }
 
             } catch (e: Throwable) {
                 if (e is CancellationException) throw e
 
                 // Notify all requests of the failure
                 for (request in requestsToSend) {
-                    request.first.callback.send(Result.failure(e))
+                    if (!request.first.callback.trySend(Result.failure(e)).isSuccess) {
+                        Log.w(TAG, "Unable to send failure back to individual request")
+                    }
                 }
             }
         }
@@ -182,7 +210,7 @@ class BatchApiExecutor<Req, Res, T>(
         val batchKey = batcher.batchKey(req)
             ?: return actualExecutor.send(ctx, req)
 
-        val callback = Channel<Result<*>>(1)
+        val callback = Channel<Result<*>>(capacity = 1)
         batchCommandSender.send(BatchCommand.Send(
             ctx = ctx,
             batchKey = batchKey,
diff --git a/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationAdapter.kt b/app/src/main/java/org/thoughtcrime/securesms/conversation/v2/ConversationAdapter.kt
@@ -8,9 +8,7 @@ import android.view.ViewGroup
 import androidx.recyclerview.widget.RecyclerView.ViewHolder
 import com.bumptech.glide.RequestManager
 import org.session.libsession.messaging.sending_receiving.attachments.DatabaseAttachment
-import org.session.libsession.utilities.Address
 import org.session.libsession.utilities.recipients.Recipient
-import org.session.libsignal.utilities.Log
 import org.thoughtcrime.securesms.conversation.v2.messages.ControlMessageView
 import org.thoughtcrime.securesms.conversation.v2.messages.VisibleMessageView
 import org.thoughtcrime.securesms.conversation.v2.messages.VisibleMessageViewDelegate
@@ -19,7 +17,6 @@ import org.thoughtcrime.securesms.database.MmsSmsColumns
 import org.thoughtcrime.securesms.database.MmsSmsDatabase
 import org.thoughtcrime.securesms.database.model.MessageId
 import org.thoughtcrime.securesms.database.model.MessageRecord
-import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.math.min
 
@@ -155,8 +152,7 @@ class ConversationAdapter(
         val c = cursor ?: return null
         for (i in 0 until itemCount) {
             if (!c.moveToPosition(i)) break
-            val rec = messageDB.readerFor(c).current ?: continue
-            if (rec.messageId == target) return i
+            if (messageDB.readCurrentMessageId(c) == target) return i
         }
         return null
     }
diff --git a/app/src/main/java/org/thoughtcrime/securesms/database/MmsSmsDatabase.java b/app/src/main/java/org/thoughtcrime/securesms/database/MmsSmsDatabase.java
@@ -55,8 +55,6 @@
 import dagger.hilt.android.qualifiers.ApplicationContext;
 import kotlin.Pair;
 import kotlin.Triple;
-import network.loki.messenger.libsession_util.protocol.ProFeature;
-import network.loki.messenger.libsession_util.protocol.ProMessageFeature;
 
 @Singleton
 public class MmsSmsDatabase extends Database {
@@ -599,6 +597,20 @@ public Reader readerFor(@NonNull Cursor cursor, boolean getQuote) {
     return new Reader(cursor, getQuote);
   }
 
+  @NonNull
+  public MessageId readCurrentMessageId(@NonNull Cursor cursor) {
+    String type = cursor.getString(cursor.getColumnIndexOrThrow(TRANSPORT));
+    long id = cursor.getLong(cursor.getColumnIndexOrThrow(ID));
+
+    if (MMS_TRANSPORT.equals(type)) {
+      return new MessageId(id, true);
+    } else if (SMS_TRANSPORT.equals(type)) {
+      return new MessageId(id, false);
+    } else {
+      throw new AssertionError("Bad type: " + type);
+    }
+  }
+
   @NonNull
   public Pair<Boolean, Long> timestampAndDirectionForCurrent(@NonNull Cursor cursor) {
     int sentColumn = cursor.getColumnIndex(MmsSmsColumns.NORMALIZED_DATE_SENT);
diff --git a/app/src/main/java/org/thoughtcrime/securesms/logging/PersistentLogger.kt b/app/src/main/java/org/thoughtcrime/securesms/logging/PersistentLogger.kt
@@ -11,11 +11,13 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+
 import kotlinx.coroutines.withTimeoutOrNull
 import org.session.libsignal.utilities.Log.Logger
 import org.thoughtcrime.securesms.dependencies.ManagerScope
 import org.thoughtcrime.securesms.dependencies.OnAppStartupComponent
 import java.io.File
+
 import java.text.SimpleDateFormat
 import java.util.Locale
 import java.util.regex.Pattern
@@ -25,6 +27,7 @@ import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.time.Duration.Companion.milliseconds
 
+
 /**
  * A [Logger] that writes logs to encrypted files in the app's cache directory.
  */
@@ -159,10 +162,9 @@ class PersistentLogger @Inject constructor(
     private suspend fun ReceiveChannel<LogEntry>.receiveBulkLogs(out: MutableList<LogEntry>) {
         out += receive()
 
-        withTimeoutOrNull(500.milliseconds) {
-            repeat(15) {
-                out += receiveCatching().getOrNull() ?: return@repeat
-            }
+        // We may have many items cached in the channel, try to receive up to 15 items
+        repeat(15) {
+            out += tryReceive().getOrNull() ?: return@repeat
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ configurations.configureEach {`
`26`	`26`	`exclude(module = "commons-logging")`
`27`	`27`	`}`
`28`	`28`
`29`		`-val canonicalVersionCode = 443`
`30`		`-val canonicalVersionName = "1.32.0"`
	`29`	`+val canonicalVersionCode = 444`
	`30`	`+val canonicalVersionName = "1.32.1"`
`31`	`31`
`32`	`32`	`val postFixSize = 10`
`33`	`33`	`val abiPostFix = mapOf(`