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 Dynamic Links, vous avez déjà effectué 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 versionnage 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:34.0.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 la Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

   (Alternative)  Ajoutez les dépendances de la bibliothèque Firebase sans utiliser BoM.

   Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier la version de chaque bibliothèque Firebase sur 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 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:23.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 de 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 des Dynamic Links de manière programmatique.

   

5. Recommandation : spécifiez 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, que ce soit à des fins de test ou pour permettre à votre équipe marketing de créer facilement un lien à utiliser dans un post sur les réseaux sociaux, par exemple, le moyen le plus simple consiste à accéder à la console Firebase et à en créer un manuellement en suivant le formulaire pas à pas.

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 un 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 Short Dynamic Link, 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 :

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 qu'une personne puisse deviner un Dynamic Link valide. Si, pour votre cas d'utilisation, il n'y a aucun risque à ce qu'une personne devine un lien raccourci, vous pouvez préférer générer des suffixes qui ne sont pas plus longs que nécessaire pour être 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 Builder Dynamic Link pour créer des Dynamic Links avec l'un des paramètres compatibles. 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 Dynamic Link long

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

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