Créer des liens dynamiques sur Android

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 dans 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 des Dynamic Links dans votre application Android, vous devez inclure le SDK Firebase. Si votre application est configurée pour recevoir des Dynamic Links, vous avez déjà effectué ces étapes et vous pouvez ignorer cette section.

1. Si ce n'est 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 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 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:35.0.1"))
   
       // 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'
   }

   Avec la Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

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

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

   Si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons vivement d'utiliser la BoM pour gérer les versions des bibliothèques, 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:24.0.0'
   }

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é : spécifiez les formats d'URL autorisés dans vos liens profonds et vos liens de remplacement. Vous empêchez ainsi les tiers non autorisés de créer des Dynamic Links qui redirigent les utilisateurs de votre domaine vers des sites que vous ne contrôlez pas. Consultez Autoriser des formats d'URL spécifiques.

Utiliser la console Firebase

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

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

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

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

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

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, qui rend le lien court disponible une fois la requête terminée. Exemple :

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

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, ce qui rend extrêmement improbable que quelqu'un puisse deviner un Dynamic Link valide. Si, dans votre cas d'utilisation, il n'y a aucun risque que quelqu'un devine un lien court, vous pouvez générer des suffixes d'une longueur minimale pour qu'ils soient uniques. Pour ce faire, transmettez ShortDynamicLink.Suffix.SHORT à la méthode buildShortDynamicLink :

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

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

Paramètres Dynamic Link

Vous pouvez utiliser l'API Dynamic Link Builder pour créer un 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 :

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

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 :

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

Raccourcir un long Dynamic Link

Pour raccourcir un Dynamic Link long, spécifiez l'URL du Dynamic Link à l'aide de setLongLink au lieu de définir des paramètres avec les autres méthodes de compilation :

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

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