Layoutänderungen mit einem Übergang animieren

Schreiben Sie jetzt

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

AnimierteContent →

Mit dem Transition-Framework von Android können Sie alle Arten von Bewegungen auf Ihrer Benutzeroberfläche animieren, indem Sie die Start- und Endlayouts bereitstellen. Sie können die Art der Animation auswählen, z. B. Ansichten ein- oder ausblenden oder die Ansichtsgröße ändern. Das Übergangs-Framework bestimmt, wie die Animation vom Start- bis zum Endlayout ausgeführt wird.

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:Für gängige Effekte wie Ausblendung oder Bewegung können vordefinierte Animationen verwendet werden.
• Unterstützung von Ressourcendateien:Ansichtshierarchien und integrierte Animationen aus Layoutressourcendateien werden geladen.
• Lebenszyklus-Callbacks:Sie erhalten Callbacks, die die Kontrolle über die Animation und den Hierarchieänderungsprozess bieten.

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

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

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

Das Diagramm in Abbildung 1 veranschaulicht die Beziehung zwischen Layout, Szenen, Übergang und fertiger Animation.

Abbildung 1: Grundlegende Darstellung, wie das Übergangs-Framework eine Animation erstellt.

Szene erstellen

In Szenen wird der Status einer Ansichtshierarchie gespeichert, einschließlich aller Ansichten und ihrer Attributwerte. Mit dem Übergangs-Framework lassen sich Animationen zwischen einer Start- und einer Schlussszene ausführen.

Sie können Ihre Szenen aus einer Layoutressourcendatei oder einer Gruppe von Ansichten in Ihrem Code erstellen. Allerdings wird der Ausgangspunkt für den Übergang häufig automatisch über die aktuelle UI ermittelt.

Für eine Szene können auch eigene Aktionen definiert werden, die ausgeführt werden, wenn Sie einen Szenenwechsel vornehmen. Diese Funktion ist hilfreich, 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 überwiegend statisch ist. Die resultierende Szene stellt den Status 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 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 Szenenstammelement erstellen. Die Snippets veranschaulichen außerdem, dass Sie mehrere zusammengehörige Scene-Objekte laden können, ohne anzugeben, dass sie miteinander verknüpft sind.

Das Beispiel besteht aus den 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 zwei Textfeldern in unterschiedlicher Reihenfolge.

Das Beispiel ist so konzipiert, dass die gesamte Animation innerhalb des untergeordneten Layouts 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 Szenestamm. Das Layout für die erste Szene ist in der Hauptlayoutdatei enthalten. Auf diese Weise kann die App sie als Teil der anfänglichen 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 wie folgt 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 Textfelder – mit denselben IDs – in unterschiedlicher Reihenfolge. Sie ist wie folgt 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" >
    
    
</androidx.constraintlayout.widget.ConstraintLayout>

Szenen aus Layouts generieren

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

Das folgende Code-Snippet zeigt, wie Sie einen Verweis auf den Szenenstamm 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 Anwendung gibt es jetzt zwei Scene-Objekte, die auf Ansichtshierarchien basieren. Beide Szenen verwenden den vom Element FrameLayout in res/layout/activity_main.xml definierten Szenenstamm.

Eine Szene in Ihrem Code erstellen

Sie können im Code auch eine Scene-Instanz aus einem ViewGroup-Objekt erstellen. Verwenden Sie diese Technik, wenn Sie die Ansichtshierarchien direkt im Code ändern oder 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 bereits eine Layoutdatei aufgeblasen haben.

Im folgenden Code-Snippet sehen Sie, wie Sie eine Scene-Instanz aus dem Szenenstammelement 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 diesem Framework können Sie benutzerdefinierte Szenenaktionen definieren, die das System beim Betreten oder Verlassen einer Szene ausführt. In vielen Fällen ist das Definieren benutzerdefinierter Szenenaktionen nicht erforderlich, da das Framework den Wechsel zwischen den Szenen automatisch animiert.

Szenenaktionen sind in folgenden Fällen nützlich:

• Zum Animieren von Ansichten, die nicht in derselben Hierarchie sind Sie können die Ansichten für die Start- und Endszenen mithilfe der Aktionen für Ausgangs- und Eingangsszenen animieren.
• Zum Animieren von Ansichten, die mit dem Übergangs-Framework nicht automatisch animiert werden können, z. B. ListView-Objekte. Weitere Informationen finden Sie im Abschnitt zu Einschränkungen.

Wenn Sie benutzerdefinierte Szenenaktionen bereitstellen möchten, definieren Sie die 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, bevor die Übergangsanimation ausgeführt wird, und die Funktion setEnterAction() in der Schlussszene auf, nachdem die Übergangsanimation ausgeführt wurde.

Übergang anwenden

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

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

Übergang erstellen

Im vorherigen Abschnitt wird gezeigt, wie Sie Szenen erstellen, die den Status verschiedener Ansichtshierarchien darstellen. Nachdem Sie die Start- und Endszene festgelegt haben, zwischen der 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 im Code eine Inflation vornehmen oder eine Instanz eines integrierten Übergangs direkt in Ihrem Code erstellen.

Tabelle 1 Integrierte Übergangstypen

Transition-Instanz 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 von Ihrem 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 in diesem Verzeichnis eine neue XML-Ressourcendatei.
• 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 innerhalb Ihrer Aktivität aus einer Ressourcendatei in die Höhe treiben:

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

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

Transition-Instanz im Code erstellen

Diese Technik eignet sich zum dynamischen Erstellen von Übergangsobjekten, wenn Sie die Benutzeroberfläche in Ihrem Code ändern, und um einfache integrierte Übergangsinstanzen mit wenigen oder keinen Parametern zu erstellen.

