Créer des liens dynamiques sur Android

Vous pouvez créer des liens dynamiques courts ou longs avec l'API Firebase Dynamic Links Builder. Cette API accepte soit un lien dynamique long, soit un objet contenant des paramètres de lien dynamique, et renvoie des URL comme dans les exemples suivants :

https://example.com/link/WXYZ
https://example.page.link/WXYZ

Avant de pouvoir créer des liens dynamiques dans votre application Android, vous devez inclure le SDK Firebase. Si votre application est configurée pour recevoir des liens dynamiques, vous avez déjà effectué ces étapes et vous pouvez ignorer cette section.

  1. Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet Android .

    Lorsque vous enregistrez votre application, spécifiez votre clé de signature SHA-1. Si vous utilisez App Links, spécifiez également votre clé SHA-256.

  2. Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), ajoutez la dépendance pour les liens dynamiques bibliothèque pour Android. Nous vous recommandons d'utiliser la BoM Android Firebase pour contrôler la gestion des versions de la bibliothèque.

    Pour une expérience optimale avec Dynamic Links, nous vous recommandons d'activer Google Analytics dans votre projet Firebase et d'ajouter le SDK Firebase pour Google Analytics à votre application.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.3"))
    
        // Add the dependencies for the Dynamic Links and Analytics libraries
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-dynamic-links'
        implementation 'com.google.firebase:firebase-analytics'
    }
    

    En utilisant Firebase Android BoM , votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

    (Alternative) Ajouter des dépendances de la bibliothèque Firebase sans utiliser la BoM

    Si vous choisissez de ne pas utiliser la BoM Firebase, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

    Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons fortement d'utiliser la BoM pour gérer les versions de bibliothèque, ce qui garantit que toutes les versions sont compatibles.

    dependencies {
        // Add the dependencies for the Dynamic Links and Analytics libraries
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation 'com.google.firebase:firebase-dynamic-links:21.2.0'
        implementation 'com.google.firebase:firebase-analytics:21.5.1'
    }
    
    Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir d' octobre 2023 (Firebase BoM 32.5.0) , les développeurs Kotlin et Java peuvent s'appuyer sur le module de bibliothèque principal (pour plus de détails, consultez la FAQ sur cette initiative ).
  3. Dans la console Firebase, ouvrez la section Liens dynamiques .
  4. Si vous n'avez pas encore accepté les conditions d'utilisation et défini un domaine pour vos Dynamic Links, faites-le lorsque vous y êtes invité.

    Si vous possédez déjà un domaine Dynamic Links, prenez-en note. Vous devez fournir un domaine Dynamic Links lorsque vous créez des Dynamic Links par programme.

  5. Recommandé : Spécifiez les modèles d'URL autorisés dans vos liens profonds et vos liens de secours. Ce faisant, vous empêchez des tiers non autorisés de créer des liens dynamiques qui redirigent depuis votre domaine vers des sites que vous ne contrôlez pas. Voir Autoriser des modèles d'URL spécifiques .

Utiliser la console Firebase

Si vous souhaitez générer un seul lien dynamique, soit à des fins de test, soit pour que votre équipe marketing puisse créer facilement un lien pouvant être utilisé dans quelque chose comme une publication sur les réseaux sociaux, le moyen le plus simple serait de visiter la console Firebase et d'en créer un. en suivant manuellement le formulaire étape par étape.

Pour créer un Dynamic Link, créez un nouvel objet DynamicLink avec son Builder, en spécifiant les paramètres Dynamic Link avec les méthodes Builder. Ensuite, appelez buildDynamicLink ou buildShortDynamicLink .

L'exemple minimal suivant crée un long lien dynamique vers https://www.example.com/ qui s'ouvre avec votre application Android sur Android et l'application com.example.ios sur iOS :

Kotlin+KTX

val dynamicLink = Firebase.dynamicLinks.dynamicLink {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Open links with this app on Android
    androidParameters { }
    // Open links with com.example.ios on iOS
    iosParameters("com.example.ios") { }
}

val dynamicLinkUri = dynamicLink.uri

Java

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Open links with this app on Android
        .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build())
        // Open links with com.example.ios on iOS
        .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build())
        .buildDynamicLink();

Uri dynamicLinkUri = dynamicLink.getUri();

