Criar classes DeepLinkMatcher personalizadas

Se os correspondentes fornecidos não forem suficientes para seus casos de uso, você poderá criar seus próprios correspondentes estendendo a classe DeepLinkMatcher.

Ao estender DeepLinkMatcher<T, R>, é necessário especificar dois argumentos de tipo: o tipo de chave de navegação de destino (T : Any) e o tipo de resultado da correspondência (R : DeepLinkMatcher.MatchResult<T>). Se o correspondente não precisar de classificação de resultados personalizados ou metadados extras, use DeepLinkMatcher.MatchResult<T> como o segundo argumento de tipo.

Por exemplo, confira uma implementação básica de um TelDeepLinkMatcher que oferece suporte a URIs tel (como tel:5550100). Como as UR1s tel são opacas, UriDeepLinkMatcher não oferece suporte a elas:

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

Classificar classes MatchResult personalizadas

Se houver uma maneira significativa de comparar os resultados da correspondência do seu correspondente personalizado, você deve estender DeepLinkMatcher.MatchResult e substituir o compareTo método para classificar os resultados.

Ao criar uma subclasse MatchResult personalizada, atualize a declaração de classe do correspondente para especificar essa subclasse como o segundo parâmetro de tipo R (como class TelDeepLinkMatcher : DeepLinkMatcher<DialerKey, TelMatchResult>()). Isso permite que os autores da chamada acessem as propriedades de resultado personalizadas sem conversão implícita não verificada.

Por exemplo, para oferecer suporte à correspondência de padrões de caracteres curinga em TelDeepLinkMatcher, você pode implementar um TelMatchResult para garantir que as correspondências exatas sejam classificadas mais alto do que as correspondências de caracteres curinga. Se o correspondente estiver encapsulado em withBackStack, desembrulhe WrappedMatchResult antes de comparar para que a precedência seja avaliada em relação ao resultado da correspondência subjacente:

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