Rufen Sie einen der öffentlichen Konstruktoren in den abgeleiteten Klassen der Transition-Klasse auf, um eine Instanz eines integrierten Übergangs zu erstellen. Im folgenden Code-Snippet wird beispielsweise eine Instanz des Übergangs Fade erstellt:

var fadeTransition: Transition = Fade()

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. Stellen Sie sich beispielsweise eine Such-App vor: Wenn der Nutzer einen Suchbegriff eingibt und auf die Suchschaltfläche tippt, wechselt die App zu einer Szene, die das Ergebnislayout darstellt. Dabei wird ein Übergang angewendet, bei dem die Suchschaltfläche ausgeblendet und in den Suchergebnissen ausgeblendet wird.

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

TransitionManager.go(endingScene, fadeTransition)

TransitionManager.go(endingScene, fadeTransition);

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

Wenn Sie keine Transition-Instanz 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 eine Teilmenge der Ansichten in einer Szene anzuwenden. Mit diesem Framework können Sie bestimmte Ansichten auswählen, die animiert werden sollen. Das Framework unterstützt beispielsweise keine Animationen für ListView-Objekte. Versuchen Sie also nicht, sie während eines Übergangs zu animieren.

Jede Ansicht, die durch den Übergang animiert wird, 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 den Übergang starten. 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

Um eine optimale Wirkung zu erzielen, sollten Sie die Animation an die Art der Änderungen anpassen, die zwischen den Szenen auftreten. Wenn Sie beispielsweise einige Ansichten entfernen und andere zwischen Szenen hinzufügen, weist das Ein- oder Ausblenden der Animation 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 die Nutzer die neue Position der Ansichten erkennen.

Sie müssen nicht nur eine Animation auswählen, da Sie mit dem Übergangs-Framework Animationseffekte in einem Übergangsset kombinieren können, das 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 ein Übergangs-Dataset angegeben wird, das 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 Übergangs-Dataset in ein TransitionSet-Objekt in Ihrem Code umwandeln möchten, rufen Sie die Funktion TransitionInflater.from() in Ihrer Aktivität auf. Die Klasse TransitionSet ist Teil der Klasse Transition und kann 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, Ihre Benutzeroberfläche zu ändern. Sie können auch Änderungen vornehmen, indem Sie untergeordnete Ansichten innerhalb der aktuellen Hierarchie hinzufügen, ändern oder 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 so ändern möchten, dass die Ergebnisse angezeigt werden, entfernen Sie die Suchschaltfläche, wenn der Nutzer darauf tippt. Dazu rufen Sie die Funktion ViewGroup.removeView() auf und fügen die Suchergebnisse durch Aufrufen der Funktion ViewGroup.addView() hinzu.

Sie können diesen Ansatz verwenden, wenn die Alternative darin besteht, zwei nahezu identische Hierarchien zu verwenden. 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 auf diese Weise Änderungen an der aktuellen Ansichtshierarchie vornehmen, müssen Sie keine Szene erstellen. Stattdessen können Sie mit einem verzögerten Übergang einen Übergang zwischen zwei Zuständen einer Ansichtshierarchie erstellen und anwenden. Diese Funktion des Frameworks für Übergänge beginnt mit dem aktuellen Status der Ansichtshierarchie, zeichnet Änderungen an den Ansichten auf 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 ihre Property-Werte.
2. Nehmen Sie die für Ihren Anwendungsfall erforderlichen Änderungen an den untergeordneten Ansichten vor. Das Framework erfasst die Änderungen, die Sie an den untergeordneten Ansichten und ihren Properties 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 Status.

Das folgende Beispiel zeigt, wie das Hinzufügen einer Textansicht zu einer Ansichtshierarchie mit einem verzögerten Übergang 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, der das Hinzufügen der Textansicht animiert:

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

Callbacks für den Übergangslebenszyklus sind beispielsweise nützlich, um einen Ansichtseigenschaftswert während eines Szenenwechsels von der Hierarchie der Startansicht in die Endansichtshierarchie zu kopieren. Sie können den Wert nicht einfach aus der Startansicht in die Ansicht in der abschließenden Ansichtshierarchie kopieren, da sich die Endansichtshierarchie erst nach Abschluss des Übergangs erhöht. Stattdessen müssen Sie den Wert in einer Variablen speichern und dann in die abschließende Ansichtshierarchie kopieren, wenn das Framework den Übergang abgeschlossen hat. Implementieren Sie die Funktion TransitionListener.onTransitionEnd() in Ihrer Aktivität, um über den Abschluss der Umstellung informiert zu werden.

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

Einschränkungen

In diesem Abschnitt werden einige bekannte Einschränkungen des Frameworks für Umstellungen aufgeführt:

• Animationen, die auf einen SurfaceView angewendet werden, werden möglicherweise nicht korrekt angezeigt. SurfaceView-Instanzen werden über einen Thread aktualisiert, der nicht auf der Benutzeroberfläche basiert. Daher können die Updates mit den Animationen anderer Ansichten nicht synchron sein.
• Einige bestimmte Übergangstypen erzeugen möglicherweise nicht den gewünschten Animationseffekt, wenn sie auf eine TextureView angewendet werden.
• Klassen, die AdapterView erweitern, z. B. ListView, verwalten ihre untergeordneten Ansichten auf eine Weise, die nicht mit dem Transition-Framework kompatibel ist. Wenn Sie versuchen, eine Ansicht basierend auf AdapterView zu animieren, reagiert das Gerätedisplay möglicherweise nicht mehr.
• Wenn Sie versuchen, die Größe eines TextView mit einer Animation zu ändern, ändert sich der Text an eine neue Position, bevor die Größe des Objekts vollständig angepasst wird. Um dieses Problem zu vermeiden, animieren Sie die Größenänderung von Ansichten nicht, die Text enthalten.