Layoutänderungen mit einem Übergang animieren

Funktion „Schreiben“ ausprobieren

Jetpack Compose ist das empfohlene UI-Toolkit für Android. Hier erfahren Sie, wie Sie Animationen in Compose verwenden.

AnimierteContent →

Hinweis: In dieser Dokumentation wird beschrieben, wie Übergänge zwischen Layouts innerhalb derselben Aktivität erstellt werden. Wenn der Nutzer zwischen Aktivitäten wechselt, lesen Sie den Artikel Aktivität mit einer Animation starten.

Mit dem Transition-Framework von Android können Sie alle Arten von Bewegungen in Ihrer UI animieren, indem Sie Start- und Endlayouts bereitstellen. Sie können die gewünschte Art der Animation auswählen, z. B. Ansichten ein- oder ausblenden oder die Größe der Ansicht ändern. Das Übergangs-Framework bestimmt dann, wie die Animation vom Anfangs- zum Endlayout erfolgt.

Das Framework für die Umstellung umfasst die folgenden Funktionen:

• Animationen auf Gruppenebene:Sie können Animationseffekte auf alle Ansichten in einer Ansichtshierarchie anwenden.
• Integrierte Animationen:Sie können vordefinierte Animationen für gängige Effekte wie Ausblendung oder Bewegung verwenden.
• Unterstützung für Ressourcendateien: Laden Sie Ansichtshierarchien und integrierte Animationen aus Layout-Ressourcendateien.
• Lebenszyklus-Callbacks:Sie erhalten Callbacks, mit denen die Animation und die Hierarchieänderungen gesteuert werden.

Beispielcode, der zwischen Layoutänderungen animiert wird, finden Sie unter BasicTransition.

Der grundlegende Ablauf der Animation zwischen zwei Layouts sieht so aus:

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

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

Abbildung 1: Darstellung einer Animation mit dem Übergangs-Framework.

Szene erstellen

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

Sie können Ihre Szenen aus einer Layout-Ressourcendatei oder aus einer Gruppe von Ansichten in Ihrem Code erstellen. Die Startszene für Ihren Übergang wird jedoch häufig automatisch über die aktuelle UI bestimmt.

Für eine Szene können auch eigene Aktionen definiert werden, die ausgeführt werden, wenn Sie einen Szenenwechsel vornehmen. Diese Funktion ist nützlich, um Ansichtseinstellungen nach dem Übergang zu einer Szene zu bereinigen.

Hinweis :Mit dem Framework können Änderungen in der Hierarchie einer einzelnen Ansicht ohne Szenen animiert werden, wie im Abschnitt Übergang ohne Szenen anwenden beschrieben. Für die Arbeit mit Übergängen ist es jedoch unerlässlich, die Szenarien zu verstehen.

Szene aus einer Layoutressource erstellen

Sie können eine Scene-Instanz direkt aus einer Layout-Ressourcendatei erstellen. Verwenden Sie dieses Verfahren, wenn die Ansichtshierarchie in der Datei größtenteils statisch ist. Die resultierende Szene stellt den Zustand der Ansichtshierarchie zum Zeitpunkt der Erstellung der Scene-Instanz dar. Wenn Sie die Ansichtshierarchie ändern, erstellen Sie die Szene neu. Das Framework erstellt die Szene anhand der gesamten Ansichtshierarchie in der Datei. Sie können keine Szene aus einem Teil einer Layoutdatei erstellen.

Wenn Sie eine Scene-Instanz aus einer Layout-Ressourcendatei 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 zwei verschiedene Szenen mit demselben Szenenstammelement erstellt werden. Die Snippets zeigen auch, dass Sie mehrere nicht zusammenhängende Scene-Objekte laden können, ohne implizieren zu müssen, dass sie miteinander in Beziehung stehen.

Das Beispiel umfasst die folgenden Layoutdefinitionen:

• Das Hauptlayout einer Aktivität mit einem Textlabel und einem untergeordneten 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 stattfindet. Die Textbeschriftung im Hauptlayout bleibt statisch.

Das Hauptlayout für die Aktivität ist wie folgt 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-Element für den Szenenstamm. Das Layout für die erste Szene ist in der Hauptlayoutdatei enthalten. Die App kann sie dann als Teil der anfänglichen Benutzeroberfläche anzeigen und auch in eine Szene laden, da das Framework nur eine gesamte Layoutdatei in einer 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" >
    
    
</androidx.constraintlayout.widget.ConstraintLayout>

Das Layout für die zweite Szene enthält die gleichen beiden Textfelder mit denselben IDs, die in unterschiedlicher Reihenfolge angeordnet sind. Sie ist wie folgt definiert:

res/layout/andere_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" >
    
    
</androidx.constraintlayout.widget.ConstraintLayout>

Szenen aus Layouts generieren

