Updated on 2026-08-14

app/src/main/java/com/tangem/tap/routing/component/impl/DefaultRoutingComponent.kt

@@ -22,6 +22,7 @@ import com.tangem.tap.routing.component.RoutingComponent
 import com.tangem.tap.routing.component.RoutingComponent.Child
 import com.tangem.tap.routing.configurator.AppRouterConfig
 import com.tangem.tap.routing.utils.ChildFactory
+import com.tangem.tap.routing.utils.DeepLinkFactory
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedFactory
 import dagger.assisted.AssistedInject
@@ -34,6 +35,7 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
     private val appRouterConfig: AppRouterConfig,
     private val uiDependencies: UiDependencies,
     private val wcRoutingComponentFactory: WcRoutingComponent.Factory,
+    private val deeplinkFactory: DeepLinkFactory,
 ) : RoutingComponent,
     AppComponentContext by context,
     SnackbarHandler {
@@ -60,7 +62,10 @@ internal class DefaultRoutingComponent @AssistedInject constructor(
 
         stack.subscribe(lifecycle) { stack ->
             val stackItems = stack.items.map { it.configuration }
+
             wcRoutingComponent.onAppRouteChange(stack.active.configuration)
+            deeplinkFactory.checkRoutingReadiness(stack.active.configuration)
+
             if (appRouterConfig.stack != stackItems) {
                 appRouterConfig.stack = stackItems
             }

app/src/main/java/com/tangem/tap/routing/utils/DeepLinkFactory.kt

@@ -0,0 +1,123 @@
+package com.tangem.tap.routing.utils
+
+import android.net.Uri
+import com.tangem.common.routing.AppRoute
+import com.tangem.common.routing.DeepLinkRoute
+import com.tangem.common.routing.DeepLinkScheme
+import com.tangem.features.onramp.deeplink.OnrampDeepLinkHandler
+import com.tangem.utils.coroutines.JobHolder
+import com.tangem.utils.coroutines.saveIn
+import dagger.hilt.android.scopes.ActivityScoped
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.transformLatest
+import timber.log.Timber
+import javax.inject.Inject
+
+@ActivityScoped
+internal class DeepLinkFactory @Inject constructor(
+    private val onrampDeepLink: OnrampDeepLinkHandler.Factory,
+) {
+    private val permittedAppRoute = MutableStateFlow(false)
+
+    private var lastDeepLink: Uri? = null
+    private val deepLinkHandlerJobHolder = JobHolder()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    fun handleDeeplink(deeplinkUri: Uri, coroutineScope: CoroutineScope) {
+        lastDeepLink = deeplinkUri
+
+        Timber.i(
+            """
+                Received deep link intent
+                |- Received URI: $deeplinkUri
+            """.trimIndent(),
+        )
+        permittedAppRoute
+            .transformLatest<Boolean, Unit> { isPermitted ->
+                if (isPermitted) {
+                    lastDeepLink?.let {
+                        launchDeepLink(it, coroutineScope)
+                    }
+                    lastDeepLink = null
+                }
+            }
+            .launchIn(coroutineScope)
+            .saveIn(deepLinkHandlerJobHolder)
+    }
+
+    /**
+     * Check if app is ready to handle deeplink
+     */
+    fun checkRoutingReadiness(appRoute: AppRoute) {
+        permittedAppRoute.value = when (appRoute) {
+            AppRoute.Initial,
+            AppRoute.Home,
+            is AppRoute.Welcome,
+            is AppRoute.Disclaimer,
+            is AppRoute.Stories,
+            is AppRoute.Onboarding,
+            -> false
+            else -> true
+        }
+    }
+
+    private fun launchDeepLink(deeplinkUri: Uri, coroutineScope: CoroutineScope) {
+        when (deeplinkUri.scheme) {
+            DeepLinkScheme.Tangem.scheme -> handleTangemDeepLinks(deeplinkUri, coroutineScope)
+            else -> {
+                Timber.i(
+                    """
+                        No match found for deep link
+                        |- Received URI: $deeplinkUri
+                    """.trimIndent(),
+                )
+            }
+        }
+    }
+
+    private fun handleTangemDeepLinks(deeplinkUri: Uri, coroutineScope: CoroutineScope) {
+        val params = getParams(deeplinkUri)
+        when (deeplinkUri.host) {
+            DeepLinkRoute.Onramp.host -> onrampDeepLink.create(coroutineScope, params)
+            else -> {
+                Timber.i(
+                    """
+                        No match found for deep link
+                        |- Received URI: $deeplinkUri
+                        |- With params: $params
+                    """.trimIndent(),
+                )
+            }
+        }
+    }
+
+    private fun getParams(uri: Uri): Map<String, String> {
+        val params = mutableMapOf<String, String>()
+
+        uri.queryParameterNames.forEach { paramName ->
+            val paramValue = uri.getQueryParameter(paramName)
+
+            if (paramName.validate() && paramValue?.validate() == true) {
+                params[paramName] = paramValue
+            }
+        }
+
+        return params
+    }
+
+    /**
+     * Check for malicious symbol in uri part
+     */
+    private fun String.validate(): Boolean {
+        val regex = DEEPLINK_VALIDATION_REGEX.toRegex()
+
+        return !regex.containsMatchIn(this)
+    }
+
+    private companion object {
+        const val DEEPLINK_VALIDATION_REGEX = "['\";<>()+\\\\]"
+    }
+}