Integrate Element Call with widget API (#1581)

* Integrate Element Call with widget API. - Add `appconfig` module and extract constants that can be overridden in forks there. - Add an Element Call feature flag, disabled by default. - Refactor the whole `ElementCallActivity`, move most logic out of it. - Integrate with the Rust Widget Driver API (note the Rust SDK version used in this PR lacks some needed changes to make the calls actually work). - Handle calls differently based on `CallType`. - Add UI to create/join a call. --------- Co-authored-by: ElementBot <benoitm+elementbot@element.io>
2023-10-19 17:38:43 +02:00
parent cf3039c6f3
commit 5e547269e7
102 changed files with 2202 additions and 166 deletions
--- a/features/call/build.gradle.kts
+++ b/features/call/build.gradle.kts
@@ -18,20 +18,44 @@ plugins {
    id("io.element.android-compose-library")
    alias(libs.plugins.anvil)
    alias(libs.plugins.ksp)
+    id("kotlin-parcelize")
+    alias(libs.plugins.kotlin.serialization)
 }

 android {
    namespace = "io.element.android.features.call"
+
+    buildFeatures {
+        buildConfig = true
+    }
+}
+
+anvil {
+    generateDaggerFactories.set(true)
 }

 dependencies {
+    implementation(projects.appnav)
+    implementation(projects.appconfig)
+    implementation(projects.anvilannotations)
    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.core)
    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.matrix.impl)
    implementation(projects.libraries.network)
+    implementation(projects.libraries.preferences.api)
+    implementation(projects.services.toolbox.api)
    implementation(libs.androidx.webkit)
+    implementation(libs.serialization.json)
    ksp(libs.showkase.processor)

-    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
    testImplementation(libs.test.robolectric)
+    testImplementation(projects.libraries.featureflag.test)
+    testImplementation(projects.libraries.preferences.test)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.tests.testutils)
 }
--- a/features/call/src/main/AndroidManifest.xml
+++ b/features/call/src/main/AndroidManifest.xml
@@ -27,7 +27,7 @@

    <application>
        <activity
-            android:name=".ElementCallActivity"
+            android:name=".ui.ElementCallActivity"
            android:label="@string/element_call"
            android:exported="true"
            android:taskAffinity="io.element.android.features.call"
--- a/features/call/src/main/kotlin/io/element/android/features/call/CallForegroundService.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/CallForegroundService.kt
@@ -26,6 +26,7 @@ import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.app.PendingIntentCompat
 import androidx.core.graphics.drawable.IconCompat
