Twórz linki dynamiczne na iOS

Możesz tworzyć krótkie lub długie linki dynamiczne za pomocą interfejsu API Firebase Dynamic Links Builder. Ten interfejs API akceptuje albo długi link dynamiczny, albo obiekt zawierający parametry łącza dynamicznego i zwraca adresy URL, takie jak poniższe przykłady:

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

Warunki wstępne

Zanim zaczniesz, pamiętaj o dodaniu Firebase do swojego projektu na iOS .

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

  1. W Xcode, przy otwartym projekcie aplikacji, przejdź do File > Add Packages .
  2. Po wyświetleniu monitu dodaj repozytorium SDK platform Firebase Apple:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę Linki dynamiczne.
  4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji celu.
  5. Aby zapewnić optymalne działanie Linków dynamicznych, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie pakietu SDK Firebase dla Google Analytics do swojej aplikacji. Można wybrać bibliotekę bez kolekcji IDFA lub z kolekcją IDFA.
  6. Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.

Teraz wykonaj kilka kroków konfiguracyjnych:

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

  2. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie ustawiłeś prefiksu URI dla swoich łączy dynamicznych, zrób to po wyświetleniu monitu.

    Jeśli masz już prefiks URI łączy dynamicznych, zanotuj go. Musisz go podać podczas programowego tworzenia łączy dynamicznych.

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

  4. Upewnij się, że w ustawieniach aplikacji określono identyfikator App Store i prefiks identyfikatora aplikacji. Aby wyświetlić i edytować ustawienia aplikacji, przejdź do strony Ustawienia projektu Firebase i wybierz aplikację na iOS.

    Upewnij się, że Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania z łączy dynamicznych w aplikacji na iOS, otwierając plik apple-app-site-association hostowany w Twojej domenie łączy dynamicznych. 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 Twoja aplikacja jest połączona, plik apple-app-site-association zawiera odniesienie do przedrostka identyfikatora aplikacji i identyfikatora pakietu. Na przykład:

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

    Jeśli właściwość details jest pusta, sprawdź dokładnie, czy określono przedrostek identyfikatora aplikacji. Pamiętaj, że prefiks identyfikatora aplikacji może różnić się od identyfikatora zespołu.

Dodaj Firebase do swojej aplikacji

  1. Zaimportuj moduł FirebaseCore do swojego UIApplicationDelegate , a także wszelkie inne moduły Firebase, których używa delegat aplikacji. Na przykład, aby użyć Cloud Firestore i uwierzytelniania:

    SwiftUI

    import SwiftUI
import FirebaseCore
import FirebaseFirestore
import FirebaseAuth
// ...

    Szybki

    import FirebaseCore
import FirebaseFirestore
import FirebaseAuth
// ...

    Cel C

    @import FirebaseCore;
@import FirebaseFirestore;
@import FirebaseAuth;
// ...
  2. Skonfiguruj udostępnioną instancję FirebaseApp w aplikacji delegata application(_:didFinishLaunchingWithOptions:) metoda:

    SwiftUI

    // Use Firebase library to configure APIs
FirebaseApp.configure()

    Szybki

    // Use Firebase library to configure APIs
FirebaseApp.configure()

    Cel 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 pośrednictwem UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor . Musisz także wyłączyć przełączanie delegatów aplikacji. Aby uzyskać więcej informacji, zapoznaj się z instrukcjami SwiftUI .

    SwiftUI

    @main
struct YourApp: App {
  // register app delegate for Firebase setup
  @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate

  var body: some Scene {
    WindowGroup {
      NavigationView {
        ContentView()
      }
    }
  }
}

Użyj konsoli Firebase

Jeśli chcesz wygenerować pojedynczy link dynamiczny do celów testowych lub aby Twój zespół marketingowy mógł łatwo utworzyć link, który można wykorzystać w postach w mediach społecznościowych, najprostszym sposobem byłoby odwiedzenie konsoli Firebase i utworzenie takiego ręcznie, postępując zgodnie z formularzem krok po kroku.

Skorzystaj z interfejsu API narzędzia iOS Builder

Możesz użyć interfejsu API narzędzia iOS Builder do tworzenia łączy dynamicznych na podstawie parametrów lub skracania długich łączy dynamicznych.

Aby utworzyć łącze dynamiczne, utwórz nowy obiekt DynamicLinkComponents i określ parametry łącza 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 shorten() .

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

Szybki

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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)")

Cel C

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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ótkie łącze dynamiczne, zbuduj DynamicLinkComponents w ten sam sposób, a następnie wywołaj funkcję shorten() .

Tworzenie krótkiego łącza wymaga wywołania sieciowego, więc zamiast bezpośrednio zwracać łącze, shorten() akceptuje procedurę obsługi uzupełniania, która jest wywoływana po zakończeniu żądania. Na przykład:

Szybki

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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)")
}

Cel C

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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 generowane są krótkie linki dynamiczne z 17-znakowymi sufiksami linków, co sprawia, że ​​odgadnięcie prawidłowego łącza dynamicznego jest bardzo mało prawdopodobne. Jeśli w twoim przypadku nie ma nic złego w tym, że ktoś pomyślnie odgadnie krótki link, możesz wolić generować sufiksy, które są tylko tak długie, jak to konieczne, aby były unikalne, co możesz zrobić, ustawiając właściwość dynamicLinkComponentsOptions :

Szybki

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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)")
}

Cel C

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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);
}];

Możesz użyć interfejsu API narzędzia Dynamic Link Builder do tworzenia łączy dynamicznych z dowolnymi obsługiwanymi parametrami. Aby uzyskać szczegółowe informacje, zobacz dokumentację API .

