Implement MSC3912 to delete server side all the data of a deleted voice broadcast

changelog.d/7967.feature

@@ -0,0 +1 @@
+[Voice Broadcast] Use MSC3912 to delete server side all the related events

changelog.d/7988.sdk

@@ -0,0 +1 @@
+Implement [MSC3912](https://github.com/matrix-org/matrix-spec-proposals/pull/3912): Relation-based redactions

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/homeserver/HomeServerCapabilities.kt

@@ -75,6 +75,11 @@ data class HomeServerCapabilities(
          * True if the home server supports remote toggle of Pusher for a given device.
          */
         val canRemotelyTogglePushNotificationsOfDevices: Boolean = false,
+
+        /**
+         * True if the home server supports event redaction with relations.
+         */
+        var canRedactEventWithRelations: Boolean = false,
 ) {
 
     enum class RoomCapabilitySupport {

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

@@ -156,11 +156,12 @@ interface SendService {
 
     /**
      * Redact (delete) the given event.
-     * @param event The event to redact
-     * @param reason Optional reason string
+     * @param event the event to redact
+     * @param reason optional reason string
+     * @param withRelations the list of relation types to redact with this event
      * @param additionalContent additional content to put in the event content
      */
-    fun redactEvent(event: Event, reason: String?, additionalContent: Content? = null): Cancelable
+    fun redactEvent(event: Event, reason: String?, withRelations: List<String>? = null, additionalContent: Content? = null): Cancelable
 
     /**
      * Schedule this message to be resent.

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/auth/version/Versions.kt

@@ -58,6 +58,8 @@ private const val FEATURE_QR_CODE_LOGIN = "org.matrix.msc3882"
 private const val FEATURE_THREADS_MSC3771 = "org.matrix.msc3771"
 private const val FEATURE_THREADS_MSC3773 = "org.matrix.msc3773"
 private const val FEATURE_REMOTE_TOGGLE_PUSH_NOTIFICATIONS_MSC3881 = "org.matrix.msc3881"
+private const val FEATURE_EVENT_REDACTION_WITH_RELATIONS = "org.matrix.msc3912"
+private const val FEATURE_EVENT_REDACTION_WITH_RELATIONS_STABLE = "org.matrix.msc3912.stable"
 
 /**
  * Return true if the SDK supports this homeserver version.
@@ -153,3 +155,13 @@ private fun Versions.getMaxVersion(): HomeServerVersion {
 internal fun Versions.doesServerSupportRemoteToggleOfPushNotifications(): Boolean {
     return unstableFeatures?.get(FEATURE_REMOTE_TOGGLE_PUSH_NOTIFICATIONS_MSC3881).orFalse()
 }
+
+/**
+ * Indicate if the server supports MSC3912: https://github.com/matrix-org/matrix-spec-proposals/pull/3912.
+ *
+ * @return true if event redaction with relations is supported
+ */
+internal fun Versions.doesServerSupportRedactEventWithRelations(): Boolean {
+    return unstableFeatures?.get(FEATURE_EVENT_REDACTION_WITH_RELATIONS).orFalse() ||
+            unstableFeatures?.get(FEATURE_EVENT_REDACTION_WITH_RELATIONS_STABLE).orFalse()
+}

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/tasks/RedactEventTask.kt

@@ -15,8 +15,10 @@
  */
 package org.matrix.android.sdk.internal.crypto.tasks
 
+import org.matrix.android.sdk.api.session.homeserver.HomeServerCapabilitiesService
 import org.matrix.android.sdk.internal.network.GlobalErrorReceiver
 import org.matrix.android.sdk.internal.network.executeRequest
+import org.matrix.android.sdk.internal.session.room.EventRedactBody
 import org.matrix.android.sdk.internal.session.room.RoomAPI
 import org.matrix.android.sdk.internal.task.Task
 import javax.inject.Inject
@@ -26,22 +28,31 @@ internal interface RedactEventTask : Task<RedactEventTask.Params, String> {
             val txID: String,
             val roomId: String,
             val eventId: String,
-            val reason: String?
+            val reason: String?,
+            val withRelations: List<String>?
     )
 }
 
 internal class DefaultRedactEventTask @Inject constructor(
         private val roomAPI: RoomAPI,
-        private val globalErrorReceiver: GlobalErrorReceiver
+        private val globalErrorReceiver: GlobalErrorReceiver,
+        private val homeServerCapabilitiesService: HomeServerCapabilitiesService,
 ) : RedactEventTask {
 
     override suspend fun execute(params: RedactEventTask.Params): String {
+        val withRelations = if (homeServerCapabilitiesService.getHomeServerCapabilities().canRedactEventWithRelations &&
+                !params.withRelations.isNullOrEmpty()) {
+            params.withRelations
+        } else {
+            null
+        }
+
         val response = executeRequest(globalErrorReceiver) {
             roomAPI.redactEvent(
                     txId = params.txID,
                     roomId = params.roomId,
                     eventId = params.eventId,
-                    reason = if (params.reason == null) emptyMap() else mapOf("reason" to params.reason)
+                    body = EventRedactBody(params.reason, withRelations, withRelations)
             )
         }
         return response.eventId

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/RealmSessionStoreMigration.kt

@@ -65,6 +65,7 @@ import org.matrix.android.sdk.internal.database.migration.MigrateSessionTo045
 import org.matrix.android.sdk.internal.database.migration.MigrateSessionTo046
 import org.matrix.android.sdk.internal.database.migration.MigrateSessionTo047
 import org.matrix.android.sdk.internal.database.migration.MigrateSessionTo048
+import org.matrix.android.sdk.internal.database.migration.MigrateSessionTo049
 import org.matrix.android.sdk.internal.util.Normalizer
 import org.matrix.android.sdk.internal.util.database.MatrixRealmMigration
 import javax.inject.Inject
@@ -73,7 +74,7 @@ internal class RealmSessionStoreMigration @Inject constructor(
         private val normalizer: Normalizer
 ) : MatrixRealmMigration(
         dbName = "Session",
-        schemaVersion = 48L,
+        schemaVersion = 49L,
 ) {
     /**
      * Forces all RealmSessionStoreMigration instances to be equal.
@@ -131,5 +132,6 @@ internal class RealmSessionStoreMigration @Inject constructor(
         if (oldVersion < 46) MigrateSessionTo046(realm).perform()
         if (oldVersion < 47) MigrateSessionTo047(realm).perform()
         if (oldVersion < 48) MigrateSessionTo048(realm).perform()
+        if (oldVersion < 49) MigrateSessionTo049(realm).perform()
     }
 }

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/mapper/HomeServerCapabilitiesMapper.kt

@@ -47,6 +47,7 @@ internal object HomeServerCapabilitiesMapper {
                 canLoginWithQrCode = entity.canLoginWithQrCode,
                 canUseThreadReadReceiptsAndNotifications = entity.canUseThreadReadReceiptsAndNotifications,
                 canRemotelyTogglePushNotificationsOfDevices = entity.canRemotelyTogglePushNotificationsOfDevices,
+                canRedactEventWithRelations = entity.canRedactEventWithRelations,
         )
     }
 

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/migration/MigrateSessionTo049.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 The Matrix.org Foundation C.I.C.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.database.migration
+
+import io.realm.DynamicRealm
+import org.matrix.android.sdk.internal.database.model.HomeServerCapabilitiesEntityFields
+import org.matrix.android.sdk.internal.extensions.forceRefreshOfHomeServerCapabilities
+import org.matrix.android.sdk.internal.util.database.RealmMigrator
+
+internal class MigrateSessionTo049(realm: DynamicRealm) : RealmMigrator(realm, 49) {
+
+    override fun doMigrate(realm: DynamicRealm) {
+        realm.schema.get("HomeServerCapabilitiesEntity")
+                ?.addField(HomeServerCapabilitiesEntityFields.CAN_REDACT_EVENT_WITH_RELATIONS, Boolean::class.java)
+                ?.transform { obj ->
+                    obj.set(HomeServerCapabilitiesEntityFields.CAN_REDACT_EVENT_WITH_RELATIONS, false)
+                }
+                ?.forceRefreshOfHomeServerCapabilities()
+    }
+}

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/model/HomeServerCapabilitiesEntity.kt

@@ -34,6 +34,7 @@ internal open class HomeServerCapabilitiesEntity(
         var canLoginWithQrCode: Boolean = false,
         var canUseThreadReadReceiptsAndNotifications: Boolean = false,
         var canRemotelyTogglePushNotificationsOfDevices: Boolean = false,
+        var canRedactEventWithRelations: Boolean = false,
 ) : RealmObject() {
 
     companion object

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/homeserver/GetHomeServerCapabilitiesTask.kt

@@ -25,6 +25,7 @@ import org.matrix.android.sdk.api.session.homeserver.HomeServerCapabilities
 import org.matrix.android.sdk.internal.auth.version.Versions
 import org.matrix.android.sdk.internal.auth.version.doesServerSupportLogoutDevices
 import org.matrix.android.sdk.internal.auth.version.doesServerSupportQrCodeLogin
+import org.matrix.android.sdk.internal.auth.version.doesServerSupportRedactEventWithRelations
 import org.matrix.android.sdk.internal.auth.version.doesServerSupportRemoteToggleOfPushNotifications
 import org.matrix.android.sdk.internal.auth.version.doesServerSupportThreadUnreadNotifications
 import org.matrix.android.sdk.internal.auth.version.doesServerSupportThreads
@@ -154,6 +155,8 @@ internal class DefaultGetHomeServerCapabilitiesTask @Inject constructor(
                         getVersionResult.doesServerSupportQrCodeLogin()
                 homeServerCapabilitiesEntity.canRemotelyTogglePushNotificationsOfDevices =
                         getVersionResult.doesServerSupportRemoteToggleOfPushNotifications()
+                homeServerCapabilitiesEntity.canRedactEventWithRelations =
+                        getVersionResult.doesServerSupportRedactEventWithRelations()
             }
 
             if (getWellknownResult != null && getWellknownResult is WellknownResult.Prompt) {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/EventRedactBody.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 The Matrix.org Foundation C.I.C.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.session.room
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+internal data class EventRedactBody(
+        @Json(name = "reason")
+        val reason: String? = null,
+
+        @Json(name = "with_relations")
+        val withRelations: List<String>? = null,
+
+        @Json(name = "org.matrix.msc3912.with_relations")
+        val withRelationsUnstable: List<String>? = null,
+)

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/RoomAPI.kt

@@ -350,14 +350,14 @@ internal interface RoomAPI {
      * @param txId the transaction Id
      * @param roomId the room id
      * @param eventId the event to delete
-     * @param reason json containing reason key {"reason": "Indecent material"}
+     * @param body body containing reason key {"reason": "Indecent material"} and with_relations
      */
     @PUT(NetworkConstants.URI_API_PREFIX_PATH_R0 + "rooms/{roomId}/redact/{eventId}/{txnId}")
     suspend fun redactEvent(
             @Path("txnId") txId: String,
             @Path("roomId") roomId: String,
             @Path("eventId") eventId: String,
-            @Body reason: Map<String, String>
+            @Body body: EventRedactBody
     ): SendResponse
 
     /**

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/DefaultSendService.kt

@@ -140,11 +140,11 @@ internal class DefaultSendService @AssistedInject constructor(
                 .let { sendEvent(it) }
     }
 
-    override fun redactEvent(event: Event, reason: String?, additionalContent: Content?): Cancelable {
+    override fun redactEvent(event: Event, reason: String?, withRelations: List<String>?, additionalContent: Content?): Cancelable {
         // TODO manage media/attachements?
-        val redactionEcho = localEchoEventFactory.createRedactEvent(roomId, event.eventId!!, reason, additionalContent)
+        val redactionEcho = localEchoEventFactory.createRedactEvent(roomId, event.eventId!!, reason, withRelations, additionalContent)
                 .also { createLocalEcho(it) }
-        return eventSenderProcessor.postRedaction(redactionEcho, reason)
+        return eventSenderProcessor.postRedaction(redactionEcho, reason, withRelations)
     }
 
     override fun resendTextMessage(localEcho: TimelineEvent): Cancelable {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/LocalEchoEventFactory.kt

@@ -70,6 +70,7 @@ import org.matrix.android.sdk.api.util.TextContent
 import org.matrix.android.sdk.internal.di.UserId
 import org.matrix.android.sdk.internal.session.content.ThumbnailExtractor
 import org.matrix.android.sdk.internal.session.permalinks.PermalinkFactory
+import org.matrix.android.sdk.internal.session.room.EventRedactBody
 import org.matrix.android.sdk.internal.session.room.send.pills.TextPillsUtils
 import org.matrix.android.sdk.internal.util.time.Clock
 import java.util.UUID
@@ -795,16 +796,21 @@ internal class LocalEchoEventFactory @Inject constructor(
         }
     }
      */
-    fun createRedactEvent(roomId: String, eventId: String, reason: String?, additionalContent: Content? = null): Event {
+    fun createRedactEvent(roomId: String, eventId: String, reason: String?, withRelations: List<String>? = null, additionalContent: Content? = null): Event {
         val localId = LocalEcho.createLocalEchoId()
+        val content = if (reason != null || withRelations != null) {
+            EventRedactBody(reason, withRelations, withRelations).toContent().plus(additionalContent.orEmpty())
+        } else {
+            additionalContent
+        }
         return Event(
                 roomId = roomId,
                 originServerTs = dummyOriginServerTs(),
                 senderId = userId,
                 eventId = localId,
                 type = EventType.REDACTION,
                 redacts = eventId,
-                content = reason?.let { mapOf("reason" to it).toContent().plus(additionalContent.orEmpty()) } ?: additionalContent,
+                content = content,
                 unsignedData = UnsignedData(age = null, transactionId = localId)
         )
     }
@@ -830,10 +836,10 @@ internal class LocalEchoEventFactory @Inject constructor(
             createMessageEvent(
                     roomId,
                     textContent.toThreadTextContent(
-                                    rootThreadEventId = rootThreadEventId,
-                                    latestThreadEventId = localEchoRepository.getLatestThreadEvent(rootThreadEventId),
-                                    msgType = MessageType.MSGTYPE_TEXT
-                            ),
+                            rootThreadEventId = rootThreadEventId,
+                            latestThreadEventId = localEchoRepository.getLatestThreadEvent(rootThreadEventId),
+                            msgType = MessageType.MSGTYPE_TEXT
+                    ),
                     additionalContent,
             )
         } else {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/RedactEventWorker.kt

@@ -19,10 +19,12 @@ import android.content.Context
 import androidx.work.WorkerParameters
 import com.squareup.moshi.JsonClass
 import org.matrix.android.sdk.api.failure.Failure
+import org.matrix.android.sdk.api.session.homeserver.HomeServerCapabilitiesService
 import org.matrix.android.sdk.internal.SessionManager
 import org.matrix.android.sdk.internal.network.GlobalErrorReceiver
 import org.matrix.android.sdk.internal.network.executeRequest
 import org.matrix.android.sdk.internal.session.SessionComponent
+import org.matrix.android.sdk.internal.session.room.EventRedactBody
 import org.matrix.android.sdk.internal.session.room.RoomAPI
 import org.matrix.android.sdk.internal.worker.SessionSafeCoroutineWorker
 import org.matrix.android.sdk.internal.worker.SessionWorkerParams
@@ -43,25 +45,34 @@ internal class RedactEventWorker(context: Context, params: WorkerParameters, ses
             val roomId: String,
             val eventId: String,
             val reason: String?,
+            val withRelations: List<String>? = null,
             override val lastFailureMessage: String? = null
     ) : SessionWorkerParams
 
     @Inject lateinit var roomAPI: RoomAPI
     @Inject lateinit var globalErrorReceiver: GlobalErrorReceiver
+    @Inject lateinit var homeServerCapabilitiesService: HomeServerCapabilitiesService
 
     override fun injectWith(injector: SessionComponent) {
         injector.inject(this)
     }
 
     override suspend fun doSafeWork(params: Params): Result {
         val eventId = params.eventId
+        val withRelations = if (homeServerCapabilitiesService.getHomeServerCapabilities().canRedactEventWithRelations &&
+                !params.withRelations.isNullOrEmpty()) {
+            params.withRelations
+        } else {
+            null
+        }
+
         return runCatching {
             executeRequest(globalErrorReceiver) {
                 roomAPI.redactEvent(
                         params.txID,
                         params.roomId,
                         eventId,
-                        if (params.reason == null) emptyMap() else mapOf("reason" to params.reason)
+                        EventRedactBody(params.reason, withRelations, withRelations)
                 )
             }
         }.fold(

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/EventSenderProcessor.kt

@@ -26,9 +26,9 @@ internal interface EventSenderProcessor : SessionLifecycleObserver {
 
     fun postEvent(event: Event, encrypt: Boolean): Cancelable
 
-    fun postRedaction(redactionLocalEcho: Event, reason: String?): Cancelable
+    fun postRedaction(redactionLocalEcho: Event, reason: String?, withRelations: List<String>? = null): Cancelable
 
-    fun postRedaction(redactionLocalEchoId: String, eventToRedactId: String, roomId: String, reason: String?): Cancelable
+    fun postRedaction(redactionLocalEchoId: String, eventToRedactId: String, roomId: String, reason: String?, withRelations: List<String>? = null): Cancelable
 
     fun postTask(task: QueuedTask): Cancelable
 

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/send/queue/EventSenderProcessorCoroutine.kt

@@ -101,12 +101,18 @@ internal class EventSenderProcessorCoroutine @Inject constructor(
         return postTask(task)
     }
 
-    override fun postRedaction(redactionLocalEcho: Event, reason: String?): Cancelable {
-        return postRedaction(redactionLocalEcho.eventId!!, redactionLocalEcho.redacts!!, redactionLocalEcho.roomId!!, reason)
+    override fun postRedaction(redactionLocalEcho: Event, reason: String?, withRelations: List<String>?): Cancelable {
+        return postRedaction(redactionLocalEcho.eventId!!, redactionLocalEcho.redacts!!, redactionLocalEcho.roomId!!, reason, withRelations)
     }
 
-    override fun postRedaction(redactionLocalEchoId: String, eventToRedactId: String, roomId: String, reason: String?): Cancelable {
-        val task = queuedTaskFactory.createRedactTask(redactionLocalEchoId, eventToRedactId, roomId, reason)
+    override fun postRedaction(
+            redactionLocalEchoId: String,
+            eventToRedactId: String,
+            roomId: String,
+            reason: String?,
+            withRelations: List<String>?
+    ): Cancelable {
+        val task = queuedTaskFactory.createRedactTask(redactionLocalEchoId, eventToRedactId, roomId, reason, withRelations)
         return postTask(task)
     }