Tworzenie linków dynamicznych w iOS

Krótkie lub długie Dynamic Links możesz tworzyć za pomocą interfejsu Firebase Dynamic Links Builder API. Ten interfejs API akceptuje długi ciąg Dynamic Link lub obiekt zawierający parametry Dynamic Link i zwraca adresy URL podobne do tych w przykładach poniżej:

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 do zarządzania nimi możesz używać menedżera pakietów Swift.

  1. Po otwarciu projektu aplikacji wybierz w Xcode opcję File > Add Packages (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 Other Linker Flags (Inne flagi linkera) w ustawieniach kompilacji projektu.
  5. Aby w pełni korzystać z Dynamic Links, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę bez zbierania identyfikatora IDFA lub z jego zbieraniem. Zapoznaj się z naszymi odpowiedziami na najczęstsze pytania dotyczące najnowszej organizacji modułów w Google Analytics dla pakietu SDK Firebase.
  6. Gdy skończysz, Xcode zacznie automatycznie wyszukiwać i pobierać zależności w tle.

Teraz wykonaj kilka czynności konfiguracyjnych:

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

  2. Jeśli nie masz jeszcze zaakceptowanych warunków korzystania z usługi i nie masz ustawionego prefiksu URI dla Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.

    Jeśli masz już Dynamic Links prefiks URI, zanotuj go. Musisz go podać podczas programowego tworzenia Dynamic Links.

  3. Zalecane: określ wzorce adresów URL dozwolone w precyzyjnych linkach i linkach zastępczych. W ten sposób uniemożliwisz nieupoważnionym osobom tworzenie Dynamic Links, które przekierowują z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz Zezwalanie na określone wzorce adresów URL.

  4. Sprawdź, czy w ustawieniach aplikacji podany jest identyfikator App Store i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, otwórz stronę Ustawienia projektu Firebase i wybierz aplikację na iOS.

    Sprawdź, czy projekt Firebase jest prawidłowo skonfigurowany do używania w aplikacji na iOS, otwierając plik Dynamic Links, który jest hostowany w Twojej domenie Dynamic Links.apple-app-site-association Firebase będzie udostępniać 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 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 podano 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, a także inne moduły Firebase, których używa delegat 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 udostępnioną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) delegata 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ć delegata aplikacji i dołączyć go do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć zamianę delegata aplikacji. Więcej informacji znajdziesz w instrukcjach dotyczących 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, np. na potrzeby testów lub aby zespół marketingowy mógł łatwo utworzyć link, który można wykorzystać np. w poście w mediach społecznościowych, najprostszym sposobem będzie przejście do Firebasekonsoli i ręczne utworzenie go za pomocą formularza krok po kroku.

Korzystanie z interfejsu iOS Builder API

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 pobierz długi link z właściwości url obiektu lub krótki link, wywołując shorten().

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

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach 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 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 film Dynamic Link, utwórz DynamicLinkComponents w ten sam sposób, a następnie wywołaj shorten().

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

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach 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 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 linki Dynamic Links są generowane z 17-znakowymi sufiksami, które sprawiają, że odgadnięcie prawidłowego linku Dynamic Link jest niezwykle mało prawdopodobne. Jeśli w Twoim przypadku nie ma nic złego w tym, że ktoś odgadnie krótki link, możesz wygenerować sufiksy, które są tylko tak długie, jak to konieczne, aby były niepowtarzalne. Możesz to zrobić, ustawiając właściwość dynamicLinkComponentsOptions:

Swift

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

Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć Dynamic Links z dowolnymi obsługiwanymi parametrami. Więcej informacji znajdziesz w  dokumentacji interfejsu API.

