Layoutänderungen mit einem Übergang animieren

Compose ausprobieren

Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zur Verwendung von Animationen in Compose

AnimatedContent →

Mit dem Übergangs-Framework von Android können Sie alle Arten von Bewegungen in Ihrer Benutzeroberfläche animieren, indem Sie die Start- und Endlayouts angeben. Sie können auswählen, welche Art von Animation Sie verwenden möchten, z. B. zum Ein- oder Ausblenden von Ansichten oder zum Ändern der Ansichtsgrößen. Das Übergangs-Framework bestimmt dann, wie die Animation vom Start- zum Endlayout erfolgt.

Das Übergangs-Framework umfasst die folgenden Funktionen:

• Animationen auf Gruppenebene:Sie können Animationseffekte auf alle Ansichten in einer Ansichtshierarchie anwenden.
• Integrierte Animationen:Verwenden Sie vordefinierte Animationen für gängige Effekte wie Ein- oder Ausblenden oder Bewegung.
• Unterstützung von Ressourcendateien:Ansichtshierarchien und integrierte Animationen aus Layout-Ressourcendateien laden.
• Lebenszyklus-Callbacks:Sie erhalten Callbacks, mit denen Sie den Animations- und Hierarchieänderungsprozess steuern können.

Beispielcode, der Animationen zwischen Layoutänderungen ausführt, finden Sie unter BasicTransition.

Der grundlegende Prozess für die Animation zwischen zwei Layouts sieht so aus:

1. Erstellen Sie ein Scene-Objekt für die Start- und Endlayouts. Die Szene des Startlayouts wird jedoch häufig automatisch aus dem aktuellen Layout bestimmt.
2. Erstellen Sie ein Transition-Objekt, um den gewünschten Animationstyp zu definieren.
3. Rufen Sie TransitionManager.go() auf. Das System führt dann die Animation aus, um die Layouts zu tauschen.

Das Diagramm in Abbildung 1 veranschaulicht die Beziehung zwischen Ihren Layouts, den Szenen, dem Übergang und der endgültigen Animation.

Abbildung 1. Grundlegende Darstellung der Erstellung einer Animation durch das Übergangs-Framework.

Szene erstellen

In Szenen wird der Status einer Ansichtshierarchie gespeichert, einschließlich aller Ansichten und ihrer Eigenschaftswerte. Mit dem Transitions-Framework können Animationen zwischen einer Start- und einer Endszene ausgeführt werden.

Sie können Ihre Szenen aus einer Layoutressourcendatei oder aus einer Gruppe von Ansichten in Ihrem Code erstellen. Die Startszene für den Übergang wird jedoch häufig automatisch aus der aktuellen Benutzeroberfläche bestimmt.

Eine Szene kann auch eigene Aktionen definieren, die ausgeführt werden, wenn Sie die Szene ändern. Diese Funktion ist nützlich, um Ansichtseinstellungen nach dem Übergang zu einer Szene zu bereinigen.

Szene aus einer Layoutressource erstellen

Sie können eine Scene-Instanz direkt aus einer Layoutressourcendatei erstellen. Verwenden Sie diese Technik, wenn die Ansichtshierarchie in der Datei größtenteils statisch ist. Die resultierende Szene stellt den Zustand der Ansichtshierarchie zu dem Zeitpunkt dar, als Sie die Scene-Instanz erstellt haben. Wenn Sie die Ansichtshierarchie ändern, müssen Sie die Szene neu erstellen. Das Framework erstellt die Szene aus der gesamten Ansichtshierarchie in der Datei. Sie können keine Szene aus einem Teil einer Layoutdatei erstellen.

Wenn Sie eine Scene-Instanz aus einer Layoutressourcendatei erstellen möchten, rufen Sie den Szenenstamm aus Ihrem Layout als ViewGroup ab. Rufen Sie dann die Funktion Scene.getSceneForLayout() mit dem Szenenstamm und der Ressourcen-ID der Layoutdatei auf, die die Ansichtshierarchie für die Szene enthält.

Layouts für Szenen definieren

Die Code-Snippets im Rest dieses Abschnitts zeigen, wie Sie zwei verschiedene Szenen mit demselben Szenen-Rootelement erstellen. Die Code-Snippets zeigen auch, dass Sie mehrere unabhängige Scene-Objekte laden können, ohne dass sie in Beziehung zueinander stehen.

