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 przyjmuje długi Dynamic Link lub obiekt zawierający Dynamic Link parametry i zwraca adresy URL takie jak w tych przykładach:

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

Wymagania wstępne

Zanim zaczniesz, upewnij się, że dodasz Firebase do projektu na iOS.

Konfigurowanie Firebase i pakietu SDK Dynamic Links

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

1. Po otwarciu projektu aplikacji wybierz w Xcode kolejno File > Add Packages (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 Other Linker Flags (Inne flagi linkera) w ustawieniach kompilacji docelowej.
5. Aby zapewnić optymalne działanie Dynamic Links, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę bez zbierania identyfikatora IDFA lub z jego zbieraniem. Więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania dotyczące najnowszej organizacji modułów w Google Analytics dla Firebase SDK.
6. Gdy skończysz, Xcode zacznie automatycznie wyszukiwać i pobierać Twoje zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

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

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

   Jeśli masz już prefiks URI Dynamic Links, zanotuj go. Będzie on potrzebny podczas programowego tworzenia Dynamic Links.

   

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 Zezwalanie na określone wzorce adresów URL.

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

   Otwórz plik apple-app-site-association hostowany w domenie Dynamic Links, aby sprawdzić, czy projekt w Firebase jest prawidłowo skonfigurowany do używania Dynamic Links w aplikacji na iOS. Firebase będzie udostępniać plik apple-app-site-association z katalogu głównego domeny oraz z podkatalogu .well-known. 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 odniesienie 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 został podany prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może być inny niż identyfikator zespołu.

Dodaj Firebase do swojej aplikacji

1. Zaimportuj moduł FirebaseCore w UIApplicationDelegate, a także inne moduły Firebase, których używa delegat aplikacji. Aby na przykład używać 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 FirebaseApp współdzieloną instancję w metodzie application(_:didFinishLaunchingWithOptions:) delegata 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ć delegata aplikacji i dołączyć go do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizzling delegata aplikacji. Więcej informacji znajdziesz w instrukcjach dotyczących 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, np. na potrzeby testowania lub aby zespół marketingowy mógł łatwo utworzyć link, który można wykorzystać np. w poście w mediach społecznościowych, najprościej będzie otworzyć Firebase konsolę i utworzyć go ręcznie, korzystając z formularza krok po kroku.

Korzystanie z interfejsu iOS Builder API

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

Tworzenie Dynamic Link na podstawie 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 pobierz długi link z właściwości url obiektu lub pobierz 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 ten sam sposób, a następnie wywołaj funkcję shorten().

Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast bezpośrednio zwracać link, shorten() akceptuje procedurę obsługi zakończenia, która jest wywoływana po zakończeniu żą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, które sprawiają, że bardzo mało prawdopodobne jest odgadnięcie prawidłowego Dynamic Link. Jeśli w Twoim przypadku nie ma nic złego w tym, że ktoś odgadnie krótki link, możesz wygenerować sufiksy, które są tylko tak długie, jak to konieczne, aby były unikalne. 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);
}];
      

Dynamic Link parametry

Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć Dynamic Links z dowolnymi obsługiwanymi parametrami. Szczegółowe informacje znajdziesz w dokumentacji API.

Ten przykład tworzy Dynamic Link z ustawionymi kilkoma typowymi parametrami:

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 ustawić za pomocą tych obiektów i właściwości:

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

Skracanie długiego Dynamic Link

Aby skrócić długi Dynamic Link, przekaż długi Dynamic Link do 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 URI adresu URL dla Dynamic Links

Domyślnie Dynamic Links używa identyfikatora pakietu aplikacji jako schematu adresów URL potrzebnego do otwarcia aplikacji. Aby uprościć implementację, zalecamy pozostawienie tej wartości domyślnej.

Deweloperzy, którzy używają już niestandardowego schematu adresów URL do innych celów, mogą chcieć używać tego samego niestandardowego schematu URI adresu URL również w przypadku Dynamic Links. Jeśli jesteś w takiej sytuacji, możesz określić inny schemat URI adresu URL dla swoich Firebase Dynamic Links , wykonując te czynności:

1. Podczas konfigurowania aplikacji przed skonfigurowaniem współdzielonej instancji FirebaseApp określ domyślny schemat URI adresu URL, który ma być używany przez aplikację:

   Swift

   Uwaga: ten produkt Firebase nie jest dostępny na platformach 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: ten produkt Firebase nie jest dostępny na platformach 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. Za każdym razem, gdy tworzysz Dynamic Link, musisz określić niestandardowy schemat URI adresu URL używany przez twoją aplikację. Możesz to zrobić w konsoli Firebase, ustawiając customScheme w interfejsie Builder API, określając parametr ius w adresie URL lub wysyłając parametr iosCustomScheme do interfejsu REST API.

Dalsze kroki

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

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