Krótkie i długie linki dynamiczne możesz tworzyć za pomocą interfejsu Firebase Dynamic Links Builder API. Ten interfejs API akceptuje długi link dynamiczny lub obiekt zawierający link dynamiczny 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.
Konfiguracja Firebase i pakietu SDK Linków dynamicznych
Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.
- W Xcode po otwarciu projektu aplikacji przejdź do File > Dodaj pakiety.
- Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:
- Wybierz bibliotekę linków dynamicznych.
- Dodaj flagę
-ObjC
do sekcji Inne flagi łączące w ustawieniach kompilacji celu. - Aby zapewnić optymalne działanie linków dynamicznych, zalecamy włączenie 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 danych IDFA.
- Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie lub zależności w tle.
https://github.com/firebase/firebase-ios-sdk.git
Teraz wykonaj kilka czynności konfiguracyjnych:
- W konsoli Firebase otwórz sekcję Linki dynamiczne.
-
Jeśli nie zostały jeszcze zaakceptowane warunki korzystania z usługi i ustawiono prefiks identyfikatora URI linków dynamicznych, gdy pojawi się taka prośba.
Jeśli masz już prefiks identyfikatora URI Linków dynamicznych, zanotuj go. Czynności, które musisz wykonać go podczas automatycznego tworzenia linków dynamicznych.
- Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom Tworzenie linków dynamicznych przekierowujących z domeny do witryn, nad którymi nie masz kontroli. Patrz sekcja Zezwalaj na określone treści Wzorce adresów URL.
-
Upewnij się, że identyfikator App Store Twojej aplikacji oraz prefiks identyfikatora aplikacji 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 Linki dynamiczne w aplikacji na iOS po otwarciu
apple-app-site-association
plik hostowany na Domena Linków dynamicznych. 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
- Zaimportuj moduł
FirebaseCore
doUIApplicationDelegate
, jak i wszelkie inne Moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć Cloud Firestore i Uwierzytelniania:SwiftUI
import SwiftUI import FirebaseCore import FirebaseFirestore import FirebaseAuth // ...
Swift
import FirebaseCore import FirebaseFirestore import FirebaseAuth // ...
Objective-C
@import FirebaseCore; @import FirebaseFirestore; @import FirebaseAuth; // ...
- Skonfiguruj
FirebaseApp
współdzielonej instancji w uprawnieniach przedstawiciela aplikacji Metodaapplication(_: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];
- Jeśli używasz SwiftUI, musisz utworzyć i dołączyć przedstawiciela aplikacji.
do struktury
App
za pomocąUIApplicationDelegateAdaptor
lubNSApplicationDelegateAdaptor
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 link dynamiczny 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, otwórz 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 tworzyć linki dynamiczne na podstawie parametrów oraz by skrócić długi link dynamiczny.
Tworzenie linku dynamicznego na podstawie parametrów
Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLinkComponents
i określ parametry linku dynamicznego, ustawiając odpowiednią
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 pozwala utworzyć długi link dynamiczny do
https://www.example.com/my-page
, który otwiera się w aplikacji na iOS
iOS i aplikacja com.example.android
na Androida:
Swift
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
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 link dynamiczny, 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
linkBuilder.shorten() { url, warnings, error in guard let url = url, error != nil else { return } print("The short URL is: \(url)") }
Objective-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, które
zmniejsza więc prawdopodobieństwo odgadnięcia prawidłowego linku dynamicznego przez użytkownika. 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
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
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 linku dynamicznego
Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć linki dynamiczne z dowolnymi obsługiwane parametry. Zobacz API.
Przykład poniżej tworzy link dynamiczny z kilkoma wspólnymi parametrami ustaw:
Swift
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
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 Linków dynamicznych 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 | Prefiks adresu URL linku dynamicznego, który możesz znaleźć w konsoli Firebase. O
Domena linku dynamicznego wygląda jak 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. Aplikację należy połączyć 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 ustawisz wartość „1”, pomiń stronę podglądu aplikacji po otwarciu linku dynamicznego i przekieruj ją do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może bardziej niezawodnie kierować użytkowników do najbardziej odpowiednich miejsc docelowych, gdy otwierają linki dynamiczne w aplikacjach. Jeśli jednak oczekujesz, że link dynamiczny będzie otwierany tylko w aplikacjach, które mogą niezawodnie otwierać linki dynamiczne bez tej strony, możesz go wyłączyć za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie linku dynamicznego tylko w systemie iOS. |
Parametry dynamicznego linku społecznościowego | |
---|---|
tytuł | Tytuł używany, gdy link dynamiczny jest udostępniany w poście w mediach społecznościowych. |
Tekst opisu | Opis używany, gdy link dynamiczny 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. |
Skróć długi link dynamiczny
Aby skrócić długi link dynamiczny, przekaż go do
shortenURL(url:options:)
wraz z
DynamicLinkComponentsOptions
, jeśli chcesz wygenerować
z krótkim sufiksem:
Swift
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
[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 linków dynamicznych
Domyślnie linki dynamiczne używają identyfikatora pakietu aplikacji jako schematu adresu URL niezbędnego do otwierania 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 niestandardowy schemat URL-i dla linków dynamicznych. Jeśli dotyczy Cię taka sytuacja, możesz określić zmień schemat adresu URL dla Linków dynamicznych Firebase, wykonując te czynności:
- 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; }
- Tworząc link dynamiczny, 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 parametrius
w adresie URL lub wysyłając parametriosCustomScheme
do funkcji Interfejs API typu REST
Dalsze kroki
Po utworzeniu linków dynamicznych musisz skonfigurować aplikację, aby otrzymywać Linki dynamiczne i kierowanie użytkowników po uruchomieniu przez użytkowników do właściwego miejsca w aplikacji.
Aby otrzymywać linki dynamiczne w swojej aplikacji, zapoznaj się z dokumentacją: iOS, Android C++ oraz Unity.