Poniższy przykład tworzy łącze dynamiczne z kilkoma wspólnymi zestawami parametrów:

Szybki

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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)")

Cel C

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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);

Można ustawić parametry łącza dynamicznego za pomocą następujących obiektów i właściwości:

Składniki DynamicLink
połączyć

Link, który otworzy Twoja aplikacja. Określ adres URL, który może obsłużyć Twoja aplikacja, zazwyczaj zawartość aplikacji lub ładunek, który inicjuje logikę specyficzną dla aplikacji (taką jak przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być dobrze sformatowanym adresem URL, odpowiednio zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym łączem dynamicznym.

domenaURIPrefix Twój prefiks adresu URL łącza dynamicznego, który znajdziesz w konsoli Firebase. Domena łącza dynamicznego wygląda jak w poniższych przykładach: 
https://example.com/link
https://example.page.link
Parametry DynamicLinkAndroid
zastępczy adres URL Link otwierany, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana, na przykład otworzyć mobilną wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
minimalna wersja versionCode minimalnej wersji aplikacji, która może otworzyć łącze. Jeśli zainstalowana aplikacja jest starszą wersją, użytkownik zostanie przeniesiony do Sklepu Play w celu aktualizacji aplikacji.
Parametry DynamicLinkIOSParametry
identyfikator sklepu z aplikacjami Identyfikator Twojej aplikacji w App Store, używany do odsyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
zastępczy adres URL Link otwierany, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, na przykład otworzyć mobilną wersję internetową zawartości lub wyświetlić stronę promocyjną aplikacji.
Schemat niestandardowy Niestandardowy schemat adresu URL Twojej aplikacji, jeśli zdefiniowany jako inny niż identyfikator pakietu aplikacji
Zapasowy adres URL iPada Link do otwarcia na iPadzie, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, na przykład otworzyć internetową wersję zawartości lub wyświetlić stronę promocyjną aplikacji.
ID pakietu iPada Identyfikator pakietu aplikacji na iOS, którego można używać na iPadach do otwierania łącza. Aplikacja musi być połączona z projektem na stronie Przegląd konsoli Firebase.
minimalna wersja aplikacji Numer wersji minimalnej aplikacji, w której można otworzyć link. Ta flaga jest przekazywana do aplikacji po jej otwarciu i aplikacja musi zdecydować, co z nią zrobić.
Parametry DynamicLinkNavigationInfoParameters
wymuszone przekierowanie włączone Jeśli ustawione na „1”, pomiń stronę podglądu aplikacji po otwarciu łącza dynamicznego i zamiast tego przekieruj do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może w bardziej niezawodny sposób odsyłać użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otwierają łącza dynamiczne w aplikacjach; jeśli jednak oczekujesz, że łącze dynamiczne będzie otwierane tylko w aplikacjach, które potrafią niezawodnie otwierać łącza dynamiczne bez tej strony, możesz je wyłączyć za pomocą tego parametru. Ten parametr będzie miał wpływ na zachowanie łącza dynamicznego tylko w systemie iOS.
Parametry DynamicLinkSocialMetaTag
tytuł Tytuł używany podczas udostępniania łącza dynamicznego w poście społecznościowym.
opisTekst Opis używany w przypadku udostępniania łącza dynamicznego w poście społecznościowym.
adres URL obrazu Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300x200 px i mniej niż 300 KB.
Parametry DynamicLinkGoogleAnalytics
źródło
średni
kampania
termin
treść		 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.
Parametry DynamicLinkItunesConnectAnalytics
token dostawcy
token partnerski
Token kampanii		 Parametry analityczne iTunes Connect. Te parametry ( pt , at , ct ) są przekazywane do App Store.

Aby skrócić długi link dynamiczny, przekaż długi link dynamiczny do shortenURL(url:options:) wraz z obiektem DynamicLinkComponentsOptions , jeśli chcesz wygenerować link z krótkim sufiksem:

Szybki

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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)")
}

Cel C

Uwaga: ten produkt Firebase nie jest dostępny w systemach 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 Twojej aplikacji jako schematu adresu URL potrzebnego do otwarcia aplikacji. Zalecamy pozostanie przy tej wartości domyślnej, aby zapewnić prostotę implementacji.

Jednak programiści, którzy już korzystają z niestandardowego schematu adresu URL do innych celów, mogą chcieć użyć tego samego niestandardowego schematu adresu URL również w swoich linkach dynamicznych. Jeśli znajdziesz się w takiej sytuacji, możesz określić inny schemat adresu URL dla linków dynamicznych Firebase, wykonując następujące kroki:

  1. Konfigurując aplikację, przed skonfigurowaniem udostępnionej instancji FirebaseApp upewnij się, że określiłeś domyślny schemat adresu URL, który będzie używany przez aplikację:

    Szybki

    Uwaga: ten produkt Firebase nie jest dostępny w systemach 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
}

    Cel C

    Uwaga: ten produkt Firebase nie jest dostępny w systemach 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. Za każdym razem, gdy tworzysz łącze dynamiczne, musisz określić niestandardowy schemat adresu URL, z którego korzysta Twoja aplikacja. Możesz to zrobić za pomocą konsoli Firebase, ustawiając customScheme w API Builder, określając parametr ius w swoim adresie URL lub wysyłając parametr iosCustomScheme do API REST

Następne kroki

Po utworzeniu linków dynamicznych musisz skonfigurować aplikację tak, aby otrzymywała linki dynamiczne i odsyłała użytkowników do odpowiedniego miejsca w aplikacji, gdy użytkownik je otworzy.

Aby otrzymać linki dynamiczne w swojej aplikacji, zapoznaj się z dokumentacją systemów iOS , Android , C++ i Unity .