Das Beispiel besteht aus den folgenden Layoutdefinitionen:

• Das Hauptlayout einer Aktivität mit einem Textlabel und einem untergeordneten Element FrameLayout.
• Ein ConstraintLayout für die erste Szene mit zwei Textfeldern.
• Ein ConstraintLayout für die zweite Szene mit denselben beiden Textfeldern in unterschiedlicher Reihenfolge.

Das Beispiel ist so konzipiert, dass die gesamte Animation im untergeordneten Layout des Hauptlayouts für die Aktivität erfolgt. Das Textlabel im Hauptlayout bleibt statisch.

Das Hauptlayout für die Aktivität ist so definiert:

res/layout/activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/master_layout">
    <TextView
        android:id="@+id/title"
        ...
        android:text="Title"/>
    <FrameLayout
        android:id="@+id/scene_root">
        <include layout="@layout/a_scene" />
    </FrameLayout>
</LinearLayout>

Diese Layoutdefinition enthält ein Textfeld und ein untergeordnetes FrameLayout für den Szenenroot. Das Layout für die erste Szene ist in der Hauptlayoutdatei enthalten. So kann die App sie als Teil der ersten Benutzeroberfläche anzeigen und auch in eine Szene laden, da das Framework nur eine ganze Layoutdatei in eine Szene laden kann.

Das Layout für die erste Szene ist so definiert:

res/layout/a_scene.xml

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/scene_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    <TextView
        android:id="@+id/text_view1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:text="Text Line 1"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>
    <TextView
        android:id="@+id/text_view2"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:text="Text Line 2"
        app:layout_constraintTop_toBottomOf="@id/text_view1"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Das Layout für die zweite Szene enthält dieselben beiden Textfelder mit denselben IDs, die in einer anderen Reihenfolge angeordnet sind. Sie wird so definiert:

res/layout/another_scene.xml

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/scene_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    <TextView
        android:id="@+id/text_view2"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:text="Text Line 2"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
    <TextView
        android:id="@+id/text_view1"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:text="Text Line 1"
        app:layout_constraintTop_toBottomOf="@id/text_view2"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"/>
</androidx.constraintlayout.widget.ConstraintLayout>

Szenen aus Layouts generieren

Nachdem Sie Definitionen für die beiden ConstraintLayouts erstellt haben, können Sie für jedes eine Szene abrufen. So können Sie zwischen den beiden UI-Konfigurationen wechseln. Um eine Szene zu erhalten, benötigen Sie einen Verweis auf den Szenen-Root und die Layout-Ressourcen-ID.

Das folgende Code-Snippet zeigt, wie Sie eine Referenz zum Szenenroot abrufen und zwei Scene-Objekte aus den Layoutdateien erstellen:

val sceneRoot: ViewGroup = findViewById(R.id.scene_root)
val aScene: Scene = Scene.getSceneForLayout(sceneRoot, R.layout.a_scene, this)
val anotherScene: Scene = Scene.getSceneForLayout(sceneRoot, R.layout.another_scene, this)

Scene aScene;
Scene anotherScene;

// Create the scene root for the scenes in this app.
sceneRoot = (ViewGroup) findViewById(R.id.scene_root);

// Create the scenes.
aScene = Scene.getSceneForLayout(sceneRoot, R.layout.a_scene, this);
anotherScene =
    Scene.getSceneForLayout(sceneRoot, R.layout.another_scene, this);

In der App gibt es jetzt zwei Scene-Objekte, die auf Ansichtshierarchien basieren. Für beide Szenen wird der Szenenroot verwendet, der durch das Element FrameLayout in res/layout/activity_main.xml definiert wird.

Szene im Code erstellen

Sie können auch eine Scene-Instanz in Ihrem Code aus einem ViewGroup-Objekt erstellen. Verwenden Sie diese Technik, wenn Sie die Ansichtshierarchien direkt in Ihrem Code ändern oder dynamisch generieren.

Verwenden Sie den Konstruktor Scene(sceneRoot, viewHierarchy), um eine Szene aus einer Ansichtshierarchie in Ihrem Code zu erstellen. Das Aufrufen dieses Konstruktors entspricht dem Aufrufen der Funktion Scene.getSceneForLayout(), wenn Sie bereits eine Layoutdatei eingefügt haben.

