היררכיות של ביצועים וצפיות

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

הדף הזה מתמקד בשיפור פריסות שמבוססות על View. למידע על שיפור הביצועים של Jetpack Compose, אפשר לעיין במאמר ביצועים של Jetpack Compose.

ביצועי הפריסה והמדידה

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

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

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

אי אפשר להעביר את הפעולות האלה ל-Thread עובד, והאפליקציה חייבת לעבד אותן ב-Thread הראשי. לכן, מומלץ לבצע אופטימיזציה שלהן כדי שהן יקחו כמה שפחות זמן.

ניהול פריסות מורכבות

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

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

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

מומלץ להשתמש ב-Layout Editor כדי ליצור ConstraintLayout, במקום RelativeLayout או LinearLayout, כי בדרך כלל הוא יעיל יותר ומפחית את ההטמעה של פריסות. עם זאת, לפריסות פשוטות שאפשר ליצור באמצעות FrameLayout, מומלץ להשתמש ב-FrameLayout.

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

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

מיסוי כפול

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

לדוגמה, כשמשתמשים בקונטיינר RelativeLayout, שמאפשר למקם אובייקטים מסוג View ביחס למיקומים של אובייקטים אחרים מסוג View, ה-framework מבצעת את הרצף הבא:

  1. מבצע מעבר של פריסה ומדידה, שבמהלכו ה-framework מחשב את המיקום והגודל של כל אובייקט צאצא, על סמך הבקשה של כל צאצא.
  2. ‫Google משתמשת בנתונים האלה, תוך התחשבות במשקלי האובייקטים, כדי להבין את המיקום הנכון של תצוגות קשורות.
  3. מבצעת מעבר פריסה שני כדי לקבוע את המיקומים הסופיים של האובייקטים.
  4. מעבר לשלב הבא בתהליך הרינדור.

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

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

גם מאגרים שאינם RelativeLayout עשויים להגדיל את המיסוי הכפול. לדוגמה:

  • תצוגת LinearLayout יכולה לגרום למעבר כפול של פריסה ומדידה אם הופכים אותה לאופקית. יכול להיות שיתבצע מעבר כפול של פריסה ומדידה גם בכיוון אנכי אם תוסיפו את measureWithLargestChild, ובמקרה כזה יכול להיות שה-framework יצטרך לבצע מעבר שני כדי לפתור את הגדלים המתאימים של האובייקטים.
  • גם GridLayout מאפשר מיקום יחסי, אבל בדרך כלל הוא מונע מיסוי כפול על ידי עיבוד מראש של היחסים בין המיקומים של תצוגות הצאצא. עם זאת, אם הפריסה משתמשת במשקלים או במילוי עם המחלקה Gravity, היתרון של העיבוד המקדים אובד, ויכול להיות שה-framework יצטרך לבצע כמה מעברים אם מאגר התגים הוא RelativeLayout.

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

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

אבחון בעיות בהיררכיית התצוגות

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

Perfetto

‫Perfetto הוא כלי שמספק נתונים על ביצועים. אתם יכולים לפתוח מעקבים של Android בממשק המשתמש של Perfetto.

עיבוד פרופיל ב-GPU

הכלי עיבוד GPU של פרופיל במכשיר, שזמין במכשירים עם Android מגרסה 6.0 (רמת API‏ 23) ואילך, יכול לספק לכם מידע קונקרטי על צווארי בקבוק בביצועים. הכלי הזה מאפשר לראות כמה זמן נמשך שלב הפריסה והמדידה בכל פריים של עיבוד. הנתונים האלה יכולים לעזור לכם לאבחן בעיות בביצועים בזמן הריצה, ולקבוע אילו בעיות בפריסה ובמדידה צריך לפתור.

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

Lint

הכלי Lint של Android Studio יכול לעזור לכם לזהות חוסר יעילות בהיררכיית התצוגות. כדי להשתמש בכלי הזה, בוחרים באפשרות Analyze > Inspect Code, כמו שמוצג באיור 1.

איור 1. בוחרים באפשרות Inspect Code (בדיקת הקוד) ב-Android Studio.

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

איור 2. הצגת מידע על בעיות ספציפיות שכלי ה-Lint מזהה.

לחיצה על פריט חושפת בעיות שקשורות לפריט הזה בחלונית שמשמאל.

למידע נוסף על נושאים ובעיות ספציפיים בתחום הזה, עיינו במסמכי התיעוד של Lint.

Layout Inspector

הכלי Layout Inspector ב-Android Studio מספק ייצוג חזותי של היררכיית התצוגות באפליקציה. זו דרך טובה לנווט בהיררכיה של האפליקציה, לקבל ייצוג חזותי ברור של שרשרת ההורה של תצוגה מסוימת ולבדוק את הפריסות שהאפליקציה יוצרת.

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

מידע נוסף זמין במאמר ניפוי באגים בפריסה באמצעות Layout Inspector ו-ולידציית פריסה.

פתרון בעיות בהיררכיית התצוגות

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

הסרת פריסות מיותרות שמוטמעות בתוך פריסות אחרות

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

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

אימוץ, מיזוג או הכללה

סיבה נפוצה לפריסות מקוננות מיותרות היא התג <include>. לדוגמה, אפשר להגדיר פריסה לשימוש חוזר באופן הבא:

<LinearLayout>
    <!-- some stuff here -->
</LinearLayout>

אחר כך אפשר להוסיף תג <include> כדי להוסיף את הפריט הבא למאגר ההורה:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/app_bg"
    android:gravity="center_horizontal">

    <include layout="@layout/titlebar"/>

    <TextView android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:text="@string/hello"
              android:padding="10dp" />

    ...

</LinearLayout>

ההכללה הקודמת מקננת שלא לצורך את הפריסה הראשונה בתוך הפריסה השנייה.

התג <merge> יכול לעזור למנוע את הבעיה הזו. מידע נוסף על התג הזה זמין במאמר שימוש בתג <merge>.

שימוש בפריסה זולה יותר

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

לדוגמה, יכול להיות שתגלו ש-TableLayout מספק את אותה פונקציונליות כמו פריסה מורכבת יותר עם הרבה תלויות מיקום. ספריית Jetpack ConstraintLayout מספקת פונקציונליות דומה ל-RelativeLayout, וגם תכונות נוספות שעוזרות ליצור פריסות שטוחות ויעילות יותר.