Créer des instances DeepLinkMatcher

Pour mapper les instances DeepLinkRequest entrantes à des clés pouvant être ajoutées à la pile « Retour » de votre application, vous devez définir des instances DeepLinkMatcher.

DeepLinkMatcher est une classe abstraite qui inclut deux méthodes, match et matchRequest. Les sous-classes doivent implémenter matchRequest, qui utilise un DeepLinkRequest et renvoie un DeepLinkMatcher.MatchResult si la requête correspond, ou null dans le cas contraire.

Étant donné que plusieurs outils de mise en correspondance peuvent correspondre à une seule requête, MatchResult implémente Comparable pour classer les résultats et sélectionner la meilleure correspondance.

Paramètres de type

La classe DeepLinkMatcher déclare deux paramètres de type générique : DeepLinkMatcher<T : Any, R : DeepLinkMatcher.MatchResult<T>>.

• T : Any : type de clé de navigation de destination (tel que UserProfileKey ou NavKey) renvoyé lorsque le lien profond correspond.
• R : DeepLinkMatcher.MatchResult<T> : sous-type MatchResult spécifique renvoyé par matchRequest et match.

Le deuxième paramètre de type, R, conserve les informations de correspondance spécialisées sans nécessiter de downcasting non vérifié :

• StaticKeyDeepLinkMatcher lie R à DeepLinkMatcher.MatchResult<T>.
• UriDeepLinkMatcher lie R à UriMatchResult, en conservant le chemin d'accès analysé et les arguments de requête, ainsi que les scores de correspondance de modèle.
• BackStackMatcher lie R à BackStackMatchResult, en conservant la liste de la pile "Retour" synthétique construite par withBackStack.

Préfiltrer les requêtes

Les implémentations DeepLinkMatcher peuvent spécifier une liste d'instances DeepLinkMatcher.Filter pour filtrer les requêtes avant de les évaluer.

La bibliothèque inclut des fonctions d'assistance permettant de créer des filtres courants :

• DeepLinkMatcher.mimeTypeFilter : correspond aux chaînes mimeType exactes (vérifie MimeTypeExtrasKey).
• DeepLinkMatcher.actionFilter : correspond aux chaînes action exactes (vérifie ActionExtrasKey).

Cette approche vous permet de réutiliser le même modèle d'URI pour différentes actions, telles que l'affichage et la modification :

val viewFilter = DeepLinkMatcher.actionFilter(Intent.ACTION_VIEW)
val editFilter = DeepLinkMatcher.actionFilter(Intent.ACTION_EDIT)

val imageUriPattern = DeepLinkUri("www.example.com/image/{id}")

val viewMatcher = UriDeepLinkMatcher(imageUriPattern, serializer<Gallery>(), filters = listOf(viewFilter))
val editMatcher = UriDeepLinkMatcher(imageUriPattern, serializer<Editor>(), filters = listOf(editFilter))
CreateMatchersSnippets.kt

Comme Filter est une interface fonctionnelle (SAM), vous pouvez également créer des filtres à l'aide d'expressions lambda :

val myFilter = DeepLinkMatcher.Filter { request -> request.uri != null }
CreateMatchersSnippets.kt

Utiliser les outils de mise en correspondance fournis

La bibliothèque inclut trois implémentations DeepLinkMatcher standards : StaticKeyDeepLinkMatcher, UriDeepLinkMatcher et BackStackMatcher. Si ces outils de mise en correspondance ne répondent pas aux exigences de votre application, vous pouvez créer des outils de mise en correspondance de liens profonds personnalisés.

Mettre en correspondance des liens profonds de base

Pour les liens profonds de base qui n'ont pas d'arguments à extraire, utilisez StaticKeyDeepLinkMatcher pour faire correspondre les requêtes qui répondent à tous les filtres fournis.

Par exemple, pour gérer les intents pour ACTION_APPLICATION_PREFERENCES :

val preferencesActionFilter = DeepLinkMatcher.actionFilter(Intent.ACTION_APPLICATION_PREFERENCES)

val preferencesActionDeepLinkMatcher = StaticKeyDeepLinkMatcher(PreferencesScreen, listOf(preferencesActionFilter))
CreateMatchersSnippets.kt

Faire correspondre les liens profonds d'URI

Pour mettre en correspondance des URI hiérarchiques avec des modèles et extraire des arguments, utilisez UriDeepLinkMatcher. Par exemple, vous pouvez faire correspondre www.example.com/users/{id} pour extraire l'argument id dans une clé de destination. Pour en savoir plus, consultez Mettre en correspondance les liens profonds d'URI.

Créer une pile "Retour" synthétique

Pour définir comment créer une pile "Retour" synthétique à partir d'une correspondance réussie, utilisez BackStackMatcher. Plutôt que d'instancier directement BackStackMatcher, appelez la fonction d'extension withBackStack sur un autre DeepLinkMatcher. withBackStack encapsule le récepteur dans un BackStackMatcher qui renvoie un BackStackMatchResult contenant une pile d'historique synthétique List. Étant donné que BackStackMatchResult délègue la comparaison au résultat de correspondance sous-jacent, encapsuler un outil de mise en correspondance dans withBackStack préserve son classement de correspondance d'origine.

val homeMatcher = StaticKeyDeepLinkMatcher(HomeKey, listOf(DeepLinkMatcher.actionFilter(Intent.ACTION_VIEW)))

val userListMatcher = UriDeepLinkMatcher(
    DeepLinkUri("www.example.com/users?page={page}"),
    serializer<UserListKey>()
).withBackStack { matchResult ->
    listOf(HomeKey, matchResult.key)
}

val userProfileMatcher = UriDeepLinkMatcher(
    DeepLinkUri("www.example.com/users/{id}"),
    serializer<UserProfileKey>()
).withBackStack { matchResult ->
    listOf(HomeKey, UserListKey(), matchResult.key)
}
CreateMatchersSnippets.kt

Pour gérer la pile "Retour" obtenue dans votre activité, consultez Mettre en correspondance une requête entrante.