Dynamische Links unter iOS erstellen

Mit der Firebase Dynamic Links Builder API können Sie kurze oder lange Dynamic Links erstellen. Diese API akzeptiert entweder einen langen Dynamic Link oder ein Objekt mit Dynamic Link Parametern und gibt URLs wie in den folgenden Beispielen zurück:

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

Vorbereitung

Bevor Sie beginnen, müssen Sie Ihrem iOS -Projekt Firebase hinzufügen.

Firebase und das Dynamic Links SDK einrichten

Verwenden Sie Swift Package Manager, um Firebase-Abhängigkeiten zu installieren und zu verwalten.

1. Öffnen Sie Ihr App-Projekt und gehen Sie in Xcode zu File > Add Packages (Datei > Pakete hinzufügen).
2. Fügen Sie bei entsprechender Aufforderung das Firebase Apple Platforms SDK-Repository hinzu:

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

3. Wählen Sie die Dynamic Links-Bibliothek aus.
4. Fügen Sie den Flag -ObjC im Bereich Other Linker Flags (Weitere Verknüpfungsmerker) der Build-Einstellungen Ihres Ziels hinzu.
5. Für eine optimale Nutzung von Dynamic Links empfehlen wir die Aktivierung von Google Analytics in Ihrem Firebase-Projekt und das Hinzufügen des Firebase SDK für Google Analytics zu Ihrer App. Sie können entweder die Bibliothek ohne IDFA-Erfassung oder mit IDFA-Erfassung auswählen. Weitere Informationen finden Sie in unseren FAQs zur aktuellen Organisation von Modulen im Google Analytics for Firebase SDK.
6. Wenn Sie fertig, beginnt Xcode automatisch, Ihre Abhängigkeiten im Hintergrund aufzulösen und herunterzuladen.

Führen Sie nun einige Konfigurationsschritte aus:

1. Öffnen Sie in der Firebase Console den Dynamic Links Bereich.

2. Wenn Sie die Nutzungsbedingungen noch nicht akzeptiert und kein URI-Präfix für Ihre Dynamic Links festgelegt haben, tun Sie dies, wenn Sie dazu aufgefordert werden.

   Notieren Sie sich das Dynamic Links URI-Präfix, falls Sie bereits eines haben. Sie müssen es angeben, wenn Sie Dynamic Links programmatisch erstellen.

   

3. Empfohlen: Geben Sie die in Ihren Deeplinks und Fallback-Links zulässigen URL-Muster an. So verhindern Sie, dass unbefugte Dritte Dynamic Links erstellen, die von Ihrer Domain zu Websites weiterleiten, die Sie nicht kontrollieren. Weitere Informationen finden Sie unter Bestimmte URL-Muster zulassen.

4. Achten Sie darauf, dass die App Store-ID und das App-ID-Präfix Ihrer App in den Einstellungen der App angegeben sind. Wenn Sie die Einstellungen Ihrer App aufrufen und bearbeiten möchten, rufen Sie die Seite Einstellungen Ihres Firebase-Projekts auf und wählen Sie Ihre iOS-App aus.

   Öffnen Sie die Datei apple-app-site-association, die auf Ihrer Dynamic Links Domain gehostet wird, um zu bestätigen, dass Ihr Firebase-Projekt richtig konfiguriert ist, um Dynamic Links in Ihrer iOS-App zu verwenden. Firebase stellt die apple-app-site-association Datei sowohl im Stammverzeichnis der Domain als auch im .well-known Unterverzeichnis bereit. Beispiel:

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

   Wenn Ihre App verbunden ist, enthält die apple-app-site-association Datei einen Verweis auf das App-ID-Präfix und die Paket-ID Ihrer App. Beispiel:

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

   Wenn die Eigenschaft details leer ist, prüfen Sie noch einmal, ob Sie das App-ID-Präfix angegeben haben. Beachten Sie, dass Ihr App-ID-Präfix möglicherweise nicht mit Ihrer Team-ID identisch ist.

Firebase zu Ihrer Anwendung hinzufügen

1. Importieren Sie das FirebaseCore Modul in Ihr UIApplicationDelegate, sowie alle anderen Firebase-Module, die Ihr App-Delegat verwendet. Beispiel: Cloud Firestore und Authentication verwenden:

   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. Konfigurieren Sie eine FirebaseApp freigegebene Instanz in der application(_:didFinishLaunchingWithOptions:) Methode Ihres App-Delegaten:

   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. Wenn Sie SwiftUI verwenden, müssen Sie einen App-Delegaten erstellen und ihn an Ihre App Struktur über UIApplicationDelegateAdaptor oder NSApplicationDelegateAdaptor anhängen. Außerdem müssen Sie das Swizzling des App-Delegaten deaktivieren. Weitere Informationen finden Sie in der SwiftUI-Anleitung.

   SwiftUI

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

Firebase Console verwenden

