הצגת שינויים בפריסה באמצעות מעבר

כדאי לנסות את התכונה 'כתיבה מהירה'

Jetpack Compose היא ערכת הכלים המומלצת לבניית ממשק משתמש ב-Android. איך משתמשים באנימציות במצב 'כתיבה'

AnimatedContent →

הערה: במאמר הזה מוסבר איך ליצור מעברים בין פריסות בתוך אותה פעילות. אם המשתמש עובר בין פעילויות, כדאי לעיין במאמר התחלת פעילות באמצעות אנימציה.

מסגרת המעבר של Android מאפשרת לכם להוסיף אנימציה לכל סוגי התנועה בממשק המשתמש, באמצעות פריסות ההתחלה והסיום. אתם יכולים לבחור את סוג האנימציה שתרצו – למשל, להציג את התצוגות בהדרגה או לשנות את גודל התצוגות – ותבנית המעבר תקבע איך להציג את האנימציה מהפריסה ההתחלתית לפריסה הסופית.

מסגרת המעבר כוללת את התכונות הבאות:

• אנימציות ברמת הקבוצה: החלת אפקטים של אנימציה על כל התצוגות בהיררכיית התצוגות.
• אנימציות מובנות: אפשר להשתמש באנימציות מוגדרות מראש לאפקטים נפוצים כמו דהייה או תנועה.
• תמיכה בקובצי משאבים: אפשר לטעון היררכיות תצוגה ואנימציות מובנות מקובצי משאבים של פריסה.
• קריאות חוזרות (callback) של מחזור חיים: מקבלים קריאות חוזרות (callback) שמספקות שליטה על תהליך השינוי של האנימציה וההיררכיה.

לקוד לדוגמה שבו מתבצעת אנימציה בין שינויי פריסה, ראו BasicTransition.

התהליך הבסיסי להוספת אנימציה בין שני פריסות הוא:

1. יוצרים אובייקט Scene לפריסות ההתחלה והסיום. עם זאת, לרוב הסצנה של הפריסה ההתחלתית נקבעת באופן אוטומטי מהפריסה הנוכחית.
2. יוצרים אובייקט Transition כדי להגדיר את סוג האנימציה הרצוי.
3. קוראים ל-TransitionManager.go() והמערכת מפעילה את האנימציה כדי להחליף את הפריסות.

הדיאגרמה באיור 1 ממחישה את הקשר בין הפריסות, התמונות, המעבר והאנימציה הסופית.

איור 1. איור בסיסי שמראה איך מסגרת המעבר יוצרת אנימציה.

יצירת סצנה

סצנות שומרות את המצב של היררכיית תצוגה, כולל כל התצוגות שלה וערכי המאפיינים שלהן. מסגרת המעברים יכולה להפעיל אנימציות בין סצנה ראשונית לסצנה סופית.

אפשר ליצור את הסצנות מקובץ משאב של פריסה או מקבוצה של תצוגות בקוד. עם זאת, לרוב הסצנה המתחילה של המעבר נקבעת באופן אוטומטי על סמך ממשק המשתמש הנוכחי.

לסצנה יש גם אפשרות להגדיר את הפעולות שלה שיופעלו כשאתם מבצעים שינוי בסצנה. התכונה הזו שימושית לניקוי הגדרות התצוגה אחרי שמעברים לזירת צילום.

הערה: המסגרת יכולה ליצור אנימציה של שינויים בהיררכיית תצוגה אחת בלי להשתמש בסצנות, כפי שמתואר בקטע החלת מעבר בלי סצנות. עם זאת, חשוב להבין את התמונות כדי לעבוד עם מעברים.

יצירת סצנה ממשאב פריסה

אפשר ליצור מופע של Scene ישירות מקובץ משאב של פריסה. מומלץ להשתמש בשיטה הזו כשהיררכיית התצוגה בקובץ היא בעיקר סטטית. הסצנה שתתקבל מייצגת את המצב של היררכיית התצוגה בזמן יצירת המכונה Scene. אם משנים את היררכיית התצוגה, צריך ליצור מחדש את הסצנה. ה-framework יוצר את הסצנה מכל היררכיית התצוגות של הקובץ. אי אפשר ליצור סצנה מחלק מקובץ פריסה.

