Twórz linki dynamiczne na Androidzie

Możesz tworzyć krótkie lub długie linki dynamiczne za pomocą interfejsu API Firebase Dynamic Links Builder. Ten interfejs API akceptuje albo długi link dynamiczny, albo obiekt zawierający parametry łącza dynamicznego i zwraca adresy URL, takie jak poniższe przykłady:

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

Zanim będziesz mógł utworzyć linki dynamiczne w aplikacji na Androida, musisz dołączyć pakiet SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana do otrzymywania linków dynamicznych, wykonałeś już te kroki i możesz pominąć tę sekcję.

  1. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .

    Podczas rejestrowania aplikacji podaj klucz podpisu SHA-1. Jeśli korzystasz z łączy aplikacji, podaj także klucz SHA-256.

  2. W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle ) dodaj zależność dla łączy dynamicznych biblioteka dla Androida. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.

    Aby zapewnić optymalne działanie Linków dynamicznych, zalecamy włączenie Google Analytics w projekcie Firebase i dodanie pakietu SDK Firebase dla Google Analytics do swojej aplikacji.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.3"))
    
        // 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 Firebase Android BoM , Twoja aplikacja będzie zawsze korzystać z kompatybilnych wersji bibliotek Firebase Android.

    (Alternatywa) Dodaj zależności biblioteki Firebase bez użycia BoM

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

    Pamiętaj, że jeśli używasz w swojej aplikacji wielu bibliotek Firebase, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co gwarantuje, że wszystkie wersje będą kompatybilne.

    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:21.2.0'
        implementation 'com.google.firebase:firebase-analytics:21.5.1'
    }
    
    Szukasz modułu bibliotecznego specyficznego dla Kotlina? Począwszy od października 2023 r. (Firebase BoM 32.5.0) zarówno programiści Kotlin, jak i Java mogą polegać na głównym module biblioteki (więcej informacji można znaleźć w często zadawanych pytaniach dotyczących tej inicjatywy ).
  3. W konsoli Firebase otwórz sekcję Linki dynamiczne .
  4. Jeżeli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie ustawiłeś domeny dla swoich Linków Dynamicznych, zrób to po wyświetleniu monitu.

    Jeśli masz już domenę Dynamic Links, zwróć na to uwagę. Podczas programowego tworzenia łączy dynamicznych musisz podać domenę łączy dynamicznych.

  5. Zalecane : określ dozwolone wzorce adresów URL w precyzyjnych linkach i linkach zastępczych. W ten sposób uniemożliwiasz nieupoważnionym osobom tworzenie linków dynamicznych przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Zobacz Zezwalaj na określone wzorce adresów URL .

Użyj konsoli Firebase

Jeśli chcesz wygenerować pojedynczy link dynamiczny do celów testowych lub aby Twój zespół marketingowy mógł łatwo utworzyć link, który można wykorzystać w postach w mediach społecznościowych, najprostszym sposobem byłoby odwiedzenie konsoli Firebase i utworzenie takiego ręcznie, postępując zgodnie z formularzem krok po kroku.

Aby utworzyć łącze dynamiczne, utwórz nowy obiekt DynamicLink za pomocą jego konstruktora, określając parametry łącza dynamicznego za pomocą metod konstruktora. Następnie wywołaj buildDynamicLink lub buildShortDynamicLink .

Poniższy minimalny przykład tworzy długi link dynamiczny do https://www.example.com/ , który otwiera się w aplikacji na Androida na Androidzie i aplikacji 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

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ótkie łącze dynamiczne, zbuduj DynamicLink w ten sam sposób, a następnie wywołaj buildShortDynamicLink . Budowanie krótkiego łącza wymaga wywołania sieciowego, dlatego zamiast bezpośrednio zwracać łącze, buildShortDynamicLink zwraca Task , które udostępnia krótkie łącze po zakończeniu żądania. Na 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
    // ...
}

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 generowane są krótkie linki dynamiczne z 17-znakowymi sufiksami linków, co sprawia, że ​​odgadnięcie prawidłowego łącza dynamicznego jest bardzo mało prawdopodobne. Jeśli w twoim przypadku nie ma nic złego w tym, że ktoś pomyślnie odgadnie krótki link, możesz wolić generować sufiksy, które są tylko tak długie, jak to konieczne, aby były unikalne, co możesz zrobić, przekazując ShortDynamicLink.Suffix.SHORT do metody buildShortDynamicLink :

