Extract OIDC to its own module

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/CustomTabAvailabilityChecker.kt

@@ -0,0 +1,35 @@
+/*
+ * 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.libraries.oidc.impl
+
+import android.content.Context
+import androidx.browser.customtabs.CustomTabsClient
+import io.element.android.libraries.di.ApplicationContext
+import javax.inject.Inject
+
+class CustomTabAvailabilityChecker @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    /**
+     * Return true if the device supports Custom tab, i.e. there is an third party app with
+     * CustomTab support (ex: Chrome, Firefox, etc.).
+     */
+    fun supportCustomTab(): Boolean {
+        val packageName = CustomTabsClient.getPackageName(context, null)
+        return packageName != null
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/DefaultOidcEntryPoint.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://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.libraries.oidc.impl
+
+import android.app.Activity
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.androidutils.browser.openUrlInChromeCustomTab
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+import io.element.android.libraries.oidc.impl.webview.OidcNode
+import io.element.android.libraries.oidc.api.OidcEntryPoint
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultOidcEntryPoint @Inject constructor(
+    private val customTabAvailabilityChecker: CustomTabAvailabilityChecker,
+) : OidcEntryPoint {
+    override fun canUseCustomTab(): Boolean {
+        return customTabAvailabilityChecker.supportCustomTab()
+    }
+
+    override fun openUrlInCustomTab(activity: Activity, darkTheme: Boolean, url: String) {
+        assert(canUseCustomTab()) { "Custom tab is not supported in this device." }
+        activity.openUrlInChromeCustomTab(null, darkTheme, url)
+    }
+
+    override fun createFallbackWebViewNode(parentNode: Node, buildContext: BuildContext, url: String): Node {
+        assert(!canUseCustomTab()) { "Custom tab should be used instead of the fallback node." }
+        val inputs = OidcNode.Inputs(OidcDetails(url))
+        return parentNode.createNode<OidcNode>(buildContext, listOf(inputs))
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/DefaultOidcIntentResolver.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.libraries.oidc.impl
+
+import android.content.Intent
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.oidc.api.OidcAction
+import io.element.android.libraries.oidc.api.OidcIntentResolver
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultOidcIntentResolver @Inject constructor(
+    private val oidcUrlParser: OidcUrlParser,
+) : OidcIntentResolver {
+    override fun resolve(intent: Intent): OidcAction? {
+        return oidcUrlParser.parse(intent.dataString.orEmpty())
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/OidcUrlParser.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.libraries.oidc.impl
+
+import io.element.android.libraries.matrix.api.auth.OidcConfig
+import io.element.android.libraries.oidc.api.OidcAction
+import javax.inject.Inject
+
+/**
+ * Simple parser for oidc url interception.
+ * TODO Find documentation about the format.
+ */
+class OidcUrlParser @Inject constructor() {
+    /**
+     * Return a OidcAction, or null if the url is not a OidcUrl.
+     * Note:
+     * When user press button "Cancel", we get the url:
+     * `io.element:/callback?error=access_denied&state=IFF1UETGye2ZA8pO`
+     * On success, we get:
+     * `io.element:/callback?state=IFF1UETGye2ZA8pO&code=y6X1GZeqA3xxOWcTeShgv8nkgFJXyzWB`
+     */
+    fun parse(url: String): OidcAction? {
+        if (url.startsWith(OidcConfig.REDIRECT_URI).not()) return null
+        if (url.contains("error=access_denied")) return OidcAction.GoBack
+        if (url.contains("code=")) return OidcAction.Success(url)
+
+        // Other case not supported, let's crash the app for now
+        error("Not supported: $url")
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/customtab/CustomTabHandler.kt

@@ -0,0 +1,78 @@
+/*
+ * 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.libraries.oidc.impl.customtab
+
+import android.app.Activity
+import android.content.ComponentName
+import android.content.Context
+import android.net.Uri
+import androidx.browser.customtabs.CustomTabsClient
+import androidx.browser.customtabs.CustomTabsServiceConnection
+import androidx.browser.customtabs.CustomTabsSession
+import io.element.android.libraries.androidutils.browser.openUrlInChromeCustomTab
+import io.element.android.libraries.di.ApplicationContext
+import javax.inject.Inject
+
+class CustomTabHandler @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    private var customTabsSession: CustomTabsSession? = null
+    private var customTabsClient: CustomTabsClient? = null
+    private var customTabsServiceConnection: CustomTabsServiceConnection? = null
+
+    fun prepareCustomTab(url: String) {
+        val packageName = CustomTabsClient.getPackageName(context, null)
+
+        // packageName can be null if there are 0 or several CustomTabs compatible browsers installed on the device
+        if (packageName != null) {
+            customTabsServiceConnection = object : CustomTabsServiceConnection() {
+                override fun onCustomTabsServiceConnected(name: ComponentName, client: CustomTabsClient) {
+                    customTabsClient = client.apply { warmup(0L) }
+                    prefetchUrl(url)
+                }
+
+                override fun onServiceDisconnected(name: ComponentName?) {
+                }
+            }
+                .also {
+                    CustomTabsClient.bindCustomTabsService(
+                        context,
+                        // Despite the API, packageName cannot be null
+                        packageName,
+                        it
+                    )
+                }
+        }
+    }
+
+    private fun prefetchUrl(url: String) {
+        if (customTabsSession == null) {
+            customTabsSession = customTabsClient?.newSession(null)
+        }
+
+        customTabsSession?.mayLaunchUrl(Uri.parse(url), null, null)
+    }
+
+    fun disposeCustomTab() {
+        customTabsServiceConnection?.let { context.unbindService(it) }
+        customTabsServiceConnection = null
+    }
+
+    fun open(activity: Activity, darkTheme: Boolean, url: String) {
+        activity.openUrlInChromeCustomTab(customTabsSession, darkTheme, url)
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/customtab/DefaultOidcActionFlow.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.libraries.oidc.impl.customtab
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SingleIn
+import io.element.android.libraries.oidc.api.OidcAction
+import io.element.android.libraries.oidc.api.OidcActionFlow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.MutableStateFlow
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+@SingleIn(AppScope::class)
+class DefaultOidcActionFlow @Inject constructor() : OidcActionFlow {
+    private val mutableStateFlow = MutableStateFlow<OidcAction?>(null)
+
+    override fun post(oidcAction: OidcAction) {
+        mutableStateFlow.value = oidcAction
+    }
+
+    override suspend fun collect(collector: FlowCollector<OidcAction?>) {
+        mutableStateFlow.collect(collector)
+    }
+
+    override fun reset() {
+        mutableStateFlow.value = null
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcEvents.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import io.element.android.libraries.oidc.api.OidcAction
+
+sealed interface OidcEvents {
+    data object Cancel : OidcEvents
+    data class OidcActionEvent(val oidcAction: OidcAction) : OidcEvents
+    data object ClearError : OidcEvents
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcNode.kt

@@ -0,0 +1,54 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+
+@ContributesNode(AppScope::class)
+class OidcNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: OidcPresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+    data class Inputs(
+        val oidcDetails: OidcDetails,
+    ) : NodeInputs
+
+    private val inputs: Inputs = inputs()
+    private val presenter = presenterFactory.create(inputs.oidcDetails)
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        OidcView(
+            state = state,
+            modifier = modifier,
+            onNavigateBack = ::navigateUp,
+        )
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcPresenter.kt

@@ -0,0 +1,99 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.libraries.oidc.api.OidcAction
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+import kotlinx.coroutines.launch
+
+class OidcPresenter @AssistedInject constructor(
+    @Assisted private val oidcDetails: OidcDetails,
+    private val authenticationService: MatrixAuthenticationService,
+) : Presenter<OidcState> {
+    @AssistedFactory
+    interface Factory {
+        fun create(oidcDetails: OidcDetails): OidcPresenter
+    }
+
+    @Composable
+    override fun present(): OidcState {
+        var requestState: AsyncAction<Unit> by remember {
+            mutableStateOf(AsyncAction.Uninitialized)
+        }
+        val localCoroutineScope = rememberCoroutineScope()
+
+        fun handleCancel() {
+            requestState = AsyncAction.Loading
+            localCoroutineScope.launch {
+                authenticationService.cancelOidcLogin()
+                    .fold(
+                        onSuccess = {
+                            // Then go back
+                            requestState = AsyncAction.Success(Unit)
+                        },
+                        onFailure = {
+                            requestState = AsyncAction.Failure(it)
+                        }
+                    )
+            }
+        }
+
+        fun handleSuccess(url: String) {
+            requestState = AsyncAction.Loading
+            localCoroutineScope.launch {
+                authenticationService.loginWithOidc(url)
+                    .onFailure {
+                        requestState = AsyncAction.Failure(it)
+                    }
+                // On success, the node tree will be updated, there is nothing to do
+            }
+        }
+
+        fun handleAction(action: OidcAction) {
+            when (action) {
+                OidcAction.GoBack -> handleCancel()
+                is OidcAction.Success -> handleSuccess(action.url)
+            }
+        }
+
+        fun handleEvents(event: OidcEvents) {
+            when (event) {
+                OidcEvents.Cancel -> handleCancel()
+                is OidcEvents.OidcActionEvent -> handleAction(event.oidcAction)
+                OidcEvents.ClearError -> requestState = AsyncAction.Uninitialized
+            }
+        }
+
+        return OidcState(
+            oidcDetails = oidcDetails,
+            requestState = requestState,
+            eventSink = ::handleEvents
+        )
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcState.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.libraries.oidc.impl.webview
+
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+
+data class OidcState(
+    val oidcDetails: OidcDetails,
+    val requestState: AsyncAction<Unit>,
+    val eventSink: (OidcEvents) -> Unit
+)

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcStateProvider.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.auth.OidcDetails
+
+open class OidcStateProvider : PreviewParameterProvider<OidcState> {
+    override val values: Sequence<OidcState>
+        get() = sequenceOf(
+            aOidcState(),
+            aOidcState().copy(requestState = AsyncAction.Loading),
+        )
+}
+
+fun aOidcState() = OidcState(
+    oidcDetails = aOidcDetails(),
+    requestState = AsyncAction.Uninitialized,
+    eventSink = {}
+)
+
+fun aOidcDetails() = OidcDetails(
+    url = "aUrl",
+)

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcView.kt

@@ -0,0 +1,94 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import android.webkit.WebView
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.viewinterop.AndroidView
+import io.element.android.libraries.core.bool.orFalse
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.oidc.impl.OidcUrlParser
+
+@Composable
+fun OidcView(
+    state: OidcState,
+    onNavigateBack: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val oidcUrlParser = remember { OidcUrlParser() }
+    var webView by remember { mutableStateOf<WebView?>(null) }
+    fun shouldOverrideUrl(url: String): Boolean {
+        val action = oidcUrlParser.parse(url)
+        if (action != null) {
+            state.eventSink.invoke(OidcEvents.OidcActionEvent(action))
+            return true
+        }
+        return false
+    }
+
+    val oidcWebViewClient = remember {
+        OidcWebViewClient(::shouldOverrideUrl)
+    }
+
+    BackHandler {
+        if (webView?.canGoBack().orFalse()) {
+            webView?.goBack()
+        } else {
+            // To properly cancel Oidc login
+            state.eventSink.invoke(OidcEvents.Cancel)
+        }
+    }
+
+    Box(modifier = modifier.statusBarsPadding()) {
+        AndroidView(
+            factory = { context ->
+                WebView(context).apply {
+                    webViewClient = oidcWebViewClient
+                    loadUrl(state.oidcDetails.url)
+                }.also {
+                    webView = it
+                }
+            }
+        )
+
+        AsyncActionView(
+            async = state.requestState,
+            onSuccess = { onNavigateBack() },
+            onErrorDismiss = { state.eventSink(OidcEvents.ClearError) }
+        )
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun OidcViewPreview(@PreviewParameter(OidcStateProvider::class) state: OidcState) = ElementPreview {
+    OidcView(
+        state = state,
+        onNavigateBack = {},
+    )
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/OidcWebViewClient.kt

@@ -0,0 +1,38 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+import android.webkit.WebResourceRequest
+import android.webkit.WebView
+import android.webkit.WebViewClient
+
+class OidcWebViewClient(
+    private val eventListener: WebViewEventListener,
+) : WebViewClient() {
+    override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
+        return shouldOverrideUrl(request.url.toString())
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean {
+        return shouldOverrideUrl(url)
+    }
+
+    private fun shouldOverrideUrl(url: String): Boolean {
+        return eventListener.shouldOverrideUrlLoading(url)
+    }
+}

libraries/oidc/impl/src/main/kotlin/io/element/android/libraries/oidc/impl/webview/WebViewEventListener.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.libraries.oidc.impl.webview
+
+fun interface WebViewEventListener {
+    /**
+     * Triggered when a Webview loads an url.
+     *
+     * @param url The url about to be rendered.
+     * @return true if the method needs to manage some custom handling
+     */
+    fun shouldOverrideUrlLoading(url: String): Boolean
+}

libraries/oidc/impl/src/test/kotlin/io/element/android/libraries/oidc/impl/OidcUrlParserTest.kt

@@ -0,0 +1,60 @@
+/*
+ * 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.libraries.oidc.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.auth.OidcConfig
+import io.element.android.libraries.oidc.api.OidcAction
+import org.junit.Assert
+import org.junit.Test
+
+class OidcUrlParserTest {
+    @Test
+    fun `test empty url`() {
+        val sut = OidcUrlParser()
+        assertThat(sut.parse("")).isNull()
+    }
+
+    @Test
+    fun `test regular url`() {
+        val sut = OidcUrlParser()
+        assertThat(sut.parse("https://matrix.org")).isNull()
+    }
+
+    @Test
+    fun `test cancel url`() {
+        val sut = OidcUrlParser()
+        val aCancelUrl = OidcConfig.REDIRECT_URI + "?error=access_denied&state=IFF1UETGye2ZA8pO"
+        assertThat(sut.parse(aCancelUrl)).isEqualTo(OidcAction.GoBack)
+    }
+
+    @Test
+    fun `test success url`() {
+        val sut = OidcUrlParser()
+        val aSuccessUrl = OidcConfig.REDIRECT_URI + "?state=IFF1UETGye2ZA8pO&code=y6X1GZeqA3xxOWcTeShgv8nkgFJXyzWB"
+        assertThat(sut.parse(aSuccessUrl)).isEqualTo(OidcAction.Success(aSuccessUrl))
+    }
+
+    @Test
+    fun `test unknown url`() {
+        val sut = OidcUrlParser()
+        val anUnknownUrl = OidcConfig.REDIRECT_URI + "?state=IFF1UETGye2ZA8pO&goat=y6X1GZeqA3xxOWcTeShgv8nkgFJXyzWB"
+        Assert.assertThrows(IllegalStateException::class.java) {
+            assertThat(sut.parse(anUnknownUrl))
+        }
+    }
+}

libraries/oidc/impl/src/test/kotlin/io/element/android/libraries/oidc/impl/webview/OidcPresenterTest.kt

@@ -0,0 +1,151 @@
+/*
+ * 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.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.libraries.oidc.impl.webview
+
+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.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.test.A_THROWABLE
+import io.element.android.libraries.matrix.test.auth.A_OIDC_DATA
+import io.element.android.libraries.matrix.test.auth.FakeMatrixAuthenticationService
+import io.element.android.libraries.oidc.api.OidcAction
+import io.element.android.tests.testutils.WarmUpRule
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class OidcPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            FakeMatrixAuthenticationService(),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.oidcDetails).isEqualTo(A_OIDC_DATA)
+            assertThat(initialState.requestState).isEqualTo(AsyncAction.Uninitialized)
+        }
+    }
+
+    @Test
+    fun `present - go back`() = runTest {
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            FakeMatrixAuthenticationService(),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(OidcEvents.Cancel)
+            val loadingState = awaitItem()
+            assertThat(loadingState.requestState).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.requestState).isEqualTo(AsyncAction.Success(Unit))
+        }
+    }
+
+    @Test
+    fun `present - go back with failure`() = runTest {
+        val authenticationService = FakeMatrixAuthenticationService()
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            authenticationService,
+        )
+        authenticationService.givenOidcCancelError(A_THROWABLE)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(OidcEvents.Cancel)
+            val loadingState = awaitItem()
+            assertThat(loadingState.requestState).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.requestState).isEqualTo(AsyncAction.Failure(A_THROWABLE))
+            // Note: in real life I do not think this can happen, and the app should not block the user.
+        }
+    }
+
+    @Test
+    fun `present - user cancels from webview`() = runTest {
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            FakeMatrixAuthenticationService(),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(OidcEvents.OidcActionEvent(OidcAction.GoBack))
+            val loadingState = awaitItem()
+            assertThat(loadingState.requestState).isEqualTo(AsyncAction.Loading)
+            val finalState = awaitItem()
+            assertThat(finalState.requestState).isEqualTo(AsyncAction.Success(Unit))
+        }
+    }
+
+    @Test
+    fun `present - login success`() = runTest {
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            FakeMatrixAuthenticationService(),
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(OidcEvents.OidcActionEvent(OidcAction.Success("A_URL")))
+            val loadingState = awaitItem()
+            assertThat(loadingState.requestState).isEqualTo(AsyncAction.Loading)
+            // In this case, no success, the session is created and the node get destroyed.
+        }
+    }
+
+    @Test
+    fun `present - login error`() = runTest {
+        val authenticationService = FakeMatrixAuthenticationService()
+        val presenter = OidcPresenter(
+            A_OIDC_DATA,
+            authenticationService,
+        )
+        authenticationService.givenLoginError(A_THROWABLE)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            initialState.eventSink.invoke(OidcEvents.OidcActionEvent(OidcAction.Success("A_URL")))
+            val loadingState = awaitItem()
+            assertThat(loadingState.requestState).isEqualTo(AsyncAction.Loading)
+            val errorState = awaitItem()
+            assertThat(errorState.requestState).isEqualTo(AsyncAction.Failure(A_THROWABLE))
+            errorState.eventSink.invoke(OidcEvents.ClearError)
+            val finalState = awaitItem()
+            assertThat(finalState.requestState).isEqualTo(AsyncAction.Uninitialized)
+        }
+    }
+}