Pour créer un Dynamic Link court, créez un DynamicLink de la même manière, puis appelez buildShortDynamicLink . La création d'un lien court nécessite un appel réseau, donc au lieu de renvoyer directement le lien, buildShortDynamicLink renvoie un Task , qui rend le lien court disponible une fois la demande terminée. Par exemple:

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    // Set parameters
    // ...
}.addOnSuccessListener { (shortLink, flowchartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowchartLink)
}.addOnFailureListener {
    // Error
    // ...
}

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        // Set parameters
        // ...
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });

Par défaut, les liens dynamiques courts sont générés avec des suffixes de lien de 17 caractères, ce qui rend extrêmement improbable que quelqu'un puisse deviner un lien dynamique valide. Si, pour votre cas d'utilisation, il n'y a aucun mal à ce que quelqu'un réussisse à deviner un lien court, vous préférerez peut-être générer des suffixes aussi longs que nécessaire pour être uniques, ce que vous pouvez faire en passant ShortDynamicLink.Suffix.SHORT à la méthode buildShortDynamicLink . :

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) {
    // Set parameters
    // ...
}

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        // ...
        .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT);
        // ...

Vous pouvez utiliser l'API Dynamic Link Builder pour créer des liens dynamiques avec l'un des paramètres pris en charge. Consultez la référence API pour plus de détails.

L'exemple suivant crée un lien dynamique avec plusieurs paramètres communs définis :

Kotlin+KTX

val dynamicLink = Firebase.dynamicLinks.dynamicLink { // or Firebase.dynamicLinks.shortLinkAsync
    link = Uri.parse("https://www.example.com/")
    domainUriPrefix = "https://example.page.link"
    androidParameters("com.example.android") {
        minimumVersion = 125
    }
    iosParameters("com.example.ios") {
        appStoreId = "123456789"
        minimumVersion = "1.0.1"
    }
    googleAnalyticsParameters {
        source = "orkut"
        medium = "social"
        campaign = "example-promo"
    }
    itunesConnectAnalyticsParameters {
        providerToken = "123456"
        campaignToken = "example-promo"
    }
    socialMetaTagParameters {
        title = "Example of a Dynamic Link"
        description = "This link works whether the app is installed or not!"
    }
}

Java

DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLink(Uri.parse("https://www.example.com/"))
        .setDomainUriPrefix("https://example.page.link")
        .setAndroidParameters(
                new DynamicLink.AndroidParameters.Builder("com.example.android")
                        .setMinimumVersion(125)
                        .build())
        .setIosParameters(
                new DynamicLink.IosParameters.Builder("com.example.ios")
                        .setAppStoreId("123456789")
                        .setMinimumVersion("1.0.1")
                        .build())
        .setGoogleAnalyticsParameters(
                new DynamicLink.GoogleAnalyticsParameters.Builder()
                        .setSource("orkut")
                        .setMedium("social")
                        .setCampaign("example-promo")
                        .build())
        .setItunesConnectAnalyticsParameters(
                new DynamicLink.ItunesConnectAnalyticsParameters.Builder()
                        .setProviderToken("123456")
                        .setCampaignToken("example-promo")
                        .build())
        .setSocialMetaTagParameters(
                new DynamicLink.SocialMetaTagParameters.Builder()
                        .setTitle("Example of a Dynamic Link")
                        .setDescription("This link works whether the app is installed or not!")
                        .build())
        .buildDynamicLink();  // Or buildShortDynamicLink()

Vous pouvez définir les paramètres Dynamic Link avec les méthodes suivantes :

Paramètres DynamicLink
setLink

Le lien que votre application ouvrira. Spécifiez une URL que votre application peut gérer, généralement le contenu ou la charge utile de l'application, qui lance une logique spécifique à l'application (par exemple, créditer l'utilisateur d'un coupon ou afficher un écran de bienvenue). Ce lien doit être une URL bien formatée, être correctement codée en URL, utiliser HTTP ou HTTPS et ne peut pas être un autre lien dynamique.