כדי ליצור מופע של Scene מקובץ משאב של פריסה, צריך לאחזר את שורש הסצנה מהפריסה בתור ViewGroup. לאחר מכן, קוראים לפונקציה Scene.getSceneForLayout() עם שורש הסצנה ומזהה המשאב של קובץ הפריסה שמכיל את היררכיית התצוגה של הסצנה.

הגדרת פריסות לסצנות

קטעי הקוד שבהמשך הקטע הזה מדגימים איך ליצור שתי סצנות שונות עם אותו רכיב בסיס של סצנה. קטעי הקוד גם מדגימים שאפשר לטעון מספר אובייקטים לא קשורים של Scene בלי לרמוז שהם קשורים זה לזה.

הדוגמה כוללת את הגדרות הפריסה הבאות:

• הפריסה הראשית של פעילות עם תווית טקסט ורכיב צאצא FrameLayout.
• ConstraintLayout לסצנה הראשונה עם שני שדות טקסט.
• ConstraintLayout לסצנה השנייה עם אותם שני שדות הטקסט בסדר שונה.

הדוגמה תוכננה כך שכל האנימציה תתבצע בפריסה הראשית של הפעילות (צאצא). תווית הטקסט בפריסה הראשית נשארת סטטית.

הפריסה הראשית של הפעילות מוגדרת באופן הבא:

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>

הגדרת הפריסה הזו מכילה שדה טקסט וצאצא FrameLayout בשביל הרמה הבסיסית של הסצנה. הפריסה של הסצנה הראשונה כלולה בקובץ הפריסה הראשי. כך האפליקציה יכולה להציג אותו כחלק מממשק המשתמש הראשוני וגם לטעון אותו לסצנה, כי המסגרת יכולה לטעון לסצנה רק קובץ פריסה שלם.

הפריסה של הסצנה הראשונה מוגדרת באופן הבא:

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>

הפריסה של הסצנה השנייה מכילה את אותם שני שדות טקסט עם אותם מזהים, בסדר שונה. הוא מוגדר כך:

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>

יצירת סצנות מפריסות

אחרי שיוצרים הגדרות לשני פריסות האילוצים, אפשר לקבל סצנה לכל אחת מהן. כך ניתן לעבור בין שתי ההגדרות של ממשק המשתמש. כדי לקבל סצנה, צריך הפניה לשורש הסצנה ולמזהה המשאב של הפריסה.

בקטע הקוד הבא מוסבר איך לקבל הפניה לשורש הסצנה וליצור שני אובייקטים מסוג Scene מקובצי הפריסה:

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);

עכשיו יש באפליקציה שני אובייקטים מסוג Scene שמבוססים על היררכיות תצוגה. שתי הסצנות משתמשות ברמה הבסיסית (root) של הסצנה שהוגדרה על ידי הרכיב FrameLayout ב-res/layout/activity_main.xml.

יצירת סצנה בקוד

אפשר גם ליצור מופע Scene בקוד מאובייקט ViewGroup. מומלץ להשתמש בשיטה הזו כשמשנים את היררכיות התצוגה ישירות בקוד או יוצרים אותן באופן דינמי.

כדי ליצור סצנה מהיררכיית תצוגה בקוד, משתמשים ב-constructor‏ Scene(sceneRoot, viewHierarchy). קריאה ל-constructor הזה זהה לקריאה לפונקציה Scene.getSceneForLayout() אחרי שכבר הרחבת קובץ פריסה.

קטע הקוד הבא מראה איך יוצרים מופע Scene מהרכיב הבסיסי של הסצנה ומההיררכיה של התצוגה של הסצנה בקוד:

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);

יצירת פעולות בסצנה

המסגרת מאפשרת להגדיר פעולות מותאמות אישית של סצנות שהמערכת מריצה כשנכנסים לסצנה או יוצאים ממנה. במקרים רבים אין צורך להגדיר פעולות מותאמות אישית לסצנות, כי ה-framework מנפש את השינוי בין הסצנות באופן אוטומטי.

