Créer des liens dynamiques sur iOS

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

Prérequis

Avant de commencer, veillez à ajouter Firebase à votre projet iOS.

Configurer Firebase et le SDK Dynamic Links

Utilisez Swift Package Manager pour installer et gérer les dépendances Firebase.

1. Dans Xcode, avec votre projet d'application ouvert, accédez à File > Add Packages (Fichier > Ajouter des packages).
2. Lorsque vous y êtes invité, ajoutez le dépôt du SDK des plates-formes Firebase pour Apple :

  https://github.com/firebase/firebase-ios-sdk.git

3. Choisissez la bibliothèque Dynamic Links.
4. Ajoutez l'indicateur -ObjC à la section Other Linker Flags (Autres indicateurs Linker) des paramètres de compilation de votre cible.
5. 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. Vous pouvez sélectionner la bibliothèque sans collecte de l'IDFA ou avec collecte de l'IDFA.
6. Lorsque vous avez terminé, Xcode commence à résoudre et à télécharger automatiquement vos dépendances en arrière-plan.

Effectuez maintenant les étapes de configuration suivantes :

1. Dans la console Firebase, ouvrez la section Dynamic Links.

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

   Si vous disposez déjà d'un préfixe d'URI Dynamic Links, prenez-en note. Vous devez le fournir lorsque vous créez Dynamic Links de manière programmatique.

   

3. 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.

4. Assurez-vous que l'ID App Store de votre application et son préfixe sont spécifiés dans les paramètres de votre application. Pour afficher et modifier les paramètres de votre application, accédez à la page des paramètres de votre projet Firebase, puis sélectionnez votre application iOS.

   Vérifiez que votre projet Firebase est correctement configuré pour utiliser Dynamic Links dans votre application iOS en ouvrant le fichier apple-app-site-association hébergé sur votre domaine Dynamic Links. Firebase diffuse le fichier apple-app-site-association à partir de la racine du domaine et du sous-répertoire .well-known. Exemple :

       https://example.com/apple-app-site-association
       https://example.com/.well-known/apple-app-site-association
       

   Si votre application est connectée, le fichier apple-app-site-association contient une référence au préfixe de l'ID d'application et à l'ID du bundle de votre application. Exemple :

   {"applinks":{"apps":[],"details":[{"appID":"1234567890.com.example.ios","paths":["/*"]}]}}

   Si la propriété details est vide, vérifiez que vous avez spécifié le préfixe d'ID de votre application. Notez que le préfixe de votre ID d'application peut être différent de votre ID d'équipe.

Ajoutez Firebase à votre application

1. Importez le module FirebaseCore dans votre UIApplicationDelegate, ainsi que tous les autres modules Firebase utilisés par votre délégué d'application. Par exemple, pour utiliser Cloud Firestore et Authentication:

   SwiftUI

   import SwiftUI
   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Swift

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Objective-C

   @import FirebaseCore;
   @import FirebaseFirestore;
   @import FirebaseAuth;
   // ...
         

2. Configurez une instance partagée FirebaseApp dans la méthode application(_:didFinishLaunchingWithOptions:) de votre délégué d'application :

   SwiftUI

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Swift

   // Use Firebase library to configure APIs
   FirebaseApp.configure()

   Objective-C

   // Use Firebase library to configure APIs
   [FIRApp configure];

3. Si vous utilisez SwiftUI, vous devez créer un délégué d'application et l'associer à votre structure App via UIApplicationDelegateAdaptor ou NSApplicationDelegateAdaptor. Vous devez également désactiver le mélange des délégués d'application. Pour en savoir plus, consultez les instructions SwiftUI.

   SwiftUI

   @main
   struct YourApp: App {
     // register app delegate for Firebase setup
     @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
         

Utiliser la console Firebase

Si vous souhaitez générer un seul Dynamic Link, soit à des fins de test, soit pour permettre à votre équipe marketing de 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 détaillé.

Utiliser l'API iOS Builder

Vous pouvez utiliser l'API iOS Builder pour créer des Dynamic Links à partir de paramètres ou pour raccourcir un Dynamic Link long.

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

Pour créer un Dynamic Link, créez un objet DynamicLinkComponents et spécifiez les paramètres Dynamic Link en définissant les propriétés correspondantes de l'objet. Ensuite, obtenez le lien long à partir de la propriété url de l'objet ou le lien court en appelant shorten().

L'exemple minimal suivant crée une longue Dynamic Link vers https://www.example.com/my-page qui s'ouvre avec votre application iOS sur iOS et l'application com.example.android sur Android :

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPrefix: dynamicLinksDomainURIPRefix)
linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                               domainURIPrefix:dynamicLinksDomainURIPrefix];
linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];

