Tworzenie linków dynamicznych w iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz utworzyć krótki lub długi plik Dynamic Links. Ten interfejs API akceptuje długą wartość Dynamic Link lub obiekt zawierający Dynamic Link 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.

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:
    3.   https://github.com/firebase/firebase-ios-sdk.git
  3. Wybierz bibliotekę Dynamic Links.
  4. Dodaj flagę -ObjC do sekcji Inne flagi łączące w ustawieniach kompilacji celu.
  5. Aby zapewnić optymalne działanie usługi Dynamic Links, zalecamy włączam 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 tych danych.
  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ę Dynamic Links.

  2. Jeśli nie zostały jeszcze zaakceptowane warunki korzystania z usługi i ustawiono prefiks identyfikatora URI Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.

    Jeśli masz już prefiks identyfikatora URI Dynamic Links, zanotuj go. Czynności, które musisz wykonać go podczas automatycznego tworzenia obiektu Dynamic Links.

  3. Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom utworzenie Dynamic Links przekierowujących z Twojej 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 aplikacji w sklepie App Store oraz jej prefiks 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 Dynamic Links w aplikacji na iOS, otwierając apple-app-site-association plik hostowany na Dynamic Links. 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ć atrybutów 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 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 element Dynamic Link 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, odwiedź 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 skompilować obiekt Dynamic Links na podstawie parametrów lub skróć długie Dynamic Link.

Aby utworzyć obiekt Dynamic Link, utwórz nowy obiekt DynamicLinkComponents. i określ parametry Dynamic Link, ustawiając odpowiednią wartość 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 tworzy długi Dynamic Link do https://www.example.com/my-page, który otwiera się w aplikacji na iOS iOS i aplikacja com.example.android na Androida:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na systemy docelowe macOS, Mac Catalyst, tvOS i 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 systemy docelowe macOS, Mac Catalyst, tvOS i 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 format Dynamic Link, 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:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na systemy docelowe macOS, Mac Catalyst, tvOS i 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 systemy docelowe macOS, Mac Catalyst, tvOS i 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ótki plik Dynamic Links jest generowany z 17-znakowymi sufiksami linków, które zmniejsza więc prawdopodobieństwo, że ktoś odgadnie poprawną wartość w polu Dynamic Link. 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:

Swift

Uwaga: ta usługa Firebase nie jest dostępna na systemy docelowe macOS, Mac Catalyst, tvOS i 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 systemy docelowe macOS, Mac Catalyst, tvOS i 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 Dynamic Link Builder API, aby utworzyć Dynamic Links z dowolną z obsługiwane parametry. Zobacz API.

Ten przykład tworzy Dynamic Link z kilkoma wspólnymi parametrami ustaw:

Swift

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

Komponenty DynamicLink
link

Link, który otworzy się Twoja aplikacja. Określ adres URL, który może obsługiwać aplikacja (zwykle jest to zawartość aplikacji) lub ładunku, które inicjują logikę związaną z daną aplikacją (np. przypisanie użytkownikowi kuponu lub wyświetlając ekran powitalny). Link ten musi być dobrze sformatowanym adresem URL, prawidłowo zakodowanym adresem URL oraz musi to być protokół HTTP lub HTTPS i nie może być kolejnym linkiem dynamicznym.
Prefiks URI domeny Twój prefiks adresu URL Dynamic Link, który znajdziesz w konsoli Firebase. O Domena Dynamic Link wygląda podobnie do tych w tych przykładach: 
https://example.com/link
https://example.page.link
Parametry dynamicznego linku na Androidzie
zastępczy URL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Wybierz tę opcję, jeśli chcesz, by aplikacja nie była zainstalowana ze Sklepu Play. Może to być na przykład otwarcie mobilnej wersji treści lub wyświetlenie strony promocyjnej aplikacji.
minimalna wersja versionCode minimalnej wersji aplikacji, w której można otworzyć link. Jeśli zainstalowana jest starsza wersja aplikacji, użytkownik zostanie przekierowany do Sklepu Play, aby ją uaktualnić.
Parametry dynamicznego linku
identyfikator_sklepu_aplikacji Identyfikator App Store Twojej aplikacji używany do kierowania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
zastępczy URL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Wybierz to ustawienie, jeśli chcesz, by aplikacja nie była zainstalowana z App Store. Może to być na przykład otwarcie mobilnej wersji treści lub wyświetlanie strony promocyjnej aplikacji.
schemat niestandardowy Schemat niestandardowego adresu URL aplikacji, jeśli został zdefiniowany jako inny niż identyfikator pakietu aplikacji
Zastępczy URL iPada Link do otwierania się na iPadzie, gdy aplikacja nie jest zainstalowana. Wybierz to ustawienie, jeśli aplikacja nie jest zainstalowana z App Store. Może to być na przykład otwarcie internetowej wersji treści lub wyświetlanie strony promocyjnej aplikacji.
Identyfikator pakietu iPada Identyfikator pakietu aplikacji na iOS, którego chcesz użyć na iPadzie do otwarcia linku. Musisz połączyć aplikację z projektem na stronie Przegląd w konsoli Firebase.
minimalna wersjaAppVersion Numer wersji minimalnej wersji aplikacji, w której można otworzyć link. Ta flaga jest przekazywana do aplikacji po otwarciu, która musi zdecydować, co z nią zrobić.
Parametry dynamicznego linku nawigacyjnego
forcedRedirectEnabled Jeśli ma wartość „1”, pomiń stronę podglądu aplikacji po otwarciu Dynamic Link i przekieruj ją do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może bardziej niezawodnie odsyłać użytkowników do najbardziej odpowiednich miejsc docelowych, gdy otwierają Dynamic Links w aplikacjach. Jeśli jednak oczekujesz, że element Dynamic Link będzie otwierany tylko w aplikacjach, które mogą niezawodnie otwierać Dynamic Links bez tej strony, możesz go wyłączyć za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie funkcji Dynamic Link tylko w systemie iOS.
Parametry dynamicznego linku społecznościowego
tytuł Tytuł używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych.
Tekst opisu Opis używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych.
URL obrazu Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary przynajmniej 300 × 200 pikseli i rozmiar mniejszy niż 300 KB.
DynamicLinkGoogleAnalyticsParameters
źródło
medium
kampania
hasło
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 linków.
DynamicLinkItunesConnectAnalyticsParameters
ProviderToken
affiliateToken
campaignToken		 Parametry analityczne iTunes Connect. Te parametry (pt, at i ct) są przekazywane do App Store.

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

Swift

Uwaga: ta usługa Firebase nie jest dostępna na systemy docelowe macOS, Mac Catalyst, tvOS i 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 systemy docelowe macOS, Mac Catalyst, tvOS i 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 niezbędnego do otwarcia 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 schemat niestandardowego adresu URL dla strony Dynamic Links. Jeśli dotyczy Cię taka sytuacja, możesz określić zmień schemat adresu URL dla swojego urządzenia Firebase Dynamic Links, 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 Dynamic Link, 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 grupy Dynamic Links musisz skonfigurować aplikację, aby otrzymywać Dynamic Links i kieruj użytkowników do właściwego miejsca w aplikacji, gdy użytkownik je otworzy.

Aby otrzymywać Dynamic Links w swojej aplikacji, zapoznaj się z dokumentacją usługi iOS, Android C++ oraz Unity.