Créer des liens dynamiques sur Android

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

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

Configurer Firebase et le Dynamic Links SDK

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à 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 la 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:34.12.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 les Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

   (Autre solution)  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.

   Notez que 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:23.2.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 vos 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 Dynamic Links domaine 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 les parties non autorisées de créer Dynamic Links qui redirigent de votre domaine vers des sites que vous ne contrôlez pas. Consultez Autoriser des formats d'URL spécifiques.

Utiliser la Firebase console

Si vous souhaitez générer un seul Dynamic Link, à des fins de test ou pour que votre équipe marketing puisse facilement créer un lien à utiliser dans un post sur les réseaux sociaux, par exemple, le plus simple serait d'accéder à la Firebase console et de le créer 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 nouvel objet DynamicLink avec son générateur, en spécifiant les paramètres du Dynamic Link avec les méthodes du générateur. Ensuite, appelez buildDynamicLink ou buildShortDynamicLink.

L'exemple minimal suivant crée un long 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 court Dynamic Link, créez un DynamicLink de la même manière, et appelez ensuite 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 une 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 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 inconvénient à ce que quelqu'un devine un lien court, vous pouvez préférer générer des suffixes qui ne sont 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

Dynamic Link paramètres

Vous pouvez utiliser l'API Dynamic Link Builder pour créer 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 des paramètres Dynamic Link avec les méthodes suivantes :

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

Raccourcir un long Dynamic Link

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