Tworzenie linków dynamicznych w iOS

Krótkie i długie linki dynamiczne możesz tworzyć za pomocą interfejsu Firebase Dynamic Links Builder API. Ten interfejs API akceptuje długi link dynamiczny lub obiekt zawierający link dynamiczny 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.

Konfiguracja Firebase i pakietu SDK Linków dynamicznych

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ę linków dynamicznych.
4. Dodaj flagę -ObjC do sekcji Inne flagi łączące w ustawieniach kompilacji celu.
5. Aby zapewnić optymalne działanie linków dynamicznych, zalecamy włączenie 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 danych IDFA.
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ę Linki dynamiczne.

2. Jeśli nie zostały jeszcze zaakceptowane warunki korzystania z usługi i ustawiono prefiks identyfikatora URI linków dynamicznych, gdy pojawi się taka prośba.

   Jeśli masz już prefiks identyfikatora URI Linków dynamicznych, zanotuj go. Czynności, które musisz wykonać go podczas automatycznego tworzenia linków dynamicznych.

   

3. Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom Tworzenie linków dynamicznych przekierowujących z 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 App Store Twojej aplikacji oraz prefiks identyfikatora aplikacji 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 Linki dynamiczne w aplikacji na iOS po otwarciu apple-app-site-association plik hostowany na Domena Linków dynamicznych. 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ć Cloud Firestore i Uwierzytelniania:

   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 link dynamiczny 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, otwórz 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 tworzyć linki dynamiczne na podstawie parametrów oraz by skrócić długi link dynamiczny.

Tworzenie linku dynamicznego na podstawie parametrów

Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLinkComponents i określ parametry linku dynamicznego, ustawiając odpowiednią 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 pozwala utworzyć długi link dynamiczny 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 link dynamiczny, 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ótkie linki dynamiczne są generowane z 17-znakowymi sufiksami linków, które zmniejsza więc prawdopodobieństwo odgadnięcia prawidłowego linku dynamicznego przez użytkownika. 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);
}];
      

Parametry linku dynamicznego

Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć linki dynamiczne z dowolnymi obsługiwane parametry. Zobacz API.

Przykład poniżej tworzy link dynamiczny 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 Linków dynamicznych możesz ustawić za pomocą tych 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ż go 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 linków dynamicznych

Domyślnie linki dynamiczne używają identyfikatora pakietu aplikacji jako schematu adresu URL niezbędnego do otwierania 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 niestandardowy schemat URL-i dla linków dynamicznych. Jeśli dotyczy Cię taka sytuacja, możesz określić zmień schemat adresu URL dla Linków dynamicznych Firebase, 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 link dynamiczny, 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 linków dynamicznych musisz skonfigurować aplikację, aby otrzymywać Linki dynamiczne i kierowanie użytkowników po uruchomieniu przez użytkowników do właściwego miejsca w aplikacji.

Aby otrzymywać linki dynamiczne w swojej aplikacji, zapoznaj się z dokumentacją: iOS, Android C++ oraz Unity.