Aktivität mit einer Animation starten

Aktivitätsübergänge in Material Design-Apps schaffen visuelle Verbindungen zwischen verschiedenen Stadien durch Bewegung und Transformationen zwischen gemeinsamen Elementen. Sie können benutzerdefinierte Animationen für Ein- und Beendigungsübergänge sowie für Übergänge gemeinsam genutzter Elemente zwischen Aktivitäten angeben.

• Ein enter-Übergang bestimmt, wie Ansichten in einer Aktivität in die Szene gelangen. Beim Übergang zu explode treten die Ansichten beispielsweise von außen in die Szene ein und fliegen in die Mitte des Bildschirms hinein.
• Ein Exit-Übergang bestimmt, wie Ansichten in einer Aktivität die Szene beenden. Beim Exit-Übergang explode verlassen die Ansichten beispielsweise die Szene weg von der Mitte.
• Ein Übergang zu gemeinsam genutzten Elementen bestimmt, wie Ansichten, die zwischen zwei Aktivitäten geteilt werden, zwischen diesen Aktivitäten übergehen. Wenn beispielsweise zwei Aktivitäten dasselbe Bild an unterschiedlichen Positionen und Größen haben, wird das Bild durch den changeImageTransform-Übergang des gemeinsamen Elements zwischen diesen Aktivitäten gleichmäßig übersetzt und skaliert.

Android unterstützt diese Eingabe- und Exit-Übergänge:

• explode: Verschiebt Ansichten in die Mitte der Szene oder aus ihr heraus.
• slide: verschiebt Ansichten von einem Rand der Szene aus ein- oder aus.
• fade: Zum Hinzufügen oder Entfernen einer Ansicht zur Szene wird die Deckkraft geändert.

Jeder Übergang, der die Visibility-Klasse erweitert, wird als Start- oder Exit-Übergang unterstützt. Weitere Informationen finden Sie in der API-Referenz zur Klasse Transition.

Android unterstützt außerdem die folgenden Übergänge für gemeinsame Elemente:

• changeBounds: animiert die Änderungen an den Layoutgrenzen der Zielansichten.
• changeClipBounds: animiert die Änderungen der Clipgrenzen von Zielansichten.
• changeTransform: animiert die Skalierungs- und Rotationsänderungen der Zielansichten.
• changeImageTransform: animiert die Größen- und Skalierungsänderungen der Zielbilder.

Wenn Sie in Ihrer App Aktivitätsübergänge aktivieren, wird der standardmäßige Übergang zwischen den Einstiegs- und Beenden-Aktivitäten aktiviert.

Abbildung 2: Ein Szenenübergang mit einem gemeinsamen Element.

Beispielcode, der zwischen Aktivitäten mithilfe gemeinsam genutzter Elemente animiert wird, finden Sie unter ActivitySceneTransitionBasic.

Systemversion prüfen

Activity Transit APIs sind unter Android 5.0 (API 21) und höher verfügbar. Um die Kompatibilität mit früheren Android-Versionen aufrechtzuerhalten, solltest du das System-version zur Laufzeit prüfen, bevor du die APIs für eine der folgenden Funktionen aufrufst:

// Check if we're running on Android 5.0 or higher
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // Apply activity transition
} else {
    // Swap without transition
}

// Check if we're running on Android 5.0 or higher
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    // Apply activity transition
} else {
    // Swap without transition
}

Benutzerdefinierte Übergänge angeben

Aktivieren Sie zuerst die Übergänge für Fensterinhalte mit dem Attribut android:windowActivityTransitions, wenn Sie einen Stil definieren, der aus dem Material-Design übernommen wird. Sie können in Ihrer Stildefinition auch Übergänge zum Öffnen, Beenden und Teilen von Elementen angeben:

<style name="BaseAppTheme" parent="android:Theme.Material">
  <!-- enable window content transitions -->
  <item name="android:windowActivityTransitions">true</item>

  <!-- specify enter and exit transitions -->
  <item name="android:windowEnterTransition">@transition/explode</item>
  <item name="android:windowExitTransition">@transition/explode</item>

  <!-- specify shared element transitions -->
  <item name="android:windowSharedElementEnterTransition">
    @transition/change_image_transform</item>
  <item name="android:windowSharedElementExitTransition">
    @transition/change_image_transform</item>
</style>

Der Übergang change_image_transform in diesem Beispiel ist so definiert:

<!-- res/transition/change_image_transform.xml -->
<!-- (see also Shared Transitions below) -->
<transitionSet xmlns:android="http://schemas.android.com/apk/res/android">
  <changeImageTransform/>
</transitionSet>

Das Element changeImageTransform entspricht der Klasse ChangeImageTransform. Weitere Informationen finden Sie in der API-Referenz zu Transition.

Wenn Sie stattdessen in Ihrem Code Übergänge für Fensterinhalt aktivieren möchten, rufen Sie die Funktion Window.requestFeature() auf:

// Inside your activity (if you did not enable transitions in your theme)
with(window) {
    requestFeature(Window.FEATURE_ACTIVITY_TRANSITIONS)

    // Set an exit transition
    exitTransition = Explode()
}

// Inside your activity (if you did not enable transitions in your theme)
getWindow().requestFeature(Window.FEATURE_ACTIVITY_TRANSITIONS);

