Criar classes DeepLinkMatcher personalizadas

Se os comparadores fornecidos não forem suficientes para seus casos de uso, crie os seus 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 de correspondência (R : DeepLinkMatcher.MatchResult<T>). Se o matcher não precisar de classificação de resultados personalizada ou metadados extras, use DeepLinkMatcher.MatchResult<T> como o segundo argumento de tipo.

Por exemplo, veja uma implementação básica de um TelDeepLinkMatcher que oferece suporte a URIs tel (como tel:5550100). Como os URIs tel são opacos, o UriDeepLinkMatcher não oferece suporte a eles:

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 personalizadas de MatchResult

Se houver uma maneira significativa de comparar os resultados de correspondência do seu comparador personalizado, estenda DeepLinkMatcher.MatchResult e substitua o método compareTo 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 de chamada acessem as propriedades de resultado personalizadas sem downcasting não verificado.

Por exemplo, para oferecer suporte à correspondência de padrões de caracteres curinga em TelDeepLinkMatcher, é possível implementar um TelMatchResult para garantir que as correspondências exatas tenham uma classificação mais alta do que as correspondências de caracteres curinga. Se o matcher estiver encapsulado em withBackStack, remova o encapsulamento de WrappedMatchResult antes de comparar para que a precedência seja avaliada em relação ao resultado de correspondência:

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