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 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.7.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 par programmation.

   

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 la section 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:

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, 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 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:

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 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:

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 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:

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