+import io.element.android.features.call.ui.ElementCallActivity
 import io.element.android.libraries.designsystem.utils.CommonDrawables

 class CallForegroundService : Service() {
--- a/features/call/src/main/kotlin/io/element/android/features/call/CallType.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/CallType.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2023 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.call
+
+import android.os.Parcelable
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import kotlinx.parcelize.Parcelize
+
+sealed interface CallType : NodeInputs, Parcelable {
+    @Parcelize
+    data class ExternalUrl(val url: String) : CallType
+
+    @Parcelize
+    data class RoomCall(
+        val sessionId: SessionId,
+        val roomId: RoomId,
+    ) : CallType
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/data/WidgetMessage.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/data/WidgetMessage.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023 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.call.data
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class WidgetMessage(
+    @SerialName("api") val direction: Direction,
+    @SerialName("widgetId") val widgetId: String,
+    @SerialName("requestId") val requestId: String,
+    @SerialName("action") val action: Action,
+) {
+
+    @Serializable
+    enum class Direction {
+        @SerialName("fromWidget")
+        FromWidget,
+        @SerialName("toWidget")
+        ToWidget
+    }
+
+    @Serializable
+    enum class Action {
+        @SerialName("im.vector.hangup")
+        HangUp
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/di/CallBindings.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/di/CallBindings.kt
@@ -17,7 +17,7 @@
 package io.element.android.features.call.di

 import com.squareup.anvil.annotations.ContributesTo
-import io.element.android.features.call.ElementCallActivity
+import io.element.android.features.call.ui.ElementCallActivity
 import io.element.android.libraries.di.AppScope

@ContributesTo(AppScope::class)
--- a/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreeEvents.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreeEvents.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 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.call.ui
+
+import io.element.android.features.call.utils.WidgetMessageInterceptor
+
+sealed interface CallScreeEvents {
+    data object Hangup : CallScreeEvents
+    data class SetupMessageChannels(val widgetMessageInterceptor: WidgetMessageInterceptor) : CallScreeEvents
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenPresenter.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenPresenter.kt
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2023 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.call.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.features.call.CallType
+import io.element.android.features.call.data.WidgetMessage
+import io.element.android.features.call.utils.CallWidgetProvider
+import io.element.android.features.call.utils.WidgetMessageInterceptor
+import io.element.android.features.call.utils.WidgetMessageSerializer
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
+import io.element.android.libraries.network.useragent.UserAgentProvider
+import io.element.android.services.toolbox.api.systemclock.SystemClock
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import java.util.UUID
+
+class CallScreenPresenter @AssistedInject constructor(
+    @Assisted private val callType: CallType,
+    @Assisted private val navigator: CallScreenNavigator,
+    private val callWidgetProvider: CallWidgetProvider,
+    private val userAgentProvider: UserAgentProvider,
+    private val clock: SystemClock,
+    private val dispatchers: CoroutineDispatchers,
+) : Presenter<CallScreenState> {
+
+    @AssistedFactory
+    interface Factory {
+        fun create(callType: CallType, navigator: CallScreenNavigator): CallScreenPresenter
+    }
+
+    private val isInWidgetMode = callType is CallType.RoomCall
+    private val userAgent = userAgentProvider.provide()
+
+    @Composable
+    override fun present(): CallScreenState {
+        val coroutineScope = rememberCoroutineScope()
+        val urlState = remember { mutableStateOf<Async<String>>(Async.Uninitialized) }
+        val callWidgetDriver = remember { mutableStateOf<MatrixWidgetDriver?>(null) }
+        val messageInterceptor = remember { mutableStateOf<WidgetMessageInterceptor?>(null) }
+
+        LaunchedEffect(Unit) {
+            loadUrl(callType, urlState, callWidgetDriver)
+        }
+
+        callWidgetDriver.value?.let { driver ->
+            LaunchedEffect(Unit) {
+                driver.incomingMessages
+                    .onEach {
+                        // Relay message to the WebView
+                        messageInterceptor.value?.sendMessage(it)
+                    }
+                    .launchIn(this)
+
+                driver.run()
+            }
+        }
+
+        messageInterceptor.value?.let { interceptor ->
+            LaunchedEffect(Unit) {
+                interceptor.interceptedMessages
+                    .onEach {
+                        // Relay message to Widget Driver
+                        callWidgetDriver.value?.send(it)
+
+                        val parsedMessage = parseMessage(it)
+                        if (parsedMessage?.direction == WidgetMessage.Direction.FromWidget && parsedMessage.action == WidgetMessage.Action.HangUp) {
+                            close(callWidgetDriver.value, navigator)
+                        }
+                    }
+                    .launchIn(this)
+            }
+        }
+
+        fun handleEvents(event: CallScreeEvents) {
+            when (event) {
+                is CallScreeEvents.Hangup -> {
+                    val widgetId = callWidgetDriver.value?.id
+                    val interceptor = messageInterceptor.value
+                    if (widgetId != null && interceptor != null) {
+                        sendHangupMessage(widgetId, interceptor)
+                    }
+                    coroutineScope.launch {
+                        close(callWidgetDriver.value, navigator)
+                    }
+                }
+                is CallScreeEvents.SetupMessageChannels -> {
+                    messageInterceptor.value = event.widgetMessageInterceptor
+                }
+            }
+        }
+
+        return CallScreenState(
+            urlState = urlState.value,
+            userAgent = userAgent,
+            isInWidgetMode = isInWidgetMode,
+            eventSink = ::handleEvents,
+        )
+    }
+
+    private fun CoroutineScope.loadUrl(
+        inputs: CallType,
+        urlState: MutableState<Async<String>>,
+        callWidgetDriver: MutableState<MatrixWidgetDriver?>,
+    ) = launch {
+        urlState.runCatchingUpdatingState {
+            when (inputs) {
+                is CallType.ExternalUrl -> {
+                    inputs.url
+                }
+                is CallType.RoomCall -> {
+                    val (driver, url) = callWidgetProvider.getWidget(
+                        sessionId = inputs.sessionId,
+                        roomId = inputs.roomId,
+                        clientId = UUID.randomUUID().toString(),
+                    ).getOrThrow()
+                    callWidgetDriver.value = driver
+                    url
+                }
+            }
+        }
+    }
+
+    private fun parseMessage(message: String): WidgetMessage? {
+        return WidgetMessageSerializer.deserialize(message).getOrNull()
+    }
+
+    private fun sendHangupMessage(widgetId: String, messageInterceptor: WidgetMessageInterceptor) {
+        val message = WidgetMessage(
+            direction = WidgetMessage.Direction.ToWidget,
+            widgetId = widgetId,
+            requestId = "widgetapi-${clock.epochMillis()}",
+            action = WidgetMessage.Action.HangUp,
+        )
+        messageInterceptor.sendMessage(WidgetMessageSerializer.serialize(message))
+    }
+
+    private fun CoroutineScope.close(widgetDriver: MatrixWidgetDriver?, navigator: CallScreenNavigator) = launch(dispatchers.io) {
+        navigator.close()
+        widgetDriver?.close()
+    }
+
+}
+
--- a/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenState.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenState.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 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.call.ui
+
+import io.element.android.libraries.architecture.Async
+
+data class CallScreenState(
+    val urlState: Async<String>,
+    val userAgent: String,
+    val isInWidgetMode: Boolean,
+    val eventSink: (CallScreeEvents) -> Unit,
+)
--- a/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenView.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ui/CallScreenView.kt
@@ -14,106 +14,128 @@
 * limitations under the License.
 */

-package io.element.android.features.call
+package io.element.android.features.call.ui

 import android.annotation.SuppressLint
 import android.view.ViewGroup
 import android.webkit.PermissionRequest
 import android.webkit.WebChromeClient
 import android.webkit.WebView
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.viewinterop.AndroidView
+import io.element.android.features.call.R
+import io.element.android.features.call.utils.WebViewWidgetMessageInterceptor
+import io.element.android.libraries.architecture.Async
 import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
 import io.element.android.libraries.designsystem.theme.components.Scaffold
 import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
 import io.element.android.libraries.designsystem.utils.CommonDrawables
-import io.element.android.libraries.theme.ElementTheme

 typealias RequestPermissionCallback = (Array<String>) -> Unit

+interface CallScreenNavigator {
+    fun close()
+}
+
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 internal fun CallScreenView(
-    url: String?,
-    userAgent: String,
+    state: CallScreenState,
    requestPermissions: (Array<String>, RequestPermissionCallback) -> Unit,
-    onClose: () -> Unit,
    modifier: Modifier = Modifier,
 ) {
-    ElementTheme {
-        Scaffold(
-            modifier = modifier,
-            topBar = {
-                TopAppBar(
-                    title = { Text(stringResource(R.string.element_call)) },
-                    navigationIcon = {
-                        BackButton(
-                            resourceId = CommonDrawables.ic_compound_close,
-                            onClick = onClose
-                        )
-                    }
-                )
-            }
-        ) { padding ->
-            CallWebView(
-                modifier = Modifier
-                    .padding(padding)
-                    .consumeWindowInsets(padding)
-                    .fillMaxSize(),
-                url = url,
-                userAgent = userAgent,
-                onPermissionsRequested = { request ->
-                    val androidPermissions = mapWebkitPermissions(request.resources)
-                    val callback: RequestPermissionCallback = { request.grant(it) }
-                    requestPermissions(androidPermissions.toTypedArray(), callback)
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.element_call)) },
+                navigationIcon = {
+                    BackButton(
+                        resourceId = CommonDrawables.ic_compound_close,
+                        onClick = { state.eventSink(CallScreeEvents.Hangup) }
+                    )
                }
            )
        }
+    ) { padding ->
+        BackHandler {
+            state.eventSink(CallScreeEvents.Hangup)
+        }
+        CallWebView(
+            modifier = Modifier
+                .padding(padding)
+                .consumeWindowInsets(padding)
+                .fillMaxSize(),
+            url = state.urlState,
+            userAgent = state.userAgent,
+            onPermissionsRequested = { request ->
+                val androidPermissions = mapWebkitPermissions(request.resources)
+                val callback: RequestPermissionCallback = { request.grant(it) }
+                requestPermissions(androidPermissions.toTypedArray(), callback)
+            },
+            onWebViewCreated = { webView ->
+                val interceptor = WebViewWidgetMessageInterceptor(webView)
+                state.eventSink(CallScreeEvents.SetupMessageChannels(interceptor))
+            }
+        )
    }
 }

@Composable
 private fun CallWebView(
-    url: String?,
+    url: Async<String>,
    userAgent: String,
    onPermissionsRequested: (PermissionRequest) -> Unit,
+    onWebViewCreated: (WebView) -> Unit,
    modifier: Modifier = Modifier,
 ) {
-    val isInpectionMode = LocalInspectionMode.current
-    AndroidView(
-        modifier = modifier,
-        factory = { context ->
-            WebView(context).apply {
-                if (!isInpectionMode) {
-                    setup(userAgent, onPermissionsRequested)
-                    if (url != null) {
-                        loadUrl(url)
-                    }
-                }
-            }
-        },
-        update = { webView ->
-            if (!isInpectionMode && url != null) {
-                webView.loadUrl(url)
-            }
-        },
-        onRelease = { webView ->
-            webView.destroy()
+    if (LocalInspectionMode.current) {
+        Box(modifier = modifier, contentAlignment = Alignment.Center) {
+            Text("WebView - can't be previewed")
        }
-    )
+    } else {
+        AndroidView(
+            modifier = modifier,
+            factory = { context ->
+                WebView(context).apply {
+                    setup(userAgent, onPermissionsRequested)
+                    if (url is Async.Success) {
+                        loadUrl(url.data)
+                    }
+
+                    onWebViewCreated(this)
+                }
+            },
+            update = { webView ->
+                if (url is Async.Success && webView.url != url.data) {
+                    webView.loadUrl(url.data)
+                }
+            },
+            onRelease = { webView ->
+                webView.destroy()
+            }
+        )
+    }
 }

@SuppressLint("SetJavaScriptEnabled")
-private fun WebView.setup(userAgent: String, onPermissionsRequested: (PermissionRequest) -> Unit) {
+private fun WebView.setup(
+    userAgent: String,
+    onPermissionsRequested: (PermissionRequest) -> Unit,
+) {
    layoutParams = ViewGroup.LayoutParams(
        ViewGroup.LayoutParams.MATCH_PARENT,
        ViewGroup.LayoutParams.MATCH_PARENT
@@ -140,12 +162,15 @@ private fun WebView.setup(userAgent: String, onPermissionsRequested: (Permission
@PreviewsDayNight
@Composable
 internal fun CallScreenViewPreview() {
-    ElementTheme {
+    ElementPreview {
        CallScreenView(
-            url = "https://call.element.io/some-actual-call?with=parameters",
-            userAgent = "",
+            state = CallScreenState(
+                urlState = Async.Success("https://call.element.io/some-actual-call?with=parameters"),
+                isInWidgetMode = false,
+                userAgent = "",
+                eventSink = {},
+            ),
            requestPermissions = { _, _ -> },
-            onClose = { },
        )
    }
 }
--- a/features/call/src/main/kotlin/io/element/android/features/call/ui/ElementCallActivity.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ui/ElementCallActivity.kt
@@ -14,10 +14,12 @@
 * limitations under the License.
 */

-package io.element.android.features.call
+package io.element.android.features.call.ui

 import android.Manifest
+import android.content.Context
 import android.content.Intent
+import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
 import android.content.res.Configuration
 import android.media.AudioAttributes
 import android.media.AudioFocusRequest
@@ -26,20 +28,40 @@ import android.os.Build
 import android.os.Bundle
 import android.view.WindowManager
 import android.webkit.PermissionRequest
-import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.mutableStateOf
+import androidx.core.content.IntentCompat
+import com.bumble.appyx.core.integrationpoint.NodeComponentActivity
+import io.element.android.features.call.CallForegroundService
+import io.element.android.features.call.CallType
 import io.element.android.features.call.di.CallBindings
+import io.element.android.features.call.utils.CallIntentDataParser
 import io.element.android.libraries.architecture.bindings
-import io.element.android.libraries.network.useragent.UserAgentProvider
+import io.element.android.libraries.theme.ElementTheme
 import javax.inject.Inject

-class ElementCallActivity : ComponentActivity() {
+class ElementCallActivity : NodeComponentActivity(), CallScreenNavigator {
+    companion object {
+        private const val EXTRA_CALL_WIDGET_SETTINGS = "EXTRA_CALL_WIDGET_SETTINGS"
+
+        fun start(
+            context: Context,
+            callInputs: CallType,
+        ) {
+            val intent = Intent(context, ElementCallActivity::class.java).apply {
+                putExtra(EXTRA_CALL_WIDGET_SETTINGS, callInputs)
+                addFlags(FLAG_ACTIVITY_NEW_TASK)
+            }
+            context.startActivity(intent)
+        }
+    }

-    @Inject lateinit var userAgentProvider: UserAgentProvider
    @Inject lateinit var callIntentDataParser: CallIntentDataParser
+    @Inject lateinit var presenterFactory: CallScreenPresenter.Factory
+
+    private lateinit var presenter: CallScreenPresenter

    private lateinit var audioManager: AudioManager

@@ -51,7 +73,7 @@ class ElementCallActivity : ComponentActivity() {
    private val requestPermissionsLauncher = registerPermissionResultLauncher()

    private var isDarkMode = false
-    private val urlState = mutableStateOf<String?>(null)
+    private val webViewTarget = mutableStateOf<CallType?>(null)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
@@ -60,10 +82,7 @@ class ElementCallActivity : ComponentActivity() {

        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)

-        urlState.value = intent?.dataString?.let(::parseUrl) ?: run {
-            finish()
-            return
-        }
+        setCallType(intent)

        if (savedInstanceState == null) {
            updateUiMode(resources.configuration)
@@ -72,18 +91,17 @@ class ElementCallActivity : ComponentActivity() {
        audioManager = getSystemService(AUDIO_SERVICE) as AudioManager
        requestAudioFocus()

-        val userAgent = userAgentProvider.provide()
-
        setContent {
-            CallScreenView(
-                url = urlState.value,
-                userAgent = userAgent,
-                onClose = this::finish,
-                requestPermissions = { permissions, callback ->
-                    requestPermissionCallback = callback
-                    requestPermissionsLauncher.launch(permissions)
-                }
-            )
+            val state = presenter.present()
+            ElementTheme {
+                CallScreenView(
+                    state = state,
+                    requestPermissions = { permissions, callback ->
+                        requestPermissionCallback = callback
+                        requestPermissionsLauncher.launch(permissions)
+                    }
+                )
+            }
        }
    }

@@ -96,15 +114,7 @@ class ElementCallActivity : ComponentActivity() {
    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)

-        val intentUrl = intent?.dataString?.let(::parseUrl)
-        when {
-            // New URL, update it and reload the webview
-            intentUrl != null -> urlState.value = intentUrl
-            // Re-opened the activity but we have no url to load or a cached one, finish the activity
-            intent?.dataString == null && urlState.value == null -> finish()
-            // Coming back from notification, do nothing
-            else -> return
-        }
+        setCallType(intent)
    }

    override fun onStart() {
@@ -130,6 +140,32 @@ class ElementCallActivity : ComponentActivity() {
        finishAndRemoveTask()
    }

+    override fun close() {
+        finish()
+    }
+
+    private fun setCallType(intent: Intent?) {
+        val inputs = intent?.let {
+            IntentCompat.getParcelableExtra(it, EXTRA_CALL_WIDGET_SETTINGS, CallType::class.java)
+        }
+        val intentUrl = intent?.dataString?.let(::parseUrl)
+        when {
+            // Re-opened the activity but we have no url to load or a cached one, finish the activity
+            intent?.dataString == null && inputs == null && webViewTarget.value == null -> finish()
+            inputs != null -> {
+                webViewTarget.value = inputs
+                presenter = presenterFactory.create(inputs, this)
+            }
+            intentUrl != null -> {
+                val fallbackInputs = CallType.ExternalUrl(intentUrl)
+                webViewTarget.value = fallbackInputs
+                presenter = presenterFactory.create(fallbackInputs, this)
+            }
+            // Coming back from notification, do nothing
+            else -> return
+        }
+    }
+
    private fun parseUrl(url: String?): String? = callIntentDataParser.parse(url)

    private fun registerPermissionResultLauncher(): ActivityResultLauncher<Array<String>> {
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/CallIntentDataParser.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/CallIntentDataParser.kt
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package io.element.android.features.call
+package io.element.android.features.call.utils

 import android.net.Uri
 import javax.inject.Inject
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/CallWidgetProvider.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/CallWidgetProvider.kt
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
+
+interface CallWidgetProvider {
+    suspend fun getWidget(
+        sessionId: SessionId,
+        roomId: RoomId,
+        clientId: String,
+        languageTag: String? = null,
+        theme: String? = null,
+    ): Result<Pair<MatrixWidgetDriver, String>>
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/DefaultCallWidgetProvider.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/DefaultCallWidgetProvider.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.appconfig.ElementCallConfig
+import io.element.android.features.preferences.api.store.PreferencesStore
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.MatrixClientProvider
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.widget.CallWidgetSettingsProvider
+import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
+import kotlinx.coroutines.flow.firstOrNull
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultCallWidgetProvider @Inject constructor(
+    private val matrixClientsProvider: MatrixClientProvider,
+    private val preferencesStore: PreferencesStore,
+    private val callWidgetSettingsProvider: CallWidgetSettingsProvider,
+) : CallWidgetProvider {
+    override suspend fun getWidget(
+        sessionId: SessionId,
+        roomId: RoomId,
+        clientId: String,
+        languageTag: String?,
+        theme: String?,
+    ): Result<Pair<MatrixWidgetDriver, String>> = runCatching {
+        val room = matrixClientsProvider.getOrRestore(sessionId).getOrThrow().getRoom(roomId) ?: error("Room not found")
+        val baseUrl = preferencesStore.getCustomElementCallBaseUrlFlow().firstOrNull() ?: ElementCallConfig.DEFAULT_BASE_URL
+        val widgetSettings = callWidgetSettingsProvider.provide(baseUrl)
+        val callUrl = room.generateWidgetWebViewUrl(widgetSettings, clientId, languageTag, theme).getOrThrow()
+        room.getWidgetDriver(widgetSettings).getOrThrow() to callUrl
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/WebViewWidgetMessageInterceptor.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/WebViewWidgetMessageInterceptor.kt
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import android.graphics.Bitmap
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.webkit.WebViewCompat
+import androidx.webkit.WebViewFeature
+import io.element.android.features.call.BuildConfig
+import kotlinx.coroutines.flow.MutableSharedFlow
+
+class WebViewWidgetMessageInterceptor(
+    private val webView: WebView,
+) : WidgetMessageInterceptor {
+
+    companion object {
+        // We call both the WebMessageListener and the JavascriptInterface objects in JS with this
+        // 'listenerName' so they can both receive the data from the WebView when
+        // `${LISTENER_NAME}.postMessage(...)` is called
+        const val LISTENER_NAME = "elementX"
+    }
+
+    override val interceptedMessages = MutableSharedFlow<String>(replay = 1, extraBufferCapacity = 2)
+
+    init {
+        webView.webViewClient = object : WebViewClient() {
+            override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
+                super.onPageStarted(view, url, favicon)
+
+                // We inject this JS code when the page starts loading to attach a message listener to the window.
+                // This listener will receive both messages:
+                // - EC widget API -> Element X (message.data.api == "fromWidget")
+                // - Element X -> EC widget API (message.data.api == "toWidget"), we should ignore these
+                view?.evaluateJavascript(
+                    """
+                        window.addEventListener('message', function(event) {
+                            let message = {data: event.data, origin: event.origin}
+                            if (message.data.response && message.data.api == "toWidget"
+                                || !message.data.response && message.data.api == "fromWidget") {
+                                let json = JSON.stringify(event.data) 
+                                ${"console.log('message sent: ' + json);".takeIf { BuildConfig.DEBUG } }
+                                ${LISTENER_NAME}.postMessage(json);
+                            } else {
+                                ${"console.log('message received (ignored): ' + JSON.stringify(event.data));".takeIf { BuildConfig.DEBUG } }
+                            }
+                        });
+                    """.trimIndent(),
+                    null
+                )
+            }
+        }
+
+        // Create a WebMessageListener, which will receive messages from the WebView and reply to them
+        val webMessageListener = WebViewCompat.WebMessageListener { _, message, _, _, _ ->
+            onMessageReceived(message.data)
+        }
+
+        // Use WebMessageListener if supported, otherwise use JavascriptInterface
+        if (WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)) {
+            WebViewCompat.addWebMessageListener(
+                webView,
+                LISTENER_NAME,
+                setOf("*"),
+                webMessageListener
+            )
+        } else {
+            webView.addJavascriptInterface(object {
+                @JavascriptInterface
+                fun postMessage(json: String?) {
+                    onMessageReceived(json)
+                }
+            }, LISTENER_NAME)
+        }
+    }
+
+    override fun sendMessage(message: String) {
+        webView.evaluateJavascript("postMessage($message, '*')", null)
+    }
+
+    private fun onMessageReceived(json: String?) {
+        // Here is where we would handle the messages from the WebView, passing them to the Rust SDK
+        json?.let { interceptedMessages.tryEmit(it) }
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/WidgetMessageInterceptor.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/WidgetMessageInterceptor.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import kotlinx.coroutines.flow.Flow
+
+interface WidgetMessageInterceptor {
+    val interceptedMessages: Flow<String>
+    fun sendMessage(message: String)
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/utils/WidgetMessageSerializer.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/utils/WidgetMessageSerializer.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import io.element.android.features.call.data.WidgetMessage
+import kotlinx.serialization.json.Json
+
+object WidgetMessageSerializer {
+
+    private val coder = Json { ignoreUnknownKeys = true }
+
+    fun deserialize(message: String): Result<WidgetMessage> {
+        return runCatching { coder.decodeFromString(WidgetMessage.serializer(), message) }
+    }
+
+    fun serialize(message: WidgetMessage): String {
+        return coder.encodeToString(WidgetMessage.serializer(), message)
+    }
+}
--- a/features/call/src/test/kotlin/io/element/android/features/call/MapWebkitPermissionsTest.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/MapWebkitPermissionsTest.kt
@@ -19,6 +19,7 @@ package io.element.android.features.call
 import android.Manifest
 import android.webkit.PermissionRequest
 import com.google.common.truth.Truth.assertThat
+import io.element.android.features.call.ui.mapWebkitPermissions
 import org.junit.Test

 class MapWebkitPermissionsTest {
--- a/features/call/src/test/kotlin/io/element/android/features/call/ui/CallScreenPresenterTest.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/ui/CallScreenPresenterTest.kt
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2023 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.call.ui
+
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.call.CallType
+import io.element.android.features.call.utils.FakeCallWidgetProvider
+import io.element.android.features.call.utils.FakeWidgetMessageInterceptor
+import io.element.android.libraries.architecture.Async
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.widget.FakeWidgetDriver
+import io.element.android.libraries.network.useragent.UserAgentProvider
+import io.element.android.services.toolbox.api.systemclock.SystemClock
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.testCoroutineDispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class CallScreenPresenterTest {
+
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - with CallType ExternalUrl just loads the URL`() = runTest {
+        val presenter = createCallScreenPresenter(CallType.ExternalUrl("https://call.element.io"))
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            // Wait until the URL is loaded
+            skipItems(1)
+
+            val initialState = awaitItem()
+            assertThat(initialState.urlState).isEqualTo(Async.Success("https://call.element.io"))
+            assertThat(initialState.isInWidgetMode).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - with CallType RoomCall loads URL and runs WidgetDriver`() = runTest {
+        val widgetDriver = FakeWidgetDriver()
+        val widgetProvider = FakeCallWidgetProvider(widgetDriver)
+        val presenter = createCallScreenPresenter(
+            callType = CallType.RoomCall(A_SESSION_ID, A_ROOM_ID),
+            widgetDriver = widgetDriver,
+            widgetProvider = widgetProvider,
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            // Wait until the URL is loaded
+            skipItems(1)
+
+            val initialState = awaitItem()
+            assertThat(initialState.urlState).isInstanceOf(Async.Success::class.java)
+            assertThat(initialState.isInWidgetMode).isTrue()
+            assertThat(widgetProvider.getWidgetCalled).isTrue()
+            assertThat(widgetDriver.runCalledCount).isEqualTo(1)
+        }
+    }
+
+    @Test
+    fun `present - set message interceptor, send and receive messages`() = runTest {
+        val widgetDriver = FakeWidgetDriver()
+        val presenter = createCallScreenPresenter(
+            callType = CallType.RoomCall(A_SESSION_ID, A_ROOM_ID),
+            widgetDriver = widgetDriver,
+        )
+        val messageInterceptor = FakeWidgetMessageInterceptor()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(CallScreeEvents.SetupMessageChannels(messageInterceptor))
+
+            // And incoming message from the Widget Driver is passed to the WebView
+            widgetDriver.givenIncomingMessage("A message")
+            assertThat(messageInterceptor.sentMessages).containsExactly("A message")
+
+            // And incoming message from the WebView is passed to the Widget Driver
+            messageInterceptor.givenInterceptedMessage("A reply")
+            assertThat(widgetDriver.sentMessages).containsExactly("A reply")
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - hang up event closes the screen and stops the widget driver`() = runTest(UnconfinedTestDispatcher()) {
+        val navigator = FakeCallScreenNavigator()
+        val widgetDriver = FakeWidgetDriver()
+        val presenter = createCallScreenPresenter(
+            callType = CallType.RoomCall(A_SESSION_ID, A_ROOM_ID),
+            widgetDriver = widgetDriver,
+            navigator = navigator,
+            dispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true),
+        )
+        val messageInterceptor = FakeWidgetMessageInterceptor()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(CallScreeEvents.SetupMessageChannels(messageInterceptor))
+
+            initialState.eventSink(CallScreeEvents.Hangup)
+
+            // Let background coroutines run
+            runCurrent()
+
+            assertThat(navigator.closeCalled).isTrue()
+            assertThat(widgetDriver.closeCalledCount).isEqualTo(1)
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - a received hang up message closes the screen and stops the widget driver`() = runTest(UnconfinedTestDispatcher()) {
+        val navigator = FakeCallScreenNavigator()
+        val widgetDriver = FakeWidgetDriver()
+        val presenter = createCallScreenPresenter(
+            callType = CallType.RoomCall(A_SESSION_ID, A_ROOM_ID),
+            widgetDriver = widgetDriver,
+            navigator = navigator,
+            dispatchers = testCoroutineDispatchers(useUnconfinedTestDispatcher = true),
+        )
+        val messageInterceptor = FakeWidgetMessageInterceptor()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink(CallScreeEvents.SetupMessageChannels(messageInterceptor))
+
+            messageInterceptor.givenInterceptedMessage("""{"action":"im.vector.hangup","api":"fromWidget","widgetId":"1","requestId":"1"}""")
+
+            // Let background coroutines run
+            runCurrent()
+
+            assertThat(navigator.closeCalled).isTrue()
+            assertThat(widgetDriver.closeCalledCount).isEqualTo(1)
+
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+
+    private fun TestScope.createCallScreenPresenter(
+        callType: CallType,
+        navigator: CallScreenNavigator = FakeCallScreenNavigator(),
+        widgetDriver: FakeWidgetDriver = FakeWidgetDriver(),
+        widgetProvider: FakeCallWidgetProvider = FakeCallWidgetProvider(widgetDriver),
+        dispatchers: CoroutineDispatchers = testCoroutineDispatchers(),
+    ): CallScreenPresenter {
+        val userAgentProvider = object : UserAgentProvider {
+            override fun provide(): String {
+                return "Test"
+            }
+        }
+        val clock = SystemClock { 0 }
+        return CallScreenPresenter(
+            callType,
+            navigator,
+            widgetProvider,
+            userAgentProvider,
+            clock,
+            dispatchers,
+        )
+    }
+}
--- a/features/call/src/test/kotlin/io/element/android/features/call/ui/FakeCallScreenNavigator.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/ui/FakeCallScreenNavigator.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2023 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.call.ui
+
+class FakeCallScreenNavigator : CallScreenNavigator {
+        var closeCalled = false
+            private set
+
+        override fun close() {
+            closeCalled = true
+        }
+    }
--- a/features/call/src/test/kotlin/io/element/android/features/call/utils/CallIntentDataParserTest.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/utils/CallIntentDataParserTest.kt
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package io.element.android.features.call
+package io.element.android.features.call.utils

 import com.google.common.truth.Truth.assertThat
 import org.junit.Test
--- a/features/call/src/test/kotlin/io/element/android/features/call/utils/DefaultCallWidgetProviderTest.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/utils/DefaultCallWidgetProviderTest.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.preferences.api.store.PreferencesStore
+import io.element.android.libraries.featureflag.test.InMemoryPreferencesStore
+import io.element.android.libraries.matrix.api.MatrixClientProvider
+import io.element.android.libraries.matrix.api.widget.CallWidgetSettingsProvider
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.FakeMatrixClientProvider
+import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import io.element.android.libraries.matrix.test.widget.FakeCallWidgetSettingsProvider
+import io.element.android.libraries.matrix.test.widget.FakeWidgetDriver
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class DefaultCallWidgetProviderTest {
+
+    @Test
+    fun `getWidget - fails if the session does not exist`() = runTest {
+        val provider = createProvider(matrixClientProvider = FakeMatrixClientProvider { Result.failure(Exception("Session not found")) })
+        assertThat(provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme").isFailure).isTrue()
+    }
+
+    @Test
+    fun `getWidget - fails if the room does not exist`() = runTest {
+        val client = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, null)
+        }
+        val provider = createProvider(matrixClientProvider = FakeMatrixClientProvider { Result.success(client) })
+        assertThat(provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme").isFailure).isTrue()
+    }
+
+    @Test
+    fun `getWidget - fails if it can't generate the URL for the widget`() = runTest {
+        val room = FakeMatrixRoom().apply {
+            givenGenerateWidgetWebViewUrlResult(Result.failure(Exception("Can't generate URL for widget")))
+        }
+        val client = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, room)
+        }
+        val provider = createProvider(matrixClientProvider = FakeMatrixClientProvider { Result.success(client) })
+        assertThat(provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme").isFailure).isTrue()
+    }
+
+    @Test
+    fun `getWidget - fails if it can't get the widget driver`() = runTest {
+        val room = FakeMatrixRoom().apply {
+            givenGenerateWidgetWebViewUrlResult(Result.success("url"))
+            givenGetWidgetDriverResult(Result.failure(Exception("Can't get a widget driver")))
+        }
+        val client = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, room)
+        }
+        val provider = createProvider(matrixClientProvider = FakeMatrixClientProvider { Result.success(client) })
+        assertThat(provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme").isFailure).isTrue()
+    }
+
+    @Test
+    fun `getWidget - returns a widget driver when all steps are successful`() = runTest {
+        val room = FakeMatrixRoom().apply {
+            givenGenerateWidgetWebViewUrlResult(Result.success("url"))
+            givenGetWidgetDriverResult(Result.success(FakeWidgetDriver()))
+        }
+        val client = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, room)
+        }
+        val provider = createProvider(matrixClientProvider = FakeMatrixClientProvider { Result.success(client) })
+        assertThat(provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme").getOrNull()).isNotNull()
+    }
+
+    @Test
+    fun `getWidget - will use a custom base url if it exists`() = runTest {
+        val room = FakeMatrixRoom().apply {
+            givenGenerateWidgetWebViewUrlResult(Result.success("url"))
+            givenGetWidgetDriverResult(Result.success(FakeWidgetDriver()))
+        }
+        val client = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, room)
+        }
+        val preferencesStore = InMemoryPreferencesStore().apply {
+            setCustomElementCallBaseUrl("https://custom.element.io")
+        }
+        val settingsProvider = FakeCallWidgetSettingsProvider()
+        val provider = createProvider(
+            matrixClientProvider = FakeMatrixClientProvider { Result.success(client) },
+            callWidgetSettingsProvider = settingsProvider,
+            preferencesStore = preferencesStore,
+        )
+        provider.getWidget(A_SESSION_ID, A_ROOM_ID, "clientId", "languageTag", "theme")
+
+        assertThat(settingsProvider.providedBaseUrls).containsExactly("https://custom.element.io")
+    }
+
+    private fun createProvider(
+        matrixClientProvider: MatrixClientProvider = FakeMatrixClientProvider(),
+        preferencesStore: PreferencesStore = InMemoryPreferencesStore(),
+        callWidgetSettingsProvider: CallWidgetSettingsProvider = FakeCallWidgetSettingsProvider()
+    ) = DefaultCallWidgetProvider(
+        matrixClientProvider,
+        preferencesStore,
+        callWidgetSettingsProvider,
+    )
+}
--- a/features/call/src/test/kotlin/io/element/android/features/call/utils/FakeCallWidgetProvider.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/utils/FakeCallWidgetProvider.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
+import io.element.android.libraries.matrix.test.widget.FakeWidgetDriver
+
+class FakeCallWidgetProvider(
+    private val widgetDriver: FakeWidgetDriver = FakeWidgetDriver(),
+    private val url: String = "https://call.element.io",
+    ) : CallWidgetProvider {
+
+        var getWidgetCalled = false
+            private set
+
+        override suspend fun getWidget(
+            sessionId: SessionId,
+            roomId: RoomId,
+            clientId: String,
+            languageTag: String?,
+            theme: String?
+        ): Result<Pair<MatrixWidgetDriver, String>> {
+            getWidgetCalled = true
+            return Result.success(widgetDriver to url)
+        }
+    }
--- a/features/call/src/test/kotlin/io/element/android/features/call/utils/FakeWidgetMessageInterceptor.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/utils/FakeWidgetMessageInterceptor.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023 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.call.utils
+
+import kotlinx.coroutines.flow.MutableSharedFlow
+
+class FakeWidgetMessageInterceptor : WidgetMessageInterceptor {
+        val sentMessages = mutableListOf<String>()
+
+        override val interceptedMessages = MutableSharedFlow<String>(extraBufferCapacity = 1)
+
+        override fun sendMessage(message: String) {
+            sentMessages += message
+        }
+
+        fun givenInterceptedMessage(message: String) {
+            interceptedMessages.tryEmit(message)
+        }
+    }