Crea link dinamici su iOS

Puoi creare link dinamici brevi o lunghi con l'API di creazione di Firebase Dynamic Links.Dynamic Links Questa API accetta un link dinamico lungo Dynamic Link o un oggetto contenente Dynamic Link parametri e restituisce URL come i seguenti esempi:

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

Prerequisiti

Prima di iniziare, assicurati di aggiungere Firebase al tuo progetto iOS project.

Configura Firebase e l'SDK Dynamic Links

Utilizza Swift Package Manager per installare e gestire le dipendenze di Firebase.

1. In Xcode, con il progetto dell'app aperto, vai a File > Add Packages (File > Aggiungi pacchetti).
2. Quando richiesto, aggiungi il repository dell'SDK delle piattaforme Apple di Firebase:

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

3. Scegli la libreria Dynamic Links.
4. Aggiungi il flag -ObjC alla sezione Other Linker Flags (Altri flag del linker) delle impostazioni di compilazione della destinazione.
5. Per un'esperienza ottimale con Dynamic Links, ti consigliamo di attivare Google Analytics nel tuo progetto Firebase e di aggiungere l'SDK Firebase per Google Analytics alla tua app. Puoi selezionare la libreria senza raccolta IDFA o con raccolta IDFA. Consulta le nostre domande frequenti (FAQ) sull'organizzazione più recente dei moduli nell'Google Analytics per SDK Firebase.
6. Al termine, Xcode inizierà automaticamente a risolvere e a scaricare le tue dipendenze in background.

Ora, esegui alcuni passaggi di configurazione:

1. Nella console Firebase, apri la sezione Dynamic Links.

2. Se non l'hai ancora fatto, accetta i Termini di servizio e imposta un prefisso URI per i Dynamic Links, quando richiesto.

   Se hai già un prefisso URI Dynamic Links, prendine nota. Dovrai fornirlo quando crei i link dinamici a livello di programmazione Dynamic Links.

   

3. Consigliato: specifica i pattern URL consentiti nei link diretti e nei link di fallback. In questo modo, impedisci a terze parti non autorizzate di creare Dynamic Links che reindirizzano dal tuo dominio a siti che non controlli. Consulta la sezione Consenti pattern URL specifici.

4. Assicurati che l'ID App Store e il prefisso ID app siano specificati nelle impostazioni dell'app. Per visualizzare e modificare le impostazioni dell'app, vai alla pagina Impostazioni del progetto Firebase e seleziona la tua app per iOS.

   Verifica che il progetto Firebase sia configurato correttamente per utilizzare Dynamic Links nella tua app per iOS aprendo il apple-app-site-association file ospitato sul tuo Dynamic Links dominio. Firebase pubblicherà il apple-app-site-association file dalla radice del dominio e dalla .well-known sottodirectory. Ad esempio:

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

   Se l'app è connessa, il file apple-app-site-association contiene un riferimento al prefisso ID app e all'ID pacchetto dell'app. Ad esempio:

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

   Se la proprietà details è vuota, controlla di aver specificato il prefisso ID app. Tieni presente che il prefisso ID app potrebbe non corrispondere all'ID team.

Aggiungi Firebase alla tua app

1. Importa il modulo FirebaseCore in UIApplicationDelegate, nonché tutti gli altri moduli Firebase utilizzati dal delegato dell'app. Ad esempio, per utilizzare Cloud Firestore e 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. Configura un'istanza condivisa nel metodo application(_:didFinishLaunchingWithOptions:) del delegato dell'app:FirebaseApp

   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. Se utilizzi SwiftUI, devi creare un delegato dell'applicazione e collegarlo alla struttura App tramite UIApplicationDelegateAdaptor o NSApplicationDelegateAdaptor. Devi anche disattivare lo swizzling del delegato dell'app. Per ulteriori informazioni, consulta le istruzioni di SwiftUI.

   SwiftUI

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

Utilizza la Firebase console

