Créer des classes DeepLinkMatcher personnalisées

Si les correspondances fournies ne sont pas suffisantes pour vos cas d'utilisation, vous pouvez créer les vôtres en étendant la classe DeepLinkMatcher.

Lorsque vous étendez DeepLinkMatcher<T, R>, vous devez spécifier deux arguments de type : le type de clé de navigation de destination (T : Any) et le type de résultat de correspondance (R : DeepLinkMatcher.MatchResult<T>). Si votre correspondance n'a pas besoin de classement personnalisé des résultats ni de métadonnées supplémentaires, utilisez DeepLinkMatcher.MatchResult<T> comme deuxième argument de type.

Par exemple, voici une implémentation de base d'un TelDeepLinkMatcher qui accepte les URI tel (telles que tel:5550100). Étant donné que les URI tel sont opaques, UriDeepLinkMatcher ne les accepte pas :

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

Classer les classes MatchResult personnalisées

S'il existe un moyen pertinent de comparer les résultats de correspondance de votre correspondance personnalisée, vous devez étendre DeepLinkMatcher.MatchResult et remplacer la compareTo méthode pour classer les résultats.

Lorsque vous créez une sous-classe MatchResult personnalisée, mettez à jour la déclaration de classe de votre correspondance pour spécifier cette sous-classe comme deuxième paramètre de type R (par exemple class TelDeepLinkMatcher : DeepLinkMatcher<DialerKey, TelMatchResult>()). Cela permet aux appelants d'accéder aux propriétés de résultat personnalisées sans effectuer de conversion descendante non vérifiée.

Par exemple, pour accepter la correspondance de schémas avec caractères génériques dans TelDeepLinkMatcher, vous pouvez implémenter un TelMatchResult afin de vous assurer que les correspondances exactes sont mieux classées que les correspondances avec caractères génériques. Si la correspondance est encapsulée dans withBackStack, supprimez l'encapsulation de WrappedMatchResult avant de comparer afin que la priorité soit évaluée par rapport au résultat de correspondance sous-jacent :

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