Twórz dynamiczne linki na iOS

Możesz tworzyć krótkie lub długie linki dynamiczne za pomocą interfejsu Firebase Dynamic Links Builder API. Ten interfejs API akceptuje długi link dynamiczny lub obiekt zawierający parametry linku dynamicznego i zwraca adresy URL, takie jak w poniższych przykładach:

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

Wymagania wstępne

Zanim zaczniesz, pamiętaj o dodaniu Firebase do swojego projektu na iOS .

Skonfiguruj Firebase i pakiet Dynamic Links SDK

Użyj Menedżera pakietów Swift, aby zainstalować i zarządzać zależnościami Firebase.

1. W Xcode przy otwartym projekcie aplikacji przejdź do File > Add Packages .
2. Po wyświetleniu monitu dodaj repozytorium Firebase Apple platforms SDK:

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

3. Wybierz bibliotekę Linki dynamiczne.
4. Aby optymalnie korzystać z Linków dynamicznych, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie pakietu Firebase SDK dla Google Analytics do swojej aplikacji. Możesz wybrać bibliotekę bez kolekcji IDFA lub z kolekcją IDFA.
5. Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.

Teraz wykonaj kilka kroków konfiguracyjnych:

1. W konsoli Firebase otwórz sekcję Linki dynamiczne .

2. Jeśli jeszcze nie zaakceptowałeś warunków korzystania z usługi i nie ustawiłeś prefiksu URI dla swoich linków dynamicznych, zrób to po wyświetleniu monitu.

   Jeśli masz już prefiks identyfikatora URI Linków dynamicznych, zanotuj go. Musisz go podać, gdy programowo tworzysz linki dynamiczne.

   

3. Zalecane : określ wzorce adresów URL dozwolone w precyzyjnych linkach i linkach rezerwowych. W ten sposób uniemożliwiasz nieupoważnionym stronom tworzenie linków dynamicznych przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz Zezwalaj na określone wzorce adresów URL .

4. Upewnij się, że w ustawieniach aplikacji określono identyfikator App Store i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, przejdź do strony Ustawienia projektu Firebase i wybierz swoją aplikację na iOS.

   Potwierdź, że Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania z linków dynamicznych w Twojej aplikacji na iOS, otwierając plik apple-app-site-association , który jest hostowany w Twojej domenie Dynamic Links. Firebase będzie obsługiwać plik apple-app-site-association z katalogu głównego domeny, jak również 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 aplikacji. Na przykład:

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

   Jeśli właściwość details jest pusta, sprawdź dokładnie, czy podałeś prefiks identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może różnić się od identyfikatora zespołu.

Dodaj Firebase do swojej aplikacji

1. Zaimportuj moduł FirebaseCore do swojego UIApplicationDelegate , a także wszelkie inne moduły Firebase, z których korzysta delegat aplikacji. Na przykład, aby użyć Cloud Firestore i uwierzytelniania:

   SwiftUI

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

   Szybki

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Cel C

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

2. Skonfiguruj udostępnioną instancję FirebaseApp w metodzie application application(_:didFinishLaunchingWithOptions:) delegata aplikacji:

   SwiftUI

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

   Szybki

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

   Cel 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 pośrednictwem UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor . Musisz także wyłączyć przełączanie delegatów aplikacji. Aby uzyskać więcej informacji, zobacz instrukcje SwiftUI .

   SwiftUI

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

Użyj konsoli Firebase

Jeśli chcesz wygenerować pojedynczy link dynamiczny do celów testowych lub dla zespołu marketingowego, aby łatwo utworzyć link, którego można użyć w czymś takim jak post w mediach społecznościowych, najprostszym sposobem byłoby odwiedzenie konsoli Firebase i utworzenie takiego linku ręcznie, postępując zgodnie z formularzem krok po kroku.

Użyj interfejsu API iOS Builder

Możesz użyć interfejsu iOS Builder API do tworzenia linków dynamicznych na podstawie parametrów lub skrócenia długiego linku dynamicznego.

Utwórz łącze dynamiczne z parametrów

Aby utworzyć łącze dynamiczne, utwórz nowy obiekt DynamicLinkComponents i określ parametry łącza dynamicznego, ustawiając odpowiednie właściwości obiektu. Następnie pobierz długie łącze z właściwości url obiektu lub pobierz krótkie łącze, wywołując shorten() .

Poniższy minimalny przykład tworzy długi link dynamiczny do https://www.example.com/my-page , który otwiera się w Twojej aplikacji na iOS na iOS i 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ótkie łącze dynamiczne, zbuduj element DynamicLinkComponents w ten sam sposób, a następnie wywołaj shorten() .

Zbudowanie krótkiego łącza wymaga wywołania sieciowego, więc zamiast bezpośredniego zwracania łącza, shorten() akceptuje procedurę obsługi uzupełniania, która jest wywoływana po zakończeniu żądania. Na 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 łącza dynamiczne są generowane z 17-znakowymi sufiksami łącza, co sprawia, że ​​odgadnięcie prawidłowego łącza dynamicznego jest bardzo mało prawdopodobne. Jeśli w twoim przypadku użycia nie ma nic złego w tym, że ktoś pomyślnie odgadnie krótki link, możesz preferować generowanie sufiksów, które są tylko tak długie, aby były unikalne, co możesz 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);
}];
      

Parametry łącza dynamicznego

Możesz użyć interfejsu Dynamic Link Builder API do tworzenia linków dynamicznych z dowolnymi obsługiwanymi parametrami. Aby uzyskać szczegółowe informacje, zapoznaj się z dokumentacją interfejsu API .

Poniższy przykład tworzy łącze dynamiczne 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 łącza dynamicznego można ustawić za pomocą następujących obiektów i właściwości:

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

Skróć długi link dynamiczny

Aby skrócić długi link dynamiczny, przekaż długi link dynamiczny 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 adresów URL dla łączy dynamicznych

Domyślnie Linki dynamiczne używają identyfikatora pakietu aplikacji jako schematu adresu URL potrzebnego do otwarcia aplikacji. Zalecamy pozostanie przy tej wartości domyślnej, aby uprościć implementację.

Jednak programiści, którzy już używają niestandardowego schematu adresów URL do innych celów, mogą chcieć używać tego samego niestandardowego schematu adresów URL również w swoich linkach dynamicznych. W takiej sytuacji możesz określić inny schemat adresów URL dla linków dynamicznych Firebase, wykonując następujące czynności:

1. Podczas konfigurowania aplikacji pamiętaj o określeniu domyślnego schematu adresów URL, który ma być używany przez aplikację, zanim skonfigurujesz udostępnioną instancję FirebaseApp :

   Szybki

   Uwaga: ten produkt Firebase nie jest dostępny w systemach 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
   }
   

   Cel C

   Uwaga: ten produkt Firebase nie jest dostępny w systemach 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. Za każdym razem, gdy tworzysz jakikolwiek link dynamiczny, musisz określić niestandardowy schemat adresów URL, z którego korzysta Twoja aplikacja. Możesz to zrobić za pomocą konsoli Firebase, ustawiając customScheme w Builder API, określając parametr ius w swoim adresie URL lub wysyłając parametr iosCustomScheme do REST API

Następne kroki

Po utworzeniu linków dynamicznych musisz skonfigurować aplikację tak, aby odbierała linki dynamiczne i odsyłała użytkowników do odpowiedniego miejsca w aplikacji po ich otwarciu przez użytkownika.

Aby otrzymywać linki dynamiczne w swojej aplikacji, zapoznaj się z dokumentacją dla systemów iOS , Android , C++ i Unity .