Tworzenie linków dynamicznych na Androidzie

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

Aby tworzyć linki dynamiczne w aplikacji na Androida, musisz uwzględnić pakiet SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana do otrzymywania linków dynamicznych, te czynności zostały już wykonane i możesz pominąć tę sekcję.

  1. Dodaj Firebase do swojego projektu Android, chyba że masz to już za sobą.

    Podczas rejestracji aplikacji podaj klucz podpisywania SHA-1. Jeśli korzystasz z linków aplikacji, podaj też klucz SHA-256.

  2. W pliku Gradle (na poziomie aplikacji) modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle) dodaj zależność z biblioteką linków dynamicznych na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie funkcji Firebase Android BoM.

    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. 

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.2"))

    // 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'
}

    Dzięki użyciu BoM Firebase Android BoM Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Dodawanie zależności bibliotek Firebase bez korzystania z BM

    Jeśli nie chcesz używać Firebase BoM, musisz określić każdą wersję biblioteki Firebase w wierszu zależności.

    Pamiętaj, że jeśli w swojej aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami bibliotek. Dzięki temu będziesz mieć pewność, że wszystkie wersje są zgodne. 

    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:22.0.2'
}
    Szukasz modułu biblioteki korzystającego z usługi Kotlin? Od października 2023 r. (Firebase BoM 32.5.0) zarówno deweloperzy aplikacji Kotlin, jak i języki Java mogą korzystać z modułu biblioteki głównej (więcej informacji znajdziesz w odpowiedziach na najczęstsze pytania o tę inicjatywę).
  3. W konsoli Firebase otwórz sekcję Linki dynamiczne.

  4. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie masz ustawionej domeny dla swoich Linków dynamicznych, zrób to, gdy pojawi się odpowiedni komunikat.

    Jeśli masz już domenę Linki dynamiczne, zanotuj ją. Podczas automatycznego tworzenia linków dynamicznych musisz podać domenę linków dynamicznych.

  5. 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.

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.

Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLink za pomocą jego kreatora, określając parametry linku dynamicznego za pomocą metod Builder. Następnie zadzwoń pod numer buildDynamicLink lub buildShortDynamicLink.

Ten minimalistyczny przykład pozwala utworzyć długi link dynamiczny do strony https://www.example.com/, który otwiera się w aplikacji na Androida i com.example.ios w systemie iOS:

Kotlin+KTX

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
MainActivity.kt

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();
MainActivity.java

Aby utworzyć krótki link dynamiczny, utwórz w ten sam sposób obiekt DynamicLink, a następnie wywołaj buildShortDynamicLink. Utworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast zwracać go bezpośrednio, buildShortDynamicLink zwraca wartość Task, dzięki której krótki link jest dostępny po zakończeniu żądania. Przykład:

Kotlin+KTX

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
    // ...
}
MainActivity.kt

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
                    // ...
                }
            }
        });
MainActivity.java

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ć sufiksy o długości tylko takiej długości, która jest unikalna, co można zrobić, przekazując ShortDynamicLink.Suffix.SHORT do metody buildShortDynamicLink:

Kotlin+KTX

val shortLinkTask = Firebase.dynamicLinks.shortLinkAsync(ShortDynamicLink.Suffix.SHORT) {
    // Set parameters
    // ...
}
MainActivity.kt

Java

Task<ShortDynamicLink> shortLinkTask = FirebaseDynamicLinks.getInstance().createDynamicLink()
        // ...
        .buildShortDynamicLink(ShortDynamicLink.Suffix.SHORT);
        // ...
MainActivity.java

Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć linki dynamiczne za pomocą dowolnych obsługiwanych parametrów. Szczegóły znajdziesz w dokumentacji interfejsu API.

Poniższy przykład pokazuje utworzenie linku dynamicznego z kilkoma wspólnymi parametrami:

Kotlin+KTX

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!"
    }
}
MainActivity.kt

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()
MainActivity.java

Parametry linku dynamicznego możesz ustawić za pomocą tych metod:

Parametry DynamicLink
setLink

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.
setDomainUriPrefix, 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 Androida
setFallbackUrl 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.
ustaw minimalną wersję 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 IOS
setAppStoreId Identyfikator App Store Twojej aplikacji używany do kierowania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
setFallbackUrl 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.
setCustomScheme Schemat niestandardowego adresu URL aplikacji, jeśli został zdefiniowany jako inny niż identyfikator pakietu aplikacji
setIpadFallbackUrl. 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 zestawuIpadBundle 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.
ustaw minimalną wersję 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 nawigacji
setForcedRedirectEnabled 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.
SocialMetaTagParameters
setTitle Tytuł używany, gdy link dynamiczny jest udostępniany w poście w mediach społecznościowych.
ustawOpis Opis używany, gdy link dynamiczny jest udostępniany w poście w mediach społecznościowych.
setImageUrl Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary przynajmniej 300 × 200 pikseli i rozmiar mniejszy niż 300 KB.
Parametry GoogleAnalytics
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 App Store.

Aby skrócić długi link dynamiczny, podaj jego adres URL za pomocą parametru setLongLink, zamiast ustawiać parametry za pomocą innych metod:

Kotlin+KTX

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
    // ...
}
MainActivity.kt

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
                    // ...
                }
            }
        });
MainActivity.java