Wenn Sie einen einzelnen Dynamic Link generieren möchten, entweder zu Testzwecken oder damit Ihr Marketingteam ganz einfach einen Link erstellen kann, der beispielsweise in einem Social-Media-Post verwendet werden kann, ist es am einfachsten, die Firebase console aufzurufen und einen Link manuell über das Schritt-für-Schritt-Formular zu erstellen.

iOS Builder API verwenden

Mit der iOS Builder API können Sie Dynamic Links aus Parametern erstellen oder einen langen Dynamic Link kürzen.

Ein Dynamic Link aus Parametern erstellen

Erstellen Sie ein neues DynamicLinkComponents-Objekt , um ein Dynamic Link zu erstellen, und geben Sie die Dynamic Link-Parameter an, indem Sie die entsprechenden Eigenschaften des Objekts festlegen. Rufen Sie dann den langen Link über die Eigenschaft url des Objekts ab oder rufen Sie shorten() auf, um den kurzen Link zu erhalten.

Im folgenden Minimalbeispiel wird ein langer Dynamic Link zu https://www.example.com/my-page erstellt, der unter iOS mit Ihrer iOS-App und unter Android mit der App com.example.android geöffnet wird:

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

Erstellen Sie auf dieselbe Weise ein DynamicLinkComponents-Objekt, um einen kurzen Dynamic Link zu erstellen, und rufen Sie dann shorten() auf.

Für die Erstellung eines kurzen Links ist ein Netzwerkaufruf erforderlich. Daher wird der Link nicht direkt zurückgegeben, sondern shorten() akzeptiert einen Completion-Handler, der aufgerufen wird, wenn die Anfrage abgeschlossen ist. Beispiel:

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

Standardmäßig werden kurze Dynamic Links mit 17-stelligen Link-Suffixen generiert, wodurch es äußerst unwahrscheinlich ist, dass jemand einen gültigen Dynamic Link erraten kann. Wenn es für Ihren Anwendungsfall kein Problem darstellt, wenn jemand einen kurzen Link errät, können Sie Suffixe generieren, die nur so lang sind, wie für die Eindeutigkeit erforderlich. Dazu legen Sie die dynamicLinkComponentsOptions Eigenschaft fest:

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 Parameter

Mit der Dynamic Link Builder API können Sie Dynamic Links mit allen unterstützten Parametern erstellen. Weitere Informationen finden Sie in der API-Referenz.

Im folgenden Beispiel wird ein Dynamic Link mit mehreren gängigen Parametern erstellt:

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

Sie können Dynamic Link Parameter mit den folgenden Objekten und Eigenschaften festlegen:

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

Langen Dynamic Link kürzen

Wenn Sie einen langen Dynamic Link kürzen möchten, übergeben Sie den langen Dynamic Link zusammen mit einem DynamicLinkComponentsOptions Objekt an shortenURL(url:options:), wenn Sie einen Link mit einem kurzen Suffix generieren möchten:

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

Benutzerdefiniertes URL-Schema für Dynamic Links angeben

Standardmäßig verwendet Dynamic Links den Paket-Identifikator Ihrer App als URL-Schema, das zum Öffnen Ihrer Anwendung erforderlich ist. Wir empfehlen, diesen Standardwert beizubehalten, um die Implementierung zu vereinfachen.

Entwickler, die bereits ein benutzerdefiniertes URL-Schema für andere Zwecke verwenden, möchten dieses benutzerdefinierte URL-Schema möglicherweise auch für ihre Dynamic Links verwenden. In diesem Fall können Sie ein anderes URL-Schema für Ihre Firebase Dynamic Links angeben. Gehen Sie dazu so vor:

1. Wenn Sie Ihre App einrichten, geben Sie das Standard-URL-Schema an, das von Ihrer Anwendung verwendet werden soll bevor Sie die FirebaseApp freigegebene Instanz konfigurieren:

   Swift

   Hinweis:Dieses Firebase-Produkt ist nicht für macOS-, Mac Catalyst-, tvOS- oder watchOS-Ziele verfügbar.

   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

   Hinweis:Dieses Firebase-Produkt ist nicht für macOS-, Mac Catalyst-, tvOS- oder watchOS-Ziele verfügbar.

   - (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. Wenn Sie einen Dynamic Link erstellen, müssen Sie das benutzerdefinierte URL-Schema angeben, das von Ihrer App verwendet wird. Sie können dies über die Firebase Console tun, indem Sie customScheme in der Builder API festlegen, den Parameter ius in Ihrer URL angeben oder den Parameter iosCustomScheme an die REST API senden.

Nächste Schritte

Nachdem Sie Dynamic Links erstellt haben, müssen Sie Ihre App so einrichten, dass sie Dynamic Links empfangen kann und Nutzer nach dem Öffnen an die richtige Stelle in Ihrer App weitergeleitet werden.

Informationen zum Empfangen von Dynamic Links in Ihrer App finden Sie in der Dokumentation für iOS, Android, C++ und Unity.