Twórz dynamiczne linki na iOS

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie lub długie linki dynamiczne. Ten interfejs API akceptuje albo długi link dynamiczny, albo obiekt zawierający parametry linku dynamicznego, i zwraca adresy URL, jak w poniższych przykładach:

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

Wymagania wstępne

Przed rozpoczęciem upewnij się, aby dodać Firebase do projektu iOS .

  1. Dodaj Firebase do projektu iOS .
  2. Zawierać następujące kapsułę w swoim Podfile :
    pod 'Firebase/Analytics'
    pod 'Firebase/DynamicLinks'
        
  3. Run pod install i otworzyć utworzony .xcworkspace pliku.
  4. W konsoli Firebase otwórz sekcję dynamiczne linki.
  5. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i ustawiłeś prefiks URI dla linków dynamicznych, zrób to po wyświetleniu monitu.

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

  6. Zalecane: Określanie wzorców adresów URL dozwolony w swoich głębokich linków i awaryjnych połączeń. W ten sposób uniemożliwiasz nieautoryzowanym stronom tworzenie linków dynamicznych, które przekierowują z Twojej domeny do witryn, których nie kontrolujesz. Zobacz Pozwól wzory określonego adresu URL .
  7. Upewnij się, że identyfikator App Store Twojej aplikacji i prefiks identyfikatora aplikacji są określone w ustawieniach aplikacji. Aby przeglądać i edytować ustawienia w aplikacji, przejdź do projektu Firebase za Ustawienia strony i wybierz swoją aplikację na iOS.

    Potwierdź, że Twój projekt Firebase jest prawidłowo skonfigurowany do korzystania dynamiczne linki w aplikacji iOS otwierając apple-app-site-association plik, który jest gospodarzem na dynamiczne linki domenie. Firebase posłuży apple-app-site-association plik z katalogu głównego domeny, jak również .well-known podkatalogu. Na przykład:

        https://example.com/apple-app-site-association
        https://example.com/.well-known/apple-app-site-association
        

    Jeśli aplikacja jest podłączony, apple-app-site-association plik zawiera odniesienie do aplikacji App ID prefiks i wiązki ID. Na przykład:

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

    Jeżeli details nieruchomość jest pusta, sprawdź, czy podano swój prefiks App ID. Pamiętaj, że prefiks identyfikatora aplikacji może nie być taki sam jak identyfikator zespołu.

Dodaj Firebase do swojej aplikacji

  1. Zaimportować moduł Firebase w UIApplicationDelegate :

    Szybki

    import Firebase

    Cel C

    @import Firebase;
  2. Skonfiguruj FirebaseApp wspólne wystąpienie, zazwyczaj w swojej aplikacji application:didFinishLaunchingWithOptions: metodę:

    Szybki

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

    Cel C

    // Use Firebase library to configure APIs
    [FIRApp configure];

Użyj konsoli Firebase

Jeśli chcesz wygenerować pojedynczy Dynamic Link, zarówno w celach testowych lub dla zespołu marketingowego, aby łatwo utworzyć łącze, które można wykorzystać w czymś w rodzaju social media postu, najprostszym sposobem byłoby odwiedzić konsolę Firebase i utworzyć ręcznie postępując zgodnie z formularzem krok po kroku.

Użyj iOS Builder API

Możesz użyć interfejsu iOS Builder API do tworzenia dynamicznych linków z parametrów lub skrócenia długiego dynamicznego linku.

Aby utworzyć Dynamic Link, należy utworzyć nowy DynamicLinkComponents obiekt i określić parametry Dynamic Link poprzez ustawienie odpowiednich właściwości obiektu. Następnie czeka długi link z obiektu url własności lub uzyskać krótki link wywołując shorten() .

Poniższy przykład tworzy minimalny długą Dynamic Link do https://www.example.com/my-page że otwiera aplikacji iOS na iOS i aplikacja com.example.android na Androida:

Szybki

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

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 stworzyć krótki Dynamic Link, zbudować DynamicLinkComponents w ten sam sposób, a następnie zadzwonić shorten() .

Budowanie krótki związek wymaga połączenia sieciowego, więc zamiast bezpośrednio powrocie link, shorten() akceptuje obsługi zakończenia, która jest wywoływana, gdy finalizuje życzenie. Na przykład:

Szybki

linkBuilder.shorten() { url, warnings, error in
  guard let url = url, error != nil else { return }
  print("The short URL is: \(url)")
}

Cel C

