Tworzenie linków dynamicznych na Androidzie

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz utworzyć krótki lub długi plik Dynamic Links. Ten interfejs API akceptuje długą wartość Dynamic Link lub obiekt zawierający Dynamic Link i zwraca adresy URL takie jak:

https://example.com/link/WXYZ
https://example.page.link/WXYZ

Zanim utworzysz Dynamic Links w aplikacji na Androida, musisz dołączyć do pakietu SDK Firebase. Jeśli Twoja aplikacja ma skonfigurowane otrzymywanie Dynamic Links, to już masz już wykonano te czynności i możesz pominąć tę sekcję.

  1. Jeśli jeszcze nie masz tego za sobą, dodaj Firebase do swojego projektu na Androida.

    Podczas rejestracji aplikacji podaj klucz podpisywania SHA-1. Jeśli używasz App Links: podaj też klucz SHA-256.

  2. w pliku Gradle (na poziomie aplikacji) modułu, (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), dodaj zależność z biblioteką Dynamic Links na Androida. Zalecamy użycie metody Firebase Android BoM aby kontrolować obsługę wersji biblioteki.

    Aby zapewnić optymalne działanie usługi Dynamic Links, zalecamy włączam Google Analytics w projekcie Firebase i dodając do aplikacji pakiet SDK Firebase dla Google Analytics. 

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.2.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'
}

    Korzystając z narzędzia Firebase Android BoM, Twoja aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Wersja alternatywna) Dodaj zależności biblioteki Firebase bez użycia komponentu BoM

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

    Pamiętaj, że jeśli używasz wielu bibliotek Firebase w aplikacji, zalecamy korzystanie z BoM do zarządzania wersjami biblioteki. Dzięki temu 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.1.0'
}
         Szukasz modułu biblioteki korzystającego z usługi Kotlin? Zaczyna się za Październik 2023 r. (Firebase BoM 32.5.0) zarówno programiści Kotlin, jak i Java zależą od modułu biblioteki głównej (więcej informacji znajdziesz w Najczęstsze pytania na temat tej inicjatywy).
  3. W konsoli Firebase otwórz sekcję Dynamic Links.

  4. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie masz skonfigurowanej domeny Dynamic Links, zrób to, gdy pojawi się odpowiedni komunikat.

    Jeśli masz już domenę Dynamic Links, zanotuj ją. Czynności, które musisz wykonać podaj domenę Dynamic Links podczas automatycznego tworzenia instancji Dynamic Links.

  5. Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom utworzenie Dynamic Links przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Patrz sekcja Zezwalaj na określone treści Wzorce adresów URL.

Korzystanie z konsoli Firebase

Jeśli chcesz wygenerować pojedynczy element Dynamic Link 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, odwiedź konsolę Firebase i utworzyć ją ręcznie, postępując zgodnie z instrukcjami.

Aby utworzyć obiekt Dynamic Link, utwórz nowy obiekt DynamicLink z parametrem Kreatora określającego parametry Dynamic Link za pomocą metod konstruktora. Następnie zadzwoń buildDynamicLink lub buildShortDynamicLink.

Poniższy minimalny przykład tworzy długi Dynamic Link do https://www.example.com/ otwiera się w aplikacji na Androida oraz com.example.ios na 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 format Dynamic Link, utwórz DynamicLink w ten sam sposób. i wywołaj buildShortDynamicLink. Do utworzenia krótkiego linku potrzebne są: przez wywołanie sieciowe, więc zamiast zwracać bezpośrednio link, buildShortDynamicLink zwraca Task, który daje krótki link, który pojawi się po realizacji prośby. 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ótki plik Dynamic Links jest generowany z 17-znakowymi sufiksami linków, które zmniejsza więc prawdopodobieństwo, że ktoś odgadnie poprawną wartość w polu Dynamic Link. 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, unikalnych użytkowników. Aby to zrobić, prześlij 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

Możesz użyć interfejsu Dynamic Link Builder API, aby utworzyć Dynamic Links z dowolną z obsługiwane parametry. Zobacz API.

Ten przykład tworzy Dynamic Link z kilkoma wspólnymi parametrami ustaw:

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 Dynamic Link możesz skonfigurować 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 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.
setDomainUriPrefix, Twój prefiks adresu URL Dynamic Link, który znajdziesz w konsoli Firebase. O Domena Dynamic Link wygląda podobnie do tych 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. Musisz połączyć aplikację 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 ma wartość „1”, pomiń stronę podglądu aplikacji po otwarciu Dynamic Link i przekieruj ją do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może bardziej niezawodnie odsyłać użytkowników do najbardziej odpowiednich miejsc docelowych, gdy otwierają Dynamic Links w aplikacjach. Jeśli jednak oczekujesz, że element Dynamic Link będzie otwierany tylko w aplikacjach, które mogą niezawodnie otwierać Dynamic Links bez tej strony, możesz go wyłączyć za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie funkcji Dynamic Link tylko w systemie iOS.
SocialMetaTagParameters
setTitle Tytuł używany, gdy Dynamic Link jest udostępniany w poście w mediach społecznościowych.
ustawOpis Opis 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 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 linków.
ItunesConnectAnalyticsParameters
setProviderToken
setaffiliateToken
setCampaignToken		 Parametry analityczne iTunes Connect. Te parametry (pt, at i ct) są przekazywane do App Store.

Aby skrócić długi Dynamic Link, określ URL elementu Dynamic Link za pomocą setLongLink zamiast ustawiać parametry za pomocą innego kreatora metody:

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