Tworzenie linków dynamicznych w iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie i długie Dynamic Links. Ten interfejs API akceptuje parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link. Zwraca adresy URL podobne do tych przykładów:

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

Wymagania wstępne

Zanim zaczniesz, dodaj Firebase do projektu na iOS.

Do instalacji zależności Firebase i zarządzania nimi możesz używać menedżera pakietów Swift.

  1. Po otwarciu projektu aplikacji w Xcode wybierz Plik > Dodaj pakiety.
  2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę Dynamic Links.
  4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
  5. Aby uzyskać optymalne wyniki w przypadku 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 zbieraniem identyfikatorów IDFA lub bez niego.
  6. Gdy to zrobisz, Xcode automatycznie zacznie wyszukiwać i pobierać zależności w tle.

Teraz wykonaj czynności konfiguracyjne:

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

  2. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie ustawiłeś prefiksu URI dla usługi Dynamic Links, zrób to, gdy pojawi się taka prośba.

    Jeśli masz już prefiks URI Dynamic Links, zanotuj go. Musisz go podać, gdy Dynamic Links tworzysz programowo.

  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 artykuł Zezwalanie na określone wzorce adresów URL.

  4. Sprawdź, czy identyfikator App Store i prefiks identyfikatora aplikacji są określone w ustawieniach aplikacji. Aby wyświetlić i zmienić ustawienia aplikacji, otwórz stronę Ustawienia w projekcie Firebase i wybierz aplikację na iOS.

    Aby sprawdzić, czy Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania z Dynamic Links w aplikacji na iOS, 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 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. Przykład:

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

    Jeśli właściwość details jest pusta, sprawdź, czy podano poprawny 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 w pliku UIApplicationDelegate oraz wszystkie inne moduły Firebase, których używa delegowany obiekt 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 współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) w delegacie 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 delegujący aplikacji i dołączyć go do struktury App za pomocą funkcji UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizlowanie zastępników aplikacji. 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 Dynamic Link na potrzeby testów lub aby umożliwić zespołowi marketingowemu łatwe tworzenie linków do wykorzystania w postach w mediach społecznościowych, najprostszym sposobem jest przejście do konsoli Firebase i ręczne utworzenie linku zgodnie z podanymi instrukcjami.

Korzystanie z interfejsu Builder API na iOS

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

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 uzyskaj 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 Dynamic Link do https://www.example.com/my-page, który otwiera się w aplikacji na iOS na iOS i w aplikacji com.example.android na Androidzie:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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)")

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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 Dynamic Link, utwórz DynamicLinkComponents w taki sam sposób, a potem wywołaj funkcję shorten().

Utworzenie krótkiego linku wymaga wywołania sieci, więc zamiast zwracania bezpośrednio linku funkcja shorten() przyjmuje procedurę obsługi zakończenia, która jest wywoływana po zakończeniu przetwarzania żądania. Przykład:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
[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 Dynamic Links są generowane z 17-znakowymi sufiksami linków, które sprawiają, że bardzo mało prawdopodobne jest, aby ktoś mógł odgadnąć prawidłowy Dynamic Link. Jeśli w Twoim przypadku nie ma znaczenia, czy ktoś zgadnie krótki link, możesz wygenerować sufiksy o długości wystarczającej do zapewnienia ich unikalności. Możesz to zrobić, ustawiając właściwość dynamicLinkComponentsOptions:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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);
}];

Do tworzenia Dynamic Links za pomocą dowolnych obsługiwanych parametrów możesz użyć interfejsu Builder API.Dynamic Link Więcej informacji znajdziesz w dokumentacji interfejsu API.

W tym przykładzie tworzymy Dynamic Link z kilkoma typowymi parametrami:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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)")

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
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 ustawiać za pomocą tych obiektów i właściwości:

DynamicLinkComponents
link