[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 sprawia, że ​​jest bardzo mało prawdopodobne, aby ktoś mógł odgadnąć prawidłowy link dynamiczny. Jeśli w Twoim przypadku użycia, nie ma nic złego w ktoś z powodzeniem zgadywania krótki link, może wolisz, aby wygenerować przyrostków, które są tylko tak długo, jak to konieczne, aby być unikalny, co można zrobić poprzez ustawienie dynamicLinkComponentsOptions właściwość:

Szybki

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

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 Dynamic Link Builder do tworzenia dynamicznych linków z dowolnymi obsługiwanymi parametrami. Zobacz odniesienie API szczegóły.

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

Szybki

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

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żesz ustawić parametry łącza dynamicznego z następującymi obiektami i właściwościami:

Komponenty DynamicLink
połączyć

Link, który otworzy Twoja aplikacja. Określ adres URL, który aplikacja może obsłużyć, zazwyczaj 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ć poprawnie sformatowanym adresem URL, być prawidłowo zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym.

domenaURIPrefix Twój prefiks adresu URL łącza dynamicznego, który znajdziesz w konsoli Firebase. Wygląd domen dołączanej dynamicznie jak w poniższych przykładach:
https://example.com/link
https://example.page.link
DynamicLinkAndroidParametry
rezerwowy URL Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ to, aby zrobić coś innego niż instalowanie aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana, na przykład otworzyć mobilną wersję treści w internecie lub wyświetlić stronę promocyjną aplikacji.
minimalna wersja versionCode wersji minimalnej swojej aplikacji, która może otworzyć link. Jeśli zainstalowana aplikacja jest starszą wersją, użytkownik zostanie przeniesiony do Sklepu Play, aby zaktualizować aplikację.
Parametry DynamicLinkIOS
AppStoreID Identyfikator App Store Twojej aplikacji, używany do wysyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
rezerwowy URL Link do otwarcia, 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ę treści w Internecie lub wyświetlić stronę promocyjną aplikacji.
schemat niestandardowy Niestandardowy schemat adresu URL Twojej aplikacji, jeśli został zdefiniowany jako coś innego niż identyfikator pakietu Twojej aplikacji
iPadpowrotny URL Link do otwierania na iPadach, gdy aplikacja nie jest zainstalowana. Określ to, 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.
IDPakietu iPada Identyfikator pakietu aplikacji na iOS, który ma być używany na iPadach do otwierania linku. Aplikację należy połączyć z projektem na stronie Przegląd w konsoli Firebase.
minimalna wersja aplikacji Numer wersji wersji minimalnej swojej aplikacji, która może otworzyć link. Ta flaga jest przekazywana do aplikacji po jej otwarciu, a aplikacja musi zdecydować, co z nią zrobić.
DynamicLinkNavigationInfoParameters
ForcedRedirectEnabled Jeśli ustawiono na „1”, pomiń stronę podglądu aplikacji po otwarciu Linku dynamicznego i zamiast tego przekieruj do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może bardziej niezawodnie wysyłać użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otworzą 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 go wyłączyć za pomocą tego parametru. Ten parametr wpłynie na zachowanie Dynamic Link tylko na iOS.
DynamicLinkSocialMetaTagParametry
tytuł Tytuł używany, gdy link dynamiczny jest udostępniany w poście społecznościowym.
opisTekst Opis do użycia, gdy link dynamiczny jest udostępniany w poście społecznościowym.
URL obrazu Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć co najmniej 300x200 px i mniej niż 300 KB.
DynamicLinkGoogleAnalyticsParametry
źródło
średni
kampania
semestr
zadowolony
Parametry analityczne Google Play. Te parametry ( utm_source , utm_medium , utm_campaign , utm_term , utm_content ) są przekazywane do Sklepu Play, jak i dołączonym do łącza ładowności.
DynamicLinkItunesConnectAnalyticsParametry
providerToken
affiliateToken
kampaniaToken
Parametry analityczne iTunes Connect. Te parametry ( pt , at , ct ) są przekazywane do App Store.

Aby skrócić długą Dynamic Link, przejść długą Dynamic Link do shortenURL(url:options:) wraz z DynamicLinkComponentsOptions sprzeciw jeśli chcesz wygenerować link z krótkim przyrostkiem:

Szybki

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

[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 uprościć implementację.

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

  1. Podczas konfigurowania aplikacji, upewnij się, że określenie domyślnego schematu URL być wykorzystywane przez aplikację przed skonfigurowaniem FirebaseApp udostępnionego instancji:

    Szybki

    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

    - (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 link dynamiczny, musisz określić niestandardowy schemat adresu URL, z którego korzysta Twoja aplikacja. Można to zrobić za pomocą konsoli Firebase, ustawienie customScheme w API Builder, określając ius parametr w adresie URL, lub wysyłając iosCustomScheme parametr API REST

Następne kroki

Teraz, po utworzeniu linków dynamicznych, musisz skonfigurować swoją aplikację tak, aby odbierała linki dynamiczne i wysyłała użytkowników we właściwe miejsce w aplikacji po ich otwarciu.

Aby otrzymać dynamiczne linki w swojej aplikacji, zobacz dokumentację dla iOS , Androida , C ++ i Jedności .