Créer des liens dynamiques sur Android

Obsolète:Firebase Dynamic Links est obsolète et ne doit pas être adopté dans les projets qui ne l'utilisent pas déjà. Le service sera arrêté le 25 août 2025. Pour en savoir plus, consultez les questions fréquentes sur l'abandon des liens dynamiques.

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

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

Configurer Firebase et le SDK Dynamic Links

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

1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android.

   Lorsque vous enregistrez votre application, spécifiez votre clé de signature SHA-1. Si vous utilisez des liens d'application, 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 la bibliothèque Dynamic Links pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler le contrôle 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:33.6.0"))
   
       // 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) Ajoutez des dépendances de bibliothèque Firebase sans utiliser BoM.

   Si vous choisissez de ne pas utiliser Firebase BoM, 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 vivement d'utiliser BoM pour gérer les versions de la 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:22.1.0'
       implementation 'com.google.firebase:firebase-analytics:22.1.2'
   }
   

   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 dépendre du module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).
3. Dans la console Firebase, ouvrez la section Dynamic Links.

4. Si vous n'avez pas encore accepté les conditions d'utilisation et défini un domaine pour votre Dynamic Links, faites-le lorsque vous y êtes invité.

   Si vous possédez déjà un domaine Dynamic Links, notez-le. Vous devez fournir un domaine Dynamic Links lorsque vous créez Dynamic Links de manière programmatique.

   

5. Recommandé: indiquez les formats d'URL autorisés pour vos liens profonds et liens de remplacement. Vous empêchez ainsi des tiers non autorisés de créer des Dynamic Links qui redirigent de votre domaine vers des sites que vous ne contrôlez pas. Consultez Autoriser des modèles d'URL spécifiques.

Utiliser la console Firebase

Si vous souhaitez générer un seul Dynamic Link, à des fins de test ou pour que votre équipe marketing crée facilement un lien pouvant être utilisé dans un post sur les réseaux sociaux, le moyen le plus simple est d'accéder à la console Firebase et d'en créer un manuellement en suivant le formulaire par étapes.

Créer un Dynamic Link à partir de paramètres

Pour créer un Dynamic Link, créez un objet DynamicLink avec son compilateur, en spécifiant les paramètres Dynamic Link avec les méthodes du compilateur. Appelez ensuite buildDynamicLink ou buildShortDynamicLink.

L'exemple minimal suivant crée une longue Dynamic Link 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
MainActivity.kt

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();
MainActivity.java

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. Par conséquent, au lieu de renvoyer directement le lien, buildShortDynamicLink renvoie un Task, ce qui rend le lien court disponible une fois la requête terminée. 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
    // ...
}
MainActivity.kt

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
                    // ...
                }
            }
        });
MainActivity.java

Par défaut, les Dynamic Links courts sont générés avec des suffixes de lien de 17 caractères qui rendent extrêmement improbable que quelqu'un puisse deviner un Dynamic Link valide. Si, pour votre cas d'utilisation, il n'y a pas de mal à ce que quelqu'un devine un lien court, vous pouvez préférer générer des suffixes aussi longs que nécessaire pour être uniques. Pour ce faire, transmettez ShortDynamicLink.Suffix.SHORT à la méthode buildShortDynamicLink:

Kotlin+KTX

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

Java

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

Paramètres Dynamic Link

Vous pouvez utiliser l'API de compilation Dynamic Link pour créer des Dynamic Links avec n'importe quel paramètre compatible. Pour en savoir plus, consultez la documentation de référence de l'API.

L'exemple suivant crée un Dynamic Link avec plusieurs paramètres courants 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!"
    }
}
MainActivity.kt

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()
MainActivity.java

Vous pouvez définir les paramètres Dynamic Link à l'aide des méthodes suivantes:

Paramètres DynamicLink
setLink	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, attribuer un bon de réduction à l'utilisateur ou afficher un écran de bienvenue). Ce lien doit être une URL bien formatée, correctement encodée en URL, utiliser HTTP ou HTTPS, et ne pas être un autre lien dynamique. Lorsque les utilisateurs ouvrent un Dynamic Link dans un navigateur Web pour ordinateur, ils chargent cette URL (sauf si le paramètre ofl est spécifié). Si vous ne disposez pas d'équivalent Web du contenu associé, l'URL n'a pas besoin de pointer vers une ressource Web valide. Dans ce cas, vous devez configurer une redirection de cette URL vers, par exemple, votre page d'accueil.
setDomainUriPrefix	Le préfixe de l'URL Dynamic Link, que vous trouverez dans la console Firebase. Un domaine Dynamic Link se présente comme suit : https://example.com/link https://example.page.link