setDomainUriPrefix Votre préfixe d'URL Dynamic Link, que vous pouvez trouver dans la console Firebase. Un domaine Dynamic Link ressemble aux exemples suivants :
https://example.com/link
https://example.page.link
Paramètres Android
setFallbackUrl Le lien à ouvrir lorsque l'application n'est pas installée. Spécifiez cette option pour faire autre chose que d'installer votre application à partir du Play Store lorsque l'application n'est pas installée, comme ouvrir la version Web mobile du contenu ou afficher une page promotionnelle pour votre application.
définirVersionMinimum Le versionCode de la version minimale de votre application qui peut ouvrir le lien. Si l'application installée est une ancienne version, l'utilisateur est redirigé vers le Play Store pour mettre à niveau l'application.
Paramètres Ios
setAppStoreId L'identifiant App Store de votre application, utilisé pour envoyer les utilisateurs vers l'App Store lorsque l'application n'est pas installée
setFallbackUrl Le lien à ouvrir lorsque l'application n'est pas installée. Spécifiez cette option pour faire autre chose que d'installer votre application depuis l'App Store lorsque l'application n'est pas installée, comme ouvrir la version Web mobile du contenu ou afficher une page promotionnelle pour votre application.
setCustomScheme Le schéma d'URL personnalisé de votre application, s'il est défini comme étant autre chose que l'ID du bundle de votre application
setIpadFallbackUrl Le lien à ouvrir sur les iPad lorsque l'application n'est pas installée. Spécifiez ceci pour faire autre chose que d'installer votre application depuis l'App Store lorsque l'application n'est pas installée, comme ouvrir la version Web du contenu ou afficher une page promotionnelle pour votre application.
setIpadBundleId L'ID du bundle de l'application iOS à utiliser sur les iPad pour ouvrir le lien. L'application doit être connectée à votre projet depuis la page Présentation de la console Firebase.
définirVersionMinimum Le numéro de version de la version minimale de votre application qui peut ouvrir le lien. Cet indicateur est transmis à votre application lors de son ouverture, et votre application doit décider quoi en faire.
NavigationInfoParamètres
setForcedRedirectEnabled S'il est défini sur « 1 », ignorez la page d'aperçu de l'application lorsque le lien dynamique est ouvert et redirigez-le vers l'application ou la boutique. La page d'aperçu de l'application (activée par défaut) peut envoyer de manière plus fiable les utilisateurs vers la destination la plus appropriée lorsqu'ils ouvrent des liens dynamiques dans les applications ; cependant, si vous vous attendez à ce qu'un Dynamic Link soit ouvert uniquement dans les applications capables d'ouvrir des Dynamic Links de manière fiable sans cette page, vous pouvez le désactiver avec ce paramètre. Ce paramètre affectera le comportement du Dynamic Link uniquement sur iOS.
SocialMetaTagParamètres
définirTitre Le titre à utiliser lorsque le lien dynamique est partagé dans une publication sociale.
setDescription Description à utiliser lorsque le lien dynamique est partagé dans une publication sociale.
setImageUrl L'URL d'une image liée à ce lien. L'image doit mesurer au moins 300 x 200 px et moins de 300 Ko.
Paramètres GoogleAnalytics
setSource
setMedium
définirCampagne
définirTerme
définirContenu
Paramètres d'analyse de Google Play. Ces paramètres ( utm_source , utm_medium , utm_campaign , utm_term , utm_content ) sont transmis au Play Store et ajoutés à la charge utile du lien.
iTunesConnectAnalyticsParamètres
setProviderToken
setAffiliateToken
setCampaignToken
Paramètres d'analyse iTunes Connect. Ces paramètres ( pt , at , ct ) sont transmis à l'App Store.

Pour raccourcir un lien dynamique long, spécifiez l'URL du lien dynamique à l'aide setLongLink au lieu de définir les paramètres avec les autres méthodes de création :

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync {
    longLink = Uri.parse(
        "https://example.page.link/?link=" +
            "https://www.example.com/&apn=com.example.android&ibn=com.example.ios",
    )
}.addOnSuccessListener { (shortLink, flowChartLink) ->
    // You'll need to import com.google.firebase.dynamiclinks.component1 and
    // com.google.firebase.dynamiclinks.component2

    // Short link created
    processShortLink(shortLink, flowChartLink)
}.addOnFailureListener {
    // Error
    // ...
}

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        .setLongLink(Uri.parse("https://example.page.link/?link=https://www.example.com/&apn=com.example.android&ibn=com.example.ios"))
        .buildShortDynamicLink()
        .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() {
            @Override
            public void onComplete(@NonNull Task<ShortDynamicLink> task) {
                if (task.isSuccessful()) {
                    // Short link created
                    Uri shortLink = task.getResult().getShortLink();
                    Uri flowchartLink = task.getResult().getPreviewLink();
                } else {
                    // Error
                    // ...
                }
            }
        });