NSLog(@"The long URL is: %@", linkBuilder.url);

Pour créer un Dynamic Link court, créez un DynamicLinkComponents de la même manière, puis appelez shorten().

La création d'un lien court nécessite un appel réseau. Par conséquent, au lieu de renvoyer directement le lien, shorten() accepte un gestionnaire de fin, qui est appelé à la fin de la requête. Exemple :

linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Par défaut, les Dynamic Links courts sont générés avec des suffixes de lien de 17 caractères, ce qui rend très peu probable qu'un utilisateur puisse deviner un Dynamic Link valide. Si, pour votre cas d'utilisation, il ne s'agit pas de nuire à quelqu'un qui réussit à deviner un lien court, vous préférerez peut-être générer des suffixes uniques qui ne durent que la durée nécessaire. Pour ce faire, définissez la propriété dynamicLinkComponentsOptions:

linkBuilder.options = DynamicLinkComponentsOptions()
linkBuilder.options.pathLength = .short
linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

linkBuilder.dynamicLinkComponentsOptions = [[FIRDynamicLinkComponentsOptions alloc] init];
linkBuilder.dynamicLinkComponentsOptions.pathLength = FIRShortDynamicLinkPathLengthShort;
[linkBuilder shortenWithCompletion:^(NSURL * _Nullable shortURL,
                                     NSArray<NSString *> * _Nullable warnings,
                                     NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];
      

Paramètres Dynamic Link

Vous pouvez utiliser l'API Dynamic Link Builder 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 :

guard let link = URL(string: "https://www.example.com/my-page") else { return }
let dynamicLinksDomainURIPrefix = "https://example.com/link"
let linkBuilder = DynamicLinkComponents(link: link, domainURIPRefix: dynamicLinksDomainURIPrefix)

linkBuilder.iOSParameters = DynamicLinkIOSParameters(bundleID: "com.example.ios")
linkBuilder.iOSParameters.appStoreID = "123456789"
linkBuilder.iOSParameters.minimumAppVersion = "1.2.3"

linkBuilder.androidParameters = DynamicLinkAndroidParameters(packageName: "com.example.android")
linkBuilder.androidParameters.minimumVersion = 123

linkBuilder.analyticsParameters = DynamicLinkGoogleAnalyticsParameters(source: "orkut",
                                                                       medium: "social",
                                                                       campaign: "example-promo")

linkBuilder.iTunesConnectParameters = DynamicLinkItunesConnectAnalyticsParameters()
linkBuilder.iTunesConnectParameters.providerToken = "123456"
linkBuilder.iTunesConnectParameters.campaignToken = "example-promo"

linkBuilder.socialMetaTagParameters = DynamicLinkSocialMetaTagParameters()
linkBuilder.socialMetaTagParameters.title = "Example of a Dynamic Link"
linkBuilder.socialMetaTagParameters.descriptionText = "This link works whether the app is installed or not!"
linkBuilder.socialMetaTagParameters.imageURL = "https://www.example.com/my-image.jpg"

guard let longDynamicLink = linkBuilder.url else { return }
print("The long URL is: \(longDynamicLink)")

NSURL *link = [[NSURL alloc] initWithString:@"https://www.example.com/my-page"];
NSString *dynamicLinksDomainURIPrefix = @"https://example.com/link";
FIRDynamicLinkComponents *linkBuilder = [[FIRDynamicLinkComponents alloc]
                                         initWithLink:link
                                         domainURIPrefix:dynamicLinksDomainURIPrefix];

linkBuilder.iOSParameters = [[FIRDynamicLinkIOSParameters alloc]
                             initWithBundleID:@"com.example.ios"];
linkBuilder.iOSParameters.appStoreID = @"123456789";
linkBuilder.iOSParameters.minimumAppVersion = @"1.2.3";

linkBuilder.androidParameters = [[FIRDynamicLinkAndroidParameters alloc]
                                 initWithPackageName:@"com.example.android"];
linkBuilder.androidParameters.minimumVersion = 123;

linkBuilder.analyticsParameters = [[FIRDynamicLinkGoogleAnalyticsParameters alloc]
                                   initWithSource:@"orkut"
                                           medium:@"social"
                                         campaign:@"example-promo"];

linkBuilder.iTunesConnectParameters = [[FIRDynamicLinkItunesConnectAnalyticsParameters alloc] init];
linkBuilder.iTunesConnectParameters.providerToken = @"123456";
linkBuilder.iTunesConnectParameters.campaignToken = @"example-promo";

linkBuilder.socialMetaTagParameters = [[FIRDynamicLinkSocialMetaTagParameters alloc] init];
linkBuilder.socialMetaTagParameters.title = @"Example of a Dynamic Link";
linkBuilder.socialMetaTagParameters.descriptionText = @"This link works whether the app is installed or not!";
linkBuilder.socialMetaTagParameters.imageURL = @"https://www.example.com/my-image.jpg";

NSLog(@"The long URL is: %@", linkBuilder.url);

Vous pouvez définir des paramètres Dynamic Link avec les objets et les propriétés suivants :

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

Raccourcir un Dynamic Link long

Pour raccourcir un Dynamic Link long, transmettez-le à shortenURL(url:options:) avec un objet DynamicLinkComponentsOptions si vous souhaitez générer un lien avec un suffixe court :Dynamic Link

DynamicLinkComponents.shortenURL(url: longLinkUrl, options: nil) { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

[FIRDynamicLinkComponents shortenURL:longLinkUrl
                             options:nil
                          completion:^(NSURL * _Nullable shortURL,
                                       NSArray<NSString *> * _Nullable warnings,
                                       NSError * _Nullable error) {
  if (error || shortURL == nil) { return; }
  NSLog(@"The short URL is: %@", shortURL);
}];

Spécifier un schéma d'URL personnalisé pour Dynamic Links

Par défaut, Dynamic Links utilise l'identifiant de groupe de votre application comme schéma d'URL nécessaire pour ouvrir votre application. Nous vous recommandons de conserver cette valeur par défaut pour simplifier votre implémentation.

Toutefois, les développeurs qui utilisent déjà un schéma d'URL personnalisé à d'autres fins peuvent également souhaiter utiliser ce même schéma d'URL personnalisée pour leur Dynamic Links. Dans ce cas, vous pouvez spécifier un autre schéma d'URL pour votre Firebase Dynamic Links en procédant comme suit :

1. Lorsque vous configurez votre application, veillez à spécifier le schéma d'URL par défaut à utiliser par votre application avant de configurer votre instance partagée FirebaseApp :

   Swift

   Remarque:Ce produit Firebase n'est pas disponible sur les cibles macOS, Mac Catalyst, tvOS et watchOS.

   func application(_ application: UIApplication,
                    didFinishLaunchingWithOptions launchOptions: [UIApplication
                      .LaunchOptionsKey: Any]?) -> Bool {
     // Set deepLinkURLScheme to the custom URL scheme you defined in your
     // Xcode project.
     FirebaseOptions.defaultOptions()?.deepLinkURLScheme = customURLScheme
     FirebaseApp.configure()
   
     return true
   }

   Objective-C

   Remarque : Ce produit Firebase n'est pas disponible sur les cibles macOS, Mac Catalyst, tvOS ou watchOS.

   - (BOOL)application:(UIApplication *)application
       didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
     // Set deepLinkURLScheme to the custom URL scheme you defined in your
     // Xcode project.
     [FIROptions defaultOptions].deepLinkURLScheme = CUSTOM_URL_SCHEME;
     [FIRApp configure];
   
     return YES;
   }

2. Chaque fois que vous créez un Dynamic Link, vous devez spécifier le schéma d'URL personnalisé utilisé par votre application. Vous pouvez le faire via la console Firebase, en définissant customScheme dans l'API Builder, en spécifiant le paramètre ius dans votre URL ou en envoyant le paramètre iosCustomScheme à l'API REST

Étapes suivantes

Maintenant que vous avez créé Dynamic Links, vous devez configurer votre application pour qu'elle reçoive Dynamic Links et redirige les utilisateurs vers le bon emplacement de votre application après qu'ils les ont ouverts.

Pour recevoir Dynamic Links dans votre application, consultez la documentation pour iOS, Android, C++ et Unity.