Tworzenie linków dynamicznych w iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie lub długie Dynamic Links. Ten interfejs API akceptuje długi parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link i zwraca adresy URL, takie jak te:

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

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do projektu na iOS.

Konfiguracja Firebase i pakietu Dynamic Links SDK

Do instalowania zależności Firebase i zarządzania nimi używaj menedżera pakietów Swift.

1. W Xcode, gdy projekt aplikacji jest otwarty, kliknij 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 łączące) w ustawieniach kompilacji celu.
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ę z gromadzeniem identyfikatorów IDFA lub bez niego. Zapoznaj się z najczęstszymi pytaniami dotyczącymi najnowszej organizacji modułów w pakiecie SDK Google Analytics dla Firebase.
6. Gdy skończysz, Xcode zacznie automatycznie przetwarzać i pobierać zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

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

2. Jeśli nie zaakceptowano jeszcze warunków korzystania z usługi i nie ustawiono prefiksu identyfikatora URI dla Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.

   Jeśli masz już prefiks identyfikatora URI Dynamic Links, zapisz go. Musisz go podać, gdy tworzysz Dynamic Links automatycznie.

   

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. Upewnij się, że w ustawieniach aplikacji podany jest jej identyfikator w sklepie z aplikacjami i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, otwórz stronę ustawień projektu w Firebase i wybierz aplikację na iOS.

   Sprawdź, czy projekt w Firebase jest prawidłowo skonfigurowany do używania Dynamic Links w aplikacji na iOS. W tym celu 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 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 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 podano 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 do pliku UIApplicationDelegate oraz wszystkie inne moduły Firebase, których używa delegat 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 udostępnioną instancję FirebaseApp 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ć obiekt delegowany 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 do celów testowych lub dla zespołu marketingowego, aby łatwo utworzyć link, który można wykorzystać na przykład w poście w mediach społecznościowych, najprostszym sposobem jest odwiedzenie konsoli Firebase i ręczne utworzenie linku za pomocą formularza.

Korzystanie z interfejsu Builder API na iOS

Możesz użyć interfejsu iOS Builder API, aby utworzyć Dynamic Links z parametrów lub skrócić długi Dynamic Link.

Utwórz 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 shorten().

Poniższy przykład pokazuje, jak utworzyć długi link Dynamic Link do https://www.example.com/my-page, który otwiera się w aplikacji na iOS na urządzeniu z iOS i w aplikacji com.example.android na urządzeniu z Androidem:

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 typ Dynamic Link, utwórz DynamicLinkComponents w ten sam sposób, a następnie wywołaj shorten().

Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast bezpośrednio zwracać link, shorten() akceptuje moduł obsługi, który jest wywoływany 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 linki Dynamic Links są generowane z 17-znakowymi sufiksami, co sprawia, że odgadnięcie prawidłowego linku Dynamic Link jest bardzo mało prawdopodobne. Jeśli w Twoim przypadku użycia nie ma znaczenia, czy 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);
}];
      

Liczba parametrów: Dynamic Link

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

W tym przykładzie tworzymy obiekt Dynamic Link z 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 filmu Dynamic Link

Aby skrócić długi Dynamic Link, przekaż goDynamic 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 aplikacji Dynamic Links

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

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

1. Podczas konfigurowania aplikacji upewnij się, że przed skonfigurowaniem udostępnionej instancji FirebaseApp został określony domyślny schemat URI adresu URL, który ma być używany przez aplikację:

   Swift

   Uwaga: ta usługa Firebase nie jest dostępna 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: ta usługa Firebase nie jest dostępna 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, którego używa Twoja aplikacja. 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 kierowała użytkowników do odpowiedniego miejsca w aplikacji po ich otwarciu.

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