פעולות סצנה שימושיות במקרים הבאים:

• כדי להוסיף אנימציה לתצוגות שלא נמצאות באותה היררכיה. אפשר להוסיף אנימציה לתצוגות של הסצנות הראשונה והאחרונה באמצעות פעולות של יציאה וסיום בסצנה.
• כדי ליצור אנימציה לתצוגות שמערכת המסגרות של המעברים לא יכולה ליצור להן אנימציה באופן אוטומטי, כמו אובייקטים מסוג ListView. למידע נוסף, ראו מגבלות.

כדי לספק פעולות מותאמות אישית בסצנה, מגדירים את הפעולות כאובייקטים מסוג Runnable ומעבירים אותן לפונקציות Scene.setExitAction() או Scene.setEnterAction(). המסגרת קוראת לפונקציה setExitAction() בסצנה ההתחלתית לפני הפעלת אנימציית המעבר, ולפונקציה setEnterAction() בסצנה הסופית אחרי הפעלת אנימציית המעבר.

הערה: אין להשתמש בפעולות סצנה כדי להעביר נתונים בין תצוגות בסצנה ההתחלתית ובסצנה הסופית. מידע נוסף זמין בקטע הגדרת קריאות חזרה של מחזור החיים של המעבר.

החלת מעבר

מסגרת המעבר מייצגת את סגנון האנימציה בין סצנות עם אובייקט Transition. אפשר ליצור מופע של Transition באמצעות תתי-כיתות מובנות, כמו AutoTransition ו-Fade, או להגדיר מעבר משלכם. לאחר מכן, תוכלו להריץ את האנימציה בין הסצנות על ידי העברת הערך הסופי Scene ו-Transition אל TransitionManager.go().

מחזור החיים של המעבר דומה למחזור החיים של הפעילות, והוא מייצג את מצבי המעבר שבהם ה-framework עוקב בין ההתחלה של האנימציה לבין הסיום שלה. במצבים חשובים במחזור החיים, המסגרת מפעילה פונקציות קריאה חוזרת (callback) שאפשר להטמיע כדי לשנות את ממשק המשתמש בשלבים שונים של המעבר.

יצירת מעבר

בקטע הקודם הוסבר איך ליצור סצנות שמייצגות את המצב של היררכיות תצוגה שונות. אחרי שמגדירים את הסצנות ההתחלתיות והסצנות הסופיות שרוצים לעבור ביניהן, יוצרים אובייקט Transition שמגדיר אנימציה. באמצעות המסגרת אפשר לציין מעבר מובנה בקובץ משאבים ולהנפיח אותו בקוד, או ליצור מופע של מעבר מובנה ישירות בקוד.

טבלה 1. סוגי מעברים מובנים.

דרגה	תיוג	אפקט
AutoTransition	<autoTransition/>	מעבר ברירת המחדל. המערכת מאטמת את התצוגות, מעבירה אותן, משנה את הגודל שלהן ומאטמת אותן חזרה, לפי הסדר הזה.
ChangeBounds	<changeBounds/>	מעבר בין תצוגות ושינוי הגודל שלהן.
ChangeClipBounds	<changeClipBounds/>	מתעד את View.getClipBounds() לפני ואחרי שינוי הסצנה, ומוסיף אנימציה לשינויים האלה במהלך המעבר.
ChangeImageTransform	<changeImageTransform/>	הפונקציה מתעדת את המטריצה של ImageView לפני ואחרי השינוי של הסצנה, ומפעילה בה אנימציה במהלך המעבר.
ChangeScroll	<changeScroll/>	מתעד את מאפייני הגלילה של היעדים לפני ואחרי השינוי בסצנה, ומוסיף אנימציה לשינויים.
ChangeTransform	<changeTransform/>	מתעד את קנה המידה והרוטציה של התצוגות לפני ואחרי שינוי הסצנה, ומוסיף אנימציה לשינויים האלה במהלך המעבר.
Explode	<explode/>	מעקב אחרי שינויים בחשיפה של תצוגות היעד בסצנות ההתחלה והסיום, והזזת התצוגות לתוך או מחוץ לקצוות הסצנה.
Fade	<fade/>	מספר הצפיות ב-fade_in נעלם. fade_out מטושטש את התצוגות. fade_in_out (ברירת המחדל) מבצע fade_out ואחריו fade_in.
Slide	<slide/>	מעקב אחרי שינויים בחשיפה של תצוגות היעד בסצנות ההתחלה והסיום, והזזת התצוגות פנימה או החוצה מאחד מהקצוות של הסצנה.

