Crea collegamenti dinamici su iOS

Puoi creare collegamenti dinamici brevi o lunghi con l'API Firebase Dynamic Links Builder. Questa API accetta un collegamento dinamico lungo o un oggetto contenente parametri di collegamento dinamico 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 .

Configura Firebase e Dynamic Links SDK

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 .
2. Quando richiesto, aggiungi il repository SDK delle piattaforme Apple Firebase:

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

3. Scegli la libreria Collegamenti dinamici.
4. Aggiungi il flag -ObjC alla sezione Altri flag del linker delle impostazioni di build del tuo target.
5. Per un'esperienza ottimale con Dynamic Links, ti consigliamo di abilitare Google Analytics nel tuo progetto Firebase e di aggiungere l'SDK Firebase per Google Analytics alla tua app. È possibile selezionare la libreria senza raccolta IDFA o con raccolta IDFA.
6. Al termine, Xcode inizierà automaticamente a risolvere e scaricare le tue dipendenze in background.

Ora, esegui alcuni passaggi di configurazione:

1. Nella console Firebase, apri la sezione Collegamenti dinamici .

2. Se non hai già accettato i termini di servizio e impostato un prefisso URI per i tuoi collegamenti dinamici, fallo quando richiesto.

   Se disponi già di un prefisso URI Dynamic Links, prendine nota. È necessario fornirlo quando crei collegamenti dinamici a livello di codice.

   

3. Consigliato : specifica i pattern URL consentiti nei link diretti e nei link di riserva. In questo modo, impedisci a soggetti non autorizzati di creare collegamenti dinamici che reindirizzano dal tuo dominio a siti che non controlli. Consulta Consentire modelli URL specifici .

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

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

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

   Se la tua app è connessa, il file apple-app-site-association contiene un riferimento al prefisso ID app e all'ID bundle della tua app. Per esempio:

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

   Se la proprietà details è vuota, verifica di aver specificato il prefisso dell'ID app. Tieni presente che il prefisso dell'ID app potrebbe non essere lo stesso dell'ID team.

Aggiungi Firebase alla tua app

1. Importa il modulo FirebaseCore nel tuo UIApplicationDelegate , così come tutti gli altri moduli Firebase utilizzati dal delegato dell'app. Ad esempio, per utilizzare Cloud Firestore e l'autenticazione:

   SwiftUI

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

   Veloce

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Obiettivo-C

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

2. Configura un'istanza condivisa FirebaseApp nel metodo application(_:didFinishLaunchingWithOptions:) del delegato dell'app:

   SwiftUI

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

   Veloce

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

   Obiettivo-C

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

3. Se utilizzi SwiftUI, devi creare un delegato dell'applicazione e allegarlo alla struttura App tramite UIApplicationDelegateAdaptor o NSApplicationDelegateAdaptor . È inoltre necessario 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 console Firebase

Se desideri generare un singolo collegamento dinamico, a scopo di test o per consentire al tuo team di marketing di creare facilmente un collegamento che possa essere utilizzato in qualcosa come un post sui social media, il modo più semplice sarebbe visitare la console Firebase e crearne uno manualmente seguendo il modulo passo passo.

Utilizza l'API iOS Builder

Puoi utilizzare l'API iOS Builder per creare collegamenti dinamici da parametri o per abbreviare un collegamento dinamico lungo.

Crea un collegamento dinamico dai parametri

Per creare un collegamento dinamico, creare un nuovo oggetto DynamicLinkComponents e specificare i parametri di collegamento dinamico impostando le proprietà corrispondenti dell'oggetto. Quindi, ottieni il collegamento lungo dalla proprietà url dell'oggetto o ottieni il collegamento breve chiamando shorten() .

Il seguente esempio minimo crea un lungo collegamento dinamico a https://www.example.com/my-page che si apre con la tua app iOS su iOS e 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 breve collegamento dinamico, crea un DynamicLinkComponents allo stesso modo, quindi chiama shorten() .

La creazione di un collegamento breve richiede una chiamata di rete, quindi invece di restituire direttamente il collegamento, shorten() accetta un gestore di completamento, che viene chiamato al completamento della richiesta. Per 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 collegamenti dinamici brevi vengono generati con suffissi di collegamento di 17 caratteri che rendono estremamente improbabile che qualcuno possa indovinare un collegamento dinamico valido. Se, per il tuo caso d'uso, non c'è nulla di male nel fatto che qualcuno indovini con successo un collegamento breve, potresti preferire generare suffissi che siano lunghi solo quanto necessario per essere univoci, cosa che puoi fare impostando la proprietà 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);
}];
      

Parametri del collegamento dinamico

Puoi utilizzare l'API Dynamic Link Builder per creare collegamenti dinamici con uno qualsiasi dei parametri supportati. Consulta il riferimento API per i dettagli.

L'esempio seguente crea un collegamento dinamico 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);

È possibile impostare i parametri di collegamento dinamico con i seguenti oggetti e proprietà:

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

Accorcia un collegamento dinamico lungo

Per abbreviare un collegamento dinamico lungo, passa il collegamento dinamico lungo a shortenURL(url:options:) insieme a un oggetto DynamicLinkComponentsOptions se desideri generare un collegamento 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 di uno schema URL personalizzato per i collegamenti dinamici

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

Tuttavia, gli sviluppatori che già utilizzano uno schema URL personalizzato per altri scopi potrebbero voler utilizzare lo stesso schema URL personalizzato anche per i propri collegamenti dinamici. Se ti trovi in ​​questa situazione, puoi specificare uno schema URL diverso per i tuoi collegamenti dinamici Firebase seguendo questi passaggi:

1. Quando configuri la tua app, assicurati di specificare lo schema URL predefinito che dovrà essere utilizzato dalla tua applicazione prima di configurare la tua istanza condivisa FirebaseApp :

   Veloce

   Nota: questo prodotto Firebase non è disponibile su 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
   }
   

   Obiettivo-C

   Nota: questo prodotto Firebase non è disponibile su 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 collegamento dinamico, dovrai specificare lo schema URL personalizzato utilizzato dalla tua app. Puoi farlo tramite la console Firebase, impostando customScheme nell'API Builder, specificando il parametro ius nel tuo URL o inviando il parametro iosCustomScheme all'API REST

Prossimi passi

Ora che hai creato i collegamenti dinamici, devi configurare la tua app per ricevere i collegamenti dinamici e indirizzare gli utenti alla posizione corretta nell'app dopo che un utente li ha aperti.

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