Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie lub długie Dynamic Links. Ten interfejs API akceptuje długi parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link i zwraca adresy URL, takie jak te:
https://example.com/link/WXYZ https://example.page.link/WXYZ
Konfiguracja Firebase i pakietu Dynamic Links SDK
Zanim utworzysz Dynamic Links w aplikacji na Androida, musisz dodać pakiet SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana do odbierania Dynamic Links, te czynności zostały już wykonane i możesz pominąć tę sekcję.
Dodaj Firebase do projektu aplikacji na Androida, jeśli nie korzystasz w nim jeszcze z tej usługi.
Podczas rejestrowania aplikacji podaj klucz podpisywania SHA-1. Jeśli używasz linków do aplikacji, podaj też klucz SHA-256.
-
W pliku Gradle modułu (na poziomie aplikacji) (zwykle
<project>/<app-module>/build.gradle.ktslub<project>/<app-module>/build.gradle) dodaj zależność z biblioteką Dynamic Links na Androida. Zalecamy używanie Firebase Android BoM do kontrolowania obsługi wersji biblioteki.Aby zapewnić optymalne działanie usługi Dynamic Links, zalecamy włączenie Google Analytics w projekcie w Firebase i dodanie do aplikacji pakietu SDK Firebase dla Google Analytics.
dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:35.0.1")) // Add the dependencies for the Dynamic Links and Analytics libraries // When using the BoM, you don't specify versions in Firebase library dependencies implementation 'com.google.firebase:firebase-dynamic-links' implementation 'com.google.firebase:firebase-analytics' }
Gdy korzystasz z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.
(Alternatywa) Dodaj zależności biblioteki Firebase bez używania BoM
Jeśli nie zdecydujesz się na użycie Firebase BoM, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.
Jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek, co zapewni zgodność wszystkich wersji.
dependencies { // Add the dependencies for the Dynamic Links and Analytics libraries // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation 'com.google.firebase:firebase-dynamic-links:22.1.0' implementation 'com.google.firebase:firebase-analytics:24.0.0' }
- W konsoli Firebase otwórz sekcję Dynamic Links.
-
Jeśli nie zaakceptowano jeszcze warunków korzystania z usługi i nie ustawiono domeny dla Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.
Jeśli masz już domenę Dynamic Links, zanotuj ją. Podczas automatycznego tworzenia Dynamic Links musisz podać domenę Dynamic Links.

- Zalecane: określ wzorce adresów URL dozwolone w precyzyjnych linkach i linkach zastępczych. Dzięki temu uniemożliwisz nieupoważnionym osobom tworzenie Dynamic Links, które przekierowują z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz Zezwalanie na określone wzorce adresów URL.
Korzystanie z konsoli Firebase
Jeśli chcesz wygenerować pojedynczy Dynamic Link do celów testowych lub dla zespołu marketingowego, aby łatwo utworzyć link, który można wykorzystać na przykład w poście w mediach społecznościowych, najprostszym sposobem jest odwiedzenie konsoli Firebase i ręczne utworzenie linku za pomocą formularza.
Utwórz Dynamic Link na podstawie parametrów
Aby utworzyć obiekt Dynamic Link, utwórz nowy obiekt DynamicLink za pomocą kreatora, określając parametry Dynamic Link za pomocą metod kreatora. Następnie zadzwoń pod numer buildDynamicLink lub buildShortDynamicLink.
Poniższy przykład pokazuje, jak utworzyć długi link Dynamic Link do https://www.example.com/, który otwiera się w aplikacji na Androida na urządzeniu z Androidem i w aplikacji com.example.ios na urządzeniu z iOS:
Kotlin
val dynamicLink = Firebase.dynamicLinks.dynamicLink { link = Uri.parse("https://www.example.com/") domainUriPrefix = "https://example.page.link" // Open links with this app on Android androidParameters { } // Open links with com.example.ios on iOS iosParameters("com.example.ios") { } } val dynamicLinkUri = dynamicLink.uri
Java
DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink() .setLink(Uri.parse("https://www.example.com/")) .setDomainUriPrefix("https://example.page.link") // Open links with this app on Android .setAndroidParameters(new DynamicLink.AndroidParameters.Builder().build()) // Open links with com.example.ios on iOS .setIosParameters(new DynamicLink.IosParameters.Builder("com.example.ios").build()) .buildDynamicLink(); Uri dynamicLinkUri = dynamicLink.getUri();
Aby utworzyć krótki obiekt Dynamic Link, utwórz obiekt DynamicLink w ten sam sposób, a następnie wywołaj buildShortDynamicLink. Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast bezpośrednio zwracać link, buildShortDynamicLink zwraca Task, dzięki czemu krótki link jest dostępny po zakończeniu żądania. Przykład:
Kotlin
val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync { link = Uri.parse("https://www.example.com/") domainUriPrefix = "https://example.page.link" // Set parameters // ... }.addOnSuccessListener { (shortLink, flowchartLink) -> // You'll need to import com.google.firebase.dynamiclinks.component1 and // com.google.firebase.dynamiclinks.component2 // Short link created processShortLink(shortLink, flowchartLink) }.addOnFailureListener { // Error // ... }
Java
Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink() .setLink(Uri.parse("https://www.example.com/")) .setDomainUriPrefix("https://example.page.link") // Set parameters // ... .buildShortDynamicLink() .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() { @Override public void onComplete(@NonNull Task<ShortDynamicLink> task) { if (task.isSuccessful()) { // Short link created Uri shortLink = task.getResult().getShortLink(); Uri flowchartLink = task.getResult().getPreviewLink(); } else { // Error // ... } } });
Domyślnie krótkie linki Dynamic Links są generowane z 17-znakowymi sufiksami, co sprawia, że odgadnięcie prawidłowego linku Dynamic Link jest bardzo mało prawdopodobne. Jeśli w Twoim przypadku nie ma znaczenia, czy ktoś odgadnie krótki link, możesz wygenerować sufiksy, które są tylko tak długie, jak to konieczne, aby były unikalne. Możesz to zrobić, przekazując ShortDynamicLink.Suffix.SHORT do metody buildShortDynamicLink:
Kotlin
val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) { // Set parameters // ... }
Java
Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink() // ... .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT); // ...
Liczba parametrów: Dynamic Link
Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć Dynamic Links z dowolnymi obsługiwanymi parametrami. Więcej informacji znajdziesz w dokumentacji interfejsu API.
W tym przykładzie tworzymy obiekt Dynamic Link z kilkoma typowymi parametrami:
Kotlin
val dynamicLink = Firebase.dynamicLinks.dynamicLink { // or Firebase.dynamicLinks.shortLinkAsync link = Uri.parse("https://www.example.com/") domainUriPrefix = "https://example.page.link" androidParameters("com.example.android") { minimumVersion = 125 } iosParameters("com.example.ios") { appStoreId = "123456789" minimumVersion = "1.0.1" } googleAnalyticsParameters { source = "orkut" medium = "social" campaign = "example-promo" } itunesConnectAnalyticsParameters { providerToken = "123456" campaignToken = "example-promo" } socialMetaTagParameters { title = "Example of a Dynamic Link" description = "This link works whether the app is installed or not!" } }
Java
DynamicLink dynamicLink = FirebaseDynamicLinks.getInstance().createDynamicLink() .setLink(Uri.parse("https://www.example.com/")) .setDomainUriPrefix("https://example.page.link") .setAndroidParameters( new DynamicLink.AndroidParameters.Builder("com.example.android") .setMinimumVersion(125) .build()) .setIosParameters( new DynamicLink.IosParameters.Builder("com.example.ios") .setAppStoreId("123456789") .setMinimumVersion("1.0.1") .build()) .setGoogleAnalyticsParameters( new DynamicLink.GoogleAnalyticsParameters.Builder() .setSource("orkut") .setMedium("social") .setCampaign("example-promo") .build()) .setItunesConnectAnalyticsParameters( new DynamicLink.ItunesConnectAnalyticsParameters.Builder() .setProviderToken("123456") .setCampaignToken("example-promo") .build()) .setSocialMetaTagParameters( new DynamicLink.SocialMetaTagParameters.Builder() .setTitle("Example of a Dynamic Link") .setDescription("This link works whether the app is installed or not!") .build()) .buildDynamicLink(); // Or buildShortDynamicLink()
Parametry Dynamic Link możesz ustawić za pomocą tych metod:
| Parametry DynamicLink | |
|---|---|
| setLink |
Link, który otworzy Twoja aplikacja. Podaj adres URL, który może obsłużyć Twoja aplikacja. Zwykle jest to zawartość lub ładunek aplikacji, który inicjuje logikę aplikacji (np. przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być prawidłowo sformatowanym adresem URL, prawidłowo zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym. |
| setDomainUriPrefix | Prefiks adresu URL Dynamic Link, który znajdziesz w konsoli Firebase. Domena Dynamic Link wygląda jak w tych przykładach:
https://example.com/link https://example.page.link |
| AndroidParameters | |
|---|---|
| setFallbackUrl | Link, który ma się otworzyć, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję treści w internecie mobilnym lub wyświetlić stronę promocyjną aplikacji. |
| setMinimumVersion | versionCode minimalnej wersji aplikacji, która może otworzyć link. Jeśli zainstalowana aplikacja jest starszą wersją, użytkownik zostanie przekierowany do Sklepu Play, aby ją zaktualizować. |
| IosParameters | |
|---|---|
| setAppStoreId | Identyfikator aplikacji w sklepie z aplikacjami, który służy do przekierowywania użytkowników do sklepu z aplikacjami, gdy aplikacja nie jest zainstalowana. |
| setFallbackUrl | Link, który ma się otworzyć, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji ze sklepu z aplikacjami, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję treści w przeglądarce mobilnej lub wyświetlić stronę promocyjną aplikacji. |
| setCustomScheme | Niestandardowy schemat URI adresu URL aplikacji, jeśli jest zdefiniowany jako coś innego niż identyfikator pakietu aplikacji. |
| setIpadFallbackUrl | Link, który ma się otwierać na iPadach, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji ze sklepu z aplikacjami, gdy aplikacja nie jest zainstalowana, np. otworzyć internetową wersję treści lub wyświetlić stronę promocyjną aplikacji. |
| setIpadBundleId | Identyfikator pakietu aplikacji na iOS, który ma być używany na iPadach do otwierania linku. Aplikacja musi być połączona z projektem na stronie Przegląd w konsoli Firebase. |
| setMinimumVersion | Numer wersji minimalnej wersji aplikacji, która może otworzyć link. Ta flaga jest przekazywana do aplikacji po jej otwarciu, a aplikacja musi zdecydować, co z nią zrobić. |
| NavigationInfoParameters | |
|---|---|
| setForcedRedirectEnabled | Jeśli ustawisz wartość „1”, po otwarciu Dynamic Link strona podglądu aplikacji zostanie pominięta, a użytkownik zostanie przekierowany do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może bardziej niezawodnie kierować użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otwierają 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 ją wyłączyć za pomocą tego parametru. Ten parametr wpływa na działanie Dynamic Link tylko na iOS. |
| SocialMetaTagParameters | |
|---|---|
| setTitle | Tytuł, który będzie używany, gdy Dynamic Link zostanie udostępniony w poście w sieci społecznościowej. |
| setDescription | Opis, który ma być używany, gdy Dynamic Link jest udostępniany w poście w sieci społecznościowej. |
| setImageUrl | Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300 x 200 pikseli i rozmiar mniejszy niż 300 KB. |
| GoogleAnalyticsParameters | |
|---|---|
| setSource setMedium setCampaign setTerm setContent |
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.
|
| ItunesConnectAnalyticsParameters | |
|---|---|
| setProviderToken setAffiliateToken setCampaignToken |
Parametry analityczne iTunes Connect. Te parametry (pt, at, ct) są przekazywane do sklepu z aplikacjami. |
Skracanie długiego filmu Dynamic Link
Aby skrócić długi Dynamic Link, określ adres URL Dynamic Link za pomocą setLongLink zamiast ustawiania parametrów za pomocą innych metod kreatora:
Kotlin
val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync { longLink = Uri.parse( "https://example.page.link/?link=" + "https://www.example.com/&apn=com.example.android&ibn=com.example.ios", ) }.addOnSuccessListener { (shortLink, flowChartLink) -> // You'll need to import com.google.firebase.dynamiclinks.component1 and // com.google.firebase.dynamiclinks.component2 // Short link created processShortLink(shortLink, flowChartLink) }.addOnFailureListener { // Error // ... }
Java
Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink() .setLongLink(Uri.parse("https://example.page.link/?link=https://www.example.com/&apn=com.example.android&ibn=com.example.ios")) .buildShortDynamicLink() .addOnCompleteListener(this, new OnCompleteListener<ShortDynamicLink>() { @Override public void onComplete(@NonNull Task<ShortDynamicLink> task) { if (task.isSuccessful()) { // Short link created Uri shortLink = task.getResult().getShortLink(); Uri flowchartLink = task.getResult().getPreviewLink(); } else { // Error // ... } } });