Layoutänderungen mit einem Übergang animieren

Compose ausprobieren

Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zum Verwenden 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 gewünschte Art der Animation auswählen, z. B. das Ein- oder Ausblenden von Ansichten oder die Änderung der Ansichtsgröße. Das Übergangs-Framework bestimmt dann, wie die Animation vom Anfangs- zum Endlayout erfolgt.

Das Übergangskonzept umfasst die folgenden Funktionen:

• Animationen auf Gruppenebene:Animationseffekte werden auf alle Ansichten in einer Ansichtshierarchie angewendet.
• Integrierte Animationen:Für gängige Effekte wie Ausblendung oder Bewegung können vordefinierte Animationen verwendet werden.
• Unterstützung von Ressourcendateien:Hierarchien von Ansichten und integrierte Animationen können aus Layout-Ressourcendateien geladen werden.
• Lebenszyklus-Callbacks: Sie erhalten Callbacks, mit denen Sie die Animation und den Hierarchieänderungsprozess steuern können.

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

So animieren Sie zwischen zwei Layouts:

1. Erstelle ein Scene-Objekt für das Start- und das End-Layout. Die Szene des Startlayouts wird jedoch oft automatisch aus dem aktuellen Layout ermittelt.
2. Erstellen Sie ein Transition-Objekt, um die gewünschte Art der Animation 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 den Layouts, den Szenen, dem Übergang und der endgültigen Animation.

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

Szene erstellen

In Szenen wird der Status einer Ansichtshierarchie gespeichert, einschließlich aller Ansichten und ihrer Attributwerte. Das Transitions-Framework kann Animationen zwischen einer Start- und einer Endszene 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 nützlich, um die Ansichtseinstellungen nach dem Wechsel zu einer Szene zu bereinigen.

Szene aus einer Layoutressource erstellen

Sie können eine Scene-Instanz direkt aus einer Layout-Ressourcedatei erstellen. Verwenden Sie diese Methode, wenn die Ansichtshierarchie in der Datei größtenteils 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 Layout-Ressourcedatei erstellen möchten, rufen Sie den Szenenstamm aus Ihrem Layout als ViewGroup ab. Rufen Sie dann die Funktion Scene.getSceneForLayout() mit dem Stammverzeichnis der Szene 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 Wurzelelement 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 Element 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.

Im Beispiel wird die gesamte Animation im untergeordneten Layout des Hauptlayouts für die Aktivität ausgeführt. Das Textlabel 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 für den Szenenknoten. Das Layout für die erste Szene ist in der Haupt-Layoutdatei enthalten. So kann die App es als Teil der ursprü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 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 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 eine Referenz auf den Szenenstamm und die Layout-Ressourcen-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 App 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 auch eine Scene-Instanz in Ihrem Code aus einem ViewGroup-Objekt erstellen. Verwenden Sie diese Methode, 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 Aufruf der Funktion Scene.getSceneForLayout(), wenn Sie bereits eine Layoutdatei aufgebläht haben.

Im folgenden Code-Snippet wird gezeigt, wie Sie eine Scene-Instanz aus dem Stammelement der Szene 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 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 die Ansichten für die Start- und Endszenen mithilfe der Aktionen für Ausgangs- und Eingangsszenen animieren.
• Zum Animieren von Ansichten, die nicht automatisch vom Übergangs-Framework 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 auf, bevor die Übergangsanimation ausgeführt wird, und die Funktion setEnterAction() in der Endszene nach Ausführung der Übergangsanimation.

Übergang anwenden

Das Übergangs-Framework stellt den Animationsstil zwischen Szenen mit einem Transition-Objekt dar. Sie können eine Transition mithilfe vordefinierter Unterklassen 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 das Framework zwischen Beginn und Ende einer Animation überwacht. In wichtigen Lebenszykluszuständen ruft das Framework Rückruffunktionen auf, die Sie implementieren können, um Ihre Benutzeroberfläche in verschiedenen Phasen der Umstellung anzupassen.

Übergang erstellen

Im vorherigen Abschnitt wurde 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 ihn in Ihrem Code aufblähen oder eine Instanz eines integrierten Übergangs direkt in Ihrem Code erstellen.

Tabelle 1 Integrierte Übergangstypen

Transition-Instanz aus einer Ressourcendatei erstellen

So können Sie die Übergangsdefinition ändern, ohne den Code Ihrer Aktivität zu ändern. Diese Methode eignet sich auch, um komplexe Übergangsdefinitionen vom Anwendungscode zu trennen, wie im Abschnitt Mehrere Übergänge angeben beschrieben.

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

• Fügen Sie das Verzeichnis res/transition/ zu Ihrem Projekt 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 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 Methode eignet sich zum dynamischen Erstellen von Übergangsobjekten, wenn Sie die Benutzeroberfläche in Ihrem Code ändern, und zum Erstellen einfacher integrierter Übergangsinstanzen mit wenigen oder gar keinen Parametern.

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

