Crea clases DeepLinkMatcher personalizadas

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

Cuando extiendes 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 un ranking de resultados personalizado ni metadatos adicionales, usa DeepLinkMatcher.MatchResult<T> como el segundo argumento de tipo.

Por ejemplo, se incluye una implementación básica de TelDeepLinkMatcher que admite tel URIs (como tel:5550100). Debido a que las URIs tel son opacas, UriDeepLinkMatcher no las 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 MatchResult personalizadas

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

Cuando creas 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 llamadores accedan a las propiedades de resultado personalizadas sin una conversión forzada no verificada.

Por ejemplo, para admitir la coincidencia de patrones con comodines en TelDeepLinkMatcher, puedes implementar un TelMatchResult para garantizar que las coincidencias exactas se clasifiquen más alto que las coincidencias con comodines. Si el comparador está incluido en withBackStack, anula el ajuste de WrappedMatchResult antes de comparar para que la precedencia se evalúe con el 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