Add analytic events to room moderation (#2553)

* Add analytic events to room moderation

* Fix typo and tests

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/analytics/AnalyticUtils.kt

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * 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 io.element.android.features.roomdetails.impl.analytics
+
+import im.vector.app.features.analytics.plan.RoomModeration
+import io.element.android.libraries.matrix.api.room.RoomMember
+import io.element.android.libraries.matrix.api.room.powerlevels.MatrixRoomPowerLevels
+import io.element.android.services.analytics.api.AnalyticsService
+
+internal fun RoomMember.Role.toAnalyticsMemberRole(): RoomModeration.Role = when (this) {
+    RoomMember.Role.ADMIN -> RoomModeration.Role.Administrator
+    RoomMember.Role.MODERATOR -> RoomModeration.Role.Moderator
+    RoomMember.Role.USER -> RoomModeration.Role.User
+}
+
+internal fun analyticsMemberRoleForPowerLevel(powerLevel: Long): RoomModeration.Role {
+    return RoomMember.Role.forPowerLevel(powerLevel).toAnalyticsMemberRole()
+}
+
+internal fun AnalyticsService.trackPermissionChangeAnalytics(initial: MatrixRoomPowerLevels?, updated: MatrixRoomPowerLevels) {
+    if (updated.ban != initial?.ban) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsBanMembers, analyticsMemberRoleForPowerLevel(updated.ban)))
+    }
+    if (updated.invite != initial?.invite) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsInviteUsers, analyticsMemberRoleForPowerLevel(updated.invite)))
+    }
+    if (updated.kick != initial?.kick) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsKickMembers, analyticsMemberRoleForPowerLevel(updated.kick)))
+    }
+    if (updated.sendEvents != initial?.sendEvents) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsSendMessages, analyticsMemberRoleForPowerLevel(updated.sendEvents)))
+    }
+    if (updated.redactEvents != initial?.redactEvents) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsRedactMessages, analyticsMemberRoleForPowerLevel(updated.redactEvents)))
+    }
+    if (updated.roomName != initial?.roomName) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsRoomName, analyticsMemberRoleForPowerLevel(updated.roomName)))
+    }
+    if (updated.roomAvatar != initial?.roomAvatar) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsRoomAvatar, analyticsMemberRoleForPowerLevel(updated.roomAvatar)))
+    }
+    if (updated.roomTopic != initial?.roomTopic) {
+        capture(RoomModeration(RoomModeration.Action.ChangePermissionsRoomTopic, analyticsMemberRoleForPowerLevel(updated.roomTopic)))
+    }
+}

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/moderation/DefaultRoomMembersModerationPresenter.kt

@@ -25,6 +25,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import com.squareup.anvil.annotations.ContributesBinding
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.runUpdatingState
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
@@ -38,6 +39,7 @@ import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.RoomMembershipState
 import io.element.android.libraries.matrix.api.room.powerlevels.canBan
 import io.element.android.libraries.matrix.api.room.powerlevels.canKick