Normalerweise wenden Sie einen Übergang an, um in 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 eine Szenenänderung vornehmen und gleichzeitig einen Übergang als Reaktion auf ein Ereignis in Ihrer Aktivität anwenden möchten, rufen Sie die Klassenfunktion TransitionManager.go() mit der Endszene und der Übergangsinstanz 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 aus der Schlussszene, während die von der Übergangsinstanz angegebene Animation ausgeführt wird. Die Startszene ist die Endszene des letzten Übergangs. Wenn es keinen vorherigen Übergang gibt, wird die Startszene automatisch anhand des aktuellen Status der Benutzeroberfläche ermittelt.

Wenn Sie keine Übergangs-Instanz angeben, kann der Übergangsmanager einen automatischen Übergang anwenden, der in den meisten Fällen 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 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 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 Überblendung 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 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 für die Klasse Transition.

Mehrere Übergänge angeben

Damit eine Animation möglichst wirkungsvoll ist, sollte sie der Art der Änderungen entsprechen, die zwischen den Szenen auftreten. Wenn du beispielsweise zwischen Szenen einige Ansichten entfernst und andere hinzufügst, ist eine Ein- oder Ausblendungsanimation ein deutlicher Hinweis darauf, dass einige Ansichten nicht mehr verfügbar sind. Wenn Sie Ansichten an verschiedene Stellen auf dem Bildschirm verschieben, sollten Sie die Bewegung animieren, damit Nutzer die neue Position der Ansichten bemerken.

Sie müssen sich nicht nur für eine Animation entscheiden, da Sie mit dem Transitions-Framework Animationen in einem Transitions-Set 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. Im folgenden Snippet wird beispielsweise gezeigt, 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 den Übergangssatz in Ihrem Code in ein TransitionSet-Objekt einfügen möchten, rufen Sie die Funktion TransitionInflater.from() in Ihrer Aktivität auf. Die TransitionSet-Klasse ist eine Erweiterung der Transition-Klasse. Sie können sie also wie jede andere Transition-Instanz mit einem Übergangsmanager verwenden.

Ü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 einzigen 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, indem Sie die Funktion ViewGroup.removeView() aufrufen. Fügen Sie dann die Suchergebnisse hinzu, indem Sie die Funktion ViewGroup.addView() aufrufen.

Sie können diesen Ansatz verwenden, wenn die Alternative darin besteht, zwei nahezu identische Hierarchien zu verwenden. Anstatt zwei separate Layoutdateien für eine geringfügige Abweichung 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 einen Übergang zwischen zwei Zuständen einer Ansichtshierarchie mit einem verzögerten Übergang erstellen und anwenden. Diese Funktion des Transitions-Frameworks beginnt mit dem aktuellen Zustand 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 eine verzögerte Überblendung 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 Attributwerte.
2. Nehmen Sie die erforderlichen Änderungen an den untergeordneten Datenansichten 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 Zustand.

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 Layoutdefinitiondatei:

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>

Im nächsten Snippet sehen Sie 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. Er stellt die Übergangszustände dar, die vom Framework während des Zeitraums zwischen einem Aufruf der TransitionManager.go()-Funktion und dem Abschluss der Animation überwacht werden. Bei wichtigen Lebenszykluszuständen ruft das Framework Rückrufe auf, die von der TransitionListener-Schnittstelle definiert sind.

Callbacks für den Übergangslebenszyklus sind beispielsweise nützlich, um bei einem Szenenwechsel einen Wert für eine Ansichtseigenschaft aus 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 der Umstellung maximiert wird. Stattdessen müssen Sie den Wert in einer Variablen speichern und dann in die Endansichtshierarchie kopieren, wenn das Framework den Übergang 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 für die Klasse TransitionListener.

Beschränkungen

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

• Animationen, die auf ein SurfaceView angewendet werden, werden möglicherweise nicht richtig angezeigt. SurfaceView-Instanzen werden über einen Thread aktualisiert, der sich nicht auf der Benutzeroberfläche befindet. Daher sind die Updates möglicherweise nicht mit den Animationen anderer Ansichten synchron.
• Bestimmte Übergangstypen erzeugen bei Anwendung auf eine TextureView möglicherweise nicht den gewünschten Animationseffekt.
• Klassen, die AdapterView erweitern, z. B. ListView, verwalten ihre untergeordneten Ansichten auf eine Weise, die nicht mit dem Transitions-Framework kompatibel ist. Wenn Sie versuchen, eine Ansicht basierend auf AdapterView zu animieren, reagiert das Display des Geräts möglicherweise nicht mehr.
• Wenn Sie versuchen, die Größe eines TextView mit einer Animation zu ändern, springt der Text an eine neue Stelle, bevor das Objekt vollständig neu skaliert wurde. Um dieses Problem zu vermeiden, animieren Sie die Größenänderung von Ansichten nicht, die Text enthalten.