Das folgende Code-Snippet zeigt, wie Sie eine Scene-Instanz aus dem Szenen-Rootelement und der Ansichtshierarchie für die Szene in Ihrem Code erstellen:

val sceneRoot = someLayoutElement as ViewGroup
val viewHierarchy = someOtherLayoutElement as ViewGroup
val scene: Scene = Scene(sceneRoot, viewHierarchy)

Scene mScene;

// Obtain the scene root element.
sceneRoot = (ViewGroup) someLayoutElement;

// Obtain the view hierarchy to add as a child of
// the scene root when this scene is entered.
viewHierarchy = (ViewGroup) someOtherLayoutElement;

// Create a scene.
mScene = new Scene(sceneRoot, mViewHierarchy);

Szenenaktionen erstellen

Mit dem Framework können Sie benutzerdefinierte Szenenaktionen definieren, die das System beim Betreten oder Verlassen einer Szene ausführt. In vielen Fällen ist es nicht erforderlich, benutzerdefinierte Szenenaktionen zu definieren, da das Framework die Änderung zwischen Szenen automatisch animiert.

Szenenaktionen sind in folgenden Fällen nützlich:

• Zum Animieren von Ansichten, die sich nicht in derselben Hierarchie befinden. Sie können Ansichten für die Start- und Endszene mit Aktionen für das Ein- und Ausblenden von Szenen animieren.
• Um Ansichten zu animieren, die vom Transitions-Framework nicht automatisch animiert werden können, z. B. ListView-Objekte. Weitere Informationen finden Sie im Abschnitt Einschränkungen.

Wenn Sie benutzerdefinierte Szenenaktionen bereitstellen möchten, definieren Sie Ihre Aktionen als Runnable-Objekte und übergeben Sie sie an die Funktionen Scene.setExitAction() oder Scene.setEnterAction(). Das Framework ruft die Funktion setExitAction() in der Startszene vor der Ausführung der Übergangsanimation und die Funktion setEnterAction() in der Endszene nach der Ausführung der Übergangsanimation auf.

Übergang anwenden

Das Übergangs-Framework stellt den Stil der Animation zwischen Szenen mit einem Transition-Objekt dar. Sie können eine Transition mit integrierten Unterklassen wie AutoTransition und Fade instanziieren oder einen eigenen Übergang definieren. Anschließend können Sie die Animation zwischen den Szenen ausführen, indem Sie das Ende Scene und das Transition an TransitionManager.go() übergeben.

Der Übergangslebenszyklus ähnelt dem Aktivitätslebenszyklus und stellt die Übergangszustände dar, die das Framework zwischen dem Start und dem Abschluss einer Animation überwacht. In wichtigen Phasen des Lebenszyklus ruft das Framework Callback-Funktionen auf, die Sie implementieren können, um die Benutzeroberfläche in verschiedenen Phasen des Übergangs anzupassen.

Übergang erstellen

Im vorherigen Abschnitt wurde gezeigt, wie Sie Szenen erstellen, die den Status verschiedener Ansichtshierarchien darstellen. Nachdem Sie die Start- und Endszene definiert haben, zwischen denen Sie wechseln möchten, erstellen Sie ein Transition-Objekt, das eine Animation definiert. Mit dem Framework können Sie entweder einen integrierten Übergang in einer Ressourcendatei angeben und ihn in Ihrem Code instanziieren oder eine Instanz eines integrierten Übergangs direkt in Ihrem Code erstellen.

Tabelle 1. Integrierte Übergangstypen

Übergangsinstanz aus einer Ressourcendatei erstellen

So können Sie die Übergangsdefinition ändern, ohne den Code Ihrer Aktivität zu ändern. Diese Technik ist auch nützlich, um komplexe Übergangsdefinitionen von Ihrem Anwendungscode zu trennen, wie im Abschnitt zum Angeben mehrerer Übergänge gezeigt.

So geben Sie einen integrierten Übergang in einer Ressourcendatei an:

• Fügen Sie Ihrem Projekt das Verzeichnis res/transition/ hinzu.
• Erstellen Sie in diesem Verzeichnis eine neue XML-Ressourcendatei.
• Fügen Sie einen XML-Knoten für einen der integrierten Übergänge hinzu.

In der folgenden Ressourcendatei wird beispielsweise der Übergang Fade angegeben:

res/transition/fade_transition.xml

