בחירת ספריות בחוכמה

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

טיפים כלליים לבחירת ספריות

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

העדפת codegen על פני השתקפות

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

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

בדיקה אם נעשה שימוש ברפלקציה (מתקדם)

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

  • משתמשת במחלקות או ב-methods מהחבילות kotlin.reflect או java.lang.reflect.
  • משתמש בפונקציות Class.forName או classLoader.getClass.
  • קורא הערות בזמן ריצה, למשל אם הוא מאחסן ערך של הערה באמצעות val value = myClass.getAnnotation() או val value = myMethod.getAnnotation() ואז עושה משהו עם value.
  • מפעילה שיטות באמצעות שם השיטה כמחרוזת, כמו בדוגמה הבאה:

    // Calls the private `processData` API with reflection
    myObject.javaClass.getMethod("processData", DataType::class.java)
    ?.invoke(myObject, data)
    

בדיקת בעיות באופטימיזציה

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

  • ספריות AndroidX וספריות כמו Hilt פועלות היטב עם אופטימיזציה של אפליקציות, כי הן משתמשות בעיקר ב-codegen במקום ב-reflection. כשהם משתמשים ברפלקציה, הם מספקים כללי שמירה מינימליים כדי לשמור רק את הקוד שצריך.
  • ספריות סריאליזציה משתמשות לעיתים קרובות ב-reflection כדי להימנע מקוד שחוזר על עצמו (boilerplate) כשיוצרים מופעים של אובייקטים או מבצעים סריאליזציה שלהם. במקום גישות שמבוססות על reflection (כמו Gson ל-JSON), כדאי לחפש ספריות שמשתמשות ב-codegen כדי להימנע מהבעיות האלה, למשל באמצעות Kotlin Serialization או Moshi עם codegen.
  • אם אפשר, כדאי להימנע מספריות שכוללות כללי שמירה שחלים על כל החבילה. כללי שמירה שחלים על כל החבילה יכולים לעזור לפתור שגיאות, אבל בסופו של דבר צריך לצמצם את כללי השמירה הרחבים כדי לשמור רק את הקוד שצריך. מידע נוסף זמין במאמר הטמעת אופטימיזציות באופן הדרגתי.
  • לפני שמפרסמים אפליקציה שמשתמשת בספרייה של צד שלישי, צריך להשתמש ב-R8 Configuration Analyzer כדי לבדוק את כללי השמירה שהיא מספקת. בעזרת הדוח, אתם יכולים לבדוק אם כללי השמירה של הספרייה רחבים מדי, ומונעים מ-R8 לבצע אופטימיזציות קריטיות בבסיס הקוד. הבדיקה הזו נועדה לוודא שהספריות שבחרתם תואמות ליעדי הביצועים של האפליקציה, ולא מוסיפות נפח מיותר להגדרות האישיות.
  • ספריות לא אמורות לדרוש מכם להעתיק ולהדביק כללי שמירה מהתיעוד לקובץ בפרויקט, במיוחד לא כללי שמירה שחלים על כל החבילה. בטווח הארוך, הכללים האלה הופכים לנטל תחזוקה על מפתח האפליקציה, וקשה לבצע בהם אופטימיזציה ושינויים לאורך זמן.

הפעלת אופטימיזציה אחרי הוספת ספרייה חדשה

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

סינון כללי שמירה לא תקינים (מתקדם)

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

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

// If you're using AGP 8.4 and higher
buildTypes {
    release {
        optimization.keepRules {
          it.ignoreFrom("com.somelibrary:somelibrary")
        }
    }
}

// If you're using AGP 7.3-8.3
buildTypes {
    release {
        optimization.keepRules {
          it.ignoreExternalDependencies("com.somelibrary:somelibrary")
        }
    }
}

תהליך העבודה המומלץ לכללי ספרייה רחבים

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

  1. עדכון הספרייה: ודאו שאתם משתמשים בגרסה העדכנית ביותר של הספרייה שסומנה על ידי R8 Configuration Analyzer, כי יכול להיות שבגרסאות חדשות יותר יש כללי שמירה צרים יותר של הצרכן. כדי למצוא את הגרסה העדכנית, בודקים את מסמכי התיעוד של הספרייה או את מאגר Maven שלה. בנוסף, Android Studio מסמן גרסאות חדשות יותר של יחסי תלות רבים. אחרי העדכון, מריצים שוב את R8 Configuration Analyzer כדי לבדוק אם כללי השמירה הרחבים עדיין קיימים.
  2. בודקים את השיפור הפוטנציאלי באופן מקומי: מעתיקים את כללי הצרכן המקובצים של הספרייה לקובץ כללי השמירה המקומי, מסננים את הכללים המקובצים כפי שמוצג בקטע סינון כללי שמירה לא תקינים ומצמצמים את הכללים שהועתקו. מריצים את הכלי לניתוח ההגדרות של R8 לפני ואחרי צמצום הכללים כדי להשוות את הציונים של האפליקציה בכיווץ, באופטימיזציה ובהסתרת קוד.
  3. דיווח על הממצאים: שולחים דוח על באג למנהל הספרייה, שכולל את הנתונים האמפיריים מהדוח של R8 Configuration Analyzer (לדוגמה, הצגת המספר הספציפי של המחלקות או השיטות ללא הפניות שנשמרו על ידי כלל התווים הכלליים לחיפוש).

מקרה לדוגמה: למה Gson לא פועל עם אופטימיזציות

‫Gson היא ספריית סריאליזציה שלעיתים קרובות גורמת לבעיות באופטימיזציה של האפליקציה, כי היא משתמשת ב-reflection בהיקף נרחב. בקטע הקוד הבא אפשר לראות איך משתמשים ב-Gson בדרך כלל, מה שעלול לגרום לקריסות בזמן הריצה. שימו לב שכאשר משתמשים ב-Gson כדי לקבל רשימה של אובייקטים של משתמשים, לא קוראים ל-constructor או מעבירים מפעל לפונקציה fromJson(). אם בונים או צורכים מחלקות שמוגדרות באפליקציה בלי אף אחד מהדברים הבאים, זה סימן לכך שספרייה עשויה להשתמש ברפלקציה פתוחה:

  • מחלקה של אפליקציה שמטמיעה ספרייה, או ממשק או מחלקה סטנדרטיים
  • פלאגין ליצירת קוד כמו KSP
class User(val name: String)
class UserList(val users: List<User>)

// This code runs in debug mode, but crashes when optimizations are enabled
Gson().fromJson("""[{"name":"myname"}]""", User::class.java).toString()

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

שימוש ב-@SerializedName עם גרסאות Gson מאוחרות יותר

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

import com.google.gson.annotations.SerializedName

class User(@SerializedName("name") val name: String)
class UserList(@SerializedName("users") val users: List<User>)

השימוש בהערה @SerializedName מאפשר ל-R8 להתאים את מחלקות המודלים לכללי השמירה שמצורפים ל-Gson בגרסה 2.11.0 ואילך. ‫R8 שומר באופן אוטומטי את השדות עם ההערות ואת ה-constructors הנדרשים, כך שאתם יכולים להסתמך על הכללים שמצורפים לספרייה בלי שתצטרכו לתחזק הגדרות ProGuard ידניות בפרויקט.

שימו לב ש-Room,‏ Hilt ו-Moshi עם codegen יוצרים סוגים שמוגדרים על ידי האפליקציה, אבל משתמשים ב-codegen כדי להימנע מהצורך ברפלקציה.