Hide Element Call entry point if Element Call service is not available. (#4783)

bmarty · ElementBot · web-flow · commit 5b9da3c41b0d · 2025-05-27T16:31:05.000+02:00
* Hide Element Call entry point if Element Call service is not available.

* No need to preview the case RoomCallState.Unavailable

* Hide start call action from user profile if Element Call is not available.

* Add mising `use` and cover the problem by a test.

* Update screenshots

* Update enterprise submodule ref.

* Ensure `enterpriseService.isElementCallAvailable()` is not called several times.
And fix unit tests on CI

---------

Co-authored-by: ElementBot &lt;android@element.io&gt;
diff --git a/enterprise b/enterprise
@@ -1 +1 @@
-Subproject commit d3dffc97bf8b39386ace2db7d857bbff05c73c18
+Subproject commit 4a07c862a23a9fd1418eabf132cf9d6b25ea4927
diff --git a/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt b/features/enterprise/api/src/main/kotlin/io/element/android/features/enterprise/api/EnterpriseService.kt
@@ -16,6 +16,8 @@ interface EnterpriseService {
     fun defaultHomeserverList(): List<String>
     suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String): Boolean
 
+    suspend fun isElementCallAvailable(): Boolean
+
     fun semanticColorsLight(): SemanticColors
     fun semanticColorsDark(): SemanticColors
 
diff --git a/features/enterprise/impl/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt b/features/enterprise/impl/src/main/kotlin/io/element/android/features/enterprise/impl/DefaultEnterpriseService.kt
@@ -25,6 +25,8 @@ class DefaultEnterpriseService @Inject constructor() : EnterpriseService {
     override fun defaultHomeserverList(): List<String> = emptyList()
     override suspend fun isAllowedToConnectToHomeserver(homeserverUrl: String) = true
 
+    override suspend fun isElementCallAvailable(): Boolean = true
+
     override fun semanticColorsLight(): SemanticColors = compoundColorsLight
 
     override fun semanticColorsDark(): SemanticColors = compoundColorsDark
diff --git a/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt b/features/enterprise/test/src/main/kotlin/io/element/android/features/enterprise/test/FakeEnterpriseService.kt
@@ -18,6 +18,7 @@ class FakeEnterpriseService(
     private val isEnterpriseUserResult: (SessionId) -> Boolean = { lambdaError() },
     private val defaultHomeserverListResult: () -> List<String> = { emptyList() },
     private val isAllowedToConnectToHomeserverResult: (String) -> Boolean = { lambdaError() },
+    private val isElementCallAvailableResult: () -> Boolean = { lambdaError() },
     private val semanticColorsLightResult: () -> SemanticColors = { lambdaError() },
     private val semanticColorsDarkResult: () -> SemanticColors = { lambdaError() },
     private val firebasePushGatewayResult: () -> String? = { lambdaError() },
@@ -35,6 +36,10 @@ class FakeEnterpriseService(
         isAllowedToConnectToHomeserverResult(homeserverUrl)
     }
 
+    override suspend fun isElementCallAvailable(): Boolean = simulateLongTask {
+        isElementCallAvailableResult()
+    }
+
     override fun semanticColorsLight(): SemanticColors {
         return semanticColorsLightResult()
     }
diff --git a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/CallMenuItem.kt b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/CallMenuItem.kt
@@ -38,6 +38,9 @@ internal fun CallMenuItem(
     modifier: Modifier = Modifier,
 ) {
     when (roomCallState) {
+        RoomCallState.Unavailable -> {
+            Box(modifier)
+        }
         is RoomCallState.StandBy -> {
             StandByCallMenuItem(
                 roomCallState = roomCallState,
diff --git a/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemCallNotifyView.kt b/features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemCallNotifyView.kt
@@ -103,17 +103,18 @@ internal fun TimelineItemCallNotifyView(
 
 @PreviewsDayNight
 @Composable
-internal fun TimelineItemCallNotifyViewPreview() {
-    ElementPreview {
-        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
-            RoomCallStateProvider().values.forEach { roomCallState ->
+internal fun TimelineItemCallNotifyViewPreview() = ElementPreview {
+    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+        RoomCallStateProvider()
+            .values
+            .filter { it !is RoomCallState.Unavailable }
+            .forEach { roomCallState ->
                 TimelineItemCallNotifyView(
                     event = aTimelineItemEvent(content = TimelineItemCallNotifyContent()),
                     roomCallState = roomCallState,
                     onLongClick = {},
                     onJoinCallClick = {},
                 )
             }
-        }
     }
 }
diff --git a/features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallState.kt b/features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallState.kt
@@ -13,6 +13,8 @@ import io.element.android.features.roomcall.api.RoomCallState.StandBy
 
 @Immutable
 sealed interface RoomCallState {
+    data object Unavailable : RoomCallState
+
     data class StandBy(
         val canStartCall: Boolean,
     ) : RoomCallState
@@ -25,6 +27,7 @@ sealed interface RoomCallState {
 }
 
 fun RoomCallState.hasPermissionToJoin() = when (this) {
+    RoomCallState.Unavailable -> false
     is StandBy -> canStartCall
     is OnGoing -> canJoinCall
 }
diff --git a/features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallStateProvider.kt b/features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallStateProvider.kt
@@ -16,6 +16,7 @@ open class RoomCallStateProvider : PreviewParameterProvider<RoomCallState> {
         anOngoingCallState(),
         anOngoingCallState(canJoinCall = false),
         anOngoingCallState(canJoinCall = true, isUserInTheCall = true),
+        RoomCallState.Unavailable,
     )
 }
 
diff --git a/features/roomcall/impl/build.gradle.kts b/features/roomcall/impl/build.gradle.kts
@@ -21,6 +21,7 @@ dependencies {
     api(projects.features.roomcall.api)
     implementation(libs.kotlinx.collections.immutable)
     implementation(projects.features.call.api)
+    implementation(projects.features.enterprise.api)
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.matrix.api)
     implementation(projects.libraries.matrixui)
@@ -32,6 +33,7 @@ dependencies {
     testImplementation(libs.test.turbine)
     testImplementation(projects.libraries.matrix.test)
     testImplementation(projects.features.call.test)
+    testImplementation(projects.features.enterprise.test)
     testImplementation(projects.tests.testutils)
     testImplementation(libs.androidx.compose.ui.test.junit)
     testReleaseImplementation(libs.androidx.compose.ui.test.manifest)
diff --git a/features/roomcall/impl/src/main/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenter.kt b/features/roomcall/impl/src/main/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenter.kt
@@ -11,9 +11,11 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
 import io.element.android.features.call.api.CurrentCall
 import io.element.android.features.call.api.CurrentCallService
+import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.roomcall.api.RoomCallState
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.matrix.api.room.JoinedRoom
@@ -23,9 +25,13 @@ import javax.inject.Inject
 class RoomCallStatePresenter @Inject constructor(
     private val room: JoinedRoom,
     private val currentCallService: CurrentCallService,
+    private val enterpriseService: EnterpriseService,
 ) : Presenter<RoomCallState> {
     @Composable
     override fun present(): RoomCallState {
+        val isAvailable by produceState(false) {
+            value = enterpriseService.isElementCallAvailable()
+        }
         val roomInfo by room.roomInfoFlow.collectAsState()
         val syncUpdateFlow = room.syncUpdateFlow.collectAsState()
         val canJoinCall by room.canCall(updateKey = syncUpdateFlow.value)
@@ -41,6 +47,7 @@ class RoomCallStatePresenter @Inject constructor(
             }
         }
         val callState = when {
+            isAvailable.not() -> RoomCallState.Unavailable
             roomInfo.hasRoomCall -> RoomCallState.OnGoing(
                 canJoinCall = canJoinCall,
                 isUserInTheCall = isUserInTheCall,
diff --git a/features/roomcall/impl/src/test/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenterTest.kt b/features/roomcall/impl/src/test/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenterTest.kt
@@ -11,6 +11,7 @@ import com.google.common.truth.Truth.assertThat
 import io.element.android.features.call.api.CurrentCall
 import io.element.android.features.call.api.CurrentCallService
 import io.element.android.features.call.test.FakeCurrentCallService
+import io.element.android.features.enterprise.test.FakeEnterpriseService
 import io.element.android.features.roomcall.api.RoomCallState
 import io.element.android.libraries.matrix.api.room.JoinedRoom
 import io.element.android.libraries.matrix.test.room.FakeBaseRoom
@@ -25,12 +26,13 @@ class RoomCallStatePresenterTest {
     @Test
     fun `present - initial state`() = runTest {
         val room = FakeJoinedRoom(
-                baseRoom = FakeBaseRoom(
+            baseRoom = FakeBaseRoom(
                 canUserJoinCallResult = { Result.success(false) },
             )
         )
         val presenter = createRoomCallStatePresenter(joinedRoom = room)
         presenter.test {
+            skipItems(1)
             val initialState = awaitItem()
             assertThat(initialState).isEqualTo(
                 RoomCallState.StandBy(
@@ -40,10 +42,29 @@ class RoomCallStatePresenterTest {
         }
     }
 
+    @Test
+    fun `present - element call not available`() = runTest {
+        val room = FakeJoinedRoom(
+            baseRoom = FakeBaseRoom(
+                canUserJoinCallResult = { Result.success(false) },
+            )
+        )
+        val presenter = createRoomCallStatePresenter(
+            joinedRoom = room,
+            isElementCallAvailable = false,
+        )
+        presenter.test {
+            val initialState = awaitItem()
+            assertThat(initialState).isEqualTo(
+                RoomCallState.Unavailable
+            )
+        }
+    }
+
     @Test
     fun `present - initial state - user can join call`() = runTest {
         val room = FakeJoinedRoom(
-                baseRoom = FakeBaseRoom(
+            baseRoom = FakeBaseRoom(
                 canUserJoinCallResult = { Result.success(true) },
             )
         )
@@ -69,6 +90,7 @@ class RoomCallStatePresenterTest {
         )
         val presenter = createRoomCallStatePresenter(joinedRoom = room)
         presenter.test {
+            skipItems(1)
             assertThat(awaitItem()).isEqualTo(
                 RoomCallState.OnGoing(
                     canJoinCall = false,
@@ -83,15 +105,15 @@ class RoomCallStatePresenterTest {
     fun `present - user has joined the call on another session`() = runTest {
         val room = FakeJoinedRoom(
             baseRoom = FakeBaseRoom(
-            canUserJoinCallResult = { Result.success(true) },
-        ).apply {
-            givenRoomInfo(
-                aRoomInfo(
-                    hasRoomCall = true,
-                    activeRoomCallParticipants = listOf(sessionId),
+                canUserJoinCallResult = { Result.success(true) },
+            ).apply {
+                givenRoomInfo(
+                    aRoomInfo(
+                        hasRoomCall = true,
+                        activeRoomCallParticipants = listOf(sessionId),
+                    )
                 )
-            )
-        }
+            }
         )
         val presenter = createRoomCallStatePresenter(joinedRoom = room)
         presenter.test {
@@ -110,15 +132,15 @@ class RoomCallStatePresenterTest {
     fun `present - user has joined the call locally`() = runTest {
         val room = FakeJoinedRoom(
             baseRoom = FakeBaseRoom(
-            canUserJoinCallResult = { Result.success(true) },
-        ).apply {
-            givenRoomInfo(
-                aRoomInfo(
-                    hasRoomCall = true,
-                    activeRoomCallParticipants = listOf(sessionId),
+                canUserJoinCallResult = { Result.success(true) },
+            ).apply {
+                givenRoomInfo(
+                    aRoomInfo(
+                        hasRoomCall = true,
+                        activeRoomCallParticipants = listOf(sessionId),
+                    )
                 )
-            )
-        }
+            }
         )
         val presenter = createRoomCallStatePresenter(
             joinedRoom = room,
@@ -140,15 +162,15 @@ class RoomCallStatePresenterTest {
     fun `present - user leaves the call`() = runTest {
         val room = FakeJoinedRoom(
             baseRoom = FakeBaseRoom(
-            canUserJoinCallResult = { Result.success(true) },
-        ).apply {
-            givenRoomInfo(
-                aRoomInfo(
-                    hasRoomCall = true,
-                    activeRoomCallParticipants = listOf(sessionId),
+                canUserJoinCallResult = { Result.success(true) },
+            ).apply {
+                givenRoomInfo(
+                    aRoomInfo(
+                        hasRoomCall = true,
+                        activeRoomCallParticipants = listOf(sessionId),
+                    )
                 )
-            )
-        }
+            }
         )
         val currentCall = MutableStateFlow<CurrentCall>(CurrentCall.RoomCall(room.roomId))
         val currentCallService = FakeCurrentCallService(currentCall = currentCall)
@@ -203,10 +225,14 @@ class RoomCallStatePresenterTest {
     private fun createRoomCallStatePresenter(
         joinedRoom: JoinedRoom,
         currentCallService: CurrentCallService = FakeCurrentCallService(),
+        isElementCallAvailable: Boolean = true,
     ): RoomCallStatePresenter {
         return RoomCallStatePresenter(
             room = joinedRoom,
             currentCallService = currentCallService,
+            enterpriseService = FakeEnterpriseService(
+                isElementCallAvailableResult = { isElementCallAvailable },
+            ),
         )
     }
 }
diff --git a/features/userprofile/impl/build.gradle.kts b/features/userprofile/impl/build.gradle.kts
@@ -33,6 +33,7 @@ dependencies {
     implementation(projects.libraries.androidutils)
     implementation(projects.libraries.mediaviewer.api)
     implementation(projects.features.call.api)
+    implementation(projects.features.enterprise.api)
     implementation(projects.features.verifysession.api)
     api(projects.features.userprofile.api)
     api(projects.features.userprofile.shared)
@@ -49,6 +50,7 @@ dependencies {
     testImplementation(libs.test.robolectric)
     testImplementation(projects.libraries.matrix.test)
     testImplementation(projects.features.createroom.test)
+    testImplementation(projects.features.enterprise.test)
     testImplementation(projects.tests.testutils)
     testImplementation(libs.androidx.compose.ui.test.junit)
     testReleaseImplementation(libs.androidx.compose.ui.test.manifest)
diff --git a/features/userprofile/impl/src/main/kotlin/io/element/android/features/userprofile/impl/root/UserProfilePresenter.kt b/features/userprofile/impl/src/main/kotlin/io/element/android/features/userprofile/impl/root/UserProfilePresenter.kt
@@ -21,6 +21,7 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
 import io.element.android.features.createroom.api.StartDMAction
+import io.element.android.features.enterprise.api.EnterpriseService
 import io.element.android.features.userprofile.api.UserProfileEvents
 import io.element.android.features.userprofile.api.UserProfileState
 import io.element.android.features.userprofile.api.UserProfileState.ConfirmationDialog
@@ -44,6 +45,7 @@ class UserProfilePresenter @AssistedInject constructor(
     @Assisted private val userId: UserId,
     private val client: MatrixClient,
     private val startDMAction: StartDMAction,
+    private val enterpriseService: EnterpriseService,
 ) : Presenter<UserProfileState> {
     @AssistedFactory
     interface Factory {
@@ -59,11 +61,21 @@ class UserProfilePresenter @AssistedInject constructor(
 
     @Composable
     private fun getCanCall(roomId: RoomId?): State<Boolean> {
-        return produceState(initialValue = false, roomId) {
-            value = if (client.isMe(userId)) {
-                false
-            } else {
-                roomId?.let { client.getRoom(it)?.canUserJoinCall(client.sessionId)?.getOrNull() == true }.orFalse()
+        val isElementCallAvailable by produceState(initialValue = false, roomId) {
+            value = enterpriseService.isElementCallAvailable()
+        }
+
+        return produceState(initialValue = false, isElementCallAvailable, roomId) {
+            value = when {
+                isElementCallAvailable.not() -> false
+                client.isMe(userId) -> false
+                else ->
+                    roomId
+                        ?.let { client.getRoom(it) }
+                        ?.use { room ->
+                            room.canUserJoinCall(client.sessionId).getOrNull()
+                        }
+                        .orFalse()
             }
         }
     }
diff --git a/features/userprofile/impl/src/test/kotlin/io/element/android/features/userprofile/impl/UserProfilePresenterTest.kt b/features/userprofile/impl/src/test/kotlin/io/element/android/features/userprofile/impl/UserProfilePresenterTest.kt
diff --git a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/FakeBaseRoom.kt b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/room/FakeBaseRoom.kt
diff --git a/tests/uitests/src/test/snapshots/images/features.messages.impl.timeline.components_CallMenuItem_Day_5_en.png b/tests/uitests/src/test/snapshots/images/features.messages.impl.timeline.components_CallMenuItem_Day_5_en.png
diff --git a/tests/uitests/src/test/snapshots/images/features.messages.impl.timeline.components_CallMenuItem_Night_5_en.png b/tests/uitests/src/test/snapshots/images/features.messages.impl.timeline.components_CallMenuItem_Night_5_en.png

Original file line number	Diff line number	Diff line change
`@@ -103,17 +103,18 @@ internal fun TimelineItemCallNotifyView(`
`103`	`103`
`104`	`104`	`@PreviewsDayNight`
`105`	`105`	`@Composable`
`106`		`-internal fun TimelineItemCallNotifyViewPreview() {`
`107`		`- ElementPreview {`
`108`		`- Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {`
`109`		`- RoomCallStateProvider().values.forEach { roomCallState ->`
	`106`	`+internal fun TimelineItemCallNotifyViewPreview() = ElementPreview {`
	`107`	`+ Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {`
	`108`	`+ RoomCallStateProvider()`
	`109`	`+ .values`
	`110`	`+ .filter { it !is RoomCallState.Unavailable }`
	`111`	`+ .forEach { roomCallState ->`
`110`	`112`	`TimelineItemCallNotifyView(`
`111`	`113`	`event = aTimelineItemEvent(content = TimelineItemCallNotifyContent()),`
`112`	`114`	`roomCallState = roomCallState,`
`113`	`115`	`onLongClick = {},`
`114`	`116`	`onJoinCallClick = {},`
`115`	`117`	`)`
`116`	`118`	`}`
`117`		`- }`
`118`	`119`	`}`
`119`	`120`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,8 @@ import io.element.android.features.roomcall.api.RoomCallState.StandBy`
`13`	`13`
`14`	`14`	`@Immutable`
`15`	`15`	`sealed interface RoomCallState {`
	`16`	`+ data object Unavailable : RoomCallState`
	`17`	`+`
`16`	`18`	`data class StandBy(`
`17`	`19`	`val canStartCall: Boolean,`
`18`	`20`	`) : RoomCallState`
`@@ -25,6 +27,7 @@ sealed interface RoomCallState {`
`25`	`27`	`}`
`26`	`28`
`27`	`29`	`fun RoomCallState.hasPermissionToJoin() = when (this) {`
	`30`	`+ RoomCallState.Unavailable -> false`
`28`	`31`	`is StandBy -> canStartCall`
`29`	`32`	`is OnGoing -> canJoinCall`
`30`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ open class RoomCallStateProvider : PreviewParameterProvider<RoomCallState> {`
`16`	`16`	`anOngoingCallState(),`
`17`	`17`	`anOngoingCallState(canJoinCall = false),`
`18`	`18`	`anOngoingCallState(canJoinCall = true, isUserInTheCall = true),`
	`19`	`+ RoomCallState.Unavailable,`
`19`	`20`	`)`
`20`	`21`	`}`
`21`	`22`