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 parametry linku dynamicznego i zwraca adresy URL takie jak w tych przykładach:
https://example.com/link/WXYZ https://example.page.link/WXYZ
Wymagania wstępne
Zanim zaczniesz, dodaj Firebase do swojego projektu na iOS.
Konfiguracja Firebase i pakietu Dynamic Links SDK
Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.
- Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > 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, włącz Google Analytics w projekcie Firebase i dodaj do aplikacji pakiet SDK Firebase dla Google Analytics. Możesz wybrać bibliotekę bez zbierania danych IDFA lub z zbieraniem identyfikatorów IDFA.
- Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie 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 zaakceptowałeś jeszcze warunków korzystania z usługi ani nie ustawiłeś prefiksu identyfikatora URI linków dynamicznych, zrób to, gdy pojawi się odpowiedni komunikat.
Jeśli masz już prefiks identyfikatora URI Linków dynamicznych, zanotuj go. Musisz go podać podczas automatycznego tworzenia linków dynamicznych.
- Zalecane: określ wzorce adresów URL dozwolone w przypadku precyzyjnych linków i linków zastępczych. Dzięki temu uniemożliwisz nieautoryzowanym osobom tworzenie linków dynamicznych przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Zapoznaj się z sekcją Zezwalanie na określone wzorce adresów URL.
-
Upewnij się, że w ustawieniach aplikacji podano identyfikator z App Store i jej prefiks. Aby wyświetlić i edytować ustawienia aplikacji, otwórz stronę Ustawienia w projekcie Firebase i wybierz swoją aplikację na iOS.
Sprawdź, czy projekt Firebase jest prawidłowo skonfigurowany do używania linków dynamicznych w aplikacji na iOS. W tym celu otwórz plik
apple-app-site-association
hostowany w Twojej domenie. Firebase będzie wyświetlać 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 odwołanie do prefiksu identyfikatora aplikacji i identyfikatora pakietu. Przykład:{"applinks":{"apps":[],"details":[{"appID":"1234567890.com.example.ios","paths":["/*"]}]}}
Jeśli właściwość
details
jest pusta, sprawdź dokładnie, czy został podany 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
do obiektuUIApplicationDelegate
, a także wszystkie inne moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć Cloud Firestore i Uwierzytelniania:Certyfikat 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 współdzieloną instancję
FirebaseApp
w metodzieapplication(_:didFinishLaunchingWithOptions:)
przedstawiciela aplikacji:Certyfikat 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ć przedstawiciela aplikacji i dołączyć go do struktury
App
za pomocąUIApplicationDelegateAdaptor
lubNSApplicationDelegateAdaptor
. Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.Certyfikat 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 dla swojego zespołu marketingowego, aby go łatwo utworzyć, np. w poście w mediach społecznościowych, najprostszym sposobem jest skorzystanie z konsoli Firebase i utworzenie linku ręcznie według instrukcji krok po kroku.
Używanie interfejsu iOS Builder API
Za pomocą interfejsu iOS Builder API możesz tworzyć linki dynamiczne na podstawie parametrów lub skracać długie linki dynamiczne.
Tworzenie linku dynamicznego na podstawie parametrów
Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLinkComponents
i określ parametry linku 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 funkcję shorten()
.
Ten minimalny przykład tworzy długi link dynamiczny do strony https://www.example.com/my-page
, który otwiera się w aplikacji na iOS na iOS i w aplikacji com.example.android
na Androidzie:
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 w ten sam sposób obiekt DynamicLinkComponents
, a następnie wywołaj shorten()
.
Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast zwracać go bezpośrednio, shorten()
akceptuje moduł obsługi uzupełniania, który jest wywoływany 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, co zapobiega odgadnięciu prawidłowego linku dynamicznego. Jeśli w Twoim przypadku nic się nie stanie, gdy ktoś odgadnie krótki link, możesz wygenerować przyrostki, których długość jest niepowtarzalna. Aby to zrobić, ustaw 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ługiwanymi parametrami. Szczegóły znajdziesz w dokumentacji interfejsu API.
Poniższy przykład pokazuje utworzenie linku dynamicznego z kilkoma ustawionymi wspólnymi parametrami:
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 zawartość lub ładunek aplikacji – który inicjuje logikę związaną z daną aplikacją (np. przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być prawidłowo sformatowanym adresem URL, mieć prawidłowo zakodowany adres URL, używać protokołu 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. 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 skuteczniej kierować użytkowników do najbardziej odpowiednich miejsc docelowych, gdy otwierają linki dynamiczne w aplikacjach. Jeśli jednak oczekujesz, że link dynamiczny będzie się otwierał tylko w aplikacjach, które mogą prawidłowo 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 linku.
|
DynamicLinkItunesConnectAnalyticsParameters | |
---|---|
ProviderToken affiliateToken campaignToken |
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ż go do shortenURL(url:options:)
wraz z obiektem DynamicLinkComponentsOptions
, jeśli chcesz wygenerować link 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 potrzebnego do otwarcia aplikacji. Zalecamy pozostawienie tej wartości domyślnej, aby implementacja była prosta.
Deweloperzy, którzy używają już niestandardowego schematu URL do innych celów, mogą jednak chcieć użyć tego samego schematu niestandardowego adresu URL również w swoich linkach dynamicznych. W takiej sytuacji możesz określić inny schemat adresu URL dla Linków dynamicznych Firebase, wykonując te czynności:
- Pamiętaj, aby podczas konfigurowania aplikacji określić domyślny schemat adresu URL, który będzie używany przez aplikację, zanim skonfigurujesz współdzieloną instancję
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; }
- Zawsze gdy tworzysz link dynamiczny, musisz określić schemat niestandardowego adresu URL, którego używa Twoja aplikacja. Możesz to zrobić za pomocą konsoli Firebase, ustawiając
customScheme
w interfejsie Builder API, określając parametrius
w adresie URL lub wysyłając parametriosCustomScheme
do interfejsu API REST
Dalsze kroki
Po utworzeniu linków dynamicznych musisz skonfigurować aplikację, aby otrzymywać linki dynamiczne i kierować użytkowników po otwarciu ich w odpowiednie miejsce.
Aby dowiedzieć się, jak korzystać z linków dynamicznych w swojej aplikacji, zapoznaj się z dokumentacją dotyczącą iOS, Androida, C++ i Unity.