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 link dynamiczny i zwraca adresy URL takie jak:

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

Konfiguracja Firebase i pakietu SDK Linków dynamicznych

Aby tworzyć linki dynamiczne w aplikacji na Androida, musisz umieścić w niej element pakietu SDK Firebase. Jeśli Twoja aplikacja jest skonfigurowana do otrzymywania linków dynamicznych, 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ą Linków dynamicznych na Androida. Zalecamy użycie metody Funkcja BoM Firebase na Androida aby kontrolować obsługę wersji biblioteki.

   Aby zapewnić optymalne działanie linków dynamicznych, zalecamy włączenie 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.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'
   }
   

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

   (Wersja alternatywna) Dodawanie zależności biblioteki 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 używasz wielu bibliotek Firebase w aplikacji, zalecamy korzystanie z BoM do zarządzania wersjami biblioteki, dzięki czemu wszystkie wersje

   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? Zaczyna się za Październik 2023 r. (Firebase BoM 32.5.0), programiści, zarówno w języku Kotlin, jak i w języku 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ę Linki dynamiczne.

4. Jeśli nie zaakceptowałeś jeszcze warunków korzystania z usługi i nie masz skonfigurowanej domeny linków dynamicznych, gdy pojawi się taka prośba.

   Jeśli masz już domenę Linki dynamiczne, zanotuj ją. Czynności, które musisz wykonać podać domenę Linków dynamicznych podczas automatycznego tworzenia linków dynamicznych.

   

5. Zalecane: określ wzorce adresów URL dozwolone w Twoich precyzyjnych linkach. i linkach zastępczych. Pozwoli to uniemożliwić nieupoważnionym osobom Tworzenie linków dynamicznych przekierowujących z 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 link dynamiczny 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, otwórz konsolę Firebase. i utworzyć ją ręcznie, postępując zgodnie z instrukcjami.

Tworzenie linku dynamicznego na podstawie parametrów

Aby utworzyć link dynamiczny, utwórz nowy obiekt DynamicLink z elementem Kreator określający parametry linku dynamicznego za pomocą metod konstruktora. Następnie zadzwoń buildDynamicLink lub buildShortDynamicLink.

Poniższy minimalny przykład pozwala utworzyć długi link dynamiczny do https://www.example.com/, który otwiera się w aplikacji na Androida oraz com.example.ios na iOS:

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

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, w ten sam sposób utwórz DynamicLink. i zadzwoń pod numer 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:

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

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, które zmniejsza więc prawdopodobieństwo odgadnięcia prawidłowego linku dynamicznego przez użytkownika. 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:

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

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

Parametry linku dynamicznego

Za pomocą interfejsu Dynamic Link Builder API możesz tworzyć linki dynamiczne z dowolnymi obsługiwane parametry. Zobacz API.

Przykład poniżej tworzy link dynamiczny z kilkoma wspólnymi parametrami ustaw:

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

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:

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

Skróć długi link dynamiczny

Aby skrócić długi link dynamiczny, podaj jego adres URL za pomocą setLongLink zamiast ustawiania parametrów za pomocą innego kreatora metody:

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

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