Nachdem Sie Definitionen für die beiden Einschränkungslayouts erstellt haben, können Sie für jedes von ihnen eine Szene abrufen. So können Sie zwischen den beiden UI-Konfigurationen wechseln. Zum Abrufen einer Szene benötigen Sie einen Verweis auf den Szenenstamm und die Layoutressourcen-ID.

Das folgende Code-Snippet zeigt, wie Sie einen Verweis auf das Szenenstammverzeichnis abrufen und zwei Scene-Objekte aus den Layoutdateien erstellen:

Kotlin

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)

Java

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 Anwendung gibt es jetzt zwei Scene-Objekte, die auf Ansichtshierarchien basieren. Für beide Szenen wird der Szenenstamm verwendet, der durch das Element FrameLayout in res/layout/activity_main.xml definiert ist.

Szene im Code erstellen

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

Verwenden Sie den Konstruktor Scene(sceneRoot, viewHierarchy), um eine Szene aus einer Ansichtshierarchie in Ihrem Code zu erstellen. Der Aufruf dieses Konstruktors entspricht dem Aufrufen der Funktion Scene.getSceneForLayout(), wenn Sie eine Layoutdatei bereits aufgebläht haben.

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

Kotlin

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

Java

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 den Wechsel zwischen den 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 Endszenen mit Aktionen für die Ausstiegs- und Einstiegsszene animieren.
• Zum Animieren von Ansichten, die vom Transition-Framework nicht automatisch animiert werden können, z. B. ListView-Objekte. Weitere Informationen finden Sie im Abschnitt zu Einschränkungen.

Definieren Sie Ihre Aktionen als Runnable-Objekte und übergeben Sie sie an die Funktionen Scene.setExitAction() oder Scene.setEnterAction(), um benutzerdefinierte Szenenaktionen bereitzustellen. Das Framework ruft die Funktion setExitAction() in der Startszene vor der Übergangsanimation und die Funktion setEnterAction() in der Endszene auf, nachdem die Übergangsanimation ausgeführt wurde.

Hinweis: Verwenden Sie Szenenaktionen nicht, um Daten zwischen Ansichten in der Start- und in der Endszene zu übergeben. Weitere Informationen finden Sie im Abschnitt zum Definieren von Callbacks für den Übergangslebenszyklus.

Übergang anwenden

Das Übergangs-Framework repräsentiert den Animationsstil zwischen den Szenen mithilfe eines Transition-Objekts. Sie können ein Transition mit integrierten Unterklassen wie AutoTransition und Fade instanziieren oder Ihre eigene Umstellung definieren. Anschließend können Sie die Animation zwischen den Szenen ausführen. Übergeben Sie dazu den letzten Scene und den Transition an TransitionManager.go().

Der Übergangslebenszyklus ähnelt dem Aktivitätslebenszyklus und stellt den Übergangsstatus dar, den das Framework zwischen dem Start und dem Ende einer Animation überwacht. Bei wichtigen Lebenszyklusstatus ruft das Framework Callback-Funktionen auf, die Sie implementieren können, um die Benutzeroberfläche in verschiedenen Phasen der Umstellung anzupassen.

Übergang erstellen

Im vorherigen Abschnitt wurde gezeigt, wie Szenen erstellt werden, die den Status verschiedener Ansichtshierarchien darstellen. Nachdem Sie die Start- und Endszenen 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 erweitern oder eine Instanz eines integrierten Übergangs direkt in Ihrem Code erstellen.

Tabelle 1 Integrierte Übergangstypen

Klasse	Taggen	Effekt
AutoTransition	<autoTransition/>	Standardübergang. Ein- und Ausblenden der Ansichten, Verschieben und Größe sowie Einblenden von Ansichten in dieser Reihenfolge.
ChangeBounds	<changeBounds/>	Verschiebt Ansichten und passt ihre Größe an.
ChangeClipBounds	<changeClipBounds/>	Erfasst die View.getClipBounds() vor und nach dem Szenenwechsel und animiert diese Änderungen während des Übergangs.
ChangeImageTransform	<changeImageTransform/>	Erfasst die Matrix einer ImageView vor und nach dem Szenenwechsel und animiert sie während des Übergangs.
ChangeScroll	<changeScroll/>	Erfasst die Scrolleigenschaften von Zielen vor und nach dem Szenenwechsel und animiert alle Änderungen.
ChangeTransform	<changeTransform/>	Erfasst Skalierung und Drehung von Ansichten vor und nach dem Szenenwechsel und animiert diese Änderungen während des Übergangs.
Explode	<explode/>	Verfolgt Änderungen an der Sichtbarkeit von Zielansichten in den Start- und Endszenen und verschiebt Ansichten in den oder aus der Szene heraus.
Fade	<fade/>	fade_in wird eingeblendet. fade_out blendet Ansichten aus. fade_in_out (Standardeinstellung) führt einen fade_out gefolgt von einem fade_in aus.
Slide	<slide/>	Verfolgt Änderungen an der Sichtbarkeit von Zielansichten in den Start- und Endszenen und verschiebt Ansichten in einen oder aus einer Szene heraus.

