Tworzenie linków dynamicznych w iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie i długie Dynamic Links. Ten interfejs API akceptuje parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link. Zwraca adresy URL podobne do tych przykładów:

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

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do projektu na iOS.

Konfigurowanie Firebase i pakietu SDK Dynamic Links

Do instalacji zależności Firebase i zarządzania nimi możesz używać menedżera pakietów Swift.

1. Po otwarciu projektu aplikacji w Xcode wybierz Plik > Dodaj pakiety.
2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:

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

3. Wybierz bibliotekę Dynamic Links.
4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
5. Aby uzyskać optymalne wyniki w przypadku Dynamic Links, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę z zbieraniem identyfikatorów IDFA lub bez niego.
6. Gdy to zrobisz, Xcode automatycznie zacznie wyszukiwać i pobierać zależności w tle.

Teraz wykonaj czynności konfiguracyjne:

1. W konsoli Firebase otwórz sekcję Dynamic Links.

2. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie ustawiłeś prefiksu URI dla usługi Dynamic Links, zrób to, gdy pojawi się taka prośba.

   Jeśli masz już prefiks URI Dynamic Links, zanotuj go. Musisz go podać, gdy Dynamic Links tworzysz programowo.

   

3. Zalecane: określ wzorce adresów URL dozwolone w precyzyjnych linkach i linkach zastępczych. Dzięki temu uniemożliwisz nieupoważnionym osobom tworzenie Dynamic Links, które przekierowują z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz sekcję Zezwalanie na określone wzorce adresów URL.

4. Sprawdź, czy identyfikator App Store i prefiks identyfikatora aplikacji są określone w ustawieniach aplikacji. Aby wyświetlić i zmienić ustawienia aplikacji, otwórz stronę Ustawienia projektu Firebase i wybierz aplikację na iOS.

   Aby sprawdzić, czy Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania z Dynamic Links w aplikacji na iOS, otwórz plik apple-app-site-association hostowany w domenie Dynamic Links. Firebase będzie udostępniać plik apple-app-site-association z poziomu katalogu głównego domeny oraz z podkatalogu .well-known. Na przykład:

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

   Jeśli aplikacja jest połączona, plik apple-app-site-association zawiera odwołanie do prefiksu identyfikatora aplikacji i identyfikatora pakietu. Przykład:

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

   Jeśli właściwość details jest pusta, sprawdź, czy podano poprawny prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może nie być taki sam jak identyfikator zespołu.

Dodaj Firebase do swojej aplikacji

1. Zaimportuj moduł FirebaseCore w pliku UIApplicationDelegate oraz wszystkie inne moduły Firebase, których używa delegowany obiekt aplikacji. Aby na przykład użyć właściwości Cloud Firestore i 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. Skonfiguruj współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) w delegacie aplikacji:

   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. Jeśli używasz SwiftUI, musisz utworzyć obiekt delegujący aplikacji i dołączyć go do struktury App za pomocą funkcji UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizlowanie zastępników aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.

   SwiftUI

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

Korzystanie z konsoli Firebase

Jeśli chcesz wygenerować pojedynczy Dynamic Link na potrzeby testów lub aby umożliwić zespołowi marketingowemu łatwe tworzenie linków do wykorzystania w postach w mediach społecznościowych, najprostszym sposobem jest przejście do konsoli Firebase i ręczne utworzenie linku zgodnie z podanymi instrukcjami.

Korzystanie z interfejsu Builder API na iOS

Za pomocą interfejsu iOS Builder API możesz tworzyć Dynamic Links na podstawie parametrów lub skracać długie Dynamic Link.

Tworzenie Dynamic Link z parametrów

Aby utworzyć Dynamic Link, utwórz nowy obiekt DynamicLinkComponents i określ parametry Dynamic Link, ustawiając odpowiednie właściwości obiektu. Następnie uzyskaj długi link z właściwości url obiektu lub uzyskaj krótki link, wywołując funkcję shorten().

Ten minimalny przykład tworzy długi Dynamic Link do https://www.example.com/my-page, który otwiera się w aplikacji na iOS na iOS i w aplikacji com.example.android na Androidzie:

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

Aby utworzyć krótki Dynamic Link, utwórz DynamicLinkComponents w taki sam sposób, a potem wywołaj funkcję shorten().

Utworzenie krótkiego linku wymaga wywołania sieci, więc zamiast zwracania bezpośrednio linku funkcja shorten() przyjmuje procedurę obsługi zakończenia, która jest wywoływana po zakończeniu przetwarzania żądania. Przykład:

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

Domyślnie krótkie Dynamic Links są generowane z 17-znakowymi sufiksami linków, które sprawiają, że bardzo mało prawdopodobne jest, aby ktoś zgadł prawidłowy Dynamic Link. Jeśli w Twoim przypadku nie ma znaczenia, czy ktoś zgadnie krótki link, możesz wygenerować sufiksy o długości wystarczającej do zapewnienia ich unikalności. Możesz to zrobić, ustawiając właściwość 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);
}];
      

Liczba parametrów: Dynamic Link

Do tworzenia Dynamic Links za pomocą dowolnych obsługiwanych parametrów możesz użyć interfejsu Builder API.Dynamic Link Więcej informacji znajdziesz w dokumentacji interfejsu API.

W tym przykładzie Dynamic Link ma kilka typowych parametrów:

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

Parametry Dynamic Link możesz ustawiać za pomocą tych obiektów i właściwości:

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

Skrócenie długiego Dynamic Link

Aby skrócić długi Dynamic Link, prześlij długi Dynamic Link do funkcji shortenURL(url:options:) wraz z obiektem DynamicLinkComponentsOptions, jeśli chcesz wygenerować link z krótkim sufiksem:

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

Określanie niestandardowego schematu adresu URL dla Dynamic Links

Domyślnie Dynamic Links używa identyfikatora pakietu aplikacji jako schematu adresu URL potrzebnego do otwarcia aplikacji. Zalecamy zachowanie tej wartości domyślnej, aby uprościć implementację.

Deweloperzy, którzy już używają niestandardowego schematu URL do innych celów, mogą jednak chcieć użyć tego samego schematu w przypadku Dynamic Links. W takim przypadku możesz określić inny schemat adresu URL dla Firebase Dynamic Links, wykonując te czynności:

1. Podczas konfigurowania aplikacji przed skonfigurowaniem FirebaseApp wspólnej instancji należy określić domyślny schemat adresów URL, którego ma używać aplikacja:

   Swift

   Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani 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

   Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani 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. Podczas tworzenia Dynamic Link musisz podać niestandardowy schemat adresu URL, którego używa Twoja aplikacja. Możesz to zrobić w konsoli Firebase, ustawiając parametr customScheme w Builder API, podając parametr ius w adresie URL lub wysyłając parametr iosCustomScheme do interfejsu API typu REST.

Dalsze kroki

Po utworzeniu Dynamic Links musisz skonfigurować aplikację tak, aby odbierała Dynamic Links i kierowała użytkowników do odpowiedniego miejsca w aplikacji po otwarciu tych wiadomości.

Aby otrzymywać Dynamic Links w aplikacji, zapoznaj się z dokumentacją dotyczącą iOS, Androida, C++ i Unity.