Send files to several rooms at a time

Author: bmarty

matrix-sdk-android/src/main/java/im/vector/matrix/android/api/session/room/send/SendService.kt

@@ -52,20 +52,27 @@ interface SendService {
      * Method to send a media asynchronously.
      * @param attachment the media to send
      * @param compressBeforeSending set to true to compress media before sending them
+     * @param roomIds set of roomIds to where the media will be sent. The current roomId will be add to this set if not present.
+     *                It can be useful to send media to multiple room. It's safe to include the current roomId in this set
      * @return a [Cancelable]
      */
     fun sendMedia(attachment: ContentAttachmentData,
             // TODO Change to a Compression Level Enum
-                  compressBeforeSending: Boolean): Cancelable
+                  compressBeforeSending: Boolean,
+                  roomIds: Set<String>): Cancelable
 
     /**
      * Method to send a list of media asynchronously.
      * @param attachments the list of media to send
+     * @param compressBeforeSending set to true to compress media before sending them
+     * @param roomIds set of roomIds to where the media will be sent. The current roomId will be add to this set if not present.
+     *                It can be useful to send media to multiple room. It's safe to include the current roomId in this set
      * @return a [Cancelable]
      */
     fun sendMedias(attachments: List<ContentAttachmentData>,
             // TODO Change to a Compression Level Enum
-                   compressBeforeSending: Boolean): Cancelable
+                   compressBeforeSending: Boolean,
+                   roomIds: Set<String>): Cancelable
 
     /**
      * Send a poll to the room.

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/di/WorkManagerProvider.kt

@@ -17,7 +17,11 @@
 package im.vector.matrix.android.internal.di
 
 import android.content.Context
-import androidx.work.*
+import androidx.work.Constraints
+import androidx.work.ListenableWorker
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
 import javax.inject.Inject
 
 internal class WorkManagerProvider @Inject constructor(
@@ -54,5 +58,7 @@ internal class WorkManagerProvider @Inject constructor(
         val workConstraints = Constraints.Builder()
                 .setRequiredNetworkType(NetworkType.CONNECTED)
                 .build()
+
+        const val BACKOFF_DELAY = 10_000L
     }
 }

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/SessionComponent.kt

@@ -38,6 +38,7 @@ import im.vector.matrix.android.internal.session.pushers.PushersModule
 import im.vector.matrix.android.internal.session.room.RoomModule
 import im.vector.matrix.android.internal.session.room.relation.SendRelationWorker
 import im.vector.matrix.android.internal.session.room.send.EncryptEventWorker
+import im.vector.matrix.android.internal.session.room.send.MultipleEventSendingDispatcherWorker
 import im.vector.matrix.android.internal.session.room.send.RedactEventWorker
 import im.vector.matrix.android.internal.session.room.send.SendEventWorker
 import im.vector.matrix.android.internal.session.signout.SignOutModule
@@ -85,23 +86,25 @@ internal interface SessionComponent {
 
     fun taskExecutor(): TaskExecutor
 
-    fun inject(sendEventWorker: SendEventWorker)
+    fun inject(worker: SendEventWorker)
 
-    fun inject(sendEventWorker: SendRelationWorker)
+    fun inject(worker: SendRelationWorker)
 
-    fun inject(encryptEventWorker: EncryptEventWorker)
+    fun inject(worker: EncryptEventWorker)
 
-    fun inject(redactEventWorker: RedactEventWorker)
+    fun inject(worker: MultipleEventSendingDispatcherWorker)
 
-    fun inject(getGroupDataWorker: GetGroupDataWorker)
+    fun inject(worker: RedactEventWorker)
 
-    fun inject(uploadContentWorker: UploadContentWorker)
+    fun inject(worker: GetGroupDataWorker)
 
-    fun inject(syncWorker: SyncWorker)
+    fun inject(worker: UploadContentWorker)
 
-    fun inject(addHttpPusherWorker: AddHttpPusherWorker)
+    fun inject(worker: SyncWorker)
 
-    fun inject(sendVerificationMessageWorker: SendVerificationMessageWorker)
+    fun inject(worker: AddHttpPusherWorker)
+
+    fun inject(worker: SendVerificationMessageWorker)
 
     @Component.Factory
     interface Factory {

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/content/UploadContentWorker.kt

@@ -24,11 +24,15 @@ import im.vector.matrix.android.api.session.content.ContentAttachmentData
 import im.vector.matrix.android.api.session.events.model.Event
 import im.vector.matrix.android.api.session.events.model.toContent
 import im.vector.matrix.android.api.session.events.model.toModel
-import im.vector.matrix.android.api.session.room.model.message.*
+import im.vector.matrix.android.api.session.room.model.message.MessageAudioContent
+import im.vector.matrix.android.api.session.room.model.message.MessageContent
+import im.vector.matrix.android.api.session.room.model.message.MessageFileContent
+import im.vector.matrix.android.api.session.room.model.message.MessageImageContent
+import im.vector.matrix.android.api.session.room.model.message.MessageVideoContent
 import im.vector.matrix.android.internal.crypto.attachments.MXEncryptedAttachments
 import im.vector.matrix.android.internal.crypto.model.rest.EncryptedFileInfo
 import im.vector.matrix.android.internal.network.ProgressRequestBody
-import im.vector.matrix.android.internal.session.room.send.SendEventWorker
+import im.vector.matrix.android.internal.session.room.send.MultipleEventSendingDispatcherWorker
 import im.vector.matrix.android.internal.worker.SessionWorkerParams
 import im.vector.matrix.android.internal.worker.WorkerParamsFactory
 import im.vector.matrix.android.internal.worker.getSessionComponent
@@ -43,8 +47,7 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
     @JsonClass(generateAdapter = true)
     internal data class Params(
             override val sessionId: String,
-            val roomId: String,
-            val event: Event,
+            val events: List<Event>,
             val attachment: ContentAttachmentData,
             val isRoomEncrypted: Boolean,
             val compressBeforeSending: Boolean,
@@ -68,14 +71,17 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
         val sessionComponent = getSessionComponent(params.sessionId) ?: return Result.success()
         sessionComponent.inject(this)
 
-        val eventId = params.event.eventId ?: return Result.success()
         val attachment = params.attachment
 
         val attachmentFile = try {
             File(attachment.path)
         } catch (e: Exception) {
             Timber.e(e)
-            contentUploadStateTracker.setFailure(params.event.eventId, e)
+            params.events
+                    .mapNotNull { it.eventId }
+                    .forEach {
+                        contentUploadStateTracker.setFailure(it, e)
+                    }
             return Result.success(
                     WorkerParamsFactory.toData(params.copy(
                             lastFailureMessage = e.localizedMessage
@@ -91,14 +97,22 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
         ThumbnailExtractor.extractThumbnail(params.attachment)?.let { thumbnailData ->
             val thumbnailProgressListener = object : ProgressRequestBody.Listener {
                 override fun onProgress(current: Long, total: Long) {
-                    contentUploadStateTracker.setProgressThumbnail(eventId, current, total)
+                    params.events
+                            .mapNotNull { it.eventId }
+                            .forEach {
+                                contentUploadStateTracker.setProgressThumbnail(it, current, total)
+                            }
                 }
             }
 
             try {
                 val contentUploadResponse = if (params.isRoomEncrypted) {
                     Timber.v("Encrypt thumbnail")
-                    contentUploadStateTracker.setEncryptingThumbnail(eventId)
+                    params.events
+                            .mapNotNull { it.eventId }
+                            .forEach {
+                                contentUploadStateTracker.setEncryptingThumbnail(it)
+                            }
                     val encryptionResult = MXEncryptedAttachments.encryptAttachment(ByteArrayInputStream(thumbnailData.bytes), thumbnailData.mimeType)
                     uploadedThumbnailEncryptedFileInfo = encryptionResult.encryptedFileInfo
                     fileUploader.uploadByteArray(encryptionResult.encryptedByteArray,
@@ -121,11 +135,15 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
 
         val progressListener = object : ProgressRequestBody.Listener {
             override fun onProgress(current: Long, total: Long) {
-                if (isStopped) {
-                    contentUploadStateTracker.setFailure(eventId, Throwable("Cancelled"))
-                } else {
-                    contentUploadStateTracker.setProgress(eventId, current, total)
-                }
+                params.events
+                        .mapNotNull { it.eventId }
+                        .forEach {
+                            if (isStopped) {
+                                contentUploadStateTracker.setFailure(it, Throwable("Cancelled"))
+                            } else {
+                                contentUploadStateTracker.setProgress(it, current, total)
+                            }
+                        }
             }
         }
 
@@ -134,7 +152,11 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
         return try {
             val contentUploadResponse = if (params.isRoomEncrypted) {
                 Timber.v("Encrypt file")
-                contentUploadStateTracker.setEncrypting(eventId)
+                params.events
+                        .mapNotNull { it.eventId }
+                        .forEach {
+                            contentUploadStateTracker.setEncrypting(it)
+                        }
 
                 val encryptionResult = MXEncryptedAttachments.encryptAttachment(FileInputStream(attachmentFile), attachment.mimeType)
                 uploadedFileEncryptedFileInfo = encryptionResult.encryptedFileInfo
@@ -154,7 +176,12 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
     }
 
     private fun handleFailure(params: Params, failure: Throwable): Result {
-        contentUploadStateTracker.setFailure(params.event.eventId!!, failure)
+        params.events
+                .mapNotNull { it.eventId }
+                .forEach {
+                    contentUploadStateTracker.setFailure(it, failure)
+                }
+
         return Result.success(
                 WorkerParamsFactory.toData(
                         params.copy(
@@ -170,9 +197,18 @@ internal class UploadContentWorker(context: Context, params: WorkerParameters) :
                               thumbnailUrl: String?,
                               thumbnailEncryptedFileInfo: EncryptedFileInfo?): Result {
         Timber.v("handleSuccess $attachmentUrl, work is stopped $isStopped")
-        contentUploadStateTracker.setSuccess(params.event.eventId!!)
-        val event = updateEvent(params.event, attachmentUrl, encryptedFileInfo, thumbnailUrl, thumbnailEncryptedFileInfo)
-        val sendParams = SendEventWorker.Params(params.sessionId, params.roomId, event)
+        params.events
+                .mapNotNull { it.eventId }
+                .forEach {
+                    contentUploadStateTracker.setSuccess(it)
+                }
+
+        val updatedEvents = params.events
+                .map {
+                    updateEvent(it, attachmentUrl, encryptedFileInfo, thumbnailUrl, thumbnailEncryptedFileInfo)
+                }
+
+        val sendParams = MultipleEventSendingDispatcherWorker.Params(params.sessionId, updatedEvents, params.isRoomEncrypted)
         return Result.success(WorkerParamsFactory.toData(sendParams))
     }
 

matrix-sdk-android/src/main/java/im/vector/matrix/android/internal/session/room/relation/DefaultRelationService.kt

@@ -196,13 +196,13 @@ internal class DefaultRelationService @AssistedInject constructor(
 
     private fun createEncryptEventWork(event: Event, keepKeys: List<String>?): OneTimeWorkRequest {
         // Same parameter
-        val params = EncryptEventWorker.Params(sessionId, roomId, event, keepKeys)
+        val params = EncryptEventWorker.Params(sessionId, event, keepKeys)
         val sendWorkData = WorkerParamsFactory.toData(params)
         return timeLineSendEventWorkCommon.createWork<EncryptEventWorker>(sendWorkData, true)
     }
 
     private fun createSendEventWork(event: Event, startChain: Boolean): OneTimeWorkRequest {
-        val sendContentWorkerParams = SendEventWorker.Params(sessionId, roomId, event)
+        val sendContentWorkerParams = SendEventWorker.Params(sessionId, event)
         val sendWorkData = WorkerParamsFactory.toData(sendContentWorkerParams)
         return timeLineSendEventWorkCommon.createWork<SendEventWorker>(sendWorkData, startChain)
     }