כיצד לייעל קוד ומשאבים עם R8 באפליקציות אנדרואיד שלך

העדכון אחרון: 18 נובמבר 2026
מחבר: TecnoDigital
  • R8 מסיר קוד ומשאבים שאף אחד לא משתמש בהם, כותב מחדש את השאר ומקצר שמות כדי ליצור אפליקציות קטנות יותר עם זמני הפעלה מהירים יותר ופחות בעיות של חוסר תגובה.
  • מומלץ לאפשר אופטימיזציה בבניית הגרסה ולהתאים את כללי השימור, שהם המכשול העיקרי המונע מ-R8 לפעול במלוא הפוטנציאל.
  • מנתח התצורה של R8 מודד כמה קוד זמין לצמצום, אופטימיזציה וטשטוש, ומסמן כללים רחבים, כפולים או חסרי תועלת.
  • השלמת המשימה באמצעות App Bundles, תמונות קלות משקל, התאמות שפה וצפיפות ומדידת גודל קבועה יוצרת הבדל משמעותי במהירות ההורדה.

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

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

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

מה בדיוק עושה R8 ולמה כדאי לסמוך עליו?

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

R8 פועל בסדרה של שלבים מקושרים. ראשית, הוא מנתח את נקודות הכניסה בפועל, כגון הפעילויות או השירותים המוצהרים במניפסט, בונה מפה של כל מה שאליו מתייחסים, וזורק כל דבר מחוץ למפה זו . לאחר מכן, הוא עובר לאופטימיזציות לוגיות: החלפת קריאות בגוף המתודה הנקראת, מיזוג מחלקות וממשקים, פישוט מבנים והפחתת תקורת הביצוע. לבסוף, הוא מקצר את שמות המחלקות, השדות והמתודות, כך שמשהו כמו com.example.MyActivity יכול להיקרא בסופו של דבר aba, עם חיסכון כתוצאה מכך במטא-דאטה.

  • פחות קוד מתתלויות שאתה משתמש בהן רק באחוז קטן מפסיקות לשאת את כל משקלן.
  • ביצוע יעיל יותרהוספת מתודות ומיזוג מחלקות מפחיתות קריאות ועומס על הזיכרון.
  • קבצי DEX קלים יותרערפול שומר מטא-דאטה ומאיץ את טעינת המחלקה.
  • משאבים מותאמיםמאז גרסה 8.12 של תוסף Gradle, R8 משתתף גם באופטימיזציה של משאבים.

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

הפעל אופטימיזציה בהתבסס על גרסת התוסף Gradle

אם אתם עובדים עם גרסאות עדכניות של תוסף האנדרואיד עבור Gradle, הדברים פושטו מאוד. פשוט הפעילו דגל יחיד בתוך בלוק האופטימיזציה של סוג הבנייה של הגרסה והציבו את כללי ה-keep שלכם בקבוצת קוד מקור ספציפית, עם קבצים המסתיימים ב-.keep, לדוגמה, בתוך src/main/keepRules. גישה חדשה זו כוללת גם קוד וגם משאבים וכוללת כללי פלטפורמה ברירת מחדל המקבילים לכללי ProGuard ההיסטוריים עם אופטימיזציה, כך שאין צורך להצהיר על קבצים נוספים.

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

מצב מלא וצמצום משאבים אופטימלי

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

  Moment.js: הסבר מלא ודוגמאות מעשיות של ספריית התאריכים

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

מנתח התצורה של R8 ושלושת הציונים שלו

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

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

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

כיצד להפיק את הדוח מבלי לבזבז זמן

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

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

שפר את כללי השימור מבלי לשבור את האפליקציה

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

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

חוקים כפולים, חוקים שאינם בשימוש וחוקים בספרייה

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

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

  המדריך המלא לשפת הדוגמנות המאוחדת UML

ProGuard ו-R8: דומים, אך לא זהים

במשך שנים, ProGuard עשתה ארבעה דברים: היא הסירה אלמנטים שאינם בשימוש, ביצעה אופטימיזציה של קוד בייט, ערפלה שמות והוסיפה מידע לבדיקה מוקדמת. R8 ממשיכה מהנקודה בה הפסיקה ודוחפת קדימה: היא מוסיפה מתודות בצורה אגרסיבית יותר, משלבת מחלקות, ממירה ספירות למספרים שלמים במידת האפשר, ויש לה הבנה טובה יותר של התכונות של Kotlin . היא גם מבצעת קומפילציה מהירה יותר, ועם הפחתת המתיקות של ספריית הליבה, מאפשרת שימוש ב-APIs מודרניים של Java בגרסאות ישנות יותר של אנדרואיד.

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

טעויות אופייניות בעת מזעור וכיצד לצאת מהתקלה

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

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

צמצום משאבים: תמונות, צפיפות ושפות

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

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

פריסות, סגנונות והיררכיות של תצוגות

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

חבילות אפליקציות, מודולים דינמיים וספריות מקוריות

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

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

מדוד את הגודל ועקוב אחר ההתפתחות

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

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

כיצד השתנתה ההתנהגות בין הגרסאות?

כדאי לבחון את האבולוציה האחרונה משום שהיא מסבירה תצורות מדור קודם רבות שאינן רלוונטיות עוד. גרסה 8.0 אפשרה מצב מלא כברירת מחדל ; 8.6 שיפרה את המעקב מחדש, כולל מעקב מחדש אחר קבצים ושורות עבור כל minSdk; 8.12 הציגה אופטימיזציה של צמצום משאבים ומעקב מחדש אוטומטי ב-Logcat; 9.0 אפשרה זאת כברירת מחדל, סיננה אפשרויות גלובליות בכללי הצרכן, ואופטימיזציה של בדיקת null ב-Kotlin; 9.1 ארזה מחדש את המחלקות כברירת מחדל; ו-9.3 הציגה את בלוק האופטימיזציה הפשוט ואת מערך הכללים .keep.

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

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

TecnoDigital

TecnoDigital

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

שאלות נפוצות

מה בדיוק R8 עושה עם קוד האפליקציה שלי?

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

כיצד ניתן להפעיל אופטימיזציה של R8 בגרסאות האחרונות של תוסף Gradle?

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

מה ההבדל בין צמצום קוד לצמצום משאבים?

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

למה משמש מנתח התצורה R8?

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

מדוע כלל שימור רחב פוגע בביצועי האפליקציה שלי?

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

האם עדיף לפרסם עם App Bundles במקום APK אוניברסלי?

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

כיצד ניתן לקרוא מעקב מחסנית (stack trace) מבנייה מעורפלת?

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

האם כדאי לבצע אופטימיזציה של ספרייה שאני הולך לפרסם?

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