Se vuoi generare un singolo Dynamic Link, per scopi di test o per consentire al tuo team di marketing di creare facilmente un link da utilizzare, ad esempio, in un post sui social media, il modo più semplice sarebbe visitare la Firebase console e crearne uno manualmente seguendo il modulo passo passo.

Utilizza l'API di creazione per iOS

Puoi utilizzare l'API di creazione per iOS per creare Dynamic Links dai parametri o per abbreviare un link dinamico lungo Dynamic Link.

Crea un Dynamic Link dai parametri

Per creare un Dynamic Link, crea un nuovo oggetto DynamicLinkComponents e specifica i parametri del Dynamic Link impostando le proprietà corrispondenti dell'oggetto. Poi, recupera il link lungo dalla proprietà url dell'oggetto o recupera il link breve chiamando shorten().

L'esempio minimo seguente crea un lungo Dynamic Link a https://www.example.com/my-page che si apre con la tua app per iOS su iOS e con l'app com.example.android su 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);

Per creare un Dynamic Link breve, crea un DynamicLinkComponents nello stesso modo, poi chiama shorten().

La creazione di un link breve richiede una chiamata di rete, quindi, anziché restituire direttamente il link, shorten() accetta un gestore di completamento, che viene chiamato al termine della richiesta. Ad esempio:

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

Per impostazione predefinita, i link dinamici brevi Dynamic Links vengono generati con suffissi di link di 17 caratteri che rendono estremamente improbabile che qualcuno possa indovinare un link dinamico valido Dynamic Link. Se, per il tuo caso d'uso, non c'è alcun rischio che qualcuno indovini un link breve, potresti preferire generare suffissi che siano solo della lunghezza necessaria per essere univoci, cosa che puoi fare impostando la dynamicLinkComponentsOptions proprietà:

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 parametri

Puoi utilizzare l'API di creazione Dynamic Link per creare Dynamic Links con uno qualsiasi dei parametri supportati. Per ulteriori dettagli, consulta il riferimento API.

L'esempio seguente crea un Dynamic Link con diversi parametri comuni impostati:

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

Puoi impostare i parametri Dynamic Link con i seguenti oggetti e proprietà:

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

Abbrevia un link dinamico lungo Dynamic Link

Per abbreviare un Dynamic Link lungo, passa il Dynamic Link lungo a shortenURL(url:options:) insieme a un DynamicLinkComponentsOptions oggetto se vuoi generare un link con un suffisso breve:

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

Specifica uno schema URL personalizzato per Dynamic Links

Per impostazione predefinita, Dynamic Links utilizza l'identificatore pacchetto dell'app come schema URL necessario per aprire la tua applicazione. Ti consigliamo di mantenere questo valore predefinito per semplificare l'implementazione.

Tuttavia, gli sviluppatori che utilizzano già uno schema URL personalizzato per altri scopi potrebbero voler utilizzare lo stesso schema URL personalizzato anche per i Dynamic Links as well. In questo caso, puoi specificare uno schema URL diverso per i tuoi Firebase Dynamic Links seguendo questi passaggi:

1. Quando configuri l'app, assicurati di specificare lo schema URL predefinito da utilizzare per l'applicazione prima di configurare l'istanza condivisa FirebaseApp:

   Swift

   Nota: questo prodotto Firebase non è disponibile per le destinazioni macOS, Mac Catalyst, tvOS o 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

   Nota: questo prodotto Firebase non è disponibile per le destinazioni macOS, Mac Catalyst, tvOS o 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. Ogni volta che crei un Dynamic Link, dovrai specificare lo schema URL personalizzato utilizzato dalla tua app. Puoi farlo tramite la Firebase console, impostando il customScheme nell'API di creazione, specificando il parametro ius nell'URL o inviando il parametro iosCustomScheme all' API REST.

Passaggi successivi

Ora che hai creato Dynamic Links, devi configurare la tua app per ricevere Dynamic Links e indirizzare gli utenti alla posizione corretta nella tua app dopo che li hanno aperti.

Per ricevere Dynamic Links nella tua app, consulta la documentazione per iOS, Android, C++ e Unity.