Dynamische Links auf Android-Geräten erstellen

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

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

Firebase und das Dynamic Links SDK einrichten

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

1. Falls noch nicht geschehen, fügen Sie Ihrem Android-Projekt Firebase 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 der Gradle-Datei Ihres Moduls (auf Anwendungsebene) (in der Regel <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) die Abhängigkeit für die Dynamic Links Bibliothek für Android hinzu. Wir empfehlen, die Firebase Android BoM zu verwenden, um die Bibliotheksversionierung zu steuern.

   Für eine optimale Nutzung von Dynamic Links empfehlen wir die Aktivierung von Google Analytics in Ihrem Firebase-Projekt und das Hinzufügen des Firebase SDK für Google Analytics zu Ihrer App.

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

   Mit der Firebase Android BoM, haben Sie immer eine kompatible Version der Firebase Android-Bibliotheken in Ihrer App.

   (Alternative)   Firebase-Bibliotheksabhängigkeiten ohne BoM hinzufügen

   Wenn Sie die Firebase BoM nicht verwenden möchten, müssen Sie die Version jeder Firebase-Bibliothek in der entsprechenden Abhängigkeitszeile angeben.

   Wenn Sie in Ihrer App mehrere Firebase-Bibliotheken verwenden, empfehlen wir dringend, die BoM zur Verwaltung 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:22.1.0'
       implementation 'com.google.firebase:firebase-analytics:23.2.0'
   }

3. Öffnen Sie in der Firebase Konsole den Dynamic Links Bereich.

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

   Notieren Sie sich Ihre Dynamic Links Domain, falls Sie bereits eine haben. Sie müssen eine Dynamic Links-Domain angeben, wenn Sie Dynamic Links programmatisch erstellen.

   

5. Empfohlen: Geben Sie die in Ihren Deeplinks und Fallback-Links zulässigen URL-Muster an. So verhindern Sie, dass nicht autorisierte Parteien Dynamic Links erstellen, die von Ihrer Domain zu Websites weiterleiten, die Sie nicht kontrollieren. Weitere Informationen finden Sie unter Bestimmte URL-Muster zulassen.

Firebase Konsole verwenden

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

Ein Dynamic Link aus Parametern erstellen

Erstellen Sie ein neues DynamicLink-Objekt mit dem Builder, um ein Dynamic Link zu erstellen. Geben Sie die Dynamic Link-Parameter mit den Builder-Methoden an. Rufen Sie dann buildDynamicLink oder buildShortDynamicLink auf.

Im folgenden Minimalbeispiel wird ein langer Dynamic Link zu https://www.example.com/ erstellt, der unter Android mit Ihrer Android-App und unter iOS mit der App com.example.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

Wenn Sie einen kurzen Dynamic Link erstellen möchten, erstellen Sie einen DynamicLink auf dieselbe Weise und rufen Sie dann buildShortDynamicLink auf. Für die Erstellung eines kurzen Links ist ein Netzwerkaufruf erforderlich. Daher gibt anstelle der direkten Rückgabe des Links buildShortDynamicLink eine Task zurück, wodurch der kurze Link verfügbar ist, wenn die Anfrage abgeschlossen ist. 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 Dynamic Links mit 17-stelligen Link-Suffixen generiert, sodass es äußerst unwahrscheinlich ist, dass jemand einen gültigen Dynamic Link erraten kann. Wenn es für Ihren Anwendungsfall kein Problem darstellt, wenn jemand einen kurzen Link errät, können Sie Suffixe generieren, die nur so lang sind, wie es für die Eindeutigkeit erforderlich ist. Dazu übergeben Sie ShortDynamicLink.Suffix.SHORT an die buildShortDynamicLink Methode:

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

Mit der Dynamic Link Builder API können Sie Dynamic Links mit allen unterstützten Parametern erstellen. Weitere Informationen finden Sie in der API-Referenz.

Im folgenden Beispiel wird ein Dynamic Link mit mehreren gängigen Parametern erstellt:

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

Langen Dynamic Link kürzen

Wenn Sie einen langen Dynamic Link kürzen möchten, geben Sie die URL des Dynamic Link 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