// Set an exit transition
getWindow().setExitTransition(new Explode());

Rufen Sie diese Funktionen mit einem Transition-Objekt auf, um Übergänge in Ihrem Code anzugeben:

• Window.setEnterTransition()
• Window.setExitTransition()
• Window.setSharedElementEnterTransition()
• Window.setSharedElementExitTransition()

Die Funktionen setExitTransition() und setSharedElementExitTransition() definieren den Exit-Übergang für die aufrufende Aktivität. Die Funktionen setEnterTransition() und setSharedElementEnterTransition() definieren den Eingabeübergang für die aufgerufene Aktivität.

Um die volle Wirkung eines Übergangs zu erzielen, müssen Sie Fensterinhaltsübergänge sowohl für die aufrufenden als auch die aufgerufenen Aktivitäten aktivieren. Andernfalls startet die aufrufende Aktivität den Exit-Übergang, aber dann sehen Sie die Fensterübergänge, z. B. Skalieren oder Ausblenden.

Verwenden Sie die Funktion Window.setAllowEnterTransitionOverlap() für die aufgerufene Aktivität, um so schnell wie möglich einen Übergang zu dem Start zu starten. Dadurch ergeben sich dramatischere Übergänge beim Einsteigen.

Aktivität mit Umstellungen starten

Wenn Sie Übergänge aktivieren und für eine Aktivität einen Exit-Übergang festlegen, wird der Übergang aktiviert, wenn Sie eine andere Aktivität starten, und zwar folgendermaßen:

startActivity(intent,
              ActivityOptions.makeSceneTransitionAnimation(this).toBundle())

startActivity(intent,
              ActivityOptions.makeSceneTransitionAnimation(this).toBundle());

Wenn Sie für die zweite Aktivität einen Eingangsübergang festlegen, wird dieser Übergang auch beim Start der Aktivität aktiviert. Wenn Sie die Übergänge beim Start einer anderen Aktivität deaktivieren möchten, geben Sie ein null-Options-Bundle an.

Aktivität mit einem gemeinsamen Element starten

So erstellen Sie eine Animation mit einem Bildschirmübergang zwischen zwei Aktivitäten, die ein gemeinsames Element haben:

1. Übergänge für Fensterinhalt in Ihrem Design aktivieren.
2. Legen Sie einen Übergang zu gemeinsam genutzten Elementen in Ihrem Stil fest.
3. Definieren Sie die Umstellung als XML-Ressource.
4. Weisen Sie den gemeinsam verwendeten Elementen in beiden Layouts mit dem Attribut android:transitionName einen gemeinsamen Namen zu.
5. Verwenden Sie die Funktion ActivityOptions.makeSceneTransitionAnimation().

// Get the element that receives the click event
val imgContainerView = findViewById<View>(R.id.img_container)

// Get the common element for the transition in this activity
val androidRobotView = findViewById<View>(R.id.image_small)

// Define a click listener
imgContainerView.setOnClickListener( {
    val intent = Intent(this, Activity2::class.java)
    // Create the transition animation - the images in the layouts
    // of both activities are defined with android:transitionName="robot"
    val options = ActivityOptions
            .makeSceneTransitionAnimation(this, androidRobotView, "robot")
    // Start the new activity
    startActivity(intent, options.toBundle())
})

// Get the element that receives the click event
final View imgContainerView = findViewById(R.id.img_container);

// Get the common element for the transition in this activity
final View androidRobotView = findViewById(R.id.image_small);

// Define a click listener
imgContainerView.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent intent = new Intent(this, Activity2.class);
        // Create the transition animation - the images in the layouts
        // of both activities are defined with android:transitionName="robot"
        ActivityOptions options = ActivityOptions
            .makeSceneTransitionAnimation(this, androidRobotView, "robot");
        // Start the new activity
        startActivity(intent, options.toBundle());
    }
});

Verwenden Sie bei gemeinsam genutzten dynamischen Ansichten, die Sie im Code generieren, die Funktion View.setTransitionName(), um in beiden Aktivitäten einen gemeinsamen Elementnamen anzugeben.

Wenn Sie die Animation mit Szenenübergang nach der zweiten Aktivität umkehren möchten, rufen Sie die Funktion Activity.finishAfterTransition() anstelle von Activity.finish() auf.

Aktivität mit mehreren gemeinsamen Elementen starten

Wenn Sie einen Szenenübergang zwischen zwei Aktivitäten mit mehr als einem gemeinsamen Element animieren möchten, definieren Sie die gemeinsam genutzten Elemente in beiden Layouts mit dem Attribut android:transitionName oder verwenden Sie in beiden Aktivitäten die Funktion View.setTransitionName(). Erstellen Sie dann wie folgt ein ActivityOptions-Objekt:

// Rename the Pair class from the Android framework to avoid a name clash
import android.util.Pair as UtilPair
...
val options = ActivityOptions.makeSceneTransitionAnimation(this,
        UtilPair.create(view1, "agreedName1"),
        UtilPair.create(view2, "agreedName2"))

ActivityOptions options = ActivityOptions.makeSceneTransitionAnimation(this,
        Pair.create(view1, "agreedName1"),
        Pair.create(view2, "agreedName2"));