Erstellen Sie dynamische Links auf Android

Mit der Firebase Dynamic Links Builder API können Sie kurze oder lange dynamische Links erstellen. Diese API akzeptiert entweder einen langen dynamischen Link oder ein Objekt mit dynamischen Link-Parametern und gibt URLs wie die folgenden Beispiele zurück:

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

Richten Sie Firebase und das Dynamic Links SDK ein

Bevor Sie dynamische Links in Ihrer Android-App erstellen können, müssen Sie das Firebase SDK einbinden. Wenn Ihre App für den Empfang dynamischer Links eingerichtet ist, haben Sie diese Schritte bereits ausgeführt und können diesen Abschnitt überspringen.

1. Falls noch nicht geschehen, fügen Sie Firebase zu Ihrem Android-Projekt hinzu .

   Geben Sie bei der Registrierung Ihrer App Ihren SHA-1-Signaturschlüssel an. Wenn Sie App Links verwenden, geben Sie auch Ihren SHA-256-Schlüssel an.

2. Fügen Sie in Ihrer Modul-Gradle-Datei (auf App-Ebene) (normalerweise <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle ) die Abhängigkeit für die dynamischen Links hinzu Bibliothek für Android. Wir empfehlen die Verwendung der Firebase Android BoM zur Steuerung der Bibliotheksversionierung.

   Für ein optimales Erlebnis mit dynamischen Links empfehlen wir, Google Analytics in Ihrem Firebase-Projekt zu aktivieren und das Firebase SDK für Google Analytics zu Ihrer App hinzuzufügen.

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

   Durch die Verwendung der Firebase Android BoM verwendet Ihre App immer kompatible Versionen der Firebase Android-Bibliotheken.

   (Alternative) Fügen Sie Firebase-Bibliotheksabhängigkeiten hinzu , ohne die Stückliste zu verwenden

   Wenn Sie die Firebase-Stückliste nicht verwenden möchten, müssen Sie jede Firebase-Bibliotheksversion in ihrer Abhängigkeitszeile angeben.

   Beachten Sie: Wenn Sie mehrere Firebase-Bibliotheken in Ihrer App verwenden, empfehlen wir dringend, die BoM zum Verwalten der Bibliotheksversionen zu verwenden, um sicherzustellen, dass alle Versionen kompatibel sind.

   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.0'
   }
   

   Suchen Sie nach einem Kotlin-spezifischen Bibliotheksmodul? Ab Oktober 2023 (Firebase BoM 32.5.0) können sich sowohl Kotlin- als auch Java-Entwickler auf das Hauptbibliotheksmodul verlassen (Einzelheiten finden Sie in den FAQ zu dieser Initiative ).
3. Öffnen Sie in der Firebase-Konsole den Abschnitt „Dynamische Links“ .

4. Wenn Sie die Nutzungsbedingungen noch nicht akzeptiert und eine Domain für Ihre dynamischen Links festgelegt haben, tun Sie dies, wenn Sie dazu aufgefordert werden.

   Wenn Sie bereits über eine Dynamic Links-Domain verfügen, notieren Sie sich diese. Sie müssen eine Dynamic Links-Domäne angeben, wenn Sie Dynamic Links programmgesteuert erstellen.

   

5. Empfohlen : Geben Sie die URL-Muster an, die in Ihren Deep-Links und Fallback-Links zulässig sind. Auf diese Weise verhindern Sie, dass Unbefugte dynamische Links erstellen, die von Ihrer Domain auf Websites weiterleiten, die nicht von Ihnen kontrolliert werden. Siehe Spezifische URL-Muster zulassen .

Verwenden Sie die Firebase-Konsole

Wenn Sie einen einzelnen dynamischen Link generieren möchten, entweder zu Testzwecken oder damit Ihr Marketingteam ganz einfach einen Link erstellen kann, der beispielsweise in einem Social-Media-Beitrag verwendet werden kann, ist es am einfachsten, die Firebase-Konsole aufzurufen und einen zu erstellen manuell dem Schritt-für-Schritt-Formular folgen.

Erstellen Sie einen dynamischen Link aus Parametern

Um einen Dynamic Link zu erstellen, erstellen Sie ein neues DynamicLink Objekt mit seinem Builder und geben Sie die Dynamic Link-Parameter mit den Builder-Methoden an. Rufen Sie dann buildDynamicLink oder buildShortDynamicLink auf.

Das folgende Minimalbeispiel erstellt einen langen dynamischen Link zu https://www.example.com/ , der mit Ihrer Android-App auf Android und der App com.example.ios auf iOS geöffnet wird:

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

Um einen kurzen dynamischen Link zu erstellen, erstellen Sie auf die gleiche Weise einen DynamicLink und rufen Sie dann buildShortDynamicLink auf. Für den Aufbau eines kurzen Links ist ein Netzwerkaufruf erforderlich. Anstatt den Link also direkt zurückzugeben, gibt buildShortDynamicLink einen Task zurück, der den kurzen Link verfügbar macht, wenn die Anfrage abgeschlossen ist. Zum Beispiel:

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

Standardmäßig werden kurze dynamische Links mit 17-stelligen Link-Suffixen generiert, wodurch es äußerst unwahrscheinlich ist, dass jemand einen gültigen dynamischen Link erraten kann. Wenn es für Ihren Anwendungsfall nicht schadet, wenn jemand einen kurzen Link erfolgreich errät, möchten Sie möglicherweise lieber Suffixe generieren, die nur so lang sind, wie nötig, um eindeutig zu sein. Dies können Sie erreichen, indem Sie ShortDynamicLink.Suffix.SHORT an die Methode buildShortDynamicLink übergeben :

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

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

Dynamic Link-Parameter

Sie können die Dynamic Link Builder-API verwenden, um dynamische Links mit jedem der unterstützten Parameter zu erstellen. Weitere Informationen finden Sie in der API-Referenz .

Das folgende Beispiel erstellt einen dynamischen Link mit mehreren allgemeinen Parametersätzen:

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

Sie können Dynamic Link-Parameter mit den folgenden Methoden festlegen:

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

Kürzen Sie einen langen dynamischen Link

Um einen langen dynamischen Link zu kürzen, geben Sie die URL des dynamischen Links mit setLongLink an, anstatt Parameter mit den anderen Builder-Methoden festzulegen:

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