Übergangsinstanz aus einer Ressourcendatei erstellen

Mit diesem Verfahren können Sie die Übergangsdefinition ändern, ohne den Code Ihrer Aktivität zu ändern. Diese Technik ist auch nützlich, um komplexe Übergangsdefinitionen vom Anwendungscode zu trennen, wie im Abschnitt Mehrere Übergänge angeben gezeigt.

So legen Sie einen integrierten Übergang in einer Ressourcendatei fest:

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

Die folgende Ressourcendatei gibt beispielsweise den Übergang Fade an:

res/transition/fade_transition.xml

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

Das folgende Code-Snippet zeigt, wie Sie eine Transition-Instanz in Ihrer Aktivität aus einer Ressourcendatei infließen:

Kotlin

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

Java

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 einfache integrierte Übergangsinstanzen mit wenigen oder keinen Parametern erstellen.

Um eine Instanz eines integrierten Übergangs zu erstellen, rufen Sie einen der öffentlichen Konstruktoren in den Unterklassen der Transition-Klasse auf. Mit dem folgenden Code-Snippet wird beispielsweise eine Instanz der Fade-Umstellung erstellt:

Kotlin

var fadeTransition: Transition = Fade()

Java

Transition fadeTransition = new Fade();

Übergang anwenden

In der Regel wenden Sie einen Übergang an, um als Reaktion auf ein Ereignis, z. B. eine Nutzeraktion, zwischen verschiedenen Ansichtshierarchien zu wechseln. Nehmen wir als Beispiel eine Such-App: Wenn der Nutzer einen Suchbegriff eingibt und auf die Suchschaltfläche tippt, wechselt die App zu einer Szene, die das Layout der Ergebnisse darstellt. Dabei wird ein Übergang angewendet, durch den die Suchschaltfläche ausgeblendet und die Suchergebnisse ausgeblendet werden.

Wenn Sie einen Szenenwechsel vornehmen möchten, während Sie einen Übergang als Reaktion auf ein Ereignis in Ihrer Aktivität anwenden, rufen Sie die Klassenfunktion TransitionManager.go() mit der Endszene und der Übergangsinstanz für die Animation auf, wie im folgenden Snippet gezeigt:

Kotlin

TransitionManager.go(endingScene, fadeTransition)

Java

TransitionManager.go(endingScene, fadeTransition);

Das Framework ändert die Ansichtshierarchie im Szenenstamm anhand der Ansichtshierarchie der Endszene, während die von der Übergangsinstanz angegebene Animation ausgeführt wird. Die Startszene ist die Endszene des letzten Übergangs. Wenn kein vorheriger Übergang vorhanden ist, wird die Startszene automatisch aus dem aktuellen Status der Benutzeroberfläche ermittelt.

Wenn Sie keine Übergangsinstanz angeben, kann der Transition Manager einen automatischen Übergang anwenden, der in den meisten Situationen sinnvoll ist. Weitere Informationen finden Sie in der API-Referenz zur Klasse TransitionManager.

Bestimmte Zielansichten auswählen

Das Framework wendet Übergänge standardmäßig auf alle Ansichten in der Start- und Endszene an. In einigen Fällen kann es sinnvoll sein, eine Animation nur auf einen Teil der Ansichten in einer Szene anzuwenden. Mit dem Framework können Sie bestimmte Ansichten auswählen, die Sie animieren möchten. Das Framework unterstützt beispielsweise keine Animationen für Änderungen an ListView-Objekten. Versuchen Sie daher nicht, sie während eines Übergangs zu animieren.

Jede durch den Übergang animierte Ansicht wird als Ziel bezeichnet. Sie können nur Ziele auswählen, die Teil der Ansichtshierarchie sind, die einer Szene zugeordnet ist.

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

Mehrere Umstellungen angeben

Damit eine Animation die größte Wirkung erzielt, sollten Sie sie der Art der Änderungen zuordnen, die zwischen den Szenen stattfinden. Wenn Sie beispielsweise einige Ansichten entfernen und zwischen Szenen weitere hinzufügen, weist eine Aus- oder Einblenden-Animation deutlich darauf hin, dass einige Ansichten nicht mehr verfügbar sind. Wenn Sie Ansichten an verschiedene Punkte auf dem Bildschirm verschieben, ist es besser, die Bewegung zu animieren, damit Nutzer die neue Position der Ansichten bemerken.

Sie müssen nicht nur eine Animation auswählen, da Sie mit dem Übergangs-Framework Animationseffekte in einem Übergangssatz kombinieren können, der eine Gruppe einzelner integrierter oder benutzerdefinierter Übergänge enthält.