יצירת מכונה של מעבר מקובץ משאב

הטכניקה הזו מאפשרת לשנות את הגדרת המעבר בלי לשנות את הקוד של הפעילות. השיטה הזו שימושית גם כדי להפריד בין הגדרות מעבר מורכבות לבין קוד האפליקציה, כפי שמתואר בקטע ציון מספר מעברים.

כדי לציין מעבר מובנה בקובץ משאבים:

• מוסיפים את הספרייה res/transition/ לפרויקט.
• יוצרים קובץ משאב XML חדש בספרייה הזו.
• מוסיפים צומת XML לאחד המעברים המובנים.

לדוגמה, קובץ המשאבים הבא מציין את המעבר ל-Fade:

res/transition/fade_transition.xml

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

קטע הקוד הבא מראה איך לנפח מופע של Transition בתוך הפעילות מקובץ משאבים:

Kotlin

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

Java

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

יצירת מכונה של מעבר בקוד

הטכניקה הזו שימושית ליצירת אובייקטים של מעברים באופן דינמי אם משנים את ממשק המשתמש בקוד, וגם ליצירת מופעים פשוטים של מעברים מובנים עם מעט פרמטרים או ללא פרמטרים בכלל.

כדי ליצור מכונה של מעבר מובנה, צריך להפעיל את אחד מהבנאים הציבוריים במחלקות המשנה של המחלקה Transition. לדוגמה, קטע הקוד הבא יוצר מכונה של המעבר Fade:

Kotlin

var fadeTransition: Transition = Fade()

Java

Transition fadeTransition = new Fade();

החלת מעבר

בדרך כלל מחילים מעבר כדי לעבור בין היררכיות תצוגה שונות בתגובה לאירוע, כמו פעולת משתמש. לדוגמה, נניח שאפליקציית חיפוש: כשהמשתמש מזין מונח חיפוש ומקיש על לחצן החיפוש, האפליקציה עוברת לסצנה שמייצגת את פריסת התוצאות, תוך החלת מעבר שמטשטש את לחצן החיפוש ומחדיר את תוצאות החיפוש.

כדי לבצע שינוי סצנה תוך החלת מעבר בתגובה לאירוע בפעילות, צריך לקרוא לפונקציה של הכיתה TransitionManager.go() עם הסצנה הסופית ומכונה של המעבר לשימוש באנימציה, כפי שמתואר בקטע הקוד הבא:

Kotlin

TransitionManager.go(endingScene, fadeTransition)

Java

TransitionManager.go(endingScene, fadeTransition);

המסגרת מחליפה את היררכיית התצוגה בתוך שורש הסצנה באותה היררכיה מהסצנה הסופית, בזמן ההפעלה של האנימציה שצוינה על ידי מופע המעבר. הסצנה ההתחלתית היא הסצנה הסופית מהמעבר האחרון. אם אין מעבר קודם, סצנת ההתחלה נקבעת באופן אוטומטי מהמצב הנוכחי של ממשק המשתמש.

אם לא מציינים מופע של מעבר, מנהל המעבר יכול להחיל מעבר אוטומטי שמבצע פעולה סבירה ברוב המצבים. למידע נוסף, ראו הפניית ה-API של הכיתה TransitionManager.

בחירה של תצוגות ספציפיות של יעדים

