[Link new device] Handle split steps in the SDK

features/linknewdevice/impl/src/main/kotlin/io/element/android/features/linknewdevice/impl/LinkNewDeviceFlowNode.kt

@@ -54,8 +54,10 @@ import io.element.android.libraries.matrix.api.linknewdevice.LinkMobileStep
 import io.element.android.libraries.matrix.api.logs.LoggerTags
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
 import kotlinx.parcelize.Parcelize
 import timber.log.Timber
 
@@ -102,6 +104,7 @@ class LinkNewDeviceFlowNode(
                 @Suppress("AssignedValueIsNeverRead")
                 linkDesktopHandlerJob = observeLinkNewDesktopHandler()
             },
+            onResume = ::onResume,
             onDestroy = {
                 linkMobileHandlerJob?.cancel()
                 linkDesktopHandlerJob?.cancel()
@@ -209,6 +212,18 @@ class LinkNewDeviceFlowNode(
             .launchIn(sessionCoroutineScope)
     }
 
+    private fun onResume() = sessionCoroutineScope.launch {
+        // Application is resumed, if the step is waiting for auth, send the confirmation
+        (linkNewMobileHandler.stepFlow.first() as? LinkMobileStep.WaitingForAuth)?.let {
+            Timber.tag(tag.value).d("Resuming while waiting for auth on mobile, sending confirmation")
+            it.continuationMessageSender.confirm()
+        }
+        (linkNewDesktopHandler.stepFlow.value as? LinkDesktopStep.WaitingForAuth)?.let {
+            Timber.tag(tag.value).d("Resuming while waiting for auth on desktop, sending confirmation")
+            it.continuationMessageSender.confirm()
+        }
+    }
+
     private fun navigateToError(errorType: ErrorType) {
         // Map the error to an error screen
         val error = when (errorType) {

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/linknewdevice/ContinuationMessageSender.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.api.linknewdevice
+
+interface ContinuationMessageSender {
+    suspend fun cancel(): Result<Unit>
+    suspend fun confirm(): Result<Unit>
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/linknewdevice/LinkDesktopHandler.kt

@@ -18,8 +18,10 @@ interface LinkDesktopHandler {
 sealed interface LinkDesktopStep {
     data object Uninitialized : LinkDesktopStep
     data object Starting : LinkDesktopStep
+
     data class WaitingForAuth(
         val verificationUri: String,
+        val continuationMessageSender: ContinuationMessageSender,
     ) : LinkDesktopStep
 
     data class EstablishingSecureChannel(

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/linknewdevice/LinkMobileHandler.kt

@@ -22,7 +22,12 @@ sealed interface LinkMobileStep {
     data object Starting : LinkMobileStep
     data class QrReady(val data: String) : LinkMobileStep
     data object QrRotating : LinkMobileStep
-    data class WaitingForAuth(val verificationUri: String) : LinkMobileStep
+
+    data class WaitingForAuth(
+        val verificationUri: String,
+        val continuationMessageSender: ContinuationMessageSender,
+    ) : LinkMobileStep
+
     data class QrScanned(val checkCodeSender: CheckCodeSender) : LinkMobileStep
     data class Error(val errorType: ErrorType) : LinkMobileStep
     data object SyncingSecrets : LinkMobileStep

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/RustContinuationMessageSender.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.linknewdevice
+
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+import io.element.android.libraries.matrix.api.linknewdevice.ContinuationMessageSender
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import org.matrix.rustcomponents.sdk.ContinuationMessageSender as FfiContinuationMessageSender
+
+class RustContinuationMessageSender(
+    private val inner: FfiContinuationMessageSender,
+    private val sessionDispatcher: CoroutineDispatcher,
+) : ContinuationMessageSender {
+    override suspend fun cancel(): Result<Unit> = withContext(sessionDispatcher) {
+        runCatchingExceptions {
+            inner.cancel()
+        }
+    }
+
+    override suspend fun confirm(): Result<Unit> = withContext(sessionDispatcher) {
+        runCatchingExceptions {
+            inner.confirm()
+        }
+    }
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/RustLinkDesktopHandler.kt

@@ -75,6 +75,10 @@ class RustLinkDesktopHandler(
         GrantQrLoginProgress.SyncingSecrets -> LinkDesktopStep.SyncingSecrets
         is GrantQrLoginProgress.WaitingForAuth -> LinkDesktopStep.WaitingForAuth(
             verificationUri = verificationUri,
+            continuationMessageSender = RustContinuationMessageSender(
+                inner = continuationSender,
+                sessionDispatcher = sessionDispatcher,
+            )
         )
         is GrantQrLoginProgress.EstablishingSecureChannel -> LinkDesktopStep.EstablishingSecureChannel(
             checkCode = checkCode,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/RustLinkMobileHandler.kt

@@ -84,7 +84,13 @@ class RustLinkMobileHandler(
             )
             GrantGeneratedQrLoginProgress.Starting -> LinkMobileStep.Starting
             GrantGeneratedQrLoginProgress.SyncingSecrets -> LinkMobileStep.SyncingSecrets
-            is GrantGeneratedQrLoginProgress.WaitingForAuth -> LinkMobileStep.WaitingForAuth(verificationUri)
+            is GrantGeneratedQrLoginProgress.WaitingForAuth -> LinkMobileStep.WaitingForAuth(
+                verificationUri = verificationUri,
+                continuationMessageSender = RustContinuationMessageSender(
+                    inner = continuationSender,
+                    sessionDispatcher = sessionDispatcher,
+                )
+            )
         }
     }
 }

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/FakeContinuationMessageSender.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.linknewdevice
+
+import io.element.android.libraries.matrix.api.linknewdevice.ContinuationMessageSender
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.simulateLongTask
+
+class FakeContinuationMessageSender(
+    private val cancelResult: () -> Result<Unit> = { lambdaError() },
+    private val confirmResult: () -> Result<Unit> = { lambdaError() },
+) : ContinuationMessageSender {
+    override suspend fun cancel(): Result<Unit> = simulateLongTask {
+        cancelResult()
+    }
+
+    override suspend fun confirm(): Result<Unit> = simulateLongTask {
+        confirmResult()
+    }
+}

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/RustLinkDesktopHandlerTest.kt

@@ -16,6 +16,8 @@ import io.element.android.libraries.matrix.api.linknewdevice.LinkDesktopStep
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiContinuationMessageSender
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiGrantLoginWithQrCodeHandler
 import io.element.android.libraries.matrix.test.QR_CODE_DATA
+import io.element.android.tests.testutils.ExpectedResult
+import io.element.android.tests.testutils.match
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
@@ -50,16 +52,18 @@ class RustLinkDesktopHandlerTest {
             runCurrent()
             // progress from the handler is mapped and emitted
             listOf(
-                GrantQrLoginProgress.Starting to LinkDesktopStep.Starting,
+                GrantQrLoginProgress.Starting to ExpectedResult(LinkDesktopStep.Starting),
-                GrantQrLoginProgress.SyncingSecrets to LinkDesktopStep.SyncingSecrets,
+                GrantQrLoginProgress.SyncingSecrets to ExpectedResult(LinkDesktopStep.SyncingSecrets),
                 GrantQrLoginProgress.WaitingForAuth("aVerificationUri", FakeFfiContinuationMessageSender())
-                    to LinkDesktopStep.WaitingForAuth("aVerificationUri"),
+                    to ExpectedResult(
+                    resultClass = LinkDesktopStep.WaitingForAuth::class.java,
+                ),
                 GrantQrLoginProgress.EstablishingSecureChannel(1.toUByte(), "1")
-                    to LinkDesktopStep.EstablishingSecureChannel(1.toUByte(), "1"),
+                    to ExpectedResult(LinkDesktopStep.EstablishingSecureChannel(1.toUByte(), "1")),
-                GrantQrLoginProgress.Done to LinkDesktopStep.Done,
+                GrantQrLoginProgress.Done to ExpectedResult(LinkDesktopStep.Done),
-            ).forEach { (progress, expectedStep) ->
+            ).forEach { (progress, expectedResult) ->
                 handler.emitScanProgress(progress)
-                assertThat(awaitItem()).isEqualTo(expectedStep)
+                assertThat(awaitItem()).match(expectedResult)
             }
             // scan returns, no new event is emitted
             completable.complete(Unit)

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/linknewdevice/RustLinkMobileHandlerTest.kt

@@ -18,6 +18,8 @@ import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiContinuati
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiGrantLoginWithQrCodeHandler
 import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeFfiQrCodeData
 import io.element.android.libraries.matrix.test.QR_CODE_DATA_RECIPROCATE
+import io.element.android.tests.testutils.ExpectedResult
+import io.element.android.tests.testutils.match
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.launch
@@ -51,18 +53,18 @@ class RustLinkMobileHandlerTest {
             runCurrent()
             // progress from the handler is mapped and emitted
             listOf(
-                GrantGeneratedQrLoginProgress.Starting to LinkMobileStep.Starting::class.java,
+                GrantGeneratedQrLoginProgress.Starting to ExpectedResult(LinkMobileStep.Starting),
-                GrantGeneratedQrLoginProgress.SyncingSecrets to LinkMobileStep.SyncingSecrets::class.java,
+                GrantGeneratedQrLoginProgress.SyncingSecrets to ExpectedResult(LinkMobileStep.SyncingSecrets),
                 GrantGeneratedQrLoginProgress.WaitingForAuth("aVerificationUri", FakeFfiContinuationMessageSender())
-                    to LinkMobileStep.WaitingForAuth::class.java,
+                    to ExpectedResult(LinkMobileStep.WaitingForAuth::class.java),
                 GrantGeneratedQrLoginProgress.QrScanned(FakeFfiCheckCodeSender())
-                    to LinkMobileStep.QrScanned::class.java,
+                    to ExpectedResult(LinkMobileStep.QrScanned::class.java),
                 GrantGeneratedQrLoginProgress.QrReady(FakeFfiQrCodeData(toBytesResult = { QR_CODE_DATA_RECIPROCATE }))
-                    to LinkMobileStep.QrReady::class.java,
+                    to ExpectedResult(LinkMobileStep.QrReady::class.java),
-                GrantGeneratedQrLoginProgress.Done to LinkMobileStep.Done::class.java,
+                GrantGeneratedQrLoginProgress.Done to ExpectedResult(LinkMobileStep.Done),
-            ).forEach { (progress, expectedStepClass) ->
+            ).forEach { (progress, expectedResult) ->
                 handler.emitGenerateProgress(progress)
-                assertThat(awaitItem()).isInstanceOf(expectedStepClass)
+                assertThat(awaitItem()).match(expectedResult)
             }
             // generate returns, no new event is emitted
             completable.complete(Unit)

tests/testutils/src/main/kotlin/io/element/android/tests/testutils/ExpectedResult.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.tests.testutils
+
+import com.google.common.truth.Subject
+
+/**
+ * A helper class to assert expected results in tests. It can be used to assert either the type of result or its value.
+ */
+data class ExpectedResult<T : Any>(
+    val resultClass: Class<out T>,
+    val result: T? = null,
+) {
+    constructor(result: T) : this(result::class.java, result)
+}
+
+fun <T : Any> Subject.match(expectedResult: ExpectedResult<T>) {
+    if (expectedResult.result != null) {
+        isEqualTo(expectedResult.result)
+    } else {
+        isInstanceOf(expectedResult.resultClass)
+    }
+}