W tym przykładzie tworzony jest obiekt Dynamic Link z kilkoma ustawionymi parametrami:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach 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 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 otworzy aplikacja. Określ adres URL, który może obsługiwać Twoja aplikacja. Zwykle jest to zawartość lub ładunek aplikacji, który inicjuje logikę specyficzną dla aplikacji (np. przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być prawidłowo sformatowanym adresem URL, odpowiednio zakodowanym, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym.
domainURIPrefix Twój prefiks adresu URL Dynamic Link, który znajdziesz w Firebase konsoli. Domena Dynamic Link wygląda tak jak w tych przykładach: 
https://example.com/link
https://example.page.link
DynamicLinkAndroidParameters
fallbackURL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby w przypadku braku zainstalowanej aplikacji wykonać inne działanie niż instalacja aplikacji ze Sklepu Play, np. otworzyć mobilną wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
minimumVersion versionCode minimalnej wersji aplikacji, która może otworzyć link. Jeśli zainstalowana aplikacja jest starszą wersją, użytkownik zostanie przekierowany do Sklepu Play, aby ją zaktualizować.
DynamicLinkIOSParameters
appStoreID Identyfikator aplikacji w sklepie App Store, który służy do przekierowywania użytkowników do sklepu App Store, gdy aplikacja nie jest zainstalowana.
fallbackURL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby w przypadku braku zainstalowanej aplikacji wykonać inne działanie niż instalacja aplikacji z App Store, np. otworzyć mobilną wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
customScheme Niestandardowy schemat adresów URL aplikacji, jeśli został zdefiniowany jako inny niż identyfikator pakietu aplikacji.
iPadFallbackURL Link do otwarcia na iPadach, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby w przypadku braku zainstalowanej aplikacji wykonać inne działanie niż instalacja aplikacji ze sklepu App Store, np. otworzyć wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
iPadBundleID Identyfikator pakietu aplikacji na iOS, która ma być używana na iPadach do otwierania linku. Aplikacja musi być połączona z projektem na stronie Przegląd w Firebase konsoli.
minimumAppVersion Numer wersji minimalnej wersji aplikacji, która może otworzyć link. Ten flag jest przekazywany do aplikacji po jej otwarciu, a aplikacja musi zdecydować, co z nim zrobić.
DynamicLinkNavigationInfoParameters
forcedRedirectEnabled Jeśli wartość parametru to „1”, po otwarciu Dynamic Link strona podglądu aplikacji zostanie pominięta, a użytkownik zostanie przekierowany do aplikacji lub sklepu. Strona podglądu aplikacji (włączona domyślnie) może skuteczniej kierować użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otwierają oni Dynamic Links w aplikacjach. Jeśli jednak oczekujesz, że Dynamic Link będzie otwierany tylko w aplikacjach, które mogą niezawodnie otwierać Dynamic Links bez tej strony, możesz ją wyłączyć za pomocą tego parametru. Ten parametr wpłynie na działanie Dynamic Link tylko na urządzeniach z iOS.
DynamicLinkSocialMetaTagParameters
tytuł Tytuł, który ma być używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych.
descriptionText Opis, który ma być używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych.
imageURL Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300 x 200 pikseli, a jego rozmiar nie może przekraczać 300 KB.
DynamicLinkGoogleAnalyticsParameters
source
medium
campaign
term
content		 parametry analityczne Google Play, Te parametry (utm_source, utm_medium, utm_campaign, utm_term, utm_content) są przekazywane do Sklepu Play i 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 adres URL Dynamic Link, przekaż go do funkcji shortenURL(url:options:) wraz z obiektem DynamicLinkComponentsOptions, jeśli chcesz wygenerować link z krótkim sufiksem:Dynamic Link

Swift

Uwaga: ta usługa Firebase nie jest dostępna na platformach 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 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. Aby uprościć implementację, zalecamy pozostawienie tej wartości domyślnej.

Deweloperzy, którzy używają już niestandardowego schematu URL do innych celów, mogą chcieć używać tego samego schematu URL również w przypadku Dynamic Links. Jeśli tak jest, możesz określić inny schemat adresu URL dla swojego Firebase Dynamic Links, wykonując te czynności:

  1. Podczas konfigurowania aplikacji przed skonfigurowaniem FirebaseAppwspólnej instancjiFirebaseApp określ domyślny schemat adresu URL, który ma być używany przez aplikację:

    Swift

    Uwaga: ta usługa Firebase nie jest dostępna na platformach 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 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 Dynamic Link, musisz podać schemat niestandardowego adresu URL, którego używa Twoja aplikacja. Możesz to zrobić w FirebasekonsoliFirebase, ustawiając parametr customScheme w interfejsie 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 linku.

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