<fade xmlns:android="http://schemas.android.com/apk/res/android" />

Das folgende Code-Snippet zeigt, wie eine Transition-Instanz in Ihrer Aktivität aus einer Ressourcendatei instanziiert wird:

var fadeTransition: Transition =
    TransitionInflater.from(this)
                      .inflateTransition(R.transition.fade_transition)

Transition fadeTransition =
        TransitionInflater.from(this).
        inflateTransition(R.transition.fade_transition);

Übergangsinstanz im Code erstellen

Diese Technik ist nützlich, um Übergangsobjekte dynamisch zu erstellen, wenn Sie die Benutzeroberfläche in Ihrem Code ändern, und um einfache integrierte Übergangsinstanzen mit wenigen oder keinen Parametern zu erstellen.

Wenn Sie eine Instanz einer integrierten Übergangsart erstellen möchten, rufen Sie einen der öffentlichen Konstruktoren in den Unterklassen der Klasse Transition auf. Mit dem folgenden Code-Snippet wird beispielsweise eine Instanz der Fade-Übergangs erstellt:

var fadeTransition: Transition = Fade()

Transition fadeTransition = new Fade();

Übergang anwenden

Normalerweise wenden Sie einen Übergang an, um zwischen verschiedenen Ansichtshierarchien zu wechseln, wenn ein Ereignis eintritt, z. B. eine Nutzeraktion. Wenn der Nutzer beispielsweise in einer Such-App einen Suchbegriff eingibt und auf die Suchschaltfläche tippt, wechselt die App zu einer Szene, die das Layout der Ergebnisse darstellt. Dabei wird eine Übergangsanimation verwendet, bei der die Suchschaltfläche ausgeblendet und die Suchergebnisse eingeblendet werden.

Wenn Sie eine Szene ändern und dabei als Reaktion auf ein Ereignis in Ihrer Aktivität einen Übergang anwenden möchten, rufen Sie die Klassenfunktion TransitionManager.go() mit der Endszene und der Übergangsvariable auf, die für die Animation verwendet werden soll, wie im folgenden Snippet gezeigt:

TransitionManager.go(endingScene, fadeTransition)

TransitionManager.go(endingScene, fadeTransition);

Das Framework ändert die Ansichtshierarchie innerhalb des Szenenstamms mit der Ansichtshierarchie der Endszene, während die durch die Übergang-Instanz angegebene Animation ausgeführt wird. Die Startszene ist die Schlussszene der letzten Überblendung. Wenn es keinen vorherigen Übergang gibt, wird die Startszene automatisch anhand des aktuellen Status der Benutzeroberfläche bestimmt.

Wenn Sie keine Übergangsinstanz angeben, kann der Übergangsmanager einen automatischen Übergang anwenden, der in den meisten Situationen sinnvoll ist. Weitere Informationen finden Sie in der API-Referenz für die Klasse TransitionManager.

Bestimmte Zielansichten auswählen

Das Framework wendet standardmäßig Übergänge auf alle Ansichten in den Start- und End-Szenen an. In einigen Fällen möchten Sie eine Animation möglicherweise nur auf eine Teilmenge von Ansichten in einer Szene anwenden. Mit dem Framework können Sie bestimmte Ansichten auswählen, die animiert werden sollen. Das Framework unterstützt beispielsweise keine Animationen von Änderungen an ListView-Objekten. Versuchen Sie also nicht, sie während eines Übergangs zu animieren.

Jede Ansicht, die durch die Übergangsanimation animiert wird, wird als Ziel bezeichnet. Sie können nur Ziele auswählen, die Teil der Ansichtshierarchie sind, die mit einer Szene verknüpft ist.

Wenn Sie eine oder mehrere Ansichten aus der Liste der Ziele entfernen möchten, rufen Sie die Methode removeTarget() auf, bevor Sie mit dem Übergang beginnen. Wenn Sie der Liste der Ziele nur die von Ihnen angegebenen Ansichten hinzufügen möchten, rufen Sie die Funktion addTarget() auf. Weitere Informationen finden Sie in der API-Referenz zur Klasse Transition.

Mehrere Übergänge angeben

