Tworzenie linków dynamicznych na Androidzie

Za pomocą interfejsu Firebase Dynamic Links Builder API możesz tworzyć krótkie i długie Dynamic Links. Ten interfejs API akceptuje parametr Dynamic Link lub obiekt zawierający parametry Dynamic Link. Zwraca adresy URL podobne do tych przykładów:

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

Zanim utworzysz Dynamic Links w aplikacji na Androida, musisz uwzględnić pakiet SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana do odbierania Dynamic Links, te czynności zostały już przez Ciebie wykonane i możesz pominąć tę sekcję.

  1. Jeśli jeszcze tego nie zrobiono, dodaj Firebase do projektu na Androida.

    Podczas rejestrowania aplikacji podaj klucz podpisywania SHA-1. Jeśli używasz linków aplikacji, podaj też klucz SHA-256.

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

    Aby uzyskać optymalne wyniki w przypadku Dynamic Links, zalecamy włączenie Google Analytics w projekcie 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:33.7.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 korzystasz z Firebase Android BoM, aplikacja zawsze używa zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie)  Dodaj zależności biblioteki Firebase bez używania pakietu BoM

    Jeśli zdecydujesz się nie używać 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. Dzięki temu wszystkie wersje będą ze sobą 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.2'
    }
    Szukasz modułu biblioteki dla Kotlina? Od października 2023 r. (Firebase BoM 32.5.0) deweloperzy Kotlina i Java mogą korzystać z głównego modułu biblioteki (szczegółowe informacje znajdziesz w często zadawanych pytaniach dotyczących 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 ustawiłeś domeny dla Dynamic Links, zrób to, gdy pojawi się taka prośba.

    Jeśli masz już domenę Dynamic Links, zanotuj ją. Podczas tworzenia za pomocą kodu Dynamic Links musisz podać domenę Dynamic Links.

  5. 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 artykuł Zezwalanie na określone wzorce adresów URL.

Korzystanie z konsoli Firebase

Jeśli chcesz wygenerować pojedynczy Dynamic Link na potrzeby testów lub aby umożliwić zespołowi marketingowemu łatwe tworzenie linków do wykorzystania w postach w mediach społecznościowych, najprostszym sposobem jest przejście do konsoli Firebase i ręczne utworzenie linku zgodnie z podanymi instrukcjami.

Aby utworzyć obiekt Dynamic Link, utwórz nowy obiekt DynamicLink za pomocą jego klasy Builder, podając parametry Dynamic Link za pomocą metod klasy Builder. Następnie zadzwoń pod numer 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 urządzeniu z Androidem oraz w aplikacji com.example.ios na iPhonie:

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ótki Dynamic Link, utwórz DynamicLink w taki sam sposób, a potem wywołaj funkcję buildShortDynamicLink. Utworzenie krótkiego linku wymaga wywołania sieci, więc zamiast zwracania bezpośrednio linku funkcja buildShortDynamicLink zwraca Task, co powoduje, że krótki link jest dostępny po zakończeniu przetwarzania żą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
    // ...
}

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 linków, które sprawiają, że bardzo mało prawdopodobne jest, aby ktoś zgadł prawidłowy Dynamic Link. Jeśli w Twoim przypadku nie ma znaczenia, czy ktoś zgadnie krótki link, możesz wygenerować sufiksy o długości wystarczającej do zapewnienia ich unikalności. Aby to zrobić, prześlij parametr 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);
        // ...

Do tworzenia Dynamic Links za pomocą dowolnych obsługiwanych parametrów możesz użyć interfejsu Builder API.Dynamic Link Więcej informacji znajdziesz w  dokumentacji interfejsu API.

W tym przykładzie tworzymy element Dynamic Link z kilkoma typowymi 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!"
    }
}

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 konfigurować na te sposoby:

Parametry DynamicLink
setLink

Link, który otwiera 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. przyznawanie użytkownikowi kuponu lub wyświetlanie ekranu powitalnego). Link musi być poprawnie 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 tak:
https://example.com/link
https://example.page.link
AndroidParameters
setFallbackUrl Link do otwarcia, gdy aplikacja nie jest zainstalowana. Wpisz ten parametr, aby wykonać inne działanie niż instalacja aplikacji ze Sklepu Play, gdy aplikacja nie jest zainstalowana. Możesz na przykład otworzyć wersję mobilną treści w przeglądarce lub wyświetlić stronę promocyjną aplikacji.
setMinimumVersion  minimalnej wersji aplikacji, która może otworzyć link.versionCode Jeśli zainstalowana aplikacja jest w starszej wersji, użytkownik zostanie przekierowany do Sklepu Play, aby ją zaktualizować.
IosParameters
setAppStoreId Identyfikator aplikacji w App Store, który służy do wysyłania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
setFallbackUrl Link do otwarcia, gdy aplikacja nie jest zainstalowana. Określ tę wartość, aby wykonać inną czynność niż zainstalowanie aplikacji z App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję mobilną treści w przeglądarce lub wyświetlić stronę promocyjną aplikacji.
setCustomScheme Niestandardowy schemat adresów URL aplikacji, jeśli jest zdefiniowany jako inny niż identyfikator pakietu aplikacji.
setIpadFallbackUrl Link do otwarcia na iPadach, gdy aplikacja nie jest zainstalowana. Określ to, aby wykonać inną czynność niż zainstalowanie aplikacji ze sklepu App Store, gdy aplikacja nie jest zainstalowana, np. otworzyć wersję internetową treści lub wyświetlić stronę promocyjną aplikacji.
setIpadBundleId Identyfikator pakietu aplikacji na iOS, której należy używać na iPadach do otwierania linku. Aplikacja musi być połączona z Twoim projektem na stronie Przegląd konsoli Firebase.
setMinimumVersion Numer wersji minimalnej wersji aplikacji, która może otworzyć link. Ten parametr jest przekazywany do aplikacji po jej otwarciu, a ona musi zdecydować, co z nim zrobić.
NavigationInfoParameters
setForcedRedirectEnabled Jeśli wartość to „1”, po otwarciu Dynamic Link pomiń stronę podglądu aplikacji i przekieruj użytkownika do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może skuteczniej kierować użytkowników do najbardziej odpowiedniego miejsca po kliknięciu Dynamic Links w aplikacjach. Jeśli jednak chcesz, aby Dynamic Link otwierał się tylko w aplikacjach, które mogą otwierać Dynamic Links bez tej strony, możesz wyłączyć ją za pomocą tego parametru. Ten parametr będzie miał wpływ na działanie Dynamic Link tylko na iOS.
SocialMetaTagParameters
setTitle Tytuł, który ma być używany podczas udostępniania Dynamic Link w postach w mediach społecznościowych.
setDescription Opis, który ma być używany, gdy Dynamic Link jest udostępniany w postach 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 nie więcej niż 300 KB.
GoogleAnalyticsParameters
setSource
setMedium
setCampaign
setTerm
setContent
Parametry Google Play. Te parametry (utm_source, utm_medium, utm_campaign, utm_term, utm_content) są przekazywane do Sklepu Play, a także dołączane do danych przesyłanych w linku.
ItunesConnectAnalyticsParameters
setProviderToken
setAffiliateToken
setCampaignToken
Parametry analityczne iTunes Connect. Te parametry (pt, at, ct) są przekazywane do App Store.

Aby skrócić długi adres Dynamic Link, określ adres URL Dynamic Link za pomocą parametru setLongLink zamiast ustawiać parametry za pomocą innych metod kreatora:

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