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 .
Skonfiguruj Firebase i pakiet SDK Linków dynamicznych
Użyj Menedżera pakietów Swift, aby zainstalować zależności Firebase i zarządzać nimi.
- W Xcode, przy otwartym projekcie aplikacji, przejdź do File > Add Packages .
- Po wyświetleniu monitu dodaj repozytorium SDK platform Firebase Apple:
- Wybierz bibliotekę Linki dynamiczne.
- Dodaj flagę
-ObjC
do sekcji Inne flagi linkera w ustawieniach kompilacji celu. - 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.
- Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk.git
Teraz wykonaj kilka kroków konfiguracyjnych:
- W konsoli Firebase otwórz sekcję Linki dynamiczne .
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.
- 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 .
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ć plikapple-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
- Zaimportuj moduł
FirebaseCore
do swojegoUIApplicationDelegate
, 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; // ...
- Skonfiguruj udostępnioną instancję
FirebaseApp
w aplikacji delegataapplication(_: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];
- Jeśli używasz SwiftUI, musisz utworzyć delegata aplikacji i dołączyć go do struktury
App
za pośrednictwemUIApplicationDelegateAdaptor
lubNSApplicationDelegateAdaptor
. 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.
Utwórz łącze dynamiczne na podstawie parametrów
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
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 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
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 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
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); }];
Parametry łącza dynamicznego
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
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ż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. |
Skróć długi link dynamiczny
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
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); }];
Określanie niestandardowego schematu adresu URL dla łączy dynamicznych
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:
- 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; }
- 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 parametrius
w swoim adresie URL lub wysyłając parametriosCustomScheme
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 .