First Commit

features/roomcall/api/build.gradle.kts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.roomcall.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+}

features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallState.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.roomcall.api
+
+import androidx.compose.runtime.Immutable
+import io.element.android.features.roomcall.api.RoomCallState.OnGoing
+import io.element.android.features.roomcall.api.RoomCallState.StandBy
+
+@Immutable
+sealed interface RoomCallState {
+    data object Unavailable : RoomCallState
+
+    data class StandBy(
+        val canStartCall: Boolean,
+    ) : RoomCallState
+
+    data class OnGoing(
+        val canJoinCall: Boolean,
+        val isUserInTheCall: Boolean,
+        val isUserLocallyInTheCall: Boolean,
+    ) : RoomCallState
+}
+
+fun RoomCallState.hasPermissionToJoin() = when (this) {
+    RoomCallState.Unavailable -> false
+    is StandBy -> canStartCall
+    is OnGoing -> canJoinCall
+}

features/roomcall/api/src/main/kotlin/io/element/android/features/roomcall/api/RoomCallStateProvider.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.roomcall.api
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class RoomCallStateProvider : PreviewParameterProvider<RoomCallState> {
+    override val values: Sequence<RoomCallState> = sequenceOf(
+        aStandByCallState(),
+        aStandByCallState(canStartCall = false),
+        anOngoingCallState(),
+        anOngoingCallState(canJoinCall = false),
+        anOngoingCallState(canJoinCall = true, isUserInTheCall = true),
+        RoomCallState.Unavailable,
+    )
+}
+
+fun anOngoingCallState(
+    canJoinCall: Boolean = true,
+    isUserInTheCall: Boolean = false,
+    isUserLocallyInTheCall: Boolean = isUserInTheCall,
+) = RoomCallState.OnGoing(
+    canJoinCall = canJoinCall,
+    isUserInTheCall = isUserInTheCall,
+    isUserLocallyInTheCall = isUserLocallyInTheCall,
+)
+
+fun aStandByCallState(
+    canStartCall: Boolean = true,
+) = RoomCallState.StandBy(
+    canStartCall = canStartCall,
+)

features/roomcall/impl/build.gradle.kts

@@ -0,0 +1,35 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+}
+
+android {
+    namespace = "io.element.android.features.roomcall.impl"
+}
+
+setupDependencyInjection()
+
+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)
+
+    testCommonDependencies(libs, true)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.features.call.test)
+    testImplementation(projects.features.enterprise.test)
+}

features/roomcall/impl/src/main/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenter.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.roomcall.impl
+
+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 dev.zacsweers.metro.Inject
+import io.element.android.features.call.api.CurrentCall
+import io.element.android.features.call.api.CurrentCallService
+import io.element.android.features.enterprise.api.SessionEnterpriseService
+import io.element.android.features.roomcall.api.RoomCallState
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import io.element.android.libraries.matrix.ui.room.canCall
+
+@Inject
+class RoomCallStatePresenter(
+    private val room: JoinedRoom,
+    private val currentCallService: CurrentCallService,
+    private val sessionEnterpriseService: SessionEnterpriseService,
+) : Presenter<RoomCallState> {
+    @Composable
+    override fun present(): RoomCallState {
+        val isAvailable by produceState(false) {
+            value = sessionEnterpriseService.isElementCallAvailable()
+        }
+        val roomInfo by room.roomInfoFlow.collectAsState()
+        val syncUpdateFlow = room.syncUpdateFlow.collectAsState()
+        val canJoinCall by room.canCall(updateKey = syncUpdateFlow.value)
+        val isUserInTheCall by remember {
+            derivedStateOf {
+                room.sessionId in roomInfo.activeRoomCallParticipants
+            }
+        }
+        val currentCall by currentCallService.currentCall.collectAsState()
+        val isUserLocallyInTheCall by remember {
+            derivedStateOf {
+                (currentCall as? CurrentCall.RoomCall)?.roomId == room.roomId
+            }
+        }
+        val callState by remember {
+            derivedStateOf {
+                when {
+                    isAvailable.not() -> RoomCallState.Unavailable
+                    roomInfo.hasRoomCall -> RoomCallState.OnGoing(
+                        canJoinCall = canJoinCall,
+                        isUserInTheCall = isUserInTheCall,
+                        isUserLocallyInTheCall = isUserLocallyInTheCall,
+                    )
+                    else -> RoomCallState.StandBy(canStartCall = canJoinCall)
+                }
+            }
+        }
+        return callState
+    }
+}