AndroidParameters
setFallbackUrl	Lien à ouvrir lorsque l'application n'est pas installée. Spécifiez cette valeur pour effectuer une action autre que l'installation de votre application depuis le Play Store lorsqu'elle n'est pas installée, par exemple ouvrir la version Web mobile du contenu ou afficher une page promotionnelle pour votre application.
setMinimumVersion	versionCode de la version minimale de votre application pouvant ouvrir le lien. Si l'application installée est une version obsolète, l'utilisateur est redirigé vers le Play Store pour la mettre à niveau.

IosParameters
setAppStoreId	ID App Store de votre application, utilisé pour rediriger les utilisateurs vers l'App Store lorsque l'application n'est pas installée
setFallbackUrl	Lien à ouvrir lorsque l'application n'est pas installée. Spécifiez cette valeur pour effectuer une action autre que l'installation de votre application depuis l'App Store lorsqu'elle n'est pas installée, par exemple ouvrir la version Web mobile du contenu ou afficher une page promotionnelle pour votre application.
setCustomScheme	Schéma d'URL personnalisé de votre application, s'il est défini comme autre chose que l'ID de bundle de votre application
setIpadFallbackUrl	Lien à ouvrir sur les iPad lorsque l'application n'est pas installée. Spécifiez cette valeur pour effectuer une action autre que l'installation de votre application depuis l'App Store lorsqu'elle n'est pas installée, par exemple ouvrir la version Web du contenu ou afficher une page promotionnelle pour votre application.
setIpadBundleId	ID du bundle de l'application iOS à utiliser sur les iPad pour ouvrir le lien. L'application doit être associée à votre projet depuis la page "Vue d'ensemble" de la console Firebase.
setMinimumVersion	Numéro de version de la version minimale de votre application pouvant ouvrir le lien. Cet indicateur est transmis à votre application lorsqu'elle est ouverte. Votre application doit décider de ce qu'elle doit en faire.

NavigationInfoParameters

setForcedRedirectEnabled

Si la valeur est "1", ignorez la page d'aperçu de l'application lorsque Dynamic Link est ouvert, et redirigez plutôt vers l'application ou la plate-forme de téléchargement. La page d'aperçu de l'application (activée par défaut) peut rediriger les utilisateurs vers la destination la plus appropriée lorsqu'ils ouvrent Dynamic Links dans les applications. Toutefois, si vous souhaitez qu'un Dynamic Link ne s'ouvre que dans les applications pouvant ouvrir Dynamic Links de manière fiable sans cette page, vous pouvez la désactiver à l'aide de ce paramètre. Ce paramètre n'affecte le comportement de Dynamic Link que sur iOS.

SocialMetaTagParameters
setTitle	Titre à utiliser lorsque le Dynamic Link est partagé dans un post sur les réseaux sociaux.
setDescription	Description à utiliser lorsque le Dynamic Link est partagé dans un post sur les réseaux sociaux.
setImageUrl	URL d'une image associée à ce lien. L'image doit faire au moins 300 x 200 pixels et être inférieure à 300 Ko.

GoogleAnalyticsParameters
setSource setMedium setCampaign setTerm setContent	Paramètres d'analyse Google Play Ces paramètres (utm_source, utm_medium, utm_campaign, utm_term et utm_content) sont transmis au Play Store et ajoutés à la charge utile du lien.

ItunesConnectAnalyticsParameters
setProviderToken setAffiliateToken setCampaignToken	Paramètres d'analyse iTunes Connect. Ces paramètres (pt, at et ct) sont transmis à l'App Store.

Raccourcir un Dynamic Link long

Pour raccourcir une Dynamic Link longue, spécifiez l'URL de la Dynamic Link à l'aide de setLongLink au lieu de définir des 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
    // ...
}
MainActivity.kt

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
                    // ...
                }
            }
        });
MainActivity.java