Crea clases DeepLinkMatcher personalizadas

Si los comparadores proporcionados no son suficientes para tus casos de uso, puedes crear uno propio extendiendo la clase DeepLinkMatcher.

Cuando extiendas DeepLinkMatcher<T, R>, debes especificar dos argumentos de tipo: el tipo de clave de navegación de destino (T : Any) y el tipo de resultado de coincidencia (R : DeepLinkMatcher.MatchResult<T>). Si tu comparador no necesita una clasificación de resultados personalizada ni metadatos adicionales, usa DeepLinkMatcher.MatchResult<T> como el segundo argumento de tipo.

Por ejemplo, aquí tienes una implementación básica de un TelDeepLinkMatcher que admite URIs tel (como tel:5550100). Debido a que los URIs tel son opacos, UriDeepLinkMatcher no los admite:

class TelDeepLinkMatcher : DeepLinkMatcher<DialerKey, DeepLinkMatcher.MatchResult<DialerKey>>() {
    override fun matchRequest(request: DeepLinkRequest): MatchResult<DialerKey>? {
        val uri = request.uri ?: return null
        if (uri.scheme != "tel") return null

        // Note: schemeSpecificPart is only available on Android
        val phoneNumber = uri.schemeSpecificPart ?: return null
        return MatchResult(DialerKey(phoneNumber = phoneNumber))
    }
}
CustomMatchersSnippets.kt

Clasifica las clases personalizadas de MatchResult

Si hay una forma significativa de comparar los resultados de coincidencia de tu comparador personalizado, debes extender DeepLinkMatcher.MatchResult y anular el método compareTo para clasificar los resultados.

Cuando crees una subclase MatchResult personalizada, actualiza la declaración de clase de tu comparador para especificar esa subclase como su segundo parámetro de tipo R (como class TelDeepLinkMatcher : DeepLinkMatcher<DialerKey, TelMatchResult>()). Esto permite que los emisores accedan a las propiedades de resultados personalizadas sin una conversión de tipo de datos no verificada.

Por ejemplo, para admitir la coincidencia de patrones con comodines en TelDeepLinkMatcher, puedes implementar un TelMatchResult para garantizar que las coincidencias exactas tengan una clasificación más alta que las coincidencias con comodines. Si el comparador está unido en withBackStack, desenvuelve WrappedMatchResult antes de comparar para que la precedencia se evalúe en función del resultado de coincidencia subyacente:

class TelMatchResult(
    key: DialerKey,
    val isExactMatch: Boolean,
    val patternLength: Int
) : DeepLinkMatcher.MatchResult<DialerKey>(key) {
    override fun compareTo(other: DeepLinkMatcher.MatchResult<DialerKey>): Int {
        // Unwrap if the other result is wrapped in a BackStackMatchResult or custom WrappedMatchResult
        val target = if (other is WrappedMatchResult<*>) other.matchResult else other
        if (target !is TelMatchResult) {
            // Determine precedence relative to other MatchResult types (e.g. UriMatchResult)
            return 1
        }

        // An exact match wins over a wildcard/prefix match
        if (isExactMatch && !target.isExactMatch) return 1
        if (!isExactMatch && target.isExactMatch) return -1

        // The more specific (longer) pattern wins (e.g., tel:1800* versus tel:*)
        val lengthDiff = this.patternLength - target.patternLength
        if (lengthDiff != 0) {
            return lengthDiff
        }

        return 0
    }
}
CustomMatchersSnippets.kt