Wenn Sie einen Übergangssatz 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 Sie einen Übergangssatz angeben, 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>

Um das festgelegte Übergangselement in Ihrem Code in ein TransitionSet-Objekt zu erweitern, rufen Sie die Funktion TransitionInflater.from() in Ihrer Aktivität auf. Die Klasse TransitionSet stammt aus der Klasse Transition und kann daher wie jede andere Transition-Instanz mit einem Transition Manager verwendet werden.

Übergang ohne Szenen anwenden

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

Sie können z. B. eine Suchinteraktion mit einem einzigen Layout implementieren. Beginnen Sie mit dem Layout mit einem Sucheingabefeld und einem Suchsymbol. Wenn Sie die Benutzeroberfläche so ändern möchten, dass die Ergebnisse angezeigt werden, entfernen Sie die Suchschaltfläche durch Aufrufen der Funktion ViewGroup.removeView(), wenn der Nutzer darauf tippt, und fügen Sie die Suchergebnisse durch Aufrufen der Funktion ViewGroup.addView() hinzu.

Sie können diesen Ansatz verwenden, wenn die Alternative wäre, zwei Hierarchien zu haben, die nahezu identisch sind. 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 in der aktuellen Ansichtshierarchie auf diese Weise vornehmen, müssen Sie keine Szene erstellen. Stattdessen können Sie mithilfe eines verzögerten Übergangs einen Übergang zwischen zwei Zuständen einer Ansichtshierarchie erstellen und anwenden. Dieses Feature des Transitions-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. Geben Sie dabei die übergeordnete Ansicht aller Ansichten, die Sie ändern möchten, und den zu verwendenden Übergang an. 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. Das Framework zeichnet die Änderungen auf, die Sie an den untergeordneten Ansichten und ihren Eigenschaften vornehmen.
3. Wenn das System die Benutzeroberfläche gemäß Ihren Änderungen neu zeichnet, animiert das Framework die Änderungen zwischen dem ursprünglichen und dem neuen Zustand.

Im folgenden Beispiel wird gezeigt, wie das Hinzufügen einer Textansicht zu einer Ansichtshierarchie mithilfe eines verzögerten Übergangs animiert wird. 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, mit dem das Hinzufügen der Textansicht animiert wird:

MainActivity

Kotlin

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)

Java

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 Übergangsstatus dar, die vom Framework während des Zeitraums zwischen dem Aufruf der Funktion TransitionManager.go() und dem Abschluss der Animation überwacht werden. Bei wichtigen Lebenszyklusstatus ruft das Framework Callbacks auf, die durch die TransitionListener-Schnittstelle definiert sind.

Callbacks für den Lebenszyklus der Umstellung sind beispielsweise nützlich, um während eines Szenenwechsels einen Ansichtsattributwert von der Hierarchie der Startansicht in die Hierarchie der Endansicht zu kopieren. Sie können den Wert nicht einfach aus der Startansicht in die Ansicht in der Hierarchie der Endansicht kopieren, da sich die Hierarchie der Endansicht erst nach Abschluss des Übergangs erhöht. Stattdessen müssen Sie den Wert in einer Variablen speichern und dann in die Hierarchie der Endansicht kopieren, wenn das Framework die Umstellung abgeschlossen hat. Wenn Sie nach Abschluss der Umstellung benachrichtigt werden möchten, implementieren Sie die Funktion TransitionListener.onTransitionEnd() in Ihrer Aktivität.

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

Einschränkungen

In diesem Abschnitt sind einige bekannte Einschränkungen des Transition-Frameworks aufgeführt:

• Animationen, die auf ein SurfaceView angewendet werden, werden möglicherweise nicht richtig angezeigt. SurfaceView-Instanzen werden aus einem Nicht-UI-Thread aktualisiert, sodass die Aktualisierungen möglicherweise nicht mit den Animationen anderer Ansichten synchron sind.
• Einige bestimmte Übergangstypen erzeugen möglicherweise nicht den gewünschten Animationseffekt, wenn sie auf ein TextureView angewendet werden.
• Klassen, die AdapterView erweitern, wie ListView, verwalten ihre untergeordneten Ansichten so, dass dies nicht mit dem Umstellungs-Framework kompatibel ist. Wenn Sie versuchen, eine Ansicht basierend auf AdapterView zu animieren, reagiert die Geräteanzeige möglicherweise nicht mehr.
• Wenn Sie versuchen, die Größe eines TextView-Elements mit einer Animation anzupassen, wird der Text an eine neue Position verschoben, bevor die Größe des Objekts vollständig angepasst wird. Um dieses Problem zu vermeiden, dürfen Sie die Größenänderung von Ansichten, die Text enthalten, nicht animieren.