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 parametry linku dynamicznego 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, dodaj Firebase do swojego projektu na iOS.

Konfiguracja Firebase i pakietu Dynamic Links SDK

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

1. Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > 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, włącz Google Analytics w projekcie Firebase i dodaj do aplikacji pakiet SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę bez zbierania danych IDFA lub z zbieraniem identyfikatorów IDFA.
6. Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

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

2. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi ani nie ustawiłeś prefiksu identyfikatora URI linków dynamicznych, zrób to, gdy pojawi się odpowiedni komunikat.

   Jeśli masz już prefiks identyfikatora URI Linków dynamicznych, zanotuj go. Musisz go podać podczas automatycznego tworzenia linków dynamicznych.

   

3. Zalecane: określ wzorce adresów URL dozwolone w przypadku precyzyjnych linków i linków zastępczych. Dzięki temu uniemożliwisz nieautoryzowanym osobom tworzenie linków dynamicznych przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Zapoznaj się z sekcją Zezwalanie na określone wzorce adresów URL.

4. Upewnij się, że w ustawieniach aplikacji podano identyfikator z App Store i jej prefiks. Aby wyświetlić i edytować ustawienia aplikacji, otwórz stronę Ustawienia w projekcie Firebase i wybierz swoją aplikację na iOS.

   Sprawdź, czy projekt Firebase jest prawidłowo skonfigurowany do używania linków dynamicznych w aplikacji na iOS. W tym celu otwórz plik apple-app-site-association hostowany w Twojej domenie. Firebase będzie wyświetlać plik apple-app-site-association z katalogu głównego domeny oraz 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 Twoja aplikacja jest połączona, plik apple-app-site-association zawiera odwołanie 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ź dokładnie, czy został podany 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 obiektu UIApplicationDelegate, a także wszystkie inne moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć Cloud Firestore i Uwierzytelniania:

   Certyfikat 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 współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) przedstawiciela aplikacji:

   Certyfikat 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ć przedstawiciela aplikacji i dołączyć go do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.

   Certyfikat 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 dla swojego zespołu marketingowego, aby go łatwo utworzyć, np. w poście w mediach społecznościowych, najprostszym sposobem jest skorzystanie z konsoli Firebase i utworzenie linku ręcznie według instrukcji krok po kroku.

Używanie interfejsu iOS Builder API

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

Tworzenie linku dynamicznego na podstawie parametrów

Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLinkComponents i określ parametry linku dynamicznego, ustawiając odpowiednie właściwości obiektu. Następnie pobierz długi link z właściwości url obiektu lub uzyskaj krótki link, wywołując funkcję shorten().

Ten minimalny przykład tworzy długi link dynamiczny do strony 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 link dynamiczny, utwórz w ten sam sposób obiekt DynamicLinkComponents, a następnie wywołaj shorten().

Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast zwracać go bezpośrednio, shorten() akceptuje moduł obsługi uzupełniania, 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 dynamiczne są generowane z 17-znakowymi sufiksami linków, co zapobiega odgadnięciu prawidłowego linku dynamicznego. Jeśli w Twoim przypadku nic się nie stanie, gdy ktoś odgadnie krótki link, możesz wygenerować przyrostki, których długość jest niepowtarzalna. Aby to zrobić, ustaw 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ługiwanymi parametrami. Szczegóły znajdziesz w dokumentacji interfejsu API.

Poniższy przykład pokazuje utworzenie linku dynamicznego z kilkoma ustawionymi wspólnymi 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 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 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 adresu URL dla linków dynamicznych

Domyślnie linki dynamiczne używają identyfikatora pakietu aplikacji jako schematu adresu URL potrzebnego do otwarcia aplikacji. Zalecamy pozostawienie tej wartości domyślnej, aby implementacja była prosta.

Deweloperzy, którzy używają już niestandardowego schematu URL do innych celów, mogą jednak chcieć użyć tego samego schematu niestandardowego adresu URL również w swoich linkach dynamicznych. W takiej sytuacji możesz określić inny schemat adresu URL dla Linków dynamicznych Firebase, wykonując te czynności:

1. Pamiętaj, aby podczas konfigurowania aplikacji określić domyślny schemat adresu URL, który będzie używany przez aplikację, zanim skonfigurujesz współdzieloną instancję 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. Zawsze gdy tworzysz link dynamiczny, musisz określić schemat niestandardowego adresu URL, którego używa Twoja aplikacja. Możesz to zrobić za pomocą 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 API REST

Dalsze kroki

Po utworzeniu linków dynamicznych musisz skonfigurować aplikację, aby otrzymywać linki dynamiczne i kierować użytkowników po otwarciu ich w odpowiednie miejsce.

Aby dowiedzieć się, jak korzystać z linków dynamicznych w swojej aplikacji, zapoznaj się z dokumentacją dotyczącą iOS, Androida, C++ i Unity.