Créer des liens dynamiques sur iOS

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

Prérequis

Avant de commencer, assurez-vous d'ajouter Firebase à votre projet iOS project.

Configurer Firebase et le Dynamic Links SDK

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

1. Dans Xcode, à partir de 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 Dynamic Links bibliothèque.
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 d'IDFA ou avec collecte d'IDFA. Consultez nos questions fréquentes sur la dernière organisation des modules dans le Google Analytics pour Firebase SDK.
6. Lorsque vous avez terminé, Xcode commence à résoudre et à télécharger automatiquement vos dépendances en arrière-plan.

Effectuez maintenant quelques étapes de configuration :

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 d'URI pour vos Dynamic Links, faites-le lorsque vous y êtes invité.

   Si vous disposez déjà d'un préfixe d'URI Dynamic Links, notez-le. Vous devrez le fournir lorsque vous créerez Dynamic Links par programmation.

   

3. Recommandé : spécifiez les formats d'URL autorisés pour vos liens profonds et liens de remplacement. Vous empêcherez ainsi des tiers non autorisés 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.

4. Assurez-vous que l'ID App Store et le préfixe d'ID d'application 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 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 apple-app-site-association fichier hébergé sur votre Dynamic Links domaine. Firebase diffusera le apple-app-site-association fichier à la racine du domaine, ainsi que dans le .well-known sous-répertoire. 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 à votre préfixe d'ID d'application et à l'ID de bundle. 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 d'application. Notez que le préfixe d'ID d'application peut être différent de l'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 le délégué de votre 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 FirebaseApp instance partagée dans la méthode application(_:didFinishLaunchingWithOptions:) du délégué de votre 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 App structure via UIApplicationDelegateAdaptor ou NSApplicationDelegateAdaptor. Vous devez également désactiver le swizzling du délégué 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 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.

Utiliser l'API iOS Builder

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

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

Pour créer un Dynamic Link, créez un nouvel 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 obtenez le lien court en appelant shorten().

L'exemple minimal suivant crée un long 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 saisie semi-automatique, qui est appelé lorsque la requête est terminée. 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 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. Si, dans votre cas d'utilisation, il n'y a aucun inconvénient à ce qu'une personne devine un lien court, vous pouvez préférer générer des suffixes qui ne sont que aussi longs que nécessaire pour être uniques. Pour ce faire, définissez la dynamicLinkComponentsOptions propriété :

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);
}];
      

Dynamic Link paramètres

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

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

Raccourcir un long Dynamic Link

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

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 bundle 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 souhaiter utiliser ce même schéma d'URL personnalisé pour leurs Dynamic Links également. Si vous vous trouvez dans cette situation, vous pouvez spécifier un autre schéma d'URL pour vos Firebase Dynamic Links en procédant comme suit :

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

   Swift

   Remarque : Ce produit Firebase n'est pas disponible sur les cibles macOS, Mac Catalyst, tvOS ni 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 ni 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 endroit dans 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.