Damit eine Animation ihre volle Wirkung entfaltet, sollte sie zum Typ der Änderungen passen, die zwischen den Szenen auftreten. Wenn Sie beispielsweise zwischen Szenen einige Ansichten entfernen und andere hinzufügen, bietet eine Ein- oder Ausblendung eine deutliche Anzeige dafür, dass einige Ansichten nicht mehr verfügbar sind. Wenn Sie Ansichten an andere Stellen auf dem Bildschirm verschieben, sollten Sie die Bewegung animieren, damit Nutzer die neue Position der Ansichten bemerken.

Sie müssen nicht nur eine Animation auswählen, da Sie mit dem Transitions-Framework Animationseffekte in einem Übergangsset kombinieren können, das eine Gruppe von einzelnen integrierten oder benutzerdefinierten Übergängen enthält.

Wenn Sie eine Übergangsgruppe aus einer Sammlung von Übergängen in XML definieren möchten, erstellen Sie eine Ressourcendatei im Verzeichnis res/transitions/ und listen Sie die Übergänge unter dem Element TransitionSet auf. Das folgende Snippet zeigt beispielsweise, wie ein Übergangssatz angegeben wird, der dasselbe Verhalten wie die Klasse AutoTransition hat:

<transitionSet xmlns:android="http://schemas.android.com/apk/res/android"
    android:transitionOrdering="sequential">
    <fade android:fadingMode="fade_out" />
    <changeBounds />
    <fade android:fadingMode="fade_in" />
</transitionSet>

Wenn Sie das Übergangsset in Ihrem Code in ein TransitionSet-Objekt umwandeln möchten, rufen Sie die Funktion TransitionInflater.from() in Ihrer Aktivität auf. Die TransitionSet-Klasse wird von der Transition-Klasse abgeleitet. Sie können sie also mit einem Übergangsmanager verwenden, genau wie jede andere Transition-Instanz.

Übergang ohne Szenen anwenden

Das Ändern von Ansichtshierarchien ist nicht die einzige Möglichkeit, die Benutzeroberfläche zu ändern. Sie können auch Änderungen vornehmen, indem Sie untergeordnete Ansichten in der aktuellen Hierarchie hinzufügen, ändern und entfernen.

Sie können beispielsweise eine Suchinteraktion mit einem einzelnen Layout implementieren. Beginnen Sie mit dem Layout, das ein Sucheingabefeld und ein Suchsymbol zeigt. Wenn Sie die Benutzeroberfläche ändern möchten, um die Ergebnisse anzuzeigen, entfernen Sie die Suchschaltfläche, wenn der Nutzer darauf tippt, indem Sie die Funktion ViewGroup.removeView() aufrufen, und fügen Sie die Suchergebnisse hinzu, indem Sie die Funktion ViewGroup.addView() aufrufen.

Sie können diesen Ansatz verwenden, wenn die Alternative zwei nahezu identische Hierarchien wären. Anstatt zwei separate Layoutdateien für einen geringfügigen Unterschied in der Benutzeroberfläche zu erstellen und zu verwalten, können Sie eine Layoutdatei mit einer Ansichtshierarchie verwenden, die Sie im Code ändern.

Wenn Sie Änderungen auf diese Weise in der aktuellen Ansichtshierarchie vornehmen, müssen Sie keine Szene erstellen. Stattdessen können Sie mit einem verzögerten Übergang einen Übergang zwischen zwei Status einer Ansichtshierarchie erstellen und anwenden. Diese Funktion des Übergangs-Frameworks beginnt mit dem aktuellen Status der Ansichtshierarchie, zeichnet Änderungen auf, die Sie an den Ansichten vornehmen, und wendet einen Übergang an, der die Änderungen animiert, wenn das System die Benutzeroberfläche neu zeichnet.

So erstellen Sie einen verzögerten Übergang innerhalb einer einzelnen Ansichtshierarchie:

1. Wenn das Ereignis eintritt, das den Übergang auslöst, rufen Sie die Funktion TransitionManager.beginDelayedTransition() auf und geben Sie die Elternansicht aller Ansichten an, die Sie ändern möchten, sowie den zu verwendenden Übergang. Das Framework speichert den aktuellen Status der untergeordneten Ansichten und deren Attributwerte.
2. Nehmen Sie die für Ihren Anwendungsfall erforderlichen Änderungen an den untergeordneten Ansichten vor. Im Framework werden die Änderungen aufgezeichnet, die Sie an den untergeordneten Ansichten und ihren Eigenschaften vornehmen.
3. Wenn das System die Benutzeroberfläche entsprechend Ihren Änderungen neu zeichnet, animiert das Framework die Änderungen zwischen dem ursprünglichen und dem neuen Zustand.