+import io.element.android.services.analytics.api.AnalyticsService
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.CoroutineScope
@@ -51,6 +53,7 @@ class DefaultRoomMembersModerationPresenter @Inject constructor(
     private val room: MatrixRoom,
     private val featureFlagService: FeatureFlagService,
     private val dispatchers: CoroutineDispatchers,
+    private val analyticsService: AnalyticsService,
 ) : RoomMembersModerationPresenter {
     private var selectedMember by mutableStateOf<RoomMember?>(null)
 
@@ -150,6 +153,7 @@ class DefaultRoomMembersModerationPresenter @Inject constructor(
         userId: UserId,
         kickUserAction: MutableState<AsyncAction<Unit>>,
     ) = runActionAndWaitForMembershipChange(kickUserAction) {
+        analyticsService.capture(RoomModeration(RoomModeration.Action.KickMember))
         room.kickUser(userId).finally { selectedMember = null }
     }
 
@@ -157,6 +161,7 @@ class DefaultRoomMembersModerationPresenter @Inject constructor(
         userId: UserId,
         banUserAction: MutableState<AsyncAction<Unit>>,
     ) = runActionAndWaitForMembershipChange(banUserAction) {
+        analyticsService.capture(RoomModeration(RoomModeration.Action.BanMember))
         room.banUser(userId).finally { selectedMember = null }
     }
 
@@ -164,6 +169,7 @@ class DefaultRoomMembersModerationPresenter @Inject constructor(
         userId: UserId,
         unbanUserAction: MutableState<AsyncAction<Unit>>,
     ) = runActionAndWaitForMembershipChange(unbanUserAction) {
+        analyticsService.capture(RoomModeration(RoomModeration.Action.UnbanMember))
         room.unbanUser(userId).finally { selectedMember = null }
     }
 

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/RolesAndPermissionsPresenter.kt

@@ -24,6 +24,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runUpdatingState
@@ -32,6 +33,7 @@ import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.MatrixRoomInfo
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.powerlevels.UserRoleChange
+import io.element.android.services.analytics.api.AnalyticsService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -39,6 +41,7 @@ import javax.inject.Inject
 class RolesAndPermissionsPresenter @Inject constructor(
     private val room: MatrixRoom,
     private val dispatchers: CoroutineDispatchers,
+    private val analyticsService: AnalyticsService,
 ) : Presenter<RolesAndPermissionsState> {
     @Composable
     override fun present(): RolesAndPermissionsState {
@@ -100,6 +103,7 @@ class RolesAndPermissionsPresenter @Inject constructor(
         resetPermissionsAction: MutableState<AsyncAction<Unit>>,
     ) = launch(dispatchers.io) {
         runUpdatingState(resetPermissionsAction) {
+            analyticsService.capture(RoomModeration(RoomModeration.Action.ResetPermissions))
             room.resetPowerLevels().map {}
         }
     }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/changeroles/ChangeRolesPresenter.kt

@@ -30,6 +30,8 @@ import androidx.compose.runtime.setValue
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.RoomModeration
+import io.element.android.features.roomdetails.impl.analytics.toAnalyticsMemberRole
 import io.element.android.features.roomdetails.impl.members.PowerLevelRoomMemberComparator
 import io.element.android.features.roomdetails.impl.members.RoomMemberListDataSource
 import io.element.android.libraries.architecture.AsyncAction
@@ -41,6 +43,7 @@ import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.powerlevels.UserRoleChange
 import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.services.analytics.api.AnalyticsService
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.persistentListOf
@@ -56,6 +59,7 @@ class ChangeRolesPresenter @AssistedInject constructor(
     @Assisted private val role: RoomMember.Role,
     private val room: MatrixRoom,
     private val dispatchers: CoroutineDispatchers,
+    private val analyticsService: AnalyticsService,
 ) : Presenter<ChangeRolesState> {
     @AssistedFactory
     interface Factory {
@@ -197,9 +201,11 @@ class ChangeRolesPresenter @AssistedInject constructor(
 
         val changes: List<UserRoleChange> = buildList {
             for (selectedUser in toAdd) {
+                analyticsService.capture(RoomModeration(RoomModeration.Action.ChangeMemberRole, role.toAnalyticsMemberRole()))
                 add(UserRoleChange(selectedUser.userId, role))
             }
             for (selectedUser in toRemove) {
+                analyticsService.capture(RoomModeration(RoomModeration.Action.ChangeMemberRole, RoomModeration.Role.User))
                 add(UserRoleChange(selectedUser.userId, RoomMember.Role.USER))
             }
         }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/rolesandpermissions/permissions/ChangeRoomPermissionsPresenter.kt

@@ -27,10 +27,12 @@ import androidx.compose.runtime.setValue
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
+import io.element.android.features.roomdetails.impl.analytics.trackPermissionChangeAnalytics
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.powerlevels.MatrixRoomPowerLevels
+import io.element.android.services.analytics.api.AnalyticsService
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.CoroutineScope
@@ -39,6 +41,7 @@ import kotlinx.coroutines.launch
 class ChangeRoomPermissionsPresenter @AssistedInject constructor(
     @Assisted private val section: ChangeRoomPermissionsSection,
     private val room: MatrixRoom,
+    private val analyticsService: AnalyticsService,
 ) : Presenter<ChangeRoomPermissionsState> {
     companion object {
         internal fun itemsForSection(section: ChangeRoomPermissionsSection) = when (section) {
@@ -135,6 +138,7 @@ class ChangeRoomPermissionsPresenter @AssistedInject constructor(
         }
         room.updatePowerLevels(updatedRoomPowerLevels)
             .onSuccess {
+                analyticsService.trackPermissionChangeAnalytics(initialPermissions, updatedRoomPowerLevels)
                 initialPermissions = currentPermissions
                 saveAction = AsyncAction.Success(Unit)
             }

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/members/moderation/DefaultRoomMembersModerationPresenterTests.kt

@@ -20,6 +20,7 @@ import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.features.roomdetails.impl.members.aRoomMember
 import io.element.android.features.roomdetails.impl.members.aVictor
 import io.element.android.features.roomdetails.impl.members.moderation.DefaultRoomMembersModerationPresenter
@@ -36,6 +37,7 @@ import io.element.android.libraries.matrix.test.A_USER_ID
 import io.element.android.libraries.matrix.test.A_USER_ID_2
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.aRoomInfo
+import io.element.android.services.analytics.test.FakeAnalyticsService
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.test.TestScope
@@ -150,13 +152,14 @@ class DefaultRoomMembersModerationPresenterTests {
 
     @Test
     fun `present - Kick removes the user`() = runTest {
+        val analyticsService = FakeAnalyticsService()
         val room = FakeMatrixRoom().apply {
             givenCanKickResult(Result.success(true))
             givenCanBanResult(Result.success(true))
             givenUserRoleResult(Result.success(RoomMember.Role.ADMIN))
         }
         val selectedMember = aVictor()
-        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room)
+        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room, analyticsService = analyticsService)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -170,18 +173,20 @@ class DefaultRoomMembersModerationPresenterTests {
                 assertThat(kickUserAsyncAction).isEqualTo(AsyncAction.Success(Unit))
                 assertThat(selectedRoomMember).isNull()
             }
+            assertThat(analyticsService.capturedEvents.last()).isEqualTo(RoomModeration(RoomModeration.Action.KickMember))
         }
     }
 
     @Test
     fun `present - BanUser requires confirmation and then bans the user`() = runTest {
+        val analyticsService = FakeAnalyticsService()
         val room = FakeMatrixRoom().apply {
             givenCanKickResult(Result.success(true))
             givenCanBanResult(Result.success(true))
             givenUserRoleResult(Result.success(RoomMember.Role.ADMIN))
         }
         val selectedMember = aVictor()
-        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room)
+        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room, analyticsService = analyticsService)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -200,11 +205,13 @@ class DefaultRoomMembersModerationPresenterTests {
                 assertThat(banUserAsyncAction).isEqualTo(AsyncAction.Success(Unit))
                 assertThat(selectedRoomMember).isNull()
             }
+            assertThat(analyticsService.capturedEvents.last()).isEqualTo(RoomModeration(RoomModeration.Action.BanMember))
         }
     }
 
     @Test
     fun `present - UnbanUser requires confirmation and then unbans the user`() = runTest {
+        val analyticsService = FakeAnalyticsService()
         val selectedMember = aRoomMember(A_USER_ID_2, membership = RoomMembershipState.BAN)
         val room = FakeMatrixRoom().apply {
             givenCanKickResult(Result.success(true))
@@ -212,7 +219,7 @@ class DefaultRoomMembersModerationPresenterTests {
             givenRoomMembersState(MatrixRoomMembersState.Ready(persistentListOf(selectedMember)))
             givenUserRoleResult(Result.success(RoomMember.Role.ADMIN))
         }
-        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room)
+        val presenter = createDefaultRoomMembersModerationPresenter(matrixRoom = room, analyticsService = analyticsService)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -227,6 +234,7 @@ class DefaultRoomMembersModerationPresenterTests {
                 assertThat(unbanUserAsyncAction).isEqualTo(AsyncAction.Success(Unit))
                 assertThat(selectedRoomMember).isNull()
             }
+            assertThat(analyticsService.capturedEvents.last()).isEqualTo(RoomModeration(RoomModeration.Action.UnbanMember))
         }
     }
 
@@ -303,11 +311,13 @@ class DefaultRoomMembersModerationPresenterTests {
         matrixRoom: FakeMatrixRoom = FakeMatrixRoom(),
         featureFlagService: FakeFeatureFlagService = FakeFeatureFlagService(initialState = mapOf(FeatureFlags.RoomModeration.key to true)),
         dispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+        analyticsService: FakeAnalyticsService = FakeAnalyticsService(),
     ): DefaultRoomMembersModerationPresenter {
         return DefaultRoomMembersModerationPresenter(
             room = matrixRoom,
             featureFlagService = featureFlagService,
             dispatchers = dispatchers,
+            analyticsService = analyticsService,
         )
     }
 }

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/rolesandpermissions/RolesAndPermissionPresenterTests.kt

@@ -20,12 +20,14 @@ import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.features.roomdetails.impl.rolesandpermissions.RolesAndPermissionsEvents
 import io.element.android.features.roomdetails.impl.rolesandpermissions.RolesAndPermissionsPresenter
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import io.element.android.services.analytics.test.FakeAnalyticsService
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.StandardTestDispatcher
@@ -120,7 +122,8 @@ class RolesAndPermissionPresenterTests {
 
     @Test
     fun `present - ResetPermissions needs confirmation, then resets permissions`() = runTest {
-        val presenter = createRolesAndPermissionsPresenter()
+        val analyticsService = FakeAnalyticsService()
+        val presenter = createRolesAndPermissionsPresenter(analyticsService = analyticsService)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -131,6 +134,7 @@ class RolesAndPermissionPresenterTests {
 
             assertThat(awaitItem().resetPermissionsAction).isEqualTo(AsyncAction.Loading)
             assertThat(awaitItem().resetPermissionsAction).isEqualTo(AsyncAction.Success(Unit))
+            assertThat(analyticsService.capturedEvents.last()).isEqualTo(RoomModeration(RoomModeration.Action.ResetPermissions))
         }
     }
 
@@ -151,7 +155,12 @@ class RolesAndPermissionPresenterTests {
     private fun TestScope.createRolesAndPermissionsPresenter(
         room: FakeMatrixRoom = FakeMatrixRoom(),
         dispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+        analyticsService: FakeAnalyticsService = FakeAnalyticsService()
     ): RolesAndPermissionsPresenter {
-        return RolesAndPermissionsPresenter(room = room, dispatchers = dispatchers)
+        return RolesAndPermissionsPresenter(
+            room = room,
+            dispatchers = dispatchers,
+            analyticsService = analyticsService
+        )
     }
 }

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/rolesandpermissions/changeroles/ChangeRolesPresenterTests.kt

@@ -20,6 +20,7 @@ import app.cash.molecule.RecompositionMode
 import app.cash.molecule.moleculeFlow
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.features.roomdetails.impl.members.aRoomMember
 import io.element.android.features.roomdetails.impl.members.aRoomMemberList
 import io.element.android.features.roomdetails.impl.rolesandpermissions.changeroles.ChangeRolesEvent
@@ -33,6 +34,7 @@ import io.element.android.libraries.matrix.test.A_USER_ID
 import io.element.android.libraries.matrix.test.A_USER_ID_2
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.aRoomInfo
+import io.element.android.services.analytics.test.FakeAnalyticsService
 import io.element.android.tests.testutils.testCoroutineDispatchers
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.toPersistentList
@@ -315,11 +317,16 @@ class ChangeRolesPresenterTests {
 
     @Test
     fun `present - Save will just save the data for moderators`() = runTest {
+        val analyticsService = FakeAnalyticsService()
         val room = FakeMatrixRoom().apply {
             givenRoomMembersState(MatrixRoomMembersState.Ready(aRoomMemberList()))
             givenRoomInfo(aRoomInfo(userPowerLevels = persistentMapOf(A_USER_ID to 50)))
         }
-        val presenter = createChangeRolesPresenter(role = RoomMember.Role.MODERATOR, room = room)
+        val presenter = createChangeRolesPresenter(
+            role = RoomMember.Role.MODERATOR,
+            room = room,
+            analyticsService = analyticsService
+        )
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -331,6 +338,7 @@ class ChangeRolesPresenterTests {
 
             awaitItem().eventSink(ChangeRolesEvent.Save)
             assertThat(awaitItem().savingState).isEqualTo(AsyncAction.Success(Unit))
+            assertThat(analyticsService.capturedEvents.last()).isEqualTo(RoomModeration(RoomModeration.Action.ChangeMemberRole, RoomModeration.Role.Moderator))
         }
     }
 
@@ -364,11 +372,13 @@ class ChangeRolesPresenterTests {
         role: RoomMember.Role = RoomMember.Role.ADMIN,
         room: FakeMatrixRoom = FakeMatrixRoom(),
         dispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+        analyticsService: FakeAnalyticsService = FakeAnalyticsService(),
     ): ChangeRolesPresenter {
         return ChangeRolesPresenter(
             role = role,
             room = room,
             dispatchers = dispatchers,
+            analyticsService = analyticsService,
         )
     }
 }

features/roomdetails/impl/src/test/kotlin/io/element/android/features/roomdetails/rolesandpermissions/permissions/ChangeRoomPermissionsPresenterTests.kt

@@ -22,6 +22,7 @@ import app.cash.turbine.Event
 import app.cash.turbine.TurbineTestContext
 import app.cash.turbine.test
 import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.RoomModeration
 import io.element.android.features.roomdetails.impl.rolesandpermissions.permissions.ChangeRoomPermissionsEvent
 import io.element.android.features.roomdetails.impl.rolesandpermissions.permissions.ChangeRoomPermissionsPresenter
 import io.element.android.features.roomdetails.impl.rolesandpermissions.permissions.ChangeRoomPermissionsSection
@@ -30,9 +31,11 @@ import io.element.android.features.roomdetails.impl.rolesandpermissions.permissi
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.matrix.api.room.RoomMember.Role.ADMIN
 import io.element.android.libraries.matrix.api.room.RoomMember.Role.MODERATOR
+import io.element.android.libraries.matrix.api.room.RoomMember.Role.USER
 import io.element.android.libraries.matrix.api.room.powerlevels.MatrixRoomPowerLevels
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.defaultRoomPowerLevels
+import io.element.android.services.analytics.test.FakeAnalyticsService
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 
@@ -160,7 +163,8 @@ class ChangeRoomPermissionsPresenterTests {
 
     @Test
     fun `present - Save updates the current permissions and resets hasChanges`() = runTest {
-        val presenter = createChangeRoomPermissionsPresenter()
+        val analyticsService = FakeAnalyticsService()
+        val presenter = createChangeRoomPermissionsPresenter(analyticsService = analyticsService)
         moleculeFlow(RecompositionMode.Immediate) {
             presenter.present()
         }.test {
@@ -169,6 +173,14 @@ class ChangeRoomPermissionsPresenterTests {
             assertThat(state.hasChanges).isFalse()
 
             state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.ROOM_NAME, MODERATOR))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.ROOM_AVATAR, MODERATOR))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.ROOM_TOPIC, MODERATOR))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.SEND_EVENTS, MODERATOR))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.REDACT_EVENTS, USER))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.KICK, ADMIN))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.BAN, ADMIN))
