Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie i długie Dynamic Links. Ten interfejs API przyjmuje długi Dynamic Link lub obiekt zawierający Dynamic Link parametry i zwraca adresy URL takie jak w tych przykładach:
https://example.com/link/WXYZ https://example.page.link/WXYZ
Konfiguracja Firebase i pakizacja Dynamic Links SDK
Zanim zaczniesz tworzyć Dynamic Links w aplikacji na Androida, musisz dodać pakiet Firebase SDK. Jeśli Twoja aplikacja jest skonfigurowana do odbierania Dynamic Links, te kroki 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 rejestracji aplikacji podaj klucz podpisywania SHA-1. Jeśli używasz linków do aplikacji, podaj też klucz SHA-256.
-
W pliku Gradle na poziomie modułu (aplikacji) (zwykle
<project>/<app-module>/build.gradle.ktslub<project>/<app-module>/build.gradle), dodaj zależność od biblioteki Dynamic Links na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie Firebase Android BoM.Aby zapewnić optymalne działanie Dynamic Links, zalecamy włączenie Google Analytics w projekcie w Firebase i dodanie do aplikacji [pakiet] SDK Firebase dla Google Analytics.
dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:34.11.0")) // 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 korzystamy z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.
(Alternatywnie) dodaj zależności od biblioteki Firebase bez użycia BoM
Jeśli nie chcesz używać Firebase BoM, musisz określić wersję każdej biblioteki Firebase w wierszu zależności.
Pamiętaj, że jeśli w aplikacji używasz kilku bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia 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:23.2.0' }
- W konsoli Firebase otwórz sekcję Dynamic Links.
-
Jeśli nie masz jeszcze zaakceptowanych warunków korzystania z usługi i nie masz ustawionej domeny dla Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.
Jeśli masz już domenę Dynamic Links, zanotuj ją. Podczas programowego 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, np. na potrzeby testowania lub aby ułatwić zespołowi marketingowemu tworzenie linków, które można wykorzystać np. w poście w mediach społecznościowych, najprościej będzie otworzyć Firebase konsolę i utworzyć link ręcznie, korzystając z formularza krok po kroku.
Tworzenie Dynamic Link na podstawie parametrów
Aby utworzyć Dynamic Link, utwórz nowy obiekt DynamicLink za pomocą jego
konstruktora, określając parametry Dynamic Link za pomocą metod konstruktora. Następnie wywołaj metodę buildDynamicLink lub buildShortDynamicLink.
Ten minimalny przykład tworzy długi Dynamic Link do
https://www.example.com/ który otwiera się w aplikacji na Androida na Androidzie
i w aplikacji com.example.ios na 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 Dynamic Link, utwórz obiekt DynamicLink w ten sam sposób, a następnie wywołaj metodę buildShortDynamicLink. Utworzenie krótkiego linku wymaga
wywołania sieciowego, więc zamiast bezpośrednio zwracać link,
buildShortDynamicLink zwraca obiekt Task, który udostępnia
krótki link 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 Dynamic Links są generowane z 17-znakowymi sufiksami, co
sprawia, że bardzo mało prawdopodobne jest, aby ktoś mógł odgadnąć prawidłowy Dynamic Link. Jeśli w Twoim przypadku nie ma nic złego w tym, że ktoś odgadnie krótki link,
możesz woleć generować sufiksy, które są tylko tak długie, jak to konieczne, aby były
unikalne. Możesz to zrobić, przekazując wartość 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); // ...
Dynamic Link parametry
Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć Dynamic Links z dowolnymi obsługiwanymi parametrami. Szczegółowe informacje znajdziesz w dokumentacji API.
Ten przykład tworzy Dynamic Link z ustawionymi 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 linku dynamicznego | |
|---|---|
| setLink |
Link, który otworzy Twoja aplikacja. Określ adres URL, który może obsługiwać Twoja aplikacja, zwykle treść lub ładunek aplikacji, który inicjuje logikę specyficzną dla aplikacji (np. przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być prawidłowo sformatowanym adresem URL, prawidłowo zakodowanym w formacie 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 wygląda tak jak w tych przykładach:Dynamic Link
https://example.com/link https://example.page.link |
| AndroidParameters | |
|---|---|
| setFallbackUrl | Link, który ma się otworzyć, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby w przypadku, gdy aplikacja nie jest zainstalowana, wykonać inne działanie niż zainstalowanie aplikacji ze Sklepu Play, np. otworzyć mobilną wersję internetową treści 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 App Store, który służy do przekierowywania użytkowników do App Store, gdy aplikacja nie jest zainstalowana. |
| setFallbackUrl | Link, który ma się otworzyć, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby w przypadku, gdy aplikacja nie jest zainstalowana, wykonać inne działanie niż zainstalowanie aplikacji z App Store, np. otworzyć mobilną wersję internetową treści lub wyświetlić stronę promocyjną aplikacji. |
| setCustomScheme | Niestandardowy schemat URI adresu URL aplikacji, jeśli jest zdefiniowany jako inny niż identyfikator pakietu aplikacji. |
| setIpadFallbackUrl | Link, który ma się otworzyć na iPadach, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby w przypadku, gdy aplikacja nie jest zainstalowana, wykonać inne działanie niż zainstalowanie aplikacji z App Store, np. otworzyć wersję internetową treści lub wyświetlić stronę promocyjną aplikacji. |
| setIpadBundleId | Identyfikator pakietu aplikacji na iOS, która ma być używana na iPadach do otwierania linku. Aplikacja musi być połączona z Twoim 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”, strona podglądu aplikacji zostanie pominięta po otwarciu Dynamic Link, a użytkownik zostanie przekierowany do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może niezawodnie przekierowywać użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otwierają 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 ją wyłączyć za pomocą tego parametru. Ten parametr będzie wpływać na działanie Dynamic Link tylko na iOS. |
| SocialMetaTagParameters | |
|---|---|
| setTitle | Tytuł, który ma być używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych. |
| setDescription | Opis, który ma być używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych. |
| 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 Google Analytics w 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 Google Analytics w iTunes Connect. Te parametry (pt,
at, ct) są przekazywane do App Store. |
Skracanie długiego Dynamic Link
Aby skrócić długi Dynamic Link, określ adres URL Dynamic Link za pomocą
setLongLink zamiast ustawiać parametry za pomocą innych metod konstruktora:
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 // ... } } });