Element Call SPA integration (#1283)

* Integrate Element Call into EX, being able to open its URLs and handle the call in-app. * Add custom scheme support with format `element:call?url=...`. * Update androix.webkit * Silence the foreground service notification. - Allow foreground service tap action to re-open the ongoing call. - Unify notification small icons in different modules using a vector one. --------- Co-authored-by: ElementBot <benoitm+elementbot@element.io>
2023-09-15 16:39:44 +02:00
parent 36119106a9
commit a06bea4d71
29 changed files with 862 additions and 16 deletions
--- a/features/call/build.gradle.kts
+++ b/features/call/build.gradle.kts
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "io.element.android.features.call"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.network)
+    implementation(libs.androidx.webkit)
+    ksp(libs.showkase.processor)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.robolectric)
+}
--- a/features/call/src/main/AndroidManifest.xml
+++ b/features/call/src/main/AndroidManifest.xml
@@ -0,0 +1,61 @@
+<!--
+  ~ 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.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <uses-feature android:name="android.hardware.microphone" android:required="false" />
+
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+
+    <application>
+        <activity
+            android:name=".ElementCallActivity"
+            android:label="@string/element_call"
+            android:exported="true"
+            android:taskAffinity="io.element.android.features.call"
+            android:configChanges="screenSize|screenLayout|orientation|keyboardHidden|keyboard|navigation|uiMode"
+            android:launchMode="singleTask">
+
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="http" />
+                <data android:scheme="https" />
+
+                <data android:host="call.element.io" />
+            </intent-filter>
+            <!-- Custom scheme to handle urls from other domains in the format: element://call?url=https%3A%2F%2Felement.io -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="element" />
+                <data android:host="call" />
+            </intent-filter>
+
+        </activity>
+        <service android:name=".CallForegroundService" android:enabled="true" android:foregroundServiceType="mediaPlayback" />
+    </application>
+
+</manifest>
--- 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
@@ -0,0 +1,89 @@
+/*
+ * 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.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationChannelCompat
+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.libraries.designsystem.utils.CommonDrawables
+
+class CallForegroundService : Service() {
+
+    companion object {
+        fun start(context: Context) {
+            val intent = Intent(context, CallForegroundService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        fun stop(context: Context) {
+            val intent = Intent(context, CallForegroundService::class.java)
+            context.stopService(intent)
+        }
+    }
+
+    private lateinit var notificationManagerCompat: NotificationManagerCompat
+
+    override fun onCreate() {
+        super.onCreate()
+
+        notificationManagerCompat = NotificationManagerCompat.from(this)
+
+        val foregroundServiceChannel = NotificationChannelCompat.Builder(
+            "call_foreground_service_channel",
+            NotificationManagerCompat.IMPORTANCE_LOW,
+        ).setName(
+            getString(R.string.call_foreground_service_channel_title_android).ifEmpty { "Ongoing call" }
+        ).build()
+        notificationManagerCompat.createNotificationChannel(foregroundServiceChannel)
+
+        val callActivityIntent = Intent(this, ElementCallActivity::class.java)
+        val pendingIntent = PendingIntentCompat.getActivity(this, 0, callActivityIntent, 0, false)
+        val notification = NotificationCompat.Builder(this, foregroundServiceChannel.id)
+            .setSmallIcon(IconCompat.createWithResource(this, CommonDrawables.ic_notification_small))
+            .setContentTitle(getString(R.string.call_foreground_service_title_android))
+            .setContentText(getString(R.string.call_foreground_service_message_android))
+            .setContentIntent(pendingIntent)
+            .build()
+        startForeground(1, notification)
+    }
+
+    @Suppress("DEPRECATION")
+    override fun onDestroy() {
+        super.onDestroy()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+        } else {
+            stopForeground(true)
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        return null
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/CallIntentDataParser.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/CallIntentDataParser.kt
@@ -0,0 +1,45 @@
+/*
+ * 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.net.Uri
+import java.net.URLDecoder
+
+object CallIntentDataParser {
+
+    private val validHttpSchemes = sequenceOf("http", "https")
+
+    fun parse(data: String?): String? {
+        val parsedUrl = data?.let { Uri.parse(data) } ?: return null
+        val scheme = parsedUrl.scheme
+        return when {
+            scheme in validHttpSchemes && parsedUrl.host == "call.element.io" -> data
+            scheme == "element" && parsedUrl.host == "call" -> {
+                // We use this custom scheme to load arbitrary URLs for other instances of Element Call,
+                // so we can only verify it's an HTTP/HTTPs URL with a non-empty host
+                parsedUrl.getQueryParameter("url")
+                    ?.let { URLDecoder.decode(it, "utf-8") }
+                    ?.takeIf {
+                        val internalUri = Uri.parse(it)
+                        internalUri.scheme in validHttpSchemes && !internalUri.host.isNullOrBlank()
+                    }
+            }
+            // This should never be possible, but we still need to take into account the possibility
+            else -> null
+        }
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/CallScreenView.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/CallScreenView.kt
@@ -0,0 +1,152 @@
+/*
+ * 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.annotation.SuppressLint
+import android.view.ViewGroup
+import android.webkit.PermissionRequest
+import android.webkit.WebChromeClient
+import android.webkit.WebView
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+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.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.DayNightPreviews
+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.theme.ElementTheme
+
+typealias RequestPermissionCallback = (Array<String>) -> Unit
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+internal fun CallScreenView(
+    url: String?,
+    userAgent: String,
+    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(
+                            imageVector = Icons.Default.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)
+                }
+            )
+        }
+    }
+}
+
+@Composable
+private fun CallWebView(
+    url: String?,
+    userAgent: String,
+    onPermissionsRequested: (PermissionRequest) -> 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()
+        }
+    )
+}
+
+@SuppressLint("SetJavaScriptEnabled")
+private fun WebView.setup(userAgent: String, onPermissionsRequested: (PermissionRequest) -> Unit) {
+    layoutParams = ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+    )
+
+    with(settings) {
+        javaScriptEnabled = true
+        allowContentAccess = true
+        allowFileAccess = true
+        domStorageEnabled = true
+        mediaPlaybackRequiresUserGesture = false
+        databaseEnabled = true
+        loadsImagesAutomatically = true
+        userAgentString = userAgent
+    }
+
+    webChromeClient = object : WebChromeClient() {
+        override fun onPermissionRequest(request: PermissionRequest) {
+            onPermissionsRequested(request)
+        }
+    }
+}
+
+@DayNightPreviews
+@Composable
+internal fun CallScreenViewPreview() {
+    ElementTheme {
+        CallScreenView(
+            url = "https://call.element.io/some-actual-call?with=parameters",
+            userAgent = "",
+            requestPermissions = { _, _ -> },
+            onClose = { },
+        )
+    }
+}
--- a/features/call/src/main/kotlin/io/element/android/features/call/ElementCallActivity.kt
+++ b/features/call/src/main/kotlin/io/element/android/features/call/ElementCallActivity.kt
@@ -0,0 +1,208 @@
+/*
+ * 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.Manifest
+import android.content.Intent
+import android.content.res.Configuration
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+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 io.element.android.features.call.di.CallBindings
+import io.element.android.libraries.architecture.bindings
+import io.element.android.libraries.network.useragent.UserAgentProvider
+import javax.inject.Inject
+
+class ElementCallActivity : ComponentActivity() {
+
+    @Inject lateinit var userAgentProvider: UserAgentProvider
+
+    private lateinit var audioManager: AudioManager
+
+    private var requestPermissionCallback: RequestPermissionCallback? = null
+
+    private var audiofocusRequest: AudioFocusRequest? = null
+    private var audioFocusChangeListener: AudioManager.OnAudioFocusChangeListener? = null
+
+    private val requestPermissionsLauncher = registerPermissionResultLauncher()
+
+    private var isDarkMode = false
+    private val urlState = mutableStateOf<String?>(null)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        applicationContext.bindings<CallBindings>().inject(this)
+
+        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+
+        urlState.value = intent?.dataString?.let(::parseUrl) ?: run {
+            finish()
+            return
+        }
+
+        if (savedInstanceState == null) {
+            updateUiMode(resources.configuration)
+        }
+
+        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)
+                }
+            )
+        }
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+
+        updateUiMode(newConfig)
+    }
+
+    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
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        CallForegroundService.stop(this)
+    }
+
+    override fun onStop() {
+        super.onStop()
+        if (!isFinishing && !isChangingConfigurations) {
+            CallForegroundService.start(this)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        releaseAudioFocus()
+        CallForegroundService.stop(this)
+    }
+
+    override fun finish() {
+        // Also remove the task from recents
+        finishAndRemoveTask()
+    }
+
+    private fun parseUrl(url: String?): String? = CallIntentDataParser.parse(url)
+
+    private fun registerPermissionResultLauncher(): ActivityResultLauncher<Array<String>> {
+        return registerForActivityResult(
+            ActivityResultContracts.RequestMultiplePermissions()
+        ) { permissions ->
+            val callback = requestPermissionCallback ?: return@registerForActivityResult
+            val permissionsToGrant = mutableListOf<String>()
+            permissions.forEach { (permission, granted) ->
+                if (granted) {
+                    val webKitPermission = when (permission) {
+                        Manifest.permission.CAMERA -> PermissionRequest.RESOURCE_VIDEO_CAPTURE
+                        Manifest.permission.RECORD_AUDIO -> PermissionRequest.RESOURCE_AUDIO_CAPTURE
+                        else -> return@forEach
+                    }
+                    permissionsToGrant.add(webKitPermission)
+                }
+            }
+            callback(permissionsToGrant.toTypedArray())
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun requestAudioFocus() {
+        val audioAttributes = AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+            .build()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val request = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                .setAudioAttributes(audioAttributes)
+                .build()
+            audioManager.requestAudioFocus(request)
+            audiofocusRequest = request
+        } else {
+            val listener = AudioManager.OnAudioFocusChangeListener { }
+            audioManager.requestAudioFocus(
+                listener,
+                AudioManager.STREAM_VOICE_CALL,
+                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE,
+            )
+
+            audioFocusChangeListener = listener
+        }
+    }
+
+    @Suppress("DEPRECATION")
+    private fun releaseAudioFocus() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            audiofocusRequest?.let { audioManager.abandonAudioFocusRequest(it) }
+        } else {
+            audioFocusChangeListener?.let { audioManager.abandonAudioFocus(it) }
+        }
+    }
+
+    private fun updateUiMode(configuration: Configuration) {
+        val prevDarkMode = isDarkMode
+        val currentNightMode = configuration.uiMode and Configuration.UI_MODE_NIGHT_YES
+        isDarkMode = currentNightMode != 0
+        if (prevDarkMode != isDarkMode) {
+            if (isDarkMode) {
+                window.setBackgroundDrawableResource(android.R.drawable.screen_background_dark)
+            } else {
+                window.setBackgroundDrawableResource(android.R.drawable.screen_background_light)
+            }
+        }
+    }
+}
+
+internal fun mapWebkitPermissions(permissions: Array<String>): List<String> {
+    return permissions.mapNotNull { permission ->
+        when (permission) {
+            PermissionRequest.RESOURCE_AUDIO_CAPTURE -> Manifest.permission.RECORD_AUDIO
+            PermissionRequest.RESOURCE_VIDEO_CAPTURE -> Manifest.permission.CAMERA
+            else -> null
+        }
+    }
+}
--- 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
@@ -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.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import io.element.android.features.call.ElementCallActivity
+import io.element.android.libraries.di.AppScope
+
+@ContributesTo(AppScope::class)
+interface CallBindings {
+    fun inject(callActivity: ElementCallActivity)
+}
--- a/features/call/src/main/res/values-fr/translations.xml
+++ b/features/call/src/main/res/values-fr/translations.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="call_foreground_service_channel_title_android">"Appel en cours"</string>
+  <string name="call_foreground_service_message_android">"Appuyez pour retourner à l\'appel."</string>
+  <string name="call_foreground_service_title_android">"☎️ Appel en cours"</string>
+</resources>
--- a/features/call/src/main/res/values/do_not_translate.xml
+++ b/features/call/src/main/res/values/do_not_translate.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  -->
+
+<resources>
+    <string translatable="false" name="element_call">Element Call</string>
+</resources>
--- a/features/call/src/main/res/values/localazy.xml
+++ b/features/call/src/main/res/values/localazy.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="call_foreground_service_channel_title_android">"Ongoing call"</string>
+  <string name="call_foreground_service_message_android">"Tap to return to the call"</string>
+  <string name="call_foreground_service_title_android">"☎️ Call in progress"</string>
+</resources>
--- a/features/call/src/test/kotlin/io/element/android/features/call/CallIntentDataParserTests.kt
+++ b/features/call/src/test/kotlin/io/element/android/features/call/CallIntentDataParserTests.kt
@@ -0,0 +1,105 @@
+/*
+ * 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 com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.net.URLEncoder
+
+@RunWith(RobolectricTestRunner::class)
+class CallIntentDataParserTests {
+
+    @Test
+    fun `a null data returns null`() {
+        val url: String? = null
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `empty data returns null`() {
+        val url = ""
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `invalid data returns null`() {
+        val url = "!"
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `data with no scheme returns null`() {
+        val url = "test"
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `Element Call urls will be returned as is`() {
+        val httpBaseUrl = "http://call.element.io"
+        val httpCallUrl = "http://call.element.io/some-actual-call?with=parameters"
+        val httpsBaseUrl = "https://call.element.io"
+        val httpsCallUrl = "https://call.element.io/some-actual-call?with=parameters"
+        assertThat(CallIntentDataParser.parse(httpBaseUrl)).isEqualTo(httpBaseUrl)
+        assertThat(CallIntentDataParser.parse(httpCallUrl)).isEqualTo(httpCallUrl)
+        assertThat(CallIntentDataParser.parse(httpsBaseUrl)).isEqualTo(httpsBaseUrl)
+        assertThat(CallIntentDataParser.parse(httpsCallUrl)).isEqualTo(httpsCallUrl)
+    }
+
+    @Test
+    fun `HTTP and HTTPS urls that don't come from EC return null`() {
+        val httpBaseUrl = "http://app.element.io"
+        val httpsBaseUrl = "https://app.element.io"
+        val httpInvalidUrl = "http://"
+        val httpsInvalidUrl = "http://"
+        assertThat(CallIntentDataParser.parse(httpBaseUrl)).isNull()
+        assertThat(CallIntentDataParser.parse(httpsBaseUrl)).isNull()
+        assertThat(CallIntentDataParser.parse(httpInvalidUrl)).isNull()
+        assertThat(CallIntentDataParser.parse(httpsInvalidUrl)).isNull()
+    }
+
+    @Test
+    fun `element scheme with call host and url param gets url extracted`() {
+        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
+        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
+        val url = "element://call?url=$encodedUrl"
+        assertThat(CallIntentDataParser.parse(url)).isEqualTo(embeddedUrl)
+    }
+
+    @Test
+    fun `element scheme with call host and no url param returns null`() {
+        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
+        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
+        val url = "element://call?no-url=$encodedUrl"
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `element scheme with no call host returns null`() {
+        val embeddedUrl = "http://call.element.io/some-actual-call?with=parameters"
+        val encodedUrl = URLEncoder.encode(embeddedUrl, "utf-8")
+        val url = "element://no-call?url=$encodedUrl"
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+
+    @Test
+    fun `element scheme with no data returns null`() {
+        val url = "element://call?url="
+        assertThat(CallIntentDataParser.parse(url)).isNull()
+    }
+}
--- 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
@@ -0,0 +1,44 @@
+/*
+ * 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.Manifest
+import android.webkit.PermissionRequest
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class MapWebkitPermissionsTest {
+
+    @Test
+    fun `given Webkit's RESOURCE_AUDIO_CAPTURE returns Android's RECORD_AUDIO permission`() {
+        val permission = mapWebkitPermissions(arrayOf(PermissionRequest.RESOURCE_AUDIO_CAPTURE))
+        assertThat(permission).isEqualTo(listOf(Manifest.permission.RECORD_AUDIO))
+    }
+
+    @Test
+    fun `given Webkit's RESOURCE_VIDEO_CAPTURE returns Android's CAMERA permission`() {
+        val permission = mapWebkitPermissions(arrayOf(PermissionRequest.RESOURCE_VIDEO_CAPTURE))
+        assertThat(permission).isEqualTo(listOf(Manifest.permission.CAMERA))
+    }
+
+    @Test
+    fun `given any other permission, it returns nothing`() {
+        val permission = mapWebkitPermissions(arrayOf(PermissionRequest.RESOURCE_PROTECTED_MEDIA_ID))
+        assertThat(permission).isEqualTo(emptyList<String>())
+    }
+
+}