כברירת מחדל, המסגרת מחילה מעברים על כל התצוגות בסצנה ההתחלתית ובסצנה הסופית. במקרים מסוימים, יכול להיות שתרצו להחיל אנימציה רק על קבוצת משנה של תצוגות בסצנה. ה-framework מאפשר לבחור תצוגות ספציפיות שרוצים להוסיף להן אנימציה. לדוגמה, המסגרת לא תומכת בהוספת אנימציה לשינויים באובייקטים מסוג ListView, לכן אל תנסו להוסיף להם אנימציה במהלך מעבר.

כל תצוגה שהאנימציה של המעבר מפעילה נקראת יעד. אפשר לבחור רק יעדים שהם חלק מהיררכיית התצוגות שמשויכת לסצנה.

כדי להסיר תצוגה אחת או יותר מרשימת היעדים, צריך לבצע קריאה ל-method removeTarget() לפני שמתחילים את המעבר. כדי להוסיף לרשימת היעדים רק את התצוגות המפורטות שציינתם, מפעילים את הפונקציה addTarget(). למידע נוסף, עיינו במסמכי העזרה של ה-API לגבי הכיתה Transition.

ציון כמה מעברים

כדי להפיק את המקסימום מהאנימציה, כדאי להתאים אותה לסוג השינויים שמתרחשים בין הסצנות. לדוגמה, אם אתם מסירים תצוגות מסוימות ומוסיפים תצוגות אחרות בין הסצנות, האפקט עמעום או הדרגתי באנימציה יכול להצביע על כך שחלק מהתצוגות כבר לא זמינות. אם מזיזים את הצפיות בנקודות שונות במסך, עדיף להנפיש את התנועה כדי שהמשתמשים יבחינו במיקום החדש של התצוגות.

אתם לא צריכים לבחור רק אנימציה אחת, כי מסגרת המעברים מאפשרת לשלב אפקטים של אנימציה בקבוצת מעברים שמכילה קבוצה של מעברים מובנים או מותאמים אישית.

כדי להגדיר קבוצת מעברים מתוך אוסף של מעברים ב-XML, יוצרים קובץ משאבים בספרייה res/transitions/ ומפרטים את המעברים מתחת לאלמנט TransitionSet. לדוגמה, קטע הקוד הבא מראה איך לציין קבוצת מעברים שיש לה את אותה התנהגות כמו של הכיתה AutoTransition:

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

כדי להנפיח את קבוצת המעברים לאובייקט TransitionSet בקוד, צריך להפעיל את הפונקציה TransitionInflater.from() בפעילות. הכיתה TransitionSet היא תת-כיתה של הכיתה Transition, כך שאפשר להשתמש בה עם מנהל המעבר בדיוק כמו בכל מופע אחר של Transition.

החלת מעבר בלי סצנות

שינוי היררכיות התצוגה הוא לא הדרך היחידה לשנות את ממשק המשתמש. אפשר גם לבצע שינויים על ידי הוספה, שינוי והסרה של תצוגות צאצא בהיררכיה הנוכחית.

לדוגמה, אפשר להטמיע אינטראקציה של חיפוש עם פריסה אחת. התחילו בפריסה שמוצגים בה שדה להזנת חיפוש וסמל חיפוש. כדי לשנות את ממשק המשתמש ולהציג את התוצאות, מסירים את לחצן החיפוש כשהמשתמש מקיש עליו באמצעות קריאה לפונקציה ViewGroup.removeView(), ומוסיפים את תוצאות החיפוש באמצעות קריאה לפונקציה ViewGroup.addView().

אפשר להשתמש בגישה הזו אם האפשרות החלופית היא שתי היררכיות כמעט זהות. במקום ליצור ולתחזק שני קובצי פריסה נפרדים בגלל הבדל קטן בממשק המשתמש, אפשר להשתמש בקובץ פריסה אחד שמכיל היררכיית תצוגות שאפשר לשנות בקוד.

אם מבצעים שינויים בתוך היררכיית התצוגה הנוכחית באופן הזה, אין צורך ליצור סצנה. במקום זאת, אפשר ליצור ולהחיל מעבר בין שני מצבים של היררכיית תצוגות באמצעות מעבר מתעכב. התכונה הזו של מסגרת המעברים מתחילה במצב הנוכחי של היררכיית התצוגות, מתעדת את השינויים שתבצעו בתצוגות ומחילה מעבר שמציג את השינויים באנימציה כשהמערכת מצייר מחדש את ממשק המשתמש.