Kotlin+KTX

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

Java

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

Możesz użyć interfejsu API narzędzia Dynamic Link Builder do tworzenia łączy dynamicznych z dowolnymi obsługiwanymi parametrami. Aby uzyskać szczegółowe informacje, zobacz dokumentację API .

Poniższy przykład tworzy łącze dynamiczne z kilkoma wspólnymi zestawami parametrów:

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!"
    }
}

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 łącza dynamicznego można ustawić następującymi metodami:

Parametry DynamicLinka
ustawLink

Link, który otworzy Twoja aplikacja. Określ adres URL, który może obsłużyć Twoja aplikacja, zazwyczaj zawartość aplikacji lub ładunek, który inicjuje logikę specyficzną dla aplikacji (taką jak przyznanie użytkownikowi kuponu lub wyświetlenie ekranu powitalnego). Ten link musi być dobrze sformatowanym adresem URL, odpowiednio zakodowanym adresem URL, używać protokołu HTTP lub HTTPS i nie może być innym łączem dynamicznym.

setDomainUriPrefix Twój prefiks adresu URL łącza dynamicznego, który znajdziesz w konsoli Firebase. Domena łącza dynamicznego wygląda jak w poniższych przykładach:
https://example.com/link
https://example.page.link
Parametry Androida
ustawFallbackUrl Link otwierany, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana, na przykład otworzyć mobilną wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
ustaw wersję minimalną versionCode minimalnej wersji aplikacji, która może otworzyć łącze. Jeśli zainstalowana aplikacja jest starszą wersją, użytkownik zostanie przeniesiony do Sklepu Play w celu aktualizacji aplikacji.
Parametry Ios
ustawAppStoreId Identyfikator Twojej aplikacji w App Store, używany do odsyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
ustawFallbackUrl Link otwierany, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, na przykład otworzyć mobilną wersję internetową zawartości lub wyświetlić stronę promocyjną aplikacji.
ustawSchemat niestandardowy Niestandardowy schemat adresu URL Twojej aplikacji, jeśli zdefiniowany jako inny niż identyfikator pakietu aplikacji
setIpadFallbackUrl Link do otwarcia na iPadzie, gdy aplikacja nie jest zainstalowana. Określ tę opcję, aby zrobić coś innego niż instalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, na przykład otworzyć internetową wersję zawartości lub wyświetlić stronę promocyjną aplikacji.
setIpadBundleId Identyfikator pakietu aplikacji na iOS, którego można używać na iPadach do otwierania łącza. Aplikacja musi być połączona z projektem na stronie Przegląd konsoli Firebase.
ustaw wersję minimalną Numer wersji minimalnej aplikacji, w której można otworzyć link. Ta flaga jest przekazywana do aplikacji po jej otwarciu i aplikacja musi zdecydować, co z nią zrobić.
Parametry nawigacji i informacji
setForcedRedirectEnabled Jeśli ustawione na „1”, pomiń stronę podglądu aplikacji po otwarciu łącza dynamicznego i zamiast tego przekieruj do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może w bardziej niezawodny sposób odsyłać użytkowników do najbardziej odpowiedniego miejsca docelowego, gdy otwierają łącza dynamiczne w aplikacjach; jeśli jednak oczekujesz, że łącze dynamiczne będzie otwierane tylko w aplikacjach, które potrafią niezawodnie otwierać łącza dynamiczne bez tej strony, możesz je wyłączyć za pomocą tego parametru. Ten parametr będzie miał wpływ na zachowanie łącza dynamicznego tylko w systemie iOS.
Parametry SocialMetaTag
ustawTytuł Tytuł używany podczas udostępniania łącza dynamicznego w poście społecznościowym.
zestawOpis Opis używany w przypadku udostępniania łącza dynamicznego w poście społecznościowym.
ustawImageUrl Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć wymiary co najmniej 300x200 px i mniej niż 300 KB.
Parametry GoogleAnalytics
ustawŹródło
zestawŚredni
ustaw kampanię
ustawTermin
ustaw zawartość
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.
Parametry ItunesConnectAnalytics
setProviderToken
ustawToken Partnerski
setCampaignToken
Parametry analityczne iTunes Connect. Te parametry ( pt , at , ct ) są przekazywane do App Store.

Aby skrócić długi link dynamiczny, określ adres URL łącza dynamicznego za pomocą setLongLink zamiast ustawiać parametry innymi metodami konstruktora:

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

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