Das folgende Beispiel zeigt, wie Sie das Hinzufügen einer Textansicht zu einer Ansichtshierarchie mithilfe eines verzögerten Übergangs animieren. Das erste Snippet zeigt die Layoutdefinitionsdatei:

res/layout/activity_main.xml

<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/mainLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    <EditText
        android:id="@+id/inputText"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
    ...
</androidx.constraintlayout.widget.ConstraintLayout>

Das nächste Snippet zeigt den Code, der die Animation des Hinzufügens der Textansicht ausführt:

MainActivity

setContentView(R.layout.activity_main)
val labelText = TextView(this).apply {
    text = "Label"
    id = R.id.text
}
val rootView: ViewGroup = findViewById(R.id.mainLayout)
val mFade: Fade = Fade(Fade.IN)
TransitionManager.beginDelayedTransition(rootView, mFade)
rootView.addView(labelText)

private TextView labelText;
private Fade mFade;
private ViewGroup rootView;
...
// Load the layout.
setContentView(R.layout.activity_main);
...
// Create a new TextView and set some View properties.
labelText = new TextView(this);
labelText.setText("Label");
labelText.setId(R.id.text);

// Get the root view and create a transition.
rootView = (ViewGroup) findViewById(R.id.mainLayout);
mFade = new Fade(Fade.IN);

// Start recording changes to the view hierarchy.
TransitionManager.beginDelayedTransition(rootView, mFade);

// Add the new TextView to the view hierarchy.
rootView.addView(labelText);

// When the system redraws the screen to show this update,
// the framework animates the addition as a fade in.

Callbacks für den Übergangslebenszyklus definieren

Der Übergangslebenszyklus ähnelt dem Aktivitätslebenszyklus. Sie stellt die Übergangszustände dar, die das Framework im Zeitraum zwischen einem Aufruf der Funktion TransitionManager.go() und dem Abschluss der Animation überwacht. In wichtigen Lebenszyklusphasen ruft das Framework von der TransitionListener-Schnittstelle definierte Callbacks auf.

Übergangs-Lifecycle-Callbacks sind beispielsweise nützlich, um den Wert einer Ansichtseigenschaft während eines Szenenwechsels von der Startansichtshierarchie in die Endansichtshierarchie zu kopieren. Sie können den Wert nicht einfach aus der Startansicht in die Ansicht in der Endansichtshierarchie kopieren, da die Endansichtshierarchie erst nach Abschluss des Übergangs aufgebläht wird. Stattdessen müssen Sie den Wert in einer Variablen speichern und ihn dann in die endgültige Ansichtshierarchie kopieren, wenn das Framework die Übergangsanimation abgeschlossen hat. Wenn Sie benachrichtigt werden möchten, wenn die Umstellung abgeschlossen ist, implementieren Sie die Funktion TransitionListener.onTransitionEnd() in Ihrer Aktivität.

Weitere Informationen finden Sie in der API-Referenz zur Klasse TransitionListener.

Beschränkungen

In diesem Abschnitt werden einige bekannte Einschränkungen des Übergangs-Frameworks aufgeführt:

• Animationen, die auf ein SurfaceView angewendet werden, werden möglicherweise nicht richtig angezeigt. SurfaceView-Instanzen werden über einen Nicht-UI-Thread aktualisiert. Die Aktualisierungen sind daher möglicherweise nicht mit den Animationen anderer Ansichten synchronisiert.
• Bei einigen bestimmten Übergangstypen wird möglicherweise nicht der gewünschte Animationseffekt erzielt, wenn sie auf ein TextureView angewendet werden.
• Klassen, die AdapterView erweitern, z. B. ListView, verwalten ihre untergeordneten Ansichten auf eine Weise, die mit dem Übergangs-Framework inkompatibel ist. Wenn Sie versuchen, eine Ansicht basierend auf AdapterView zu animieren, reagiert das Gerätedisplay möglicherweise nicht mehr.
• Wenn Sie versuchen, ein TextView mit einer Animation zu skalieren, wird der Text an eine neue Position verschoben, bevor das Objekt vollständig skaliert ist. Um dieses Problem zu vermeiden, sollten Sie die Größe von Ansichten mit Text nicht animieren.