כדי ליצור מעבר מושהה בהיררכיית תצוגה אחת:

1. כשמתרחש האירוע שמפעיל את המעבר, מפעילים את הפונקציה TransitionManager.beginDelayedTransition(), כדי לספק את תצוגת ההורה של כל התצוגות שרוצים לשנות ואת המעבר לשימוש. המסגרת שומרת את המצב הנוכחי של תצוגות הצאצאים ואת ערכי הנכסים שלהן.
2. מבצעים שינויים בתצוגות הצאצא בהתאם לתרחיש לדוגמה. המסגרת מתעדת את השינויים שתבצעו בתצוגות הצאצא ובמאפיינים שלהן.
3. כשהמערכת מצייר מחדש את ממשק המשתמש בהתאם לשינויים, המערכת מפעילה אנימציה של השינויים בין המצב המקורי למצב החדש.

בדוגמה הבאה מוסבר איך להוסיף אנימציה להוספת תצוגת טקסט להיררכיית תצוגות באמצעות מעבר עם עיכוב. קטע הקוד הראשון מציג את קובץ הגדרת הפריסה:

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>

בקטע הקוד הבא מוצג הקוד שמוסיף את תצוגת הטקסט באמצעות אנימציה:

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.

הגדרת קריאות חוזרות (callback) של מחזור החיים של מעבר

מחזור החיים של המעבר דומה למחזור החיים של הפעילות. הוא מייצג את מצבי המעבר שהמסגרת עוקבת אחריהם במהלך התקופה שבין קריאה לפונקציה TransitionManager.go() לבין השלמת האנימציה. במצבים חשובים במחזור החיים, המסגרת מפעילה קריאות חזרה (callbacks) שמוגדרות על ידי הממשק TransitionListener.

קריאות חזרה בזמן מחזור החיים של המעבר שימושיות, למשל, להעתקת ערך של מאפיין תצוגה מההיררכיה של התצוגה ההתחלתית להיררכיה של התצוגה הסופית במהלך שינוי סצנה. אי אפשר פשוט להעתיק את הערך מהתצוגה ההתחלתית שלו לתצוגה בהיררכיית התצוגה הסופית, כי היררכיית התצוגה הסופית לא מתנפחת עד שהמעבר מסתיים. במקום זאת, צריך לאחסן את הערך במשתנה ולאחר מכן להעתיק אותו להיררכיית התצוגה הסופית כשהמסגרת תסיים את המעבר. כדי לקבל התראה כשההעברה תסתיים, צריך להטמיע את הפונקציה TransitionListener.onTransitionEnd() בפעילות.

למידע נוסף, עיינו במסמכי העזרה של ה-API לגבי הכיתה TransitionListener.

מגבלות

בקטע הזה מפורטות כמה מהמגבלות הידועות של מסגרת המעברים:

• יכול להיות שאנימציות שיוחלו על SurfaceView לא יופיעו בצורה תקינה. המופעים של SurfaceView מתעדכנים משרשור שאינו בממשק המשתמש, ולכן יכול להיות שהעדכונים לא יהיו מסונכרנים עם האנימציות של תצוגות אחרות.
• יכול להיות שסוגים מסוימים של מעברים לא ייצרו את אפקט האנימציה הרצוי כשהם יוחלו על TextureView.
• כיתות שמרחיבות את AdapterView, כמו ListView, מנהלות את תצוגות הצאצאים שלהן בדרכים שלא תואמות למסגרת המעברים. אם תנסו להוסיף אנימציה לתצוגה על סמך AdapterView, יכול להיות שהמסך של המכשיר יפסיק להגיב.
• אם תנסו לשנות את הגודל של TextView עם אנימציה, הטקסט יופיע במיקום חדש לפני שהגודל של האובייקט ישתנה לגמרי. כדי למנוע את הבעיה הזו, לא כדאי להוסיף אנימציה לשינוי הגודל של תצוגות שמכילות טקסט.