+            state.eventSink(ChangeRoomPermissionsEvent.ChangeMinimumRoleForAction(RoomPermissionType.INVITE, ADMIN))
+            skipItems(7)
             assertThat(awaitItem().hasChanges).isTrue()
 
             state.eventSink(ChangeRoomPermissionsEvent.Save)
@@ -179,6 +191,18 @@ class ChangeRoomPermissionsPresenterTests {
                 assertThat(currentPermissions?.roomName).isEqualTo(MODERATOR.powerLevel)
                 assertThat(saveAction).isEqualTo(AsyncAction.Success(Unit))
             }
+            assertThat(analyticsService.capturedEvents).containsExactlyElementsIn(
+                listOf(
+                    RoomModeration(RoomModeration.Action.ChangePermissionsRoomName, RoomModeration.Role.Moderator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsRoomAvatar, RoomModeration.Role.Moderator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsRoomTopic, RoomModeration.Role.Moderator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsSendMessages, RoomModeration.Role.Moderator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsRedactMessages, RoomModeration.Role.User),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsKickMembers, RoomModeration.Role.Administrator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsBanMembers, RoomModeration.Role.Administrator),
+                    RoomModeration(RoomModeration.Action.ChangePermissionsInviteUsers, RoomModeration.Role.Administrator),
+                )
+            )
         }
     }
 
@@ -269,9 +293,11 @@ class ChangeRoomPermissionsPresenterTests {
     private fun createChangeRoomPermissionsPresenter(
         section: ChangeRoomPermissionsSection = ChangeRoomPermissionsSection.RoomDetails,
         room: FakeMatrixRoom = FakeMatrixRoom(),
+        analyticsService: FakeAnalyticsService = FakeAnalyticsService(),
     ) = ChangeRoomPermissionsPresenter(
         section = section,
         room = room,
+        analyticsService = analyticsService,
     )
 
     private fun defaultPermissions() = defaultRoomPowerLevels().run {