Tworzenie linków dynamicznych w iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz utworzyć krótki lub długi plik Dynamic Links. Ten interfejs API akceptuje długą wartość Dynamic Link lub obiekt zawierający Dynamic Link i zwraca adresy URL takie jak:

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

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do swojego systemu iOS projekt.

Skonfiguruj Firebase i pakiet SDK Dynamic Links

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

1. W Xcode po otwarciu projektu aplikacji przejdź do File > Dodaj pakiety.
2. Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:

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

3. Wybierz bibliotekę Dynamic Links.
4. Dodaj flagę -ObjC do sekcji Inne flagi łączące w ustawieniach kompilacji celu.
5. Aby zapewnić optymalne działanie usługi Dynamic Links, zalecamy włączam Google Analytics w projekcie Firebase i dodając do aplikacji pakiet SDK Firebase dla Google Analytics. Dostępne opcje wybrać bibliotekę bez zbierania danych IDFA lub z zbieraniem tych danych.
6. Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie lub zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

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

2. Jeśli nie zostały jeszcze zaakceptowane warunki korzystania z usługi i ustawiono prefiks identyfikatora URI Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.

   Jeśli masz już prefiks identyfikatora URI Dynamic Links, zanotuj go. Czynności, które musisz wykonać go podczas automatycznego tworzenia obiektu Dynamic Links.

   

3. Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom utworzenie Dynamic Links przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Patrz sekcja Zezwalaj na określone treści Wzorce adresów URL.

4. Upewnij się, że identyfikator aplikacji w sklepie App Store oraz jej prefiks to w ustawieniach aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, wejdź na do właściwości Twojego projektu Firebase stronę Ustawienia i wybierz aplikację na iOS.

   Sprawdź, czy projekt Firebase jest prawidłowo skonfigurowany do używania Dynamic Links w aplikacji na iOS, otwierając apple-app-site-association plik hostowany na Dynamic Links. Firebase będzie wyświetlać apple-app-site-association w katalogu głównym domeny oraz podkatalogu .well-known. Dla: przykład:

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

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

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

   Jeśli właściwość details jest pusta, sprawdź, czy została określona 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 UIApplicationDelegate, jak i wszelkie inne Moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć atrybutów 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ółdzielonej instancji w uprawnieniach przedstawiciela aplikacji Metoda application(_:didFinishLaunchingWithOptions:):

   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ć i dołączyć przedstawiciela aplikacji. do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Dla: 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 element Dynamic Link do celów testowych lub na potrzeby zespołu marketingowego aby utworzyć link, którego można użyć np. w poście w mediach społecznościowych, odwiedź konsolę Firebase i utworzyć ją ręcznie, postępując zgodnie z instrukcjami.

Używanie interfejsu iOS Builder API

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

Utwórz Dynamic Link na podstawie parametrów

Aby utworzyć obiekt Dynamic Link, utwórz nowy obiekt DynamicLinkComponents. i określ parametry Dynamic Link, ustawiając odpowiednią wartość usług. Następnie pobierz długi link z pliku url obiektu usługi lub uzyskać krótki link, wywołując shorten().

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

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

Stworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast bezpośrednio zwraca link, shorten() akceptuje moduł obsługi uzupełniania, który jest wywoływane 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ótki plik Dynamic Links jest generowany z 17-znakowymi sufiksami linków, które zmniejsza więc prawdopodobieństwo, że ktoś odgadnie poprawną wartość w polu Dynamic Link. Jeśli dla nie ma nic złego w odgadnięciu krótkiego linku, możesz generować przyrostki, które będą tak długie, 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

Możesz użyć interfejsu Dynamic Link Builder API, aby utworzyć Dynamic Links z dowolną z obsługiwane parametry. Zobacz API.

Ten przykład tworzy Dynamic Link z kilkoma wspólnymi parametrami ustaw:

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

Skróć długi Dynamic Link

Aby skrócić długi Dynamic Link, przekaż Dynamic Link do shortenURL(url:options:) wraz z DynamicLinkComponentsOptions, jeśli chcesz wygenerować 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 niezbędnego do otwarcia aplikacji. Zalecamy pozostawienie tej wartości domyślnej, aby implementacja była prosta.

Programiści, którzy już używają niestandardowego schematu URL do innych celów, mogą zechcieć użyć ten sam schemat niestandardowego adresu URL dla strony Dynamic Links. Jeśli dotyczy Cię taka sytuacja, możesz określić zmień schemat adresu URL dla swojego urządzenia Firebase Dynamic Links, wykonując te czynności:

1. Podczas konfigurowania aplikacji musisz określić domyślny schemat adresu URL, którego będzie ona używać przed skonfigurowaniem współdzielonej instancji FirebaseApp:

   Swift

   Uwaga: ta usługa Firebase nie jest dostępna na systemy docelowe macOS, Mac Catalyst, tvOS i 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 systemy docelowe macOS, Mac Catalyst, tvOS i 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. Tworząc Dynamic Link, musisz określić schemat niestandardowego adresu URL, zastosowania aplikacji. Możesz to zrobić w konsoli Firebase, ustawiając customScheme w Builder API. określając parametr ius w adresie URL lub wysyłając parametr iosCustomScheme do funkcji Interfejs API typu REST

Dalsze kroki

Po utworzeniu grupy Dynamic Links musisz skonfigurować aplikację, aby otrzymywać Dynamic Links i kieruj użytkowników do właściwego miejsca w aplikacji, gdy użytkownik je otworzy.

Aby otrzymywać Dynamic Links w swojej aplikacji, zapoznaj się z dokumentacją usługi iOS, Android C++ oraz Unity.