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 définissez des instances DeepLinkMatcher.

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

Étant donné que plusieurs correspondances 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, préserve 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

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

La bibliothèque inclut des fonctions d'assistance pour 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

Étant donné que 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 correspondances fournies

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

Faire correspondre des liens profonds de base

Pour les liens profonds de base qui ne comportent 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 des liens profonds d'URI

Pour faire correspondre des URI hiérarchiques à 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 Faire correspondre des 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 BackStackMatcher directement, 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 "Retour" synthétique List. Étant donné que BackStackMatchResult délègue la comparaison au résultat de correspondance sous-jacent, l'encapsulation d'une 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" résultante dans votre activité, consultez Faire correspondre une requête entrante.