features/roomcall/impl/src/main/kotlin/io/element/android/features/roomcall/impl/di/RoomCallModule.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.roomcall.impl.di
+
+import dev.zacsweers.metro.BindingContainer
+import dev.zacsweers.metro.Binds
+import dev.zacsweers.metro.ContributesTo
+import io.element.android.features.roomcall.api.RoomCallState
+import io.element.android.features.roomcall.impl.RoomCallStatePresenter
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.di.RoomScope
+
+@ContributesTo(RoomScope::class)
+@BindingContainer
+interface RoomCallModule {
+    @Binds
+    fun bindRoomCallStatePresenter(presenter: RoomCallStatePresenter): Presenter<RoomCallState>
+}

features/roomcall/impl/src/test/kotlin/io/element/android/features/roomcall/impl/RoomCallStatePresenterTest.kt

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.features.roomcall.impl
+
+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.FakeSessionEnterpriseService
+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
+import io.element.android.libraries.matrix.test.room.FakeJoinedRoom
+import io.element.android.libraries.matrix.test.room.aRoomInfo
+import io.element.android.tests.testutils.test
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class RoomCallStatePresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val room = FakeJoinedRoom(
+            baseRoom = FakeBaseRoom(
+                canUserJoinCallResult = { Result.success(false) },
+            )
+        )
+        val presenter = createRoomCallStatePresenter(joinedRoom = room)
+        presenter.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState).isEqualTo(
+                RoomCallState.StandBy(
+                    canStartCall = false,
+                )
+            )
+        }
+    }
+
+    @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(
+                canUserJoinCallResult = { Result.success(true) },
+            )
+        )
+        val presenter = createRoomCallStatePresenter(joinedRoom = room)
+        presenter.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState).isEqualTo(
+                RoomCallState.StandBy(
+                    canStartCall = true,
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - call is disabled if user cannot join it even if there is an ongoing call`() = runTest {
+        val room = FakeJoinedRoom(
+            baseRoom = FakeBaseRoom(
+                canUserJoinCallResult = { Result.success(false) },
+                initialRoomInfo = aRoomInfo(hasRoomCall = true),
+            )
+        )
+        val presenter = createRoomCallStatePresenter(joinedRoom = room)
+        presenter.test {
+            skipItems(1)
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = false,
+                    isUserInTheCall = false,
+                    isUserLocallyInTheCall = false,
+                )
+            )
+        }
+    }
+
+    @Test
+    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),
+                    )
+                )
+            }
+        )
+        val presenter = createRoomCallStatePresenter(joinedRoom = room)
+        presenter.test {
+            skipItems(1)
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = true,
+                    isUserInTheCall = true,
+                    isUserLocallyInTheCall = false,
+                )
+            )
+        }
+    }
+
+    @Test
+    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),
+                    )
+                )
+            }
+        )
+        val presenter = createRoomCallStatePresenter(
+            joinedRoom = room,
+            currentCallService = FakeCurrentCallService(MutableStateFlow(CurrentCall.RoomCall(room.roomId))),
+        )
+        presenter.test {
+            skipItems(1)
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = true,
+                    isUserInTheCall = true,
+                    isUserLocallyInTheCall = true,
+                )
+            )
+        }
+    }
+
+    @Test
+    fun `present - user leaves the call`() = runTest {
+        val room = FakeJoinedRoom(
+            baseRoom = FakeBaseRoom(
+                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)
+        val presenter = createRoomCallStatePresenter(
+            joinedRoom = room,
+            currentCallService = currentCallService
+        )
+        presenter.test {
+            skipItems(1)
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = true,
+                    isUserInTheCall = true,
+                    isUserLocallyInTheCall = true,
+                )
+            )
+            currentCall.value = CurrentCall.None
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = true,
+                    isUserInTheCall = true,
+                    isUserLocallyInTheCall = false,
+                )
+            )
+            room.givenRoomInfo(
+                aRoomInfo(
+                    hasRoomCall = true,
+                    activeRoomCallParticipants = emptyList(),
+                )
+            )
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.OnGoing(
+                    canJoinCall = true,
+                    isUserInTheCall = false,
+                    isUserLocallyInTheCall = false,
+                )
+            )
+            room.givenRoomInfo(
+                aRoomInfo(
+                    hasRoomCall = false,
+                    activeRoomCallParticipants = emptyList(),
+                )
+            )
+            assertThat(awaitItem()).isEqualTo(
+                RoomCallState.StandBy(
+                    canStartCall = true,
+                )
+            )
+        }
+    }
+
+    private fun createRoomCallStatePresenter(
+        joinedRoom: JoinedRoom,
+        currentCallService: CurrentCallService = FakeCurrentCallService(),
+        isElementCallAvailable: Boolean = true,
+    ): RoomCallStatePresenter {
+        return RoomCallStatePresenter(
+            room = joinedRoom,
+            currentCallService = currentCallService,
+            sessionEnterpriseService = FakeSessionEnterpriseService(
+                isElementCallAvailableResult = { isElementCallAvailable },
+            ),
+        )
+    }
+}