Link, który otwiera aplikacja. Podaj adres URL, który może obsłużyć Twoja aplikacja, zwykle jest to zawartość lub ładunek aplikacji, który inicjuje logikę aplikacji (np. przyznawanie użytkownikowi kuponu lub wyświetlanie ekranu powitalnego). Link musi być poprawnie sformatowanym adresem URL, prawidłowo zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym.
domainURIPrefix prefiks adresu URL Dynamic Link, który znajdziesz w konsoli Firebase. Dynamic Link domena wygląda jak w tych przykładach: 
https://example.com/link
https://example.page.link
DynamicLinkAndroidParameters
fallbackURL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Wpisz ten parametr, aby wykonać inne działanie niż instalacja aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana. Możesz na przykład otworzyć wersję internetową treści na urządzeniu mobilnym lub wyświetlić stronę promocyjną aplikacji.
minimumVersion  minimalnej wersji aplikacji, która może otworzyć link.versionCode Jeśli zainstalowana aplikacja jest w starszej wersji, użytkownik zostanie przekierowany do Sklepu Play, aby ją zaktualizować.
DynamicLinkIOSParameters
appStoreID Identyfikator aplikacji w App Store, który służy do wysyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
fallbackURL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji z App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję mobilną treści w przeglądarce lub wyświetlić stronę promocyjną aplikacji.
customScheme niestandardowy schemat adresów URL aplikacji, jeśli jest zdefiniowany jako inny niż identyfikator pakietu aplikacji;
iPadFallbackURL Link do otwarcia na iPadach, gdy aplikacja nie jest zainstalowana. Określ to, aby wykonać inną czynność niż zainstalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
iPadBundleID Identyfikator pakietu aplikacji na iOS, której należy używać na iPadach do otwierania linku. Aplikacja musi być połączona z Twoim projektem na stronie Przegląd w konsoli Firebase.
minimumAppVersion Numer wersji minimalnej wersji aplikacji, która może otworzyć link. Ten parametr jest przekazywany do aplikacji po jej otwarciu, a ona musi zdecydować, co z nim zrobić.
DynamicLinkNavigationInfoParameters
forcedRedirectEnabled Jeśli wartość to „1”, po otwarciu Dynamic Link pomiń stronę podglądu aplikacji i przekieruj użytkownika do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może skuteczniej kierować użytkowników do najbardziej odpowiedniego miejsca po kliknięciu Dynamic Links w aplikacjach. Jeśli jednak chcesz, aby Dynamic Link otwierał się tylko w aplikacjach, które mogą otwierać Dynamic Links bez tej strony, możesz wyłączyć tę stronę za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie Dynamic Link tylko na urządzeniach z iOS.
DynamicLinkSocialMetaTagParameters
tytuł Tytuł, który ma być używany podczas udostępniania Dynamic Link w postach w mediach społecznościowych.
descriptionText Opis, który ma być używany, gdy Dynamic Link jest udostępniany w postach w mediach społecznościowych.
imageURL Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300 x 200 pikseli i nie więcej niż 300 KB.
DynamicLinkGoogleAnalyticsParameters
source
medium
campaign
term
content		 Parametry Google Play. Te parametry (utm_source, utm_medium, utm_campaign, utm_term, utm_content) są przekazywane do Sklepu Play, a także dołączane do ładunku linku.
DynamicLinkItunesConnectAnalyticsParameters
providerToken
affiliateToken
campaignToken		 Parametry analityczne iTunes Connect. Te parametry (pt, at, ct) są przekazywane do App Store.

Aby skrócić długi Dynamic Link, prześlij długi Dynamic Link do funkcji shortenURL(url:options:) wraz z obiektem DynamicLinkComponentsOptions, jeśli chcesz wygenerować link z krótkim sufiksem:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
DynamicLinkComponents.shortenURL(url: longLinkUrl, options: nil) { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Objective-C

Uwaga: ta usługa Firebase nie jest dostępna na platformach docelowych macOS, Mac Catalyst, tvOS ani watchOS. 
[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);
}];

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

Deweloperzy, którzy już używają niestandardowego schematu URL do innych celów, mogą jednak chcieć użyć tego samego schematu w przypadku Dynamic Links. W takim przypadku możesz określić inny schemat adresu URL dla Firebase Dynamic Links, wykonując te czynności:

  1. Podczas konfigurowania aplikacji przed skonfigurowaniem FirebaseApp wspólnej instancji należy określić domyślny schemat adresów URL, którego ma używać aplikacja:

    Swift

    Uwaga: ta usługa Firebase nie jest dostępna na platformach 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
}

    Objective-C

    Uwaga: ta usługa Firebase nie jest dostępna na platformach 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. Podczas tworzenia Dynamic Link musisz podać niestandardowy schemat adresu URL, którego używa Twoja aplikacja. Możesz to zrobić w konsoli Firebase, ustawiając parametr customScheme w Builder API, podając parametr ius w adresie URL lub wysyłając parametr iosCustomScheme do interfejsu API typu REST.

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 otwarciu tych wiadomości.

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