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 podobne do tych w tych przykładach:

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

Aby tworzyć linki dynamiczne w aplikacji na Androida, musisz dołączyć do niej pakiet SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana tak, by otrzymywać linki dynamiczne, te czynności zostały już wykonane, więc możesz pominąć tę sekcję.

  1. Dodaj Firebase do swojego projektu na Androida, jeśli jeszcze go nie masz.

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

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

    Aby optymalnie korzystać z 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.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'
    }
    

    Dzięki wykorzystaniu BM od Firebase Android Twoja aplikacja zawsze będzie używała zgodnych wersji bibliotek Firebase na Androida.

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

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

    Pamiętaj, że jeśli w aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami biblioteki. Zapewni to 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:22.0.1'
    }
    
    Szukasz modułu biblioteki dotyczącego konkretnego narzędzia Kotlin? Od października 2023 r. (Firebase BoM w wersji 32.5.0) deweloperzy korzystający z Kotlin i Javy mogą korzystać z modułu biblioteki głównej (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania na temat tej inicjatywy).
  3. W konsoli Firebase otwórz sekcję Linki dynamiczne.
  4. Jeśli nie masz jeszcze zaakceptowanych warunków korzystania z usługi i ustawiania domeny na potrzeby linków dynamicznych, zrób to, gdy pojawi się taka prośba.

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

  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 linków dynamicznych przekierowujących z Twojej domeny do witryn, nad którymi nie masz kontroli. Patrz: Zezwalaj na określone wzorce adresów URL.

Korzystanie z konsoli Firebase

Jeśli chcesz wygenerować jeden link dynamiczny (do celów testowych) lub dla swojego zespołu marketingowego, aby łatwo utworzyć link, którego można użyć np. w poście w mediach społecznościowych, najprostszym sposobem jest otwarcie konsoli Firebase i utworzenie go ręcznie, wykonując szczegółowe instrukcje.

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

Ten minimalny przykład tworzy długi link dynamiczny do https://www.example.com/, który otwiera się w aplikacji na Androida na Androida i w 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ótki link dynamiczny, w ten sam sposób utwórz DynamicLink, a potem wywołaj buildShortDynamicLink. Stworzenie krótkiego linku wymaga wywołania sieciowego, więc zamiast bezpośrednio zwracać link, buildShortDynamicLink zwraca wartość Task, która udostępnia krótki link 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
    // ...
}

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 linki dynamiczne są generowane z 17-znakowymi sufiksami, dlatego odgadnięcie prawidłowego linku dynamicznego jest bardzo mało prawdopodobne. Jeśli w Twoim przypadku nie szkodzi, że ktoś zgaduje krótki link, możesz generować przyrostki, których długość jest jedyna w swoim zakresie, ale jest tak długa, jak to konieczne, aby przekazać w tym celu polecenie 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);
        // ...

Interfejs Dynamic Link Builder API umożliwia tworzenie linków dynamicznych za pomocą dowolnych obsługiwanych parametrów. Szczegóły znajdziesz w dokumentacji API.

Poniższy przykład pokazuje utworzenie linku dynamicznego 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 linku dynamicznego możesz ustawić, korzystając z tych metod:

Parametry DynamicLink
ustaw link

Link otwierający aplikację. Podaj adres URL, który może obsłużyć Twoja aplikacja. Zazwyczaj jest to treść lub ładunek aplikacji, który inicjuje logikę związaną z aplikacją (np. przekazuje użytkownikowi kupon lub wyświetla ekran powitalny). Link ten musi być prawidłowo sformatowanym adresem URL, poprawnie zakodowany w adresie URL, używać protokołu HTTP lub HTTPS i nie może być innym linkiem dynamicznym.

setDomainUriPrefix Prefiks adresu URL linku dynamicznego, który znajdziesz w konsoli Firebase. Domena linku dynamicznego wygląda jak w tych przykładach:
https://example.com/link
https://example.page.link
AndroidParameters
setFallbackUrl Link otwierający się, gdy aplikacja nie jest zainstalowana. Określ, czy chcesz zainstalować aplikację ze Sklepu Play, gdy aplikacja nie jest zainstalowana – na przykład otworzyć mobilną wersję treści w przeglądarce mobilnej lub wyświetlić stronę promocyjną aplikacji.
setMinimumVersion versionCode minimalnej wersji aplikacji, która może otworzyć link. Jeśli zainstalowana jest starsza wersja, użytkownik zostanie przekierowany do Sklepu Play, aby ją uaktualnić.
Parametry iOS
setAppStoreId, Identyfikator aplikacji w sklepie z aplikacjami, używany do kierowania użytkowników do App Store, gdy aplikacja nie jest zainstalowana
setFallbackUrl Link otwierający się, gdy aplikacja nie jest zainstalowana. Określ, czy chcesz zainstalować aplikację z App Store, gdy nie jest ona zainstalowana – na przykład otworzyć mobilną wersję treści w przeglądarce mobilnej lub wyświetlić stronę promocyjną aplikacji.
ustawSchemeNiestandardowy Schemat niestandardowego adresu URL aplikacji, jeśli został zdefiniowany jako inny niż identyfikator pakietu aplikacji
ustawIpadFallbackUrl Link otwierający się na iPadzie, gdy aplikacja nie jest zainstalowana. Określ, czy chcesz zainstalować aplikację z App Store, gdy nie jest ona zainstalowana – na przykład otworzyć internetową wersję treści lub wyświetlić stronę promocyjną aplikacji.
UstawIpadBundleId Identyfikator pakietu aplikacji na iOS, którego chcesz używać na iPadzie do otwarcia linku. Musisz połączyć ją z 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, gdy jest ona otwierana, a aplikacja musi podjąć decyzję, co z nią zrobić.
Parametry informacyjne nawigacji
setForcedRedirectEnabled Jeśli ma wartość „1”, pomiń stronę z podglądem aplikacji po otwarciu linku dynamicznego i zamiast tego przekieruj użytkownika do aplikacji lub sklepu. Strona podglądu aplikacji (domyślnie włączona) może z większą skutecznością odsyłać użytkowników otwierających linki dynamiczne w aplikacjach do najbardziej odpowiednich miejsc docelowych. Jeśli jednak spodziewasz się, że link dynamiczny będzie otwierany tylko w aplikacjach, w których nie ma takiej strony, możesz go wyłączyć, korzystając z tego parametru. Ten parametr będzie miał wpływ na działanie linku dynamicznego tylko w iOS.
Wskaźniki metadanych społecznościowych
ustaw_tytuł Tytuł używany, gdy link dynamiczny jest udostępniany w poście w mediach społecznościowych.
ustawOpis Opis używany podczas udostępniania linku dynamicznego w poście w mediach społecznościowych.
setImageUrl, Adres URL obrazu powiązanego z tym linkiem. Obraz powinien mieć rozmiar co najmniej 300 x 200 pikseli i mniej niż 300 KB.
Parametry Google Analytics
setSource
setMedium
setCampaign
setTerm
setContent
Parametry Statystyk 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 ł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 adres URL linku dynamicznego za pomocą parametru setLongLink zamiast określania parametrów w innych metodach 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
                    // ...
                }
            }
        });