גרסאות ישנות יותר

בהמשך מפורטות הערות על הגרסאות של Android Studio 3.6 ומטה, ושל הפלאגין Android Gradle 3.6.0 ומטה.

גרסאות ישנות יותר של Android Studio

‫3.6 (פברואר 2020)

‫Android Studio 3.6 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

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

‫3.6.3 (אפריל 2020)

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

‫3.6.2 (מרץ 2020)

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

3.6.1 (פברואר 2020)

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

כלי עיצוב

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

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

הגרסה הזו כוללת את העדכונים הבאים בכלי העריכה של העיצוב החזותי:

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

  • כדי להפעיל את התצוגה המפוצלת, לוחצים על סמל הפיצול .
  • כדי להפעיל את תצוגת מקור ה-XML, לוחצים על סמל המקור .
  • כדי להפעיל את תצוגת העיצוב, לוחצים על סמל העיצוב .

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

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

הכרטיסייה 'משאבים' בכלי לבחירת צבעים

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

Resource Manager

העדכונים הבאים בוצעו ב-Resource Manager:

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

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

עדכונים בפלאגין של Android Gradle

הגרסה העדכנית של Android Gradle plugin כוללת הרבה עדכונים, כולל אופטימיזציות למהירות הבנייה, תמיכה ב-Maven publishing plugin ותמיכה ב-View Binding. מידע נוסף זמין בהערות המוצר המלאות.

הצגת הקישור

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

החלפת findViewById() באמצעות view binding מבטלת את הסיכון לחריגות של מצביע null כתוצאה ממזהה תצוגה לא תקין.

כדי להפעיל את view binding, צריך להשתמש ב-Android Gradle plugin בגרסה 3.6.0 ואילך, ולכלול את הקוד הבא בקובץ build.gradle של כל מודול:

Groovy

  android {
      buildFeatures.viewBinding = true
  }
  

Kotlin

  android {
      buildFeatures.viewBinding = true
  }
  

החלת השינויים

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

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

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

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

1. פותחים את החלונית Project (פרויקט) על ידי בחירה באפשרות View > Tool Windows > Project (תצוגה > חלונות כלים > פרויקט) בסרגל התפריטים.
2. לוחצים לחיצה ימנית על מודול הבסיס, שבדרך כלל נקרא app, ובוחרים באפשרות Refactor > Enable Instant Apps Support (שינוי מבנה > הפעלת תמיכה באפליקציות מיידיות).
3. בתיבת הדו-שיח שמופיעה, בוחרים את מודול הבסיס מהתפריט הנפתח.
4. לוחצים על אישור.

הערה: האפשרות להפעיל באופן מיידי את מודול אפליקציית הבסיס מתוך האשף Create New Project (יצירת פרויקט חדש) הוסרה.

מידע נוסף זמין במאמר סקירה כללית של Google Play ללא התקנה.

ביטול ההסתרה של קוד בייט של מחלקה ושיטה בכלי לניתוח APK

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

1. בסרגל התפריטים, בוחרים באפשרות Build > Analyze APK (גרסה > ניתוח APK).
2. בתיבת הדו-שיח שמופיעה, עוברים אל קובץ ה-APK שרוצים לבדוק ובוחרים אותו.
3. לוחצים על פתיחה.
4. ב-APK Analyzer, בוחרים את קובץ ה-DEX שרוצים לבדוק.
5. בכלי לצפייה בקובץ DEX, טוענים את קובץ המיפוי של ProGuard עבור קובץ ה-APK שמנתחים.
6. לוחצים לחיצה ימנית על הכיתה או על השיטה שרוצים לבדוק ובוחרים באפשרות הצגת קוד בייט.

כלים מקוריים

העדכונים הבאים תומכים בפיתוח מותאם (C/C++) ב-Android Studio.

תמיכה ב-Kotlin

התכונות הבאות של NDK ב-Android Studio, שנתמכו בעבר ב-Java, נתמכות עכשיו גם ב-Kotlin:

• אפשר לעבור מהצהרת JNI לפונקציית ההטמעה המתאימה ב-C/C++. כדי לראות את המיפוי הזה, מעבירים את העכבר מעל סמן הפריט C או C++ ליד מספר השורה בקובץ קוד המקור המנוהל.

• יצירה אוטומטית של פונקציית הטמעה של הצהרת JNI. קודם מגדירים את הצהרת ה-JNI ואז מקלידים 'jni' או את שם השיטה בקובץ C/C++ כדי להפעיל אותה.

  

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

• כשמשנים את השם (מבצעים רפקטורינג) של פונקציית הטמעה מקורית, כל הצהרות ה-JNI התואמות מתעדכנות. משנים את השם של הצהרת JNI כדי לעדכן את פונקציית ההטמעה המקורית.

• בדיקת חתימה להטמעות JNI שקשורות באופן מרומז.

שיפורים אחרים ב-JNI

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

טעינה מחדש של APK לספריות Native‏ {:#3.6-reload-apk}

כבר לא צריך ליצור פרויקט חדש כשהקובץ APK בפרויקט מתעדכן מחוץ לסביבת הפיתוח המשולבת (IDE). ‫Android Studio מזהה שינויים ב-APK ומציע לכם לייבא אותו מחדש.

צירוף מקורות של קובצי APK ב-Kotlin בלבד

עכשיו אפשר לצרף מקורות חיצוניים של חבילות APK שמבוססות על Kotlin בלבד כשמבצעים פרופיל ובאגים של חבילות APK מוכנות מראש. מידע נוסף זמין במאמר בנושא צירוף מקורות Kotlin/Java.

זיהוי דליפות בכלי לניתוח ביצועי הזיכרון

כשמנתחים dump של heap בכלי Memory Profiler, אפשר עכשיו לסנן נתוני פרופילים שאולי מצביעים על דליפות זיכרון במופעים של Activity ושל Fragment באפליקציה.

סוגי הנתונים שמוצגים במסנן כוללים את הנתונים הבאים:

• מופעים של Activity שהושמדו אבל עדיין יש הפניה אליהם.
• Fragment מקרים שבהם אין FragmentManager תקף, אבל עדיין יש הפניה אליו.

צירוף מקורות של קובצי APK ב-Kotlin בלבד

עכשיו אפשר לצרף מקורות חיצוניים של חבילות APK שמבוססות על Kotlin בלבד כשמבצעים פרופיל ובאגים של חבילות APK מוכנות מראש. מידע נוסף זמין במאמר בנושא צירוף מקורות Kotlin/Java.

זיהוי דליפות בכלי לניתוח ביצועי הזיכרון

כשמנתחים dump של heap בכלי Memory Profiler, אפשר עכשיו לסנן נתוני פרופילים שאולי מצביעים על דליפות זיכרון במופעים של Activity ושל Fragment באפליקציה.

סוגי הנתונים שמוצגים במסנן כוללים את הנתונים הבאים:

• מופעים של Activity שהושמדו אבל עדיין יש הפניה אליהם.
• Fragment מקרים שבהם אין FragmentManager תקין, אבל עדיין יש הפניה אליו.

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

• נוצר Fragment אבל עדיין לא נעשה בו שימוש.
• מתבצעת שמירה במטמון של Fragment אבל לא כחלק מFragmentTransaction.

כדי להשתמש בתכונה הזו, קודם צריך ליצור קובץ heap dump או לייבא קובץ heap dump אל Android Studio. כדי להציג את הפעילויות והקטעים שעשויים לגרום לדליפת זיכרון, מסמנים את תיבת הסימון Activity/Fragment Leaks בחלונית heap dump של הכלי Memory Profiler.

סינון של dump ערימה כדי למצוא דליפות זיכרון.

אמולטורים

‫Android Studio 3.6 מאפשר לכם ליהנות מכמה עדכונים שכלולים ב-Android Emulator מגרסה 29.2.7 ומעלה, כפי שמתואר בהמשך.

תמיכה משופרת במיקום

‫Android Emulator מגרסה 29.2.7 ואילך מספק תמיכה נוספת בהדמיה של קואורדינטות GPS ומידע על מסלולים. כשפותחים את האפשרות Emulators Extended controls, האפשרויות בכרטיסייה Location מאורגנות עכשיו בשתי כרטיסיות: Single points ו-Routes.

נקודות בודדות

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

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

.

מסלולים

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

1. בתצוגת המפה, משתמשים בשדה הטקסט כדי לחפש את היעד הראשון במסלול.
2. בוחרים את המיקום מתוצאות החיפוש.
3. לוחצים על הלחצן ניווט.
4. בוחרים במפה את נקודת ההתחלה של המסלול.
5. (אופציונלי) לוחצים על הוספת יעד כדי להוסיף עוד עצירות למסלול.
6. כדי לשמור את המסלול, לוחצים על שמירת המסלול בתצוגת המפה.
7. מזינים שם למסלול ולוחצים על שמירה.

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

.

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

תמיכה בתצוגה מרובת מסכים

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

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

2. כדי להוסיף עוד מסך, לוחצים על הוספת מסך משני.

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

4. בחירת אחד מיחסי הגובה-רוחב המוגדרים מראש

5. בוחרים באפשרות בהתאמה אישית ומגדירים את הגובה, הרוחב וה-dpi של המסך המותאם אישית.

6. (אופציונלי) לוחצים על הוספת מסך משני כדי להוסיף מסך שלישי.

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

מכשירים וירטואליים חדשים ותבניות פרויקט ל-Android Automotive OS

כשיוצרים פרויקט חדש באמצעות Android Studio, אפשר לבחור מתוך שלוש תבניות בכרטיסייה Automotive (רכב) באשף Create New Project (יצירת פרויקט חדש): No Activity (ללא פעילות), Media service (שירות מדיה) ו-Messaging service (שירות הודעות). בפרויקטים קיימים, אפשר להוסיף תמיכה במכשירי Android Automotive על ידי בחירה באפשרות File > New > New Module (קובץ > חדש > מודול חדש) מסרגל התפריטים, ואז בחירה באפשרות Automotive Module (מודול לרכב). אשף Create New Module (יצירת מודול חדש) ידריך אתכם בתהליך של יצירת מודול חדש באמצעות אחת מהתבניות של פרויקט Android Automotive.

.

בנוסף, עכשיו אפשר ליצור מכשיר וירטואלי של Android‏ (AVD) למכשירי Android Automotive OS. לשם כך, בוחרים באחת מהאפשרויות הבאות בכרטיסייה Automotive באשף Virtual Device Configuration.

1. ‫Polestar 2: יוצרים מכשיר AVD שמדמה את יחידת הראש של Polestar 2.
2. ‫Automotive (לרוחב, 1024p): יוצרים AVD ליחידות מרכזיות כלליות של Android Automotive בגודל ‎1024 x 768 פיקסלים.

.

הורדות SDK שניתן להמשיך

כשמורידים רכיבים וכלים של SDK באמצעות SDK Manager, אפשר עכשיו ב-Android Studio להמשיך הורדות שהופסקו (לדוגמה, בגלל בעיה ברשת) במקום להפעיל מחדש את ההורדה מההתחלה. השיפור הזה שימושי במיוחד להורדות גדולות, כמו Android Emulator או תמונות מערכת, כשחיבור האינטרנט לא יציב.

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

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

הוצאה משימוש של Win32

גרסת 32 הביט של Android Studio ל-Windows לא תקבל יותר עדכונים אחרי דצמבר 2019, ולא תקבל יותר תמיכה אחרי דצמבר 2020. אפשר להמשיך להשתמש ב-Android Studio. עם זאת, כדי לקבל עדכונים נוספים, צריך לשדרג את תחנת העבודה לגרסת 64 ביט של Windows.

מידע נוסף על הוצאה משימוש של Windows 32-bit

אפשרות חדשה לאופטימיזציה של זמן הסנכרון של Gradle

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

כדי לשפר את הביצועים של Gradle Sync, עוברים אל File > Settings > Experimental (קובץ > הגדרות > ניסיוני) ובוחרים באפשרות Do not build Gradle task list during Gradle sync (לא ליצור רשימת משימות של Gradle במהלך Gradle Sync).

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

מיקום חדש להחלפת מצב אופליין ב-Gradle

כדי להפעיל או להשבית את מצב האופליין של Gradle, קודם בוחרים באפשרות View > Tool Windows > Gradle (תצוגה > חלונות כלים > Gradle) בסרגל התפריטים. לאחר מכן, בחלק העליון של החלון Gradle, לוחצים על החלפת מצב לא מקוון .

‫IntelliJ IDEA 2019.2

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2019.2.

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

• IntelliJ IDEA 2019.1.3
• IntelliJ IDEA 2019.1.2
• ‫IntelliJ IDEA 2019.1.1

תורמי תוכן לקהילה

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

Albert Lo Alexey Rott Andrea Leganza Benedikt Kolb סזאר פוארטה Curtis Kroetsch Damian Wieczorek Dan Lew David Burström Deepanshu Egor Andreevici Eli Graber Emin Kokalari Evan Tatarka Frantisek Nagy Greg Moens Hannes Achleitner Hans Petter Eide Henning Bunk Hugo Visser Igor Escodro

Iñaki Villar Javentira Lienata Joe Rogers Kristoffer Danielsson Liran Barsisa Louis CAD Lóránt Pintér Łukasz Wasylkowski לוק פילקה Malvin Sutanto Masatoshi Kubode מתיו וינטרס מייקל ביילי Michał Górny Mihai Neacsu Mike Scamell Monte Creasor Nelson Osacky Nelson Osacky Nick Firmani Nicklas Ansman Giertz

Niclas Kron ניקולאס ליכטמאייר Niek Haarman Niels van Hove Niklas Baudy Renato Goncalves Roar Grønmo רוסלן ברטוב Sinan Kozak Slawomir Czerwinski Stefan Wolf Stephen D'Amico Tao Wang Tomas Chladek Tomáš Procházka Tony Robalik Torbjørn Sørli וורן הוא Yenchi Lin Zac Sweers

‫3.5 (אוגוסט 2019)

‫Android Studio 3.5 היא גרסה מרכזית והיא תוצאה של Project Marble. החל מגרסה Android Studio 3.3, יוזמת Project Marble נמשכה לאורך כמה גרסאות, והתמקדה בשיפור שלושה תחומים עיקריים של סביבת הפיתוח המשולבת (IDE): תקינות המערכת, שיפור התכונות ותיקון באגים.

מידע על העדכונים האלה ועדכונים נוספים של Project Marble זמין בפוסט הזה בבלוג Android Developers או בקטעים שבהמשך.

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

‫3.5.3 (דצמבר 2019)

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

‫3.5.2 (נובמבר 2019)

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

‫3.5.1 (אוקטובר 2019)

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

Project Marble: תקינות המערכת

בקטע הזה מתוארים השינויים ב-Android Studio 3.5 שמתמקדים בשיפור תקינות המערכת.

הגדרות זיכרון מומלצות

‫Android Studio מודיע לכם עכשיו אם הוא מזהה שאפשר לשפר את הביצועים על ידי הגדלת כמות ה-RAM המקסימלית שמערכת ההפעלה צריכה להקצות לתהליכים של Android Studio, כמו הליבה של סביבת הפיתוח המשולבת, Gradle daemon ו-Kotlin daemon. אפשר לאשר את ההגדרות המומלצות בלחיצה על הקישור לפעולה בהתראה, או לשנות את ההגדרות באופן ידני. כדי לעשות זאת, בוחרים באפשרות קובץ > הגדרות (או Android Studio > העדפות ב-macOS), ואז מחפשים את הקטע הגדרות זיכרון בקטע מראה והתנהגות > הגדרות מערכת. מידע נוסף זמין במאמר גודל הערימה המקסימלי.

התראה לגבי הגדרות מומלצות של זיכרון.

דוח שימוש בזיכרון

לפעמים קשה לשחזר ולדווח על בעיות בזיכרון ב-Android Studio. כדי לפתור את הבעיה הזו, אפשר ליצור ב-Android Studio דוח על השימוש בזיכרון. לשם כך, לוחצים על Help > Analyze Memory Usage (עזרה > ניתוח השימוש בזיכרון) בסרגל התפריטים. כשאתם עושים את זה, סביבת הפיתוח המשולבת (IDE) מנקה את הנתונים ממידע אישי באופן מקומי לפני שהיא שואלת אם אתם רוצים לשלוח אותם לצוות Android Studio כדי לעזור לזהות את המקור של בעיות הזיכרון. מידע נוסף מופיע במאמר בנושא הרצת דוח על השימוש בזיכרון.

דוח על השימוש בזיכרון.

‫Windows: אופטימיזציה של קלט/פלט של קובץ אנטי-וירוס

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

‫Project Marble: ליטוש תכונות

בקטע הזה מתוארים השינויים ב-Android Studio 3.5 שמתמקדים בשיפור התכונות הקיימות.

החלת השינויים

התכונה 'החלת שינויים' מאפשרת להעביר שינויים בקוד ובמשאבים לאפליקציה שפועלת, בלי להפעיל מחדש את האפליקציה, ובמקרים מסוימים, בלי להפעיל מחדש את הפעילות הנוכחית. התכונה 'החלת שינויים' מיישמת גישה חדשה לגמרי לשימור מצב האפליקציה. בניגוד ל-Instant Run, שכתב מחדש את קוד הבייט של ה-APK, התכונה Apply Changes מגדירה מחדש את המחלקות תוך כדי תנועה באמצעות מכשור זמן הריצה שנתמך ב-Android 8.0 (רמת API‏ 26) ומעלה.

מידע נוסף זמין במאמר בנושא החלת שינויים.

לחצני סרגל הכלים להחלת השינויים.

תהליך פריסת האפליקציה

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

התפריט הנפתח של מכשיר היעד.

שיפור בסנכרון Gradle ובזיהוי מטמון

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

שיפור הפלט של שגיאות בנייה

בחלון Build מוצג עכשיו דיווח טוב יותר על שגיאות, כמו קישור לקובץ ולשורה של השגיאה שדווחה, בתהליכי הבנייה הבאים:

• הידור וקישור של AAPT
• ‫R8 ו-ProGuard
• Dexing
• מיזוג משאבים
• ניתוח קובץ XML
• קומפילציה של Javac,‏ Kotlinc ו-CMake

שדרוגים של פרויקטים

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

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

כלי לעריכת פריסות

‫Android Studio 3.5 כולל כמה שיפורים בהדמיה, בניהול ובאינטראקציה של פריסות.

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

קשרי אילוצים לרכיב בממשק המשתמש שנבחר.

באופן דומה, עכשיו אפשר למחוק אילוץ על ידי בחירה בו והקשה על המקש Delete. אפשר גם למחוק אילוץ על ידי לחיצה ממושכת על המקש Control (Command ב-macOS) ולחיצה על נקודת העיגון של האילוץ. שימו לב: כשמחזיקים את המקש Control או Command ומעבירים את העכבר מעל נקודת עיגון, כל האילוצים שמשויכים לה הופכים לאדומים, כדי לציין שאפשר ללחוץ כדי למחוק אותם.

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

שימוש בווידג'ט של אילוצים כדי ליצור אילוצים .

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

יצירת אילוץ לרכיב חופף ב-Android Studio 3.4.

יצירת אילוץ לרכיב חופף ב-Android Studio 3.5.

בנוסף לעדכונים שלמעלה, Android Studio 3.5 כולל גם את השיפורים הבאים בכלי Layout Editor:

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

מידע נוסף על השינויים האלה זמין במאמר Android Studio Project Marble: Layout Editor.

קישור נתונים

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

ביצועים של עורך הקוד ב-Android Studio 3.4.

שיפרנו את הביצועים של עריכת קוד ב-Android Studio 3.5.

תמיכה משופרת בפרויקטים של C/C++

‫Android Studio 3.5 כולל כמה שינויים שמשפרים את התמיכה בפרויקטים של C/C++.

שיפורים בחלונית 'יצירת וריאציות' לסנכרון של וריאציה יחידה

עכשיו אפשר לציין את גרסת ה-Build הפעילה ואת ה-ABI הפעיל בחלונית Build Variants. התכונה הזו מפשטת את הגדרת ה-build לכל מודול, ויכולה גם לשפר את ביצועי הסנכרון של Gradle.

מידע נוסף על שינוי גרסת ה-build

החלונית Build Variants (בניית וריאציות) עם בחירת וריאציה יחידה לפי ABI.

גרסאות זו לצד זו של NDK

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

אם הפרויקט שלכם משתמש בתוסף Android Gradle בגרסה 3.5.0 ואילך, אתם יכולים גם לציין את גרסת ה-NDK שכל מודול בפרויקט צריך להשתמש בה. אתם יכולים להשתמש בתכונה הזו כדי ליצור גרסאות build שניתן לשחזר וכדי לצמצם את חוסר התאימות בין גרסאות NDK לבין הפלאגין של Android Gradle.

מידע נוסף זמין במאמר בנושא התקנה והגדרה של NDK,‏ CMake ו-LLDB.

תמיכה ב-ChromeOS

‫Android Studio תומך עכשיו באופן רשמי במכשירי ChromeOS, כמו HP Chromebook x360 14,‏ Acer Chromebook 13/Spin 13 ועוד. אפשר לקרוא על כך בדרישות המערכת. כדי להתחיל, מורידים את Android Studio למכשיר ChromeOS התואם ופועלים לפי הוראות ההתקנה.

הערה: נכון לעכשיו, Android Studio ב-ChromeOS תומך בפריסת האפליקציה רק במכשיר חומרה מחובר. מידע נוסף זמין במאמר בנושא הפעלת אפליקציות במכשיר חומרה.

הפצה מותנית של מודולים של תכונות

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

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

• תכונות החומרה והתוכנה של המכשיר, כולל גרסת OpenGL ES
• המדינה של המשתמש
• רמת ממשק API:

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

IntelliJ IDEA 2019.1

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2019.1, כמו התאמה אישית של ערכות נושא.

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

• IntelliJ IDEA 2018.3.6{: .external-link}
• ‫IntelliJ IDEA 2018.3.5{: .external-link}

עדכונים ב-Android Gradle Plugin 3.5.0

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

תורמי תוכן לקהילה

תודה לכל חברי הקהילה שעזרו לנו לגלות באגים ודרכים אחרות לשפר את Android Studio 3.5. בפרט, אנחנו רוצים להודות לאנשים הבאים שדיווחו על באגים ברמה P0 ו-P1:

Aaron He Andreas Dybdahl Andrei Vădan Andrew Hughes Andrey Mischenko אנדריי סרדנקו Benoît 'BoD' Lubek Berkeli Alashov Bram Stolk Charles Anderson קרטיס קרוטש David Burström DeweyReed דמיטרי דולובוב Emin Kokalari Evan Tatarka Evgeny Brazgin

George Kropotkin Ido Feins יאקוב בנשבסקי Jean-Michel Fayard John Rodriguez Kamil Dudek Kenji Abe Liran Barsisa Louis CAD לוק פילקה Lóránt Pintér מארשין דוויד מריו או Mauricio Vignale מייקל ביילי מיגל אנחל רוסי סנחוחה Niklas Baudy

נואה אנדרוז Oleksandr Zakrevskyi Peter Vegh Rishabh harit Roar Grønmo סעיד טהסין דנה Shayan Sabahi Slawomir Czerwinski Stephen Yu Steven Schoen Tolriq Tony Robalik Uli Bubenheimer Vixb Xue Yi Cheng

‫3.4 (אפריל 2019)

‫Android Studio 3.4 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

‫3.4.2 (יולי 2019)

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

‫3.4.1 (מאי 2019)

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

3.4.0 בעיות מוכרות

• הפרופיל מושבת כשפורסים את האפליקציה במכשיר עם Android Q Beta.

• כשמשתמשים בספריית Data Binding, יכול להיות שהפעולה LiveDataListener.onChanged() תיכשל עם NPE. תיקון לבעיה הזו ייכלל ב-Android Studio 3.4.1, והוא כבר זמין בגרסת ה-Preview העדכנית של Android Studio 3.5. (ראו בעיה מספר 122066788)

‫IntelliJ IDEA 2018.3.4

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.3.4.

עדכונים ב-Android Gradle Plugin 3.4.0

מידע על החידושים בפלאגין Android Gradle גרסה 3.4.0 זמין בהערות על הגרסה.

תיבת דו-שיח חדשה של מבנה הפרויקט

בתיבת הדו-שיח החדשה Project Structure (מבנה הפרויקט, PSD) קל יותר לעדכן תלויות ולהגדיר היבטים שונים של הפרויקט, כמו מודולים, וריאציות של בנייה, הגדרות חתימה ומשתני בנייה.

אפשר לפתוח את קובץ ה-PSD על ידי בחירה באפשרות File > Project Structure (קובץ > מבנה הפרויקט) בסרגל התפריטים. אפשר גם לפתוח את קובץ ה-PSD על ידי הקשה על Ctrl+Shift+Alt+S ב-Windows וב-Linux, או על Command+; (נקודה ופסיק) ב-macOS. בהמשך מפורטים תיאורים של חלק מהקטעים החדשים והמעודכנים ב-PSD.

משתנים

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

• אפשר להציג ולערוך במהירות משתני build שכבר קיימים בסקריפטים של build ב-Gradle בפרויקט.
• אפשר להוסיף משתני build חדשים ברמת הפרויקט או המודול ישירות מקובץ ה-PSD.

הערה: אם קובצי ההגדרות הקיימים שלכם מקצים ערכים באמצעות סקריפטים מורכבים של Groovy, יכול להיות שלא תוכלו לערוך את הערכים האלה באמצעות ה-PSD. בנוסף, אי אפשר לערוך קובצי build שנכתבו ב-Kotlin באמצעות ה-PSD.

מודולים

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

תלויות

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

1. בחלונית הימנית של ה-PSD, בוחרים באפשרות תלויות.
2. בחלונית Modules, בוחרים מודול שרוצים לבדוק את התלויות שנפתרו שלו.
3. בצד שמאל של ה-PSD, פותחים את החלונית Resolved Dependencies, שמוצגת למטה.

אפשר גם לחפש במהירות תלות ולהוסיף אותה לפרויקט. לשם כך, בוחרים קודם מודול בקטע Dependencies של ה-PSD, לוחצים על הלחצן (+) בקטע Declared Dependencies ובוחרים את סוג התלות שרוצים להוסיף.

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

וריאציות של build

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

הצעות

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

מנהל המשאבים החדש

המרכז לניהול משאבים הוא חלון כלים חדש לייבוא, ליצירה, לניהול ולשימוש במשאבים באפליקציה. כדי לפתוח את חלון הכלים, בוחרים באפשרות View > Tool Windows > Resource Manager (תצוגה > חלונות כלים > המרכז לניהול משאבים) מסרגל התפריטים. ה-Resource Manager מאפשר לכם לבצע את הפעולות הבאות:

• הדמיה של משאבים: אפשר לראות תצוגה מקדימה של משאבים מסוג drawable, צבעים ופריסות כדי למצוא במהירות את המשאבים שאתם צריכים.
• ייבוא בכמות גדולה: אפשר לייבא כמה נכסים מסוג drawable בבת אחת. כדי לעשות זאת, אפשר לגרור אותם לחלון הכלים Resource Manager או להשתמש באשף Import drawables. כדי לגשת לאשף, לוחצים על הלחצן (+) בפינה הימנית העליונה של חלון הכלי, ואז בוחרים באפשרות Import Drawables (ייבוא תמונות) בתפריט הנפתח.
• המרת קובצי SVG לאובייקטים מסוג VectorDrawable: אפשר להשתמש באשף Import Drawables כדי להמיר תמונות SVG לאובייקטים מסוג VectorDrawable.
• גרירה ושחרור של נכסים: בחלון הכלים Resource Manager, אפשר לגרור ולשחרר משאבים מסוג drawables לתצוגות העיצוב וה-XML של Layout Editor.
• הצגת גרסאות חלופיות: עכשיו אפשר להציג גרסאות חלופיות של משאבים על ידי לחיצה כפולה על משאב בחלון כלי. בתצוגה הזו מוצגות הגרסאות השונות שיצרתם והמסננים שנכללו.
• תצוגת משבצות ותצוגת רשימה: אתם יכולים לשנות את התצוגה בחלון הכלי כדי לראות את המשאבים בסידורים שונים.

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

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

כשמספקים קובצי סמלים לניפוי באגים עבור הספריות המשותפות .so בתוך קובץ ה-APK, ‏ Android Studio מוודא שמזהה ה-build של קובצי הסמלים שסופקו תואם למזהה ה-build של הספריות .so בתוך קובץ ה-APK.

אם אתם יוצרים את הספריות המקומיות ב-APK עם מזהה build,‏ Android Studio בודק אם מזהה ה-build בקובצי הסמלים תואם למזהה ה-build בספריות המקומיות, ואם יש אי התאמה, הוא דוחה את קובצי הסמלים. אם לא השתמשתם במזהה build, יכול להיות שקובצי סמלים שגויים יגרמו לבעיות בניפוי הבאגים.

ההגדרה R8 מופעלת כברירת מחדל

‫R8 משלב את הפעולות desugaring,‏ shrinking,‏ obfuscating,‏ optimizing ו-dexing בשלב אחד – וכתוצאה מכך הביצועים של הבנייה משתפרים באופן משמעותי. ‫R8 הושק בתוסף Android Gradle בגרסה 3.3.0, ועכשיו הוא מופעל כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות Android באמצעות תוסף בגרסה 3.4.0 ואילך.

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

עכשיו, עם R8, כל הפעולות האלה – desugaring,‏ shrinking,‏ obfuscating,‏ optimizing ו-dexing ‏ (D8) – מתבצעות בשלב אחד, כפי שמוצג בהמשך.

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

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

    # Disables R8 for Android Library modules only.
    android.enableR8.libraries = false
    # Disables R8 for all modules.
    android.enableR8 = false
    
  

הערה: אם מגדירים את useProguard ל-false בקובץ build.gradle של מודול האפליקציה עבור סוג build מסוים, הפלאגין Android Gradle משתמש ב-R8 כדי לכווץ את הקוד של האפליקציה עבור סוג ה-build הזה, גם אם משביתים את R8 בקובץ gradle.properties של הפרויקט.

הכלי Navigation Editor תומך עכשיו בכל סוגי הארגומנטים

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

שיפורים ב-Layout Editor‏ {:#layout-editor}

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

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

פעולת כוונה חדשה לייבוא מהיר של תלויות

אם מתחילים להשתמש בקוד במחלקות מסוימות של Jetpack ו-Firebase, פעולת כוונה חדשה מציעה להוסיף לפרויקט את התלות הנדרשת בספריית Gradle, אם עדיין לא עשיתם זאת. לדוגמה, אם אתם מפנים למחלקה WorkManager בלי לייבא קודם את התלות הנדרשת android.arch.work:work-runtime, פעולת כוונה מאפשרת לכם לעשות זאת בקלות בלחיצה אחת, כמו שמוצג בהמשך.

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

‫3.3 (ינואר 2019)

‫Android Studio 3.3 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

‫3.3.2 (מרץ 2019)

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

‫3.3.1 (פברואר 2019)

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

IntelliJ IDEA 2018.2.2

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.2.2.

עדכונים של Android Gradle Plugin

מידע על החידושים בפלאגין של Android Gradle זמין בהערות על הגרסה.

כלי הניווט

‫Navigation Editor הוא כלי לעריכת ניווט שמאפשר ליצור במהירות תמונה חזותית של הניווט באפליקציה ולהגדיר אותו באמצעות רכיב ארכיטקטורת הניווט.

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

מחיקת ספריות של Android Studio שלא נמצאות בשימוש

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

הרשימה הבאה כוללת את הספריות ש-Android Studio שוקל למחוק:

• ‫Linux: ‏ ~/.AndroidStudio[Preview]X.Y
• ב-Mac: ‏ ~/Library/{Preferences, Caches, Logs, Application Support}/AndroidStudio[Preview]X.Y
• ב-Windows: ‏ %USER%.AndroidStudio[Preview]X.Y

שיפורים באיתור שגיאות בקוד

הפעלת Lint מ-Gradle מהירה משמעותית – בפרויקטים גדולים, Lint יכול לפעול עד פי ארבע יותר מהר.

האשף ליצירת פרויקט חדש

לאשף Create New Project (יצירת פרויקט חדש) יש מראה חדש והוא כולל עדכונים שעוזרים לייעל את יצירת הפרויקטים החדשים ב-Android Studio.

מידע נוסף זמין במאמר יצירת פרויקט.

עדכונים בכלי לניתוח ביצועים

‫Android Studio 3.3 כולל עדכונים לכמה מהפרופילים האישיים.

ביצועים משופרים

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

אפשרויות מעקב אחר הקצאת זיכרון ב-Profiler

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

בתפריט הנפתח מעקב אחר הקצאה, אפשר לבחור מבין המצבים הבאים:

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

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

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

  המעקב משפיע גם על אובייקטים של Java וגם על הפניות של JNI.

בדיקת נתוני רינדור של מסגרות

בכלי הפרופיל של CPU, אפשר עכשיו לבדוק כמה זמן לוקח לאפליקציית Java לעבד כל פריים בשרשור הראשי של ממשק המשתמש וב-RenderThread. הנתונים האלה יכולים להיות שימושיים כשבודקים צווארי בקבוק שגורמים לבעיות בממשק המשתמש ולשיעורי פריימים נמוכים. לדוגמה, כל פריים שזמן הרינדור שלו ארוך מ-16 אלפיות השנייה (הזמן הנדרש לשמירה על קצב פריימים חלק) מוצג באדום.

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

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

קטעים בציר הזמן של האירוע

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

צפייה בטקסט מעוצב של מטען ייעודי (payload) של חיבור בכלי ליצירת פרופיל רשת

בעבר, הכלי Network profiler הציג רק טקסט גולמי ממטען ייעודי (payload) של חיבורים. ב-Android Studio 3.3, פורמטים מסוימים של טקסט, כולל JSON,‏ XML ו-HTML, מוגדרים כברירת מחדל. בכרטיסיות תשובה ובקשה, לוחצים על הקישור הצגת הניתוח כדי להציג טקסט מעוצב, ולוחצים על הקישור הצגת המקור כדי להציג טקסט גולמי.

מידע נוסף זמין במאמר בדיקת תנועת הרשת באמצעות Network Profiler.

הורדה אוטומטית של רכיבי SDK

כשפרויקט צריך רכיב SDK מפלטפורמות ה-SDK, ‏ NDK או CMake, ‏ Gradle מנסה עכשיו להוריד באופן אוטומטי את החבילות הנדרשות, בתנאי שאישרתם בעבר את הסכמי הרישיון הרלוונטיים באמצעות SDK Manager.

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

תמיכה ב-Clang-Tidy

‫Android Studio כולל עכשיו תמיכה בניתוח סטטי של קוד באמצעות Clang-Tidy לפרויקטים שכוללים קוד מקורי. כדי להפעיל תמיכה ב-Clang-Tidy, צריך לעדכן את NDK לגרסה r18 ואילך.

אחר כך תוכלו להפעיל או להפעיל מחדש את הבדיקות. כדי לעשות זאת, פותחים את תיבת הדו-שיח הגדרות או העדפות ועוברים אל עורך > בדיקות > C/C++‎ > כללי > Clang-Tidy. כשבוחרים את הבדיקה הזו בתיבת הדו-שיח הגדרות או העדפות, אפשר לראות גם את רשימת הבדיקות של Clang-Tidy שמופעלות ומושבתות בקטע אפשרות בחלונית הימנית ביותר. כדי להפעיל בדיקות נוספות, מוסיפים אותן לרשימה ולוחצים על החלה.

כדי להגדיר את Clang-Tidy עם אפשרויות נוספות, לוחצים על Configure Clang-Tidy Checks Options ומוסיפים אותן בתיבת הדו-שיח שנפתחת.

הסרה של אפשרויות להתאמה אישית של C++‎

האפשרויות הבאות הוסרו מתיבת הדו-שיח Customize C++ Support (התאמה אישית של התמיכה ב-C++):

• תמיכה בחריגים (-fexceptions)
• תמיכה במידע על סוג זמן הריצה (-ftti)

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

‫CMake גרסה 3.10.2

גרסה 3.10.2 של CMake כלולה עכשיו ב-SDK Manager. הערה: Gradle עדיין משתמש בגרסה 3.6.0 כברירת מחדל.

כדי לציין גרסת CMake לשימוש ב-Gradle, מוסיפים את הקוד הבא לקובץ build.gradle של המודול:

    android {
        ...
        externalNativeBuild {
            cmake {
                ...
                version "3.10.2"
            }
        }
    }
    
  

מידע נוסף על הגדרת CMake ב-build.gradle זמין במאמר בנושא הגדרה ידנית של Gradle.

תחביר חדש עם סימן '+' לציון גרסאות מינימום של CMake

כשמציינים גרסה של CMake בקובץ build.gradle של המודול הראשי, אפשר עכשיו להוסיף את התו '+' כדי להתאים להתנהגות של הפקודה cmake_minimum_required() של CMake.

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

קובצי Android App Bundle תומכים עכשיו באפליקציות ללא התקנה

עכשיו אפשר ליצור ב-Android Studio קובצי Android App Bundle עם תמיכה מלאה ב-Google Play ללא התקנה. במילים אחרות, עכשיו אפשר ליצור ולפרוס גם אפליקציות להתקנה וגם אפליקציות ללא התקנה מפרויקט יחיד ב-Android Studio, ולכלול אותן בקובץ Android App Bundle יחיד.

אם אתם יוצרים פרויקט חדש ב-Android Studio באמצעות תיבת הדו-שיח Create New Project (יצירת פרויקט חדש), הקפידו לסמן את התיבה לצד Configure your project > This project will support instant apps (הגדרת הפרויקט > הפרויקט הזה יתמוך באפליקציות מיידיות). ‫Android Studio יוצר פרויקט אפליקציה חדש כרגיל, אבל כולל את המאפיינים הבאים במניפסט כדי להוסיף תמיכה באפליקציה מיידית למודול הבסיס של האפליקציה:

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
        <dist:module dist:instant="true" />
        ...
    </manifest>
    
  

אחר כך אפשר ליצור מודול של תכונה שמופעלת באופן מיידי: בסרגל התפריטים, בוחרים באפשרות File > New > New Module (קובץ > חדש > מודול חדש) ואז בוחרים באפשרות Instant Dynamic Feature Module (מודול של תכונה דינמית שמופעלת באופן מיידי) בתיבת הדו-שיח Create New Module (יצירת מודול חדש). חשוב לזכור: יצירת המודול הזה מפעילה באופן מיידי גם את מודול הבסיס של האפליקציה.

כדי לפרוס את האפליקציה במכשיר מקומי כחוויה מיידית, עורכים את הגדרות ההפעלה ומסמנים את התיבה לצד General > Deploy as instant app (כללי > פריסה כאפליקציה מיידית).

סנכרון פרויקט עם וריאנט יחיד

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

כדי להפעיל את האופטימיזציה הזו, צריך להשתמש ב-Android Studio מגרסה 3.3 ואילך עם Android Gradle plugin מגרסה 3.3.0 ואילך. כשעומדים בדרישות האלה, סביבת הפיתוח המשולבת (IDE) מציעה להפעיל את האופטימיזציה הזו כשמסנכרנים את הפרויקט. כברירת מחדל, האופטימיזציה מופעלת גם בפרויקטים חדשים.

כדי להפעיל את האופטימיזציה הזו באופן ידני, לוחצים על File > Settings > Experimental > Gradle (Android Studio > Preferences > Experimental > Gradle ב-Mac) ומסמנים את התיבה Only sync the active variant.

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

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

שליחת משוב מהיר

אם בחרתם לשתף נתוני שימוש כדי לעזור לשפר את Android Studio, שני הסמלים החדשים האלה יופיעו בשורת הסטטוס בחלק התחתון של חלון ה-IDE:

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

אם עוד לא עשיתם את זה, אתם יכולים להפעיל את השיתוף של נתוני השימוש על ידי פתיחת תיבת הדו-שיח הגדרות (העדפות ב-Mac), מעבר אל מראה והתנהגות > הגדרות מערכת > שיתוף נתונים וסימון האפשרות שליחת נתוני שימוש אל Google.

‫3.2 (ספטמבר 2018)

‫Android Studio 3.2 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

‫3.2.1 (אוקטובר 2018)

העדכון הזה ל-Android Studio 3.2 כולל את השינויים והתיקונים הבאים:

• גרסת Kotlin שצורפה היא עכשיו 1.2.71.
• גרסת ברירת המחדל של כלי ה-Build היא עכשיו 28.0.3.
• בספריית הניווט, שמות סוגי הארגומנטים השתנו מ-type ל-argType.
• הבאגים הבאים תוקנו:
• כשמשתמשים בספריית Data Binding, שמות משתנים עם קווים תחתונים גורמים לשגיאות קומפילציה.
• ‫CMake גרם לכשל ב-IntelliSense ובתכונות אחרות של CLion.
• הוספת SliceProvider גרמה לשגיאות קומפילציה בפרויקטים שלא השתמשו בספריות androidx.*.
• חלק מבדיקות היחידה של Kotlin לא הופעלו.
• בעיה באיגוד הנתונים גרמה לPsiInvalidElementAccessException.
• רכיבי <merge> גרמו לפעמים לקריסה של כלי הפריסה.

בעיות מוכרות בגרסה 3.2.0

הערה: הבעיות האלה נפתרו ב-Android Studio מגרסה 3.2.1

• מומלץ מאוד לא להשתמש ב-Kotlin בגרסה 1.2.70.

  ב-Kotlin גרסה 1.2.61 תוקן באג שיכול לגרום ל-Android Studio להיתקע, אבל התיקון הזה לא נכלל ב-Kotlin 1.2.70.

  עם זאת, גרסאות Kotlin 1.2.71 ואילך כוללות את התיקון הזה.

• בדרך כלל לא צריך לציין את גרסת כלי ה-build, אבל אם משתמשים בפלאגין Android Gradle בגרסה 3.2.0 עם renderscriptSupportModeEnabled שמוגדר ל-true, צריך לכלול את השורות הבאות בקובץ build.gradle של כל מודול:

  android.buildToolsVersion "28.0.3"

מה חדש ב-Assistant

עוזר חדש מודיע לכם על השינויים האחרונים ב-Android Studio.

העוזר נפתח כשמתחילים להשתמש ב-Android Studio אחרי התקנה חדשה או עדכון, אם הוא מזהה שיש מידע חדש להציג. אפשר גם לפתוח את העזרה על ידי בחירה באפשרות Help > What's new in Android Studio (עזרה > מה חדש ב-Android Studio).

Android Jetpack

‫Android Jetpack עוזר להאיץ את פיתוח האפליקציות ל-Android באמצעות רכיבים, כלים והנחיות שמבטלים משימות שחוזרות על עצמן ומאפשרים לכם ליצור אפליקציות איכותיות שאפשר לבדוק, בקלות ובמהירות. ‫Android Studio כולל את העדכונים הבאים לתמיכה ב-Jetpack. מידע נוסף מופיע במאמרי העזרה בנושא Jetpack.

כלי הניווט

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

ב-Android Studio 3.2, כלי העריכה של הניווט הוא תכונה ניסיונית. כדי להפעיל את כלי העריכה של הניווט, לוחצים על File > Settings (קובץ > הגדרות) (Android Studio > Preferences (העדפות) ב-Mac), בוחרים בקטגוריה Experimental (ניסיוני) בחלונית הימנית, מסמנים את התיבה לצד Enable Navigation Editor (הפעלת כלי העריכה של הניווט) ומפעילים מחדש את Android Studio.

מידע נוסף זמין במסמכי התיעוד של עורך הניווט.

העברה ל-AndroidX

כחלק מ-Jetpack, אנחנו מעבירים את ספריות התמיכה של Android לספריית הרחבות חדשה של Android באמצעות מרחב השמות androidx. מידע נוסף מופיע בסקירה הכללית על AndroidX.

‫Android Studio 3.2 כולל תכונת העברה חדשה שתעזור לכם בתהליך הזה.

כדי להעביר פרויקט קיים אל AndroidX, בוחרים באפשרות Refactor > Migrate to AndroidX. אם יש לכם יחסי תלות ב-Maven שלא הועברו למרחב השמות של AndroidX, מערכת ה-build של Android Studio גם ממירה באופן אוטומטי את יחסי התלות האלה בפרויקט.

פלאגין Android Gradle מספק את הדגלים הגלובליים הבאים שאפשר להגדיר בקובץ gradle.properties:

• ‫android.useAndroidX: כשהערך מוגדר ל-true, הדגל הזה מציין שרוצים להתחיל להשתמש ב-AndroidX מעכשיו. אם הדגל לא קיים, Android Studio מתנהג כאילו הדגל הוגדר לערך false.
• ‫android.enableJetifier: אם הערך הוא true, הדגל הזה מציין שרוצים לקבל תמיכה בכלי (מהתוסף Android Gradle) כדי להמיר באופן אוטומטי ספריות קיימות של צד שלישי כאילו הן נכתבו עבור AndroidX. אם הדגל לא מופיע, Android Studio מתנהג כאילו הדגל הוגדר לערך false.

שני הדגלים מוגדרים ל-true כשמשתמשים בפקודה Migrate to AndroidX.

אם אתם רוצים להתחיל להשתמש בספריות AndroidX באופן מיידי ולא צריכים להמיר ספריות קיימות של צד שלישי, אתם יכולים להגדיר את הדגל android.useAndroidX לערך true ואת הדגל android.enableJetifier לערך false.

קובץ Android App Bundle

קובץ Android App Bundle הוא פורמט העלאה חדש שכולל את כל הקוד והמשאבים המהודרים של האפליקציה, אבל דוחה את יצירת ה-APK והחתימה שלו ל-Google Play Store.

מודל חדש להצגת אפליקציות ב-Google Play משתמש בקובץ ה-App Bundle כדי ליצור ולהציג חבילות APK שעברו אופטימיזציה לכל תצורת מכשיר של משתמש, כך שכל משתמש מוריד רק את הקוד והמשאבים שהוא צריך כדי להריץ את האפליקציה. אתם כבר לא צריכים ליצור, לחתום ולנהל כמה חבילות APK, והמשתמשים מקבלים הורדות קטנות יותר שעברו אופטימיזציה.

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

כדי ליצור חבילה, בוחרים באפשרות Build > Build Bundle(s) / APK(s) > Build Bundle(s)‎.

מידע נוסף, כולל הוראות לבנייה ולניתוח של קובץ Android App Bundle, זמין במאמר בנושא Android App Bundle.

נתונים לדוגמה בכלי לעריכת פריסות

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

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

פרוסות

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

ב-Android Studio 3.2 יש תבנית מובנית שעוזרת להרחיב את האפליקציה באמצעות ממשקי ה-API החדשים של Slice Provider, וגם בדיקות lint חדשות כדי לוודא שאתם פועלים לפי השיטות המומלצות כשאתם יוצרים את ה-Slices.

כדי להתחיל, לוחצים לחיצה ימנית על תיקיית פרויקט ובוחרים באפשרות New > Other > Slice Provider (חדש > אחר > ספק פלחים).

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

‫Kotlin 1.2.61

‫Android Studio 3.2 כולל את Kotlin 1.2.61, ו-Android SDK החדש משתלב טוב יותר עם Kotlin. מידע נוסף זמין בבלוג למפתחי Android.

‫IntelliJ IDEA 2018.1.6

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.1.6.

כלי פרופיל ל-Android

כדאי לנסות את התכונות החדשות הבאות של Android Profiler ב-Android Studio 3.2.

סשנים

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

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

איסוף עקבות המערכת

בCPU Profiler, בוחרים בהגדרה החדשה System Trace כדי לבדוק את פעילות ה-CPU וה-thread במערכת של המכשיר. הגדרת המעקב הזו מבוססת על systrace והיא שימושית לחקירת בעיות ברמת המערכת, כמו תנודות בממשק המשתמש.

במהלך השימוש בהגדרת המעקב הזו, אפשר לסמן באופן חזותי שגרות קוד חשובות בציר הזמן של הפרופילר על ידי הוספת קוד ל-C/C++‎ באמצעות native tracing API או ל-Java באמצעות המחלקה Trace.

בדיקת הפניות ל-JNI בכלי Memory Profiler

אם אתם פורסים את האפליקציה במכשיר עם Android 8.0 (רמת API‏ 26) ואילך, עכשיו אתם יכולים לבדוק את הקצאות הזיכרון של קוד ה-JNI של האפליקציה באמצעות כלי פרופיל הזיכרון.

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

ייבוא, ייצוא ובדיקה של קובצי dump של זיכרון heap

מעכשיו אפשר לייבא, לייצא ולבדוק קובצי .hprof memory heap dump שנוצרו באמצעות Memory Profiler.

כדי לייבא את קובץ ה-.hprof, לוחצים על Start new profiler session (התחלת סבב חדש של פרופילר) בחלונית Sessions (סבבים) של הפרופילר, ואז בוחרים באפשרות Load from file (טעינה מקובץ). אחר כך תוכלו לבדוק את הנתונים שלו בכלי Memory Profiler, כמו בכל dump אחר של heap.

כדי לשמור נתוני dump של הערימה לבדיקה מאוחרת יותר, משתמשים בלחצן Export Heap Dump (ייצוא dump של הערימה) משמאל לערך Heap Dump (dump של הערימה) בחלונית Sessions (סשנים). בתיבת הדו-שיח Export As (ייצוא בתור) שמופיעה, שומרים את הקובץ עם הסיומת .hprof של שם הקובץ.

תיעוד פעילות ה-CPU במהלך הפעלת האפליקציה

עכשיו אפשר לתעד את פעילות המעבד במהלך הפעלת האפליקציה, באופן הבא:

1. בתפריט הראשי, בוחרים באפשרות Run > Edit Configurations (הפעלה > עריכת הגדרות).
2. בכרטיסייה Profiling (פרופיל) של הגדרת ההרצה הרצויה, מסמנים את התיבה שליד Start recording a method trace on startup (התחלת הקלטה של מעקב אחר שיטות בהפעלה).
3. בוחרים הגדרת הקלטה של מעבד לשימוש מהתפריט הנפתח.
4. כדי לפרוס את האפליקציה במכשיר עם Android 8.0 (רמת API‏ 26) ומעלה, בוחרים באפשרות Run > Profile (הפעלה > פרופיל).

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

אחרי שמקליטים את פעילות המעבד באמצעות הכלי CPU Profiler, אפשר לייצא את הנתונים כקובץ .trace כדי לשתף אותם עם אחרים או לבדוק אותם מאוחר יותר.

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

1. לוחצים לחיצה ימנית על ההקלטה שרוצים לייצא מציר הזמן של השימוש במעבד.
2. בתפריט הנפתח, בוחרים באפשרות Export trace (ייצוא נתוני מעקב).
3. עוברים למיקום שבו רוצים לשמור את הקובץ ולוחצים על שמירה.

ייבוא ובדיקה של קבצים של פרטי ההעברה של המעבד

עכשיו אפשר לייבא ולבדוק קובצי .trace שנוצרו באמצעות Debug API או CPU Profiler. (בשלב הזה אי אפשר לייבא הקלטות של System Trace).

כדי לייבא את קובץ המעקב, לוחצים על Start new profiler session (התחלת סשן חדש של כלי הפרופיל) בחלונית Sessions (סשנים) של כלי הפרופיל, ואז בוחרים באפשרות Load from file (טעינה מקובץ). לאחר מכן תוכלו לבדוק את הנתונים שלו בכלי ליצירת פרופיל של המעבד, בדומה לאופן שבו בודקים נתונים בדרך כלל, עם החריגים הבאים:

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

תיעוד פעילות המעבד באמצעות Debug API

עכשיו אפשר להתחיל ולהפסיק להקליט את פעילות המעבד בכלי CPU Profiler באמצעות הטמעה של Debug API באפליקציה. אחרי שמפעילים את האפליקציה במכשיר, הכלי ליצירת פרופילים מתחיל באופן אוטומטי להקליט את פעילות המעבד כשהאפליקציה קוראת ל-startMethodTracing(String tracePath), והוא מפסיק להקליט כשהאפליקציה קוראת ל-stopMethodTracing(). במהלך תיעוד פעילות ה-CPU שמופעלת באמצעות ה-API הזה, הכלי לניתוח ביצועי ה-CPU מציג את Debug API כהגדרת התיעוד של ה-CPU שנבחרה.

Energy Profiler

בEnergy Profiler מוצגת ויזואליזציה של צריכת האנרגיה המשוערת של האפליקציה, וגם של אירועי מערכת שמשפיעים על צריכת האנרגיה, כמו נעילות השכמה (wakelocks), התראות ועבודות.

הכלי Energy Profiler מופיע כשורה חדשה בחלק התחתון של חלון Profiler כשמריצים את האפליקציה במכשיר מחובר או ב-Android Emulator עם Android מגרסה 8.0 (API 26) ומעלה.

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

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

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

בדיקת Lint

‫Android Studio 3.2 כולל הרבה תכונות חדשות ומשופרות לבדיקות lint.

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

בדיקות Lint לשילוב עם מערכות חיצוניות ב-Java/Kotlin

כדי לוודא שקוד Java פועל בצורה חלקה עם קוד Kotlin, בדיקות lint חדשות אוכפות את השיטות המומלצות שמתוארות במדריך Kotlin Interop. דוגמאות לבדיקות כאלה כוללות חיפוש של הערות בנושא Nullability, שימוש במילות מפתח קשיחות של Kotlin והצבת פרמטרים של lambda בסוף.

כדי להפעיל את הבדיקות האלה, לוחצים על File > Settings (קובץ > הגדרות) (Android Studio > Preferences (Android Studio > העדפות) ב-Mac) כדי לפתוח את תיבת הדו-שיח Settings (הגדרות), עוברים לקטע Editor > Inspections > Android > Lint > Interoperability > Kotlin Interoperability (עורך > בדיקות > Android > Lint > יכולת פעולה הדדית > יכולת פעולה הדדית של Kotlin) ובוחרים את הכללים שרוצים להפעיל.

כדי להפעיל את הבדיקות האלה בגרסאות build משורת הפקודה, מוסיפים את הקוד הבא לקובץ build.gradle:

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות Lint לפרוסות

בדיקות חדשות של Lint ל-Slices עוזרות לוודא שאתם יוצרים Slices בצורה נכונה. לדוגמה, בדיקות lint מזהירות אתכם אם לא הקציתם פעולה ראשית ל-Slice.

יעד חדש של Gradle

אפשר להשתמש במשימת Gradle החדשה lintFix כדי להחיל את כל התיקונים הבטוחים שהוצעו על ידי בדיקת ה-lint ישירות על קוד המקור. דוגמה לבדיקת lint שמציעה תיקון בטוח שאפשר להחיל היא SyntheticAccessor.

עדכוני מטא-נתונים

מטא-נתונים שונים, כמו בדיקת ה-cast של השירות, עודכנו כדי שבדיקות ה-lint יפעלו עם Android 9 (רמת API‏ 28).

אזהרה אם מריצים lint על וריאנט חדש

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

שיפורים בבדיקות ה-lint הקיימות

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

הגברת החשיפה של מזהי בעיות

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

מידע נוסף זמין במאמר בנושא הגדרת אפשרויות של lint באמצעות Gradle.

קישור נתונים מגרסה 2

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

הסרת סוכר תחבירי ב-D8

ב-Android Studio 3.1, שילבנו את שלב ה-desugaring בכלי D8 כתכונה ניסיונית, וכך קיצרנו את זמן הבנייה הכולל. ב-Android Studio 3.2, ההגדרה desugaring עם D8 מופעלת כברירת מחדל.

כיווץ קוד חדש

‫R8 הוא כלי חדש לכיווץ קוד וערפול קוד (obfuscation) שמחליף את ProGuard. כדי להתחיל להשתמש בגרסת הטרום-השקה של R8, צריך לכלול את השורות הבאות בקובץ gradle.properties של הפרויקט:

      android.enableR8 = true
    

ממשקי ה-ABI שמוגדרים כברירת מחדל לחבילות APK מרובות שונו

כשיוצרים כמה חבילות APK שכל אחת מהן מטרגטת ממשק ABI שונה, התוסף כבר לא יוצר חבילות APK לממשקי ה-ABI הבאים כברירת מחדל: mips, mips64 ו-armeabi.

אם רוצים ליצור קובצי APK שמטרגטים את ממשקי ה-ABI האלה, צריך להשתמש ב-NDK r16b או בגרסה מוקדמת יותר ולציין את ממשקי ה-ABI בקובץ build.gradle, כמו שמוצג בהמשך:

    splits {
        abi {
            include 'armeabi', 'mips', 'mips64'
            ...
        }
    }
    

    splits {
        abi {
            include("armeabi", "mips", "mips64")
            ...
        }
    }
    

הערה: השינוי הזה בהתנהגות כלול גם ב-Android Studio 3.1 RC1 ובגרסאות מתקדמות יותר.

שיפורים בתכונות העריכה של קובצי build של CMake

אם אתם משתמשים ב-CMake כדי להוסיף קוד C ו-C++ לפרויקט, ב-Android Studio יש עכשיו תכונות עריכה משופרות שיעזרו לכם לערוך את סקריפטים ה-build של CMake, כמו:

• הדגשת תחביר והשלמת קוד: סביבת הפיתוח המשולבת (IDE) מדגישה ומציעה השלמת קוד לפקודות נפוצות של CMake. בנוסף, אפשר ללחוץ על קובץ כדי לעבור אליו תוך כדי לחיצה על מקש Control (או Command ב-Mac).
• עיצוב מחדש של קוד: עכשיו אפשר להשתמש באפשרות לעיצוב מחדש של קוד ב-IntelliJ כדי להחיל סגנונות קוד על סקריפטים של בניית CMake.
• שינוי מבנה קוד בטוח: כלי שינוי מבנה הקוד המובנים ב-IDE בודקים עכשיו גם אם אתם משנים את השם של קבצים או מוחקים קבצים שמופיעים בהפניה בסקריפטים של CMake build.

ניווט בקובצי כותרת חיצוניים

כשמשתמשים בחלון Project בגרסאות קודמות של Android Studio, אפשר לנווט ולבדוק רק את קובצי הכותרת ששייכים לספריות שיוצרים מפרויקט מקומי. בגרסה הזו, אפשר גם להציג ולבדוק קובצי כותרות שנכללים בתלות בספריות C/C++ חיצוניות שאתם מייבאים לפרויקט האפליקציה.

אם כבר הוספתם קוד וספריות של C/C++ לפרויקט, פותחים את החלון Project (פרויקט) בצד ימין של סביבת הפיתוח המשולבת (IDE). לשם כך, בוחרים באפשרות View > Tool Windows > Project (תצוגה > חלונות של כלים > פרויקט) בתפריט הראשי, ואז בוחרים באפשרות Android (אנדרואיד) בתפריט הנפתח. בספרייה cpp, כל קובצי הכותרות שנמצאים בהיקף של פרויקט האפליקציה מסודרים מתחת לצומת include לכל אחת מהתלויות בספרייה המקומית של C/C++, כמו שמוצג בהמשך.

הפעלת multidex מקומית כברירת מחדל

בגרסאות קודמות של Android Studio, הפעלתם multidex מקורי כשפרסתם את גרסת ניפוי הבאגים של אפליקציה במכשיר עם Android ברמת API 21 ומעלה. מעכשיו, בין אם אתם פורסים לאפליקציה במכשיר או יוצרים APK לפרסום, הפלאגין של Android ל-Gradle מאפשר שימוש ב-multidex מקורי לכל המודולים שמוגדרים לגרסה minSdkVersion=21 ומעלה.

הכלי AAPT2 עבר למאגר Maven של Google

החל מ-Android Studio 3.2, המקור של AAPT2 (Android Asset Packaging Tool 2) הוא מאגר Maven של Google.

כדי להשתמש ב-AAPT2, צריך לוודא שיש תלות ב-google() בקובץ build.gradle, כמו שמוצג כאן:

    buildscript {
        repositories {
            google() // here
            jcenter()
        }
        dependencies {
            classpath 'com.android.tools.build:gradle:3.2.0'
        }
    }
    allprojects {
        repositories {
            google() // and here
            jcenter()
        }
    }
    

    buildscript {
        repositories {
            google() // here
            jcenter()
        }
        dependencies {
            classpath("com.android.tools.build:gradle:3.2.0")
        }
    }
    allprojects {
        repositories {
            google() // and here
            jcenter()
        }
    }
    

בגרסה החדשה של AAPT2 תוקנו הרבה בעיות, כולל שיפור הטיפול בתווים שהם לא-ASCII ב-Windows.

הסרה של הגדרות לפי דרישה

ההעדפה Configure on demand הוסרה מ-Android Studio.

‫Android Studio כבר לא מעביר את הארגומנט --configure-on-demand ל-Gradle.

ADB Connection Assistant

הכלי החדש לחיבור ADB מספק הוראות מפורטות שיעזרו לכם להגדיר מכשיר ולהשתמש בו דרך ממשק הגישור של Android‏ (ADB).

כדי להפעיל את הכלי, בוחרים באפשרות Tools > Connection Assistant (כלים > כלי עזר לחיבור).

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

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

עכשיו אפשר לשמור ולטעון תמונות מצב של AVD (מכשיר וירטואלי של Android) בכל שלב ב-Android Emulator, וכך לחזור במהירות ובקלות למצב מוכר של מכשיר מדומה לצורך בדיקה. כשעורכים מכשיר וירטואלי באמצעות AVD Manager, אפשר לציין איזו תמונת מצב של המכשיר הווירטואלי תיטען כשהמכשיר הווירטואלי יופעל.

אמצעי הבקרה לשמירה, לטעינה ולניהול של תמונות מצב של AVD נמצאים עכשיו בכרטיסייה Snapshots בחלון Extended controls של האמולטור.

פרטים נוספים זמינים במאמר בנושא תמונות מצב.

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

‫3.1 (מרץ 2018)

‫Android Studio 3.1.0 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

3.1.4 (אוגוסט 2018)

העדכון הזה ל-Android Studio 3.1 כולל את השינויים והתיקונים הבאים:

• גרסת Kotlin שצורפה היא עכשיו 1.2.50.
• פרויקטים חדשים נוצרים עם kotlin-stdlib-jdk* artifacts, ולא עם ארטיפקטים של kotlin-stdlib-jre*, שהוצאו משימוש.
• בוצע שיפור בניתוח של כללי ProGuard ב-R8.
• הבאגים הבאים תוקנו:
• הניסיון להפעיל את המחלקה הראשית של Kotlin נכשל עם השגיאה: "Error: Could not find or load main class..."
• ‫R8 נכנס ללולאה אינסופית במהלך ביצוע אופטימיזציות מסוימות.
• השימוש בפקודה Rerun failed tests (הפעלה מחדש של בדיקות שנכשלו) בחלון Run (הפעלה) החזיר לפעמים באופן שגוי את ההודעה "No tests were found" (לא נמצאו בדיקות).
• ‫D8 לא טיפל נכון במקרים של invoke-virtual, מה שגרם לקריסה עם VerifyError: invoke-super/virtual can't be used on private method
• הקומפיילר של Data Binding הסתמך על גרסה ישנה של com.android.tools:annotations. הקומפיילר משתמש עכשיו בהערות של כלי הפרויקט הבסיסי, אם הן זמינות.
• ‫Android Studio קורס במהלך מעברים בין פרגמנטים כשמשתמשים בכלי פרופילים.
• קריסת מאתר הבאגים במהלך ניפוי באגים בפריסה עם תיבת טקסט.
• ‫D8 לא הצליח לקרוא קובצי ZIP מסוימים עם תווים מיוחדים.

‫3.1.3 (יוני 2018)

העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:

• דליפות זיכרון גרמו ל-Android Studio לפעול באיטיות ולא להגיב אחרי שהשתמשתם בכלי לעריכת פריסות. העדכון הזה כולל תיקונים לרוב הבעיות האלה. אנחנו מתכוונים לפרסם עדכון נוסף בקרוב כדי לטפל בדליפות זיכרון נוספות.
• חלק מהאפליקציות שנבנו באמצעות D8 קרסו בחלק מהטאבלטים מדגם Verizon Ellipsis.
• התקנה של אפליקציות שנבנו באמצעות D8 נכשלה עם שגיאה INSTALL_FAILED_DEXOPT במכשירים שמריצים Android 5.0 או 5.1 (רמת API‏ 21 או 22).
• חלק מהאפליקציות שהשתמשו בספריית OkHttp ונבנו באמצעות D8, קרסו במכשירים עם Android 4.4 (רמת API‏ 19).
• לפעמים ההפעלה של Android Studio נכשלה, עם ProcessCanceledException במהלך הפעלת המחלקה עבור com.intellij.psi.jsp.JspElementType.

‫3.1.2 (אפריל 2018)

העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:

• במקרים מסוימים, Android Studio נתקע ללא הגבלת זמן במהלך היציאה.

• כשמפעילים את Instant Run, בנייה שהוגדרה עם source sets נכשלת עם ההודעה הבאה:

  "The SourceSet name is not recognized by the Android Gradle Plugin."

• כשהתכונה 'הפעלה מיידית' הופעלה, בנייה של פרויקטים חדשים ב-Kotlin נכשלה כשהיא הופעלה על ידי הפקודה Run.
• במהלך העריכה של קובץ build.gradle, לפעמים היה עיכוב מורגש בין הקלדת התו לבין הופעתו במסך.

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

  "RejectedExecutionException: Thread limit exceeded replacing blocked worker"

• בחישוב של רשימת ה-DEX הראשית של D8 לא נלקחו בחשבון חלק מהקריאות הרפלקטיביות.

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

‫3.1.1 (אפריל 2018)

העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:

• במקרים מסוימים, כשפרויקט שנוצר ב-Android Studio 3.0 נפתח בפעם הראשונה ב-Android Studio 3.1, המשימה Gradle-aware Make הוסרה מהאזור Before launch בRun/Debug Configurations. התוצאה הייתה שהפרויקטים לא נוצרו כשלוחצים על הלחצן Run (הפעלה) או Debug (ניפוי באגים), מה שגרם לכשלים כמו פריסה של קובצי APK שגויים וקריסות כשמשתמשים ב-Instant Run.

  כדי לפתור את הבעיה הזו, ב-Android Studio 3.1.1 נוסף task של Gradle-aware Make להגדרת ההרצה של פרויקטים שחסר בהם הרכיב הזה. השינוי הזה מתרחש אחרי הסנכרון הראשון של Gradle, כשהפרויקט נטען.

• ניפוי הבאגים קרס כשניסיתם לנפות באגים בפריסה עם תיבת טקסט אם הפעלתם פרופיל מתקדם.
• ‫Android Studio קפא אחרי שלחצתם על Build Variants.
• קבצים מסוג AAR (ארכיון Android) חולצו פעמיים, פעם אחת במהלך תהליך הסנכרון של Gradle ופעם אחת במהלך תהליך ה-build של Gradle.
• חלק מהאלמנטים חסרו בקובצי וקטורים שניתנים לציור שיובאו מקובצי SVG.
• האזהרה לגבי הוצאה משימוש של הגדרת התלות compile עודכנה, ועכשיו היא כוללת הנחיות טובות יותר לגבי ההגדרות implementation ו-api. פרטים על מעבר משימוש בהגדרות compile זמינים במסמכי התיעוד של הגדרות התלות החדשות.

תכנות/IDE

IntelliJ 2017.3.3

סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA עד לגרסה 2017.3.3. השיפורים כוללים ניתוח טוב יותר של זרימת הבקרה באוספים ובמחרוזות, שיפור בהסקת מסקנות לגבי ערכי null, תיקונים מהירים חדשים ועוד.

פרטים נוספים זמינים בהערות הגרסה של JetBrains לגרסאות IntelliJ IDEA‏ 2017.2 ו-2017.3, וגם בהערות הגרסה של JetBrains בנושא עדכונים לתיקון באגים.

שיפורים בעריכת SQL עם Room

כשמשתמשים בספריית מסד הנתונים Room, אפשר ליהנות מכמה שיפורים בעריכת SQL:

• השלמת קוד בתוך Query מבינה טבלאות SQL (ישויות), עמודות, פרמטרים של שאילתות, כינויים, שאילתות איחוד (join), שאילתות משנה וסעיפי WITH.
• הדגשת התחביר של SQL פועלת עכשיו.
• אפשר ללחוץ לחיצה ימנית על שם של טבלה ב-SQL ולשנות את השם שלה. הפעולה הזו גם כותבת מחדש את קוד Java או Kotlin התואם (כולל, למשל, סוג ההחזרה של השאילתה). שינוי השם פועל גם בכיוון ההפוך, כך ששינוי שם של מחלקה או שדה ב-Java גורם לכתיבה מחדש של קוד ה-SQL המתאים.
• שימושים ב-SQL מוצגים כשמשתמשים באפשרות Find usages (לוחצים לחיצה ימנית ובוחרים באפשרות Find usages בתפריט ההקשר).
• כדי לעבור להצהרה של ישות SQL בקוד Java או Kotlin, אפשר ללחוץ על הישות תוך כדי החזקת המקש Control (או Command ב-Mac).

מידע על שימוש ב-SQL עם Room זמין במאמר בנושא שמירת נתונים במסד נתונים מקומי באמצעות Room.

עדכונים בנושא קישור נתונים

העדכון הזה כולל כמה שיפורים בקישור נתונים:

• עכשיו אפשר להשתמש באובייקט LiveData כשדה שניתן לצפייה בביטויים של קישור נתונים. המחלקות ViewDataBinding כוללות עכשיו את השיטה החדשה setLifecycle(), שבה משתמשים כדי לצפות באובייקטים LiveData.

• הכיתה ObservableField יכולה עכשיו לקבל אובייקטים אחרים של Observable בבונה שלה.

• אתם יכולים לראות תצוגה מקדימה של קומפיילר מצטבר חדש עבור מחלקות של קשירת נתונים. פרטים על הקומפיילר החדש הזה והוראות להפעלה שלו זמינים במאמר בנושא קומפיילר V2 של Data Binding.

  היתרונות של הקומפיילר החדש כוללים:

  • מחלקות ViewBinding נוצרות על ידי הפלאגין של Android ל-Gradle לפני קומפיילר Java.
  • המחלקה המחייבת שנוצרת בספריות נשמרת כשהאפליקציה עוברת קומפילציה, במקום ליצור אותה מחדש בכל פעם. כך אפשר לשפר משמעותית את הביצועים בפרויקטים עם כמה מודולים.

קומפיילר ו-Gradle

‫D8 הוא מהדר DEX שמוגדר כברירת מחדל

המהדר D8 משמש עכשיו כברירת מחדל ליצירת קוד בייט של DEX.

קומפיילר ה-DEX החדש מביא איתו כמה יתרונות, כולל:

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

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

אם הגדרתם את android.enableD8 לערך false ב-gradle.properties, אתם צריכים למחוק את הדגל הזה או להגדיר אותו לערך true:

        android.enableD8=true
      

פרטים נוספים זמינים במאמר בנושא מהדר DEX חדש.

הסרת סוכר תחבירי מצטברת

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

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

כדי להשבית את ההסרה ההדרגתית של תחביר סוכר, צריך לציין את ההגדרה הבאה בקובץ gradle.properties של הפרויקט:

        android.enableIncrementalDesugaring=false
      

חלון פלט פשוט

מסוף Gradle הוחלף בחלון Build, שכולל את הכרטיסיות Sync ו-Build.

פרטים על השימוש בחלון Build החדש והפשוט יותר זמינים במאמר בנושא מעקב אחרי תהליך ה-build.

עדכונים באצווה ואינדוקס מקבילי

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

‫C++‎ ו-LLDB

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

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

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

• הוספנו מעצבים (pretty printers) למבני נתונים נוספים ב-C++‎, כדי שיהיה קל יותר לקרוא את הפלט של LLDB.

• ‫LLDB פועל עכשיו רק עם Android 4.1 (רמת API‏ 16) ומעלה.

הערה: ניפוי באגים מקורי באמצעות Android Studio 3.0 ומעלה לא פועל ב-Windows ב-32 ביט. אם אתם משתמשים ב-Windows 32 bit ואתם צריכים לנפות באגים בקוד מקומי, אתם צריכים להשתמש ב-Android Studio 2.3.

Kotlin

‫Kotlin שודרג לגרסה 1.2.30

‫Android Studio 3.1 כולל את Kotlin בגרסה 1.2.30.

קוד Kotlin מנותח עכשיו באמצעות בדיקת lint בשורת הפקודה

הפעלת lint משורת הפקודה מנתחת עכשיו את מחלקות Kotlin.

בכל פרויקט שרוצים להריץ עליו את lint, צריך לכלול את מאגר ה-Maven של Google בקובץ build.gradle ברמה העליונה. מאגר Maven כבר כלול בפרויקטים שנוצרו ב-Android Studio 3.0 ומעלה.

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

דגימת תהליכי C++‎ מקוריים באמצעות הכלי לניתוח ביצועי ה-CPU

הכלי CPU Profiler כולל עכשיו הגדרת ברירת מחדל להקלטת עקבות של דגימות של השרשורים המקומיים של האפליקציה. כדי להשתמש בהגדרה הזו, צריך לפרוס את האפליקציה למכשיר עם Android 8.0 (API ברמה 26) ומעלה, ואז לבחור באפשרות Sampled (Native) (דגימה (מקומי)) בתפריט הנפתח של הגדרות ההקלטה בכלי CPU Profiler. אחר כך, מקליטים ובודקים את הנתונים כרגיל.

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

כדי לחזור למעקב אחרי השרשורים של Java, בוחרים באחת מההגדרות הבאות: Sampled (Java) או Instrumented (Java).

סינון של עקבות מעבד, תוצאות של הקצאת זיכרון ו-heap dumps

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

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

טיפ: אפשר גם לפתוח את שדה החיפוש על ידי הקשה על Control + F (או על Command + F ב-Mac).

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

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

הכרטיסייה Request (בקשה) בכלי Network Profiler

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

תצוגת השרשור בכלי לניתוח הרשת

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

• Connection View: מספק את אותו מידע כמו בגרסאות קודמות של Android Studio – מוצגים בו קבצים שנשלחו או התקבלו במהלך החלק שנבחר בציר הזמן בכל השרשורים של מעבד ה-CPU באפליקציה. לכל בקשה אפשר לבדוק את הגודל, הסוג, הסטטוס ומשך השידור.
• תצוגת שרשור: מציגה את פעילות הרשת של כל אחד משרשורי ה-CPU של האפליקציה. בתצוגה הזו אפשר לבדוק אילו מהשרשורים באפליקציה אחראים לכל בקשת רשת.

כלי לבדיקת פריסות

נוספו תכונות חדשות לכלי לבדיקת פריסה, כולל פונקציונליות שסופקה בעבר על ידי הכלים Hierarchy Viewer ו-Pixel Perfect שהוצאו משימוש:

• לחצני שינוי מרחק התצוגה ומקשי קיצור לניווט ולבדיקת פריסות
• שכבת-על של רשת ההפניה
• אפשרות לטעון תמונת הפניה ולהשתמש בה כשכבת-על (שימושי להשוואה בין הפריסה שלכם לבין מוקאפ של ממשק משתמש)
• הצגת תצוגה מקדימה של עץ משנה כדי לבודד תצוגה בפריסה מורכבת

כלי לעריכת פריסות

בוצעו הרבה שיפורים בלוח בעורך הפריסה:

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

אפשר להשתמש בפקודה החדשה Convert view (המרת תצוגה) בComponent tree (עץ הרכיבים) או בעורך העיצוב כדי להמיר תצוגה או פריסה לסוג אחר של תצוגה או פריסה.

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

הרצה והרצה מיידית

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

כשמטרגטים מכשיר עם Android 8.0 (רמת API‏ 26) ומעלה, אפשר להשתמש ב-Instant Run כדי לפרוס שינויים במשאבים בלי להפעיל מחדש את האפליקציה. האפשרות הזו קיימת כי המשאבים כלולים בקובץ APK מפוצל.

מכשיר הדמיה

לפרטים על מה חדש ומה השתנה באמולטור מאז Android Studio 3.0, אפשר לעיין בנתוני הגרסה של Android Emulator מגרסה 27.0.2 עד גרסה 27.1.12.

השיפורים העיקריים כוללים:

• תמונות מצב של הפעלה מהירה לשמירת מצב האמולטור והפעלה מהירה יותר, עם אפשרות להשתמש בפקודה Save now כדי לשמור מצב התחלה מותאם אישית.
• מסך אמולטור ללא חלון.
• תמונות מערכת ל-Android 8.0 (רמת API‏ 26), ל-Android 8.1 (רמת API‏ 27) ול-Android P Developer Preview.

שיפורים בממשק המשתמש ובחוויית המשתמש

עוד תיאורי כלים, מקשי קיצור והודעות מועילות

הוספנו תיאורי כלים ושכבות-על עם הודעות מועילות במקומות רבים ב-Android Studio.

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

הוסר התפריט 'כלים' > Android

התפריט Tools > Android הוסר. הפקודות שהיו קודם בתפריט הזה הועברו למקום אחר.

• הרבה פקודות הועברו ישירות מתחת לתפריט כלים.
• הפקודה Sync project with gradle files עברה לתפריט File.
• הפקודה Device Monitor הוסרה, כפי שמתואר בהמשך.

הכלי 'מעקב אחרי מכשירים' זמין משורת הפקודה

ב-Android Studio 3.1, התפקיד של Device Monitor מצומצם יותר ממה שהיה בעבר. במקרים רבים, הפונקציונליות שזמינה דרך הכלי Device Monitor מסופקת עכשיו על ידי כלים חדשים ומשופרים.

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

‫3.0 (אוקטובר 2017)

‫Android Studio 3.0.0 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.

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

‫3.0.1 (נובמבר 2017)

זהו עדכון קל ל-Android Studio 3.0 שכולל תיקוני באגים כלליים ושיפורי ביצועים.

Android Plugin for Gradle 3.0.0

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

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

הערה: השיפורים האלה דרשו שינויים משמעותיים שמשבשים חלק מההתנהגויות, ה-DSL וממשקי ה-API של הפלאגין. שדרוג לגרסה 3.0.0 עשוי לדרוש שינויים בקובצי ה-build ובפלאגינים של Gradle.

הגרסה הזו כוללת גם את הפריטים הבאים:

• תמיכה ב-Android 8.0.
• תמיכה ביצירת קובצי APK נפרדים על סמך משאבי שפה.
• תמיכה בספריות Java 8 ובתכונות של שפת Java 8 (ללא מהדר Jack).
• תמיכה בספריית התמיכה בבדיקות Android בגרסה 1.0 (כלי בדיקה ל-Android ותזמור בדיקות ל-Android).
• שיפור המהירות של ndk-build ו-cmake build.
• שיפור מהירות הסנכרון של Gradle.
• הכלי AAPT2 מופעל עכשיו כברירת מחדל.
• השימוש ב-ndkCompile מוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד מקומי שרוצים לארוז ב-APK. מידע נוסף זמין במאמר בנושא העברה מ-ndkcompile.

מידע נוסף על השינויים זמין בהערות על הגרסה של הפלאגין של Android ל-Gradle.

אם אתם מוכנים לשדרג לפלאגין החדש, כדאי לעיין במאמר בנושא מעבר ל-Android Plugin for Gradle 3.0.0.

תמיכה ב-Kotlin

כפי שהודענו בכנס Google I/O בשנת 2017, שפת התכנות Kotlin נתמכת עכשיו באופן רשמי ב-Android. לכן, החל מהגרסה הזו, Android Studio כולל תמיכה בשפת Kotlin לפיתוח Android.

כדי לשלב את Kotlin בפרויקט, אפשר להמיר קובץ Java ל-Kotlin (לוחצים על Code > Convert Java File to Kotlin File) או ליצור פרויקט חדש עם Kotlin באמצעות האשף New Project.

כדי להתחיל, מומלץ לקרוא איך מוסיפים Kotlin לפרויקט.

תמיכה בתכונות של שפת Java 8

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

כדי לעדכן את הפרויקט כך שיתמוך בערכת הכלים החדשה של שפת Java 8, צריך לעדכן את Source Compatibility (תאימות המקור) ואת Target Compatibility (תאימות היעד) ל-1.8 בתיבת הדו-שיח Project Structure (מבנה הפרויקט) (לוחצים על File > Project Structure (קובץ > מבנה הפרויקט)). למידע נוסף, אפשר לקרוא על שימוש בתכונות של שפת Java 8.

Android Profiler

הכלי החדש Android Profiler מחליף את הכלי Android Monitor ומספק חבילה חדשה של כלים למדידת השימוש במעבד (CPU), בזיכרון וברשת של האפליקציה בזמן אמת. אפשר לבצע מעקב אחר שיטות שמבוסס על דגימה כדי לתזמן את הביצוע של הקוד, לצלם תמונות מצב של ערימת הזיכרון (heap snapshot), לראות את הקצאות הזיכרון ולבדוק את הפרטים של קבצים שמועברים ברשת.

כדי לפתוח את הכלי, לוחצים על View > Tool Windows > Android Profiler (תצוגה > חלונות כלים > Android Profiler) או על Android Profiler בסרגל הכלים.

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

הערה: התצוגה Logcat הועברה גם היא לחלון נפרד (היא הייתה קודם ב-Android Monitor, שהוסר).

בציר הזמן של סקירת Android Profiler, לוחצים על ציר הזמן CPU,‏ MEMORY או NETWORK כדי לגשת לכלי הפרופיל המתאים.

CPU Profiler

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

מידע נוסף זמין במדריך ל-CPU Profiler.

כלי לניתוח ביצועי הזיכרון

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

מידע נוסף זמין במדריך ל-Memory Profiler.

Network Profiler

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

מידע נוסף זמין במדריך Network Profiler.

ניפוי באגים ופרופיל של קובץ APK

עכשיו אפשר ב-Android Studio ליצור פרופיל של כל קובץ APK ולנפות בו באגים בלי לבנות אותו מפרויקט Android Studio – כל עוד קובץ ה-APK בנוי כך שניפוי הבאגים מופעל ויש לכם גישה לסמלי ניפוי הבאגים ולקובצי המקור.

כדי להתחיל, לוחצים על Profile or debug APK (פרופיל או ניפוי באגים ב-APK) במסך הפתיחה של Android Studio. לחלופין, אם כבר פתוח פרויקט, לוחצים על קובץ > פרופיל או ניפוי באגים ב-APK בסרגל התפריטים. יוצגו קובצי ה-APK שחולצו, אבל הקוד לא יעבור דה-קומפילציה. לכן, כדי להוסיף נקודות עצירה ולצפות בנתוני מעקב אחר ביצוע (stack trace) בצורה תקינה, צריך לצרף קובצי מקור של Java וסמלי נייטיב של ניפוי באגים.

מידע נוסף זמין במאמר בנושא פרופיל וניפוי באגים של קובצי APK מוכנים מראש.

סייר קבצים במכשיר

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

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

מידע נוסף זמין במדריך ל-Device File Explorer.

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

הוספנו תמיכה חדשה באפליקציות ללא התקנה ל-Android, שמאפשרת ליצור אפליקציות ללא התקנה בפרויקט באמצעות שני סוגים חדשים של מודולים: מודולים של אפליקציות ללא התקנה ומודולים של תכונות (כדי להשתמש בהם צריך להתקין את Instant Apps Development SDK).

ב-Android Studio יש גם פעולת refactoring חדשה של מודולריזציה שעוזרת לכם להוסיף תמיכה באפליקציות מיידיות בפרויקט קיים. לדוגמה, אם רוצים לשנות את המבנה של הפרויקט כדי להציב כמה מחלקות במודול של תכונה של אפליקציה מיידית, בוחרים את המחלקות בחלון Project (פרויקט) ולוחצים על Refactor > Modularize (שינוי מבנה > הפיכה למודולרי). בתיבת הדו-שיח שמופיעה, בוחרים את המודול שאליו רוצים להעביר את הכיתות ולוחצים על אישור.

כשמוכנים לבדוק את האפליקציה המיידית, אפשר ליצור ולהפעיל את מודול האפליקציה המיידית במכשיר מחובר. כדי לעשות זאת, מציינים את כתובת ה-URL של האפליקציה המיידית באפשרויות ההפעלה של הגדרות ההרצה: בוחרים באפשרות Run > Edit Configurations (הפעלה > עריכת הגדרות), בוחרים את מודול האפליקציה המיידית ומגדירים את כתובת ה-URL בקטע Launch Options (אפשרויות הפעלה).

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

מודולים של Android Things

תבניות חדשות של Android Things באשפי 'פרויקט חדש' ו'מודול חדש' שיעזרו לכם להתחיל לפתח למכשירי IoT מבוססי Android.

מידע נוסף זמין במאמר בנושא יצירת פרויקט Android Things.

אשף הסמלים הדינמיים

‫Image Asset Studio תומך עכשיו בנכסי וקטור ומאפשר ליצור סמלי אפליקציה דינמיים ל-Android 8.0, ובו-זמנית ליצור סמלים רגילים (סמלים מדור קודם) למכשירים ישנים יותר.

כדי להתחיל, לוחצים לחיצה ימנית על התיקייה res בפרויקט ואז לוחצים על New > Image Asset (חדש > נכס תמונה). בחלון Asset Studio, בוחרים באפשרות Launcher Icons (Adaptive and Legacy) (סמלי מרכז האפליקציות (אדפטיביים ומדור קודם)) כסוג הסמל.

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

מידע נוסף זמין במאמר בנושא סמלים דינמיים.

תמיכה במשאבי גופנים

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

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

Firebase App Indexing Assistant

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

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

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

Android App Links Assistant

App Links Assistant עודכן עם היכולות החדשות הבאות:

• מוסיפים בדיקות של כתובות URL לכל מיפוי של כתובת URL כדי לוודא שמסנני הכוונות מטפלים בכתובות URL מהעולם האמיתי.

  אפשר גם להגדיר את הבדיקות האלה של כתובות URL באופן ידני באמצעות התג <tools:validation> שמתואר בהמשך.

• יוצרים קובץ Digital Asset Links עם רשומת האובייקט המתאימה כדי לתמוך ב-Google Smart Lock, ומוסיפים את התג asset_statements <meta-data> המתאים לקובץ המניפסט.

כלי לאימות מסנן Intent של כתובת URL

‫Android Studio תומך עכשיו בתג מיוחד בקובץ המניפסט, שמאפשר לכם לבדוק את כתובות ה-URL של מסנן ה-Intent. אלה אותם תגים שהכלי App Links Assistant יכול ליצור בשבילכם.

כדי להצהיר על כתובת URL לבדיקה של מסנן Intent, מוסיפים רכיב <tools:validation> לצד רכיב <intent-filter> המתאים. לדוגמה:

      <activity ...>
          <intent-filter>
              ...
          </intent-filter>
          <tools:validation testUrl="https://www.example.com/recipe/1138" />
      </activity>
    
    

חשוב לכלול גם את xmlns:tools="http://schemas.android.com/tools" בתג <manifest>.

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

כלי לעריכת פריסות

כלי פריסת הדפים עודכן עם מספר שיפורים, כולל:

• פריסה וסמלים חדשים בסרגל הכלים.
• הפריסה עודכנה בעץ הרכיבים.
• שיפורים בהוספת תצוגות באמצעות גרירה ושחרור.
• לוח שגיאות חדש מתחת לכלי העריכה, שבו מוצגות כל הבעיות עם הצעות לתיקון (אם יש כאלה).
• ביצענו שיפורים שונים בממשק המשתמש כדי להקל על השימוש ב-ConstraintLayout, כולל:
  • תמיכה חדשה ביצירת מחסומים.
  • תמיכה חדשה ביצירת קבוצות: בסרגל הכלים, בוחרים באפשרות הנחיות > הוספת קבוצה (נדרשת גרסה ConstraintLayout 1.1.0 beta 2 או גרסה מתקדמת יותר)
  • ממשק משתמש חדש ליצירת שרשורים: בוחרים כמה תצוגות, לוחצים לחיצה ימנית ואז בוחרים באפשרות שרשור.

כלי לבדיקת פריסות

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

הכלי לניתוח APK

עכשיו אפשר להשתמש בכלי לניתוח קובצי APK משורת הפקודה באמצעות הכלי apkanalyzer.

גם הכלי לניתוח APK עודכן, והשיפורים הבאים נוספו לו:

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

מידע נוסף זמין במאמר ניתוח של ה-Build באמצעות הכלי APK Analyzer.

תצוגה מקדימה של מהדר D8 DEX

‫Android Studio 3.0 כולל קומפיילר DEX חדש אופציונלי בשם D8. בסופו של דבר הוא יחליף את מהדר ה-DX, אבל אפשר להפעיל את מהדר ה-D8 החדש כבר עכשיו.

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

כדי לנסות את התכונה, מגדירים את הערכים הבאים בקובץ gradle.properties של הפרויקט:

android.enableD8=true
    

מידע נוסף זמין בפוסט בבלוג בנושא מהדר D8.

מאגר Maven של Google

מעכשיו, Android Studio משתמש כברירת מחדל במאגר Maven של Google, במקום להסתמך על Android SDK Manager כדי לקבל עדכונים לספריית התמיכה של Android, ל-Google Play Services, ל-Firebase ולתלויות אחרות. כך קל יותר לעדכן את הספריות, במיוחד כשמשתמשים במערכת שילוב רציף (CI).

כל הפרויקטים החדשים כוללים עכשיו את מאגר Google Maven כברירת מחדל. כדי לעדכן את הפרויקט הקיים, מוסיפים את google() בבלוק repositories של קובץ build.gradle ברמה העליונה:

      allprojects {
          repositories {
              google()
          }
      }
    
    

מידע נוסף על מאגר Maven של Google

שינויים אחרים

• ניפוי באגים מקורי באמצעות Android Studio כבר לא תומך ב-Windows בגרסת 32 סיביות. החלטנו להתמקד בפלטפורמות אחרות כי רק מעט מפתחים משתמשים בפלטפורמה הזו. אם אתם משתמשים ב-Windows 32 bit ואתם מתכננים לבצע ניפוי באגים בקוד מקורי, כדאי שתמשיכו להשתמש ב-Android Studio 2.3.
• שדרגנו את סביבת הפיתוח המשולבת הבסיסית ל-IntelliJ 2017.1.2, שכוללת מספר תכונות חדשות מ-2016.3 ומ-2017.1, כמו שינוי מבנה של שפת Java 8, רמזים לפרמטרים, הדגשה סמנטית, נקודות עצירה שאפשר לגרור, תוצאות מיידיות בחיפוש ועוד.
• נוספו הרבה בדיקות חדשות של Lint.
• אפשר גם לעיין בעדכונים האחרונים של Android Emulator.

‫2.3 (מרץ 2017)

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

‫2.3.3 (יוני 2017)

זהו עדכון קל שנועד להוסיף תמיכה ב-Android O (רמת API‏ 26).

‫2.3.2 (אפריל 2017)

זהו עדכון קל ל-Android Studio 2.3 עם השינויים הבאים:

• עדכונים ל-AVD Manager כדי לתמוך ב-Google Play בקובצי אימג' של המערכת.
• תיקוני באגים ב-NDK builds כשמשתמשים בגרסה R14 ומעלה של NDK.

אפשר גם לעיין בעדכונים התואמים ל-Android Emulator 26.0.3.

‫2.3.1 (אפריל 2017)

זהו עדכון קל ל-Android Studio 2.3 שמתקן בעיה שבה חלק ממכשירי Android פיזיים לא פעלו כראוי עם Instant Run (ראו Issue #235879).

<h3 class="hide-from-toc">
  New
</h3>

<div class="video-wrapper-left">
  <iframe class="devsite-embedded-youtube-video" data-video-id="VFyKclKBGf0"
          data-autohide="1" data-showinfo="0" frameborder="0" allowfullscreen>
  </iframe>
</div>

<ul>
  <li>Android Studio can now convert PNG, BMP, JPG, and static GIF files to
  WebP format. WebP is an image file format from Google that provides lossy
  compression (like JPEG) as well as transparency (like PNG) but can provide
  better compression than either JPEG or PNG. For more information, see
    <a href="/studio/write/convert-webp.html">Convert images to WebP in Android
    Studio</a>.
  </li>

  <li>The new <a href="/studio/write/app-link-indexing.html">App Links
  Assistant</a> simplifies the process of adding Android App Links to your app
  into a step-by-step wizard. Android App Links are HTTP URLs that bring users
  directly to specific content in your Android app.
  </li>

  <li>The Layout Editor now includes support for two new ConstraintLayout
  features:
    <ul>
      <li>Define a view size based on an aspect ratio.
      </li>
      <li>Create packed, spread, and weighted linear groups with constraint
      chains.
      </li>
    </ul>
    For more information, see <a href=
    "/training/constraint-layout/index.html">Build a Responsive UI with
    ConstraintLayout</a>.
  </li>

  <li>The Layout Editor also now lets you create a list of <a href=
  "/studio/write/layout-editor.html#edit-properties">favorite attributes</a> so
  you don't have to click <b>View all attributes</b> to access the attributes
  you use most.
  </li>

  <li>When adding a material icon using the Vector Import Dialog (<b>File &gt;
  New &gt; Vector Asset</b>), you can now filter the list of available icons by
  category or by icon name. For more information, see <a href=
  "/studio/write/vector-asset-studio.html#materialicon">Adding a material
  icon</a>.
  </li>

  <li>
    <a href="/studio/write/annotations.html#accessibility">New and updated
    annotations</a>. The new <code>@RestrictTo</code> annotation for methods,
    classes, and packages lets you restrict an API. The updated
    <code>@VisibleForTesting</code> annotation now has an optional
    <code>otherwise</code> argument that lets you designate what the visibility
    of a method should be if not for the need to make it visible for testing.
    Lint uses the <code>otherwise</code> option to enforce the intended
    visibility of the method.
  </li>

  <li>New <a href="/studio/write/lint.html#snapshot">lint baseline support</a>
  allows you to use a snapshot of your project's current set of warnings as a
  baseline for future inspection runs so only new issues are reported. The
  baseline snapshot lets you start using lint to fail the build for new issues
  without having to go back and address all existing issues first.
  </li>

  <li>New lint checks, including the following:
    <ul>
      <li>Obsolete <code>SDK_INT</code> Checks: Android Studio removes obsolete
      code that checks for SDK versions.
      </li>
      <li>Object Animator Validation: Lint analyzes your code to make sure that
      your <code>ObjectAnimator</code> calls reference valid methods with the
      right signatures and checks that those methods are annotated with <code>
        @Keep</code> to prevent ProGuard from renaming or removing them during
        release builds.
      </li>
      <li>Unnecessary Item Decorator Copy: Older versions of the
      <code>RecyclerView</code> library did not include a divider decorator
      class, but one was provided as a sample in the support demos. Recent
      versions of the library have a divider decorator class. Lint looks for
      the old sample and suggests replacing it with the new one.
      </li>
      <li>WifiManager Leak: Prior to Android 7.0 (API level 24), initializing
      the <code>WifiManager</code> with <code><a href="/reference/android/content/Context.html#getSystemService(java.lang.Class&lt;T&gt;)">Context.getSystemService()</a></code>
      can cause a memory leak if the context is not the application context.
      Lint looks for these initializations, and if it <em>cannot</em> determine
      that the context is the application context, it suggests you use <code><a href="/reference/android/content/Context.html#getApplicationContext()">Context.getApplicationContext()</a></code> to get the proper context for the
      initialization.
      </li>
      <li>Improved Resource Prefix: The existing <code>resourcePrefix</code>
      lint check had many limitations. You can now configure your project with
      a prefix, such as <code>android { resourcePrefix '<var>my_lib</var>'
      }</code>, and lint makes sure that all of your resources are using this
      prefix. You can use variations of the name for styles and themes. For
      example for the <var>my_lib</var> prefix, you can have themes named
      <code>MyLibTheme</code>, <code>myLibAttr</code>,
      <code>my_lib_layout</code>, and so on.
      </li>
      <li>Switch to WebP: This check identifies images in your project that can
      be converted to WebP format based on your project’s
      <code>minSdkVersion</code> setting. An associated quickfix can
      automatically convert the images, or you can <a href=
      "/studio/write/convert-webp.html">convert images to WebP</a> manually.
      </li>
      <li>Unsafe WebP: If your project already includes WebP images, this check
      analyzes your project to ensure that your <code>minSdkVersion</code>
      setting is high enough to support the included images. For more
      information about WebP support in Android and Android Studio, see
      <a class="external" href=
      "https://developers.google.com/speed/webp/faq#which_web_browsers_natively_support_webp">
        Which browsers natively support WebP?</a> and <a href=
        "/studio/write/convert-webp.html">Create WebP Images Using Android
        Studio</a>.
      </li>
    </ul>
  </li>
</ul>

<h3 class="hide-from-toc">
  Changes
</h3>

<ul>
  <li>A separate button to push changes with Instant Run: After deploying your
  app, you now click <b>Apply Changes</b> <img src=
  "/studio/images/buttons/toolbar-apply-changes.svg" alt="" class=
  "inline-icon"> to quickly push incremental changes to your running app using
  Instant Run. The <b>Run</b> <img src="/studio/images/buttons/toolbar-run.png"
    alt="" class="inline-icon"> and <b>Debug</b> <img src=
    "/studio/images/buttons/toolbar-debug.png" alt="" class="inline-icon">
    buttons are always available to you when you want to reliably push your
    changes and force an app restart.
    <ul>
      <li>Instant Run is supported only when deploying your app to a target
      device running Android 5.0 (API level 21) or higher.
      </li>
      <li>Instant Run is no longer disabled for projects that <a href=
      "/studio/projects/add-native-code.html">link to external native
      projects</a> using CMake or ndk-build. However, you can only use Instant
      Run to push incremental changes to your Java code, not your native code.
      </li>
      <li>Cold swaps (which you can force for a running app by clicking
      <strong>Run</strong> <img src="/studio/images/buttons/toolbar-run.png"
      alt="" class="inline-icon">) are now more reliable. Forcing a cold swap
      also fixes the issue where changes to notification and widget UIs were
      not updated on the target device.
      </li>
      <li>Includes optimizations that make app startup much faster. These
      optimizations may affect profiling, so you should temporarily <a href=
      "/studio/run/index.html#disable-ir">disable Instant Run</a> whenever
      profiling your app.
      </li>
    </ul>
  </li>

  <li>
    <p>
      The <b>AVD Manager</b> <img src=
      "/studio/images/buttons/toolbar-avd-manager.png" alt="" class=
      "inline-icon"> and <b>SDK Manager</b> <img src=
      "/studio/images/buttons/toolbar-sdk-manager.png" alt="" class=
      "inline-icon"> buttons are now included in the lean Navigation Bar as
      well as the full Toolbar. To use the lean Navigation Bar, click
      <b>View</b> to open the View menu, then ensure that <b>Navigation Bar</b>
      is selected and <b>Toolbar</b> is <em>not</em> selected.
    </p>
    <img src="/studio/images/releases/navigationbar_sdkavd_2x.png" width="757">
  </li>

  <li>The "Hybrid" debugger has been renamed to "Dual" debugger.
  </li>

  <li>In the <a href="/studio/run/rundebugconfig.html">Run/Debug
  Configurations</a> dialog, under Defaults in the left pane, the following run
  configuration names have changed with no behavior changes:
    <ul>
      <li>The JUnit name has changed to Android JUnit. If you have a project
      that uses JUnit run configurations, those configurations are transformed
      to Android JUnit run configurations the first time you open the project
      with Android Studio. A dialog appears to inform you of the name change.
      </li>
      <li>The Android Tests name has changed to Android Instrumented Tests.
      </li>
    </ul>
  </li>

  <li>The <a href="/studio/debug/am-gpu-debugger.html">GPU Debugger</a> has
  been removed from Android Studio as of version 2.3. An open-source,
  standalone version of the tool is now available on <a href=
  "https://github.com/google/gapid" class="external-link">GitHub</a>.
  </li>

  <li>The Run/Debug option is no longer available when you right-click a <code>
    *.gradle build</code> script.
  </li>

  <li>All templates now use <code>ConstraintLayout</code> as the default
  layout.
  </li>

  <li>The Widgets palette in the Layout Editor has been redesigned.
  </li>
</ul>

<p>
  This release also includes a number of bug fixes. <a href=
  "https://code.google.com/p/android/issues/list?can=1&amp;q=target%3D2.3+status%3DReleased&amp;colspec=ID+Status+Priority+Owner+Summary+Stars+Reporter+Opened&amp;cells=tiles">
  See all bug fixes in 2.3.0.</a>
</p>

<p class="note">
  <b>Known issue:</b> Some device manufacturers block apps from automatically
  launching after being installed on the device. When deploying your app to a
  physical device using Android Studio 2.3, this restriction breaks the
  intended behavior of Instant Run and causes the following error output:
  <code>Error: Not found; no service started</code>. To avoid this issue,
  either <a href="/studio/run/emulator.html">use the emulator</a> or enable
  automatic launching for your app in your device's settings. The procedure
  for doing this is different for each device, so check the instructions
  provided by the manufacturer. To learn more about this issue, see
  <a href="https://code.google.com/p/android/issues/detail?id=235879">Issue
    #235879</a>.
</p>

‫2.2 (ספטמבר 2016)

‫2.2.3 (דצמבר 2016)

<p>
  This is a minor update to Android Studio 2.2. It includes a bug fixes
  focused around gradle, the core IDE, and lint.
</p>

<p>
  Highlighted build changes:
</p>

<ul>
  <li>ProGuard version rollback. Due to a <a href=
  "https://sourceforge.net/p/proguard/bugs/625/">correctness issue</a>
  discovered in ProGuard 5.3.1, we have rolled back to ProGuard 5.2.1. We
  have worked with the ProGuard team on getting a fix quickly, and we expect
  to roll forward to ProGuard 5.3.2 in Android Studio 2.3 Canary 3.
  </li>
  <li>Bug fix for <code>aaptOptions</code> <code>IgnoreAssetsPattern</code>
  not working properly (<a href="http://b.android.com/224167">issue
  224167</a>)
  </li>
  <li>Bug fix for Gradle autodownload for Constraint Layout library
    (<a href="https://code.google.com/p/android/issues/detail?id=212128">issue
    212128</a>)
  </li>
  <li>Bug fix for a JDK8/Kotlin compiler + dx issue (<a href=
  "http://b.android.com/227729">issue 227729</a>)
  </li>
</ul>

<p>
  <a href=
  "https://code.google.com/p/android/issues/list?can=1&amp;q=target%3D2.2.3+status%3AReleased+&amp;colspec=ID+Status+Priority+Owner+Summary+Stars+Reporter+Opened&amp;cells=tiles">
  See all bug fixes in 2.2.3</a>.
</p>

‫2.2.2 (אוקטובר 2016)

<p>
  This is a minor update to Android Studio 2.2. It includes a number of small
  changes and bug fixes, including:
</p>

<ul>
  <li>When reporting Instant Run issues through the IDE, the report now also
  includes logcat output for <code>InstantRun</code> events. To help us
  improve Instant Run, please <a href=
  "/studio/run/index.html#submit-feedback">enable extra logging and report
  any issues</a>.
  </li>
  <li>A number of small bug fixes for Gradle.
  </li>
  <li>A fix for problems with generating multiple APKs.
  </li>
</ul>

‫2.2.1 (אוקטובר 2016)

<p>
  This is a minor update to Android Studio 2.2. It includes several bug fixes
  and a new feature to enable extra logging to help us troubleshoot Instant
  Run issues—to help us improve Instant Run, please <a href=
  "/studio/run/index.html#submit-feedback">enable extra logging and report
  any issues</a>.
</p>

חדש

• כלי חדש לעריכת פריסות עם כלים שנוצרו במיוחד לתמיכה ב-ConstraintLayout.

<li>New <strong><a href=
"http://tools.android.com/tech-docs/layout-inspector">Layout
Inspector</a></strong> lets you examine snapshots of your layout hierarchy
while your app is running on the emulator or a device.
</li>

<li>New <strong><a href="/studio/write/firebase.html">Assistant</a></strong>
window to help you integrate Firebase services into your app.
</li>

<li>New <strong><a href="/studio/debug/apk-analyzer.html">APK
Analyzer</a></strong> tool so you can inspect the contents of your packaged
app.
</li>

<li>New <strong><a href=
"http://tools.android.com/tech-docs/test-recorder">Espresso Test
Recorder</a></strong> tool (currently in beta) to help you create UI tests by
recording your own interactions.
</li>

<li>New <strong><a href=
"http://tools.android.com/tech-docs/build-cache">build cache</a></strong>
(currently experimental) to speed up build performance.
</li>

<li>New <strong>C/C++ build integration with CMake and ndk-build</strong>.
Compile and build new or existing native code into libraries packaged into
your APK, and debug using lldb. For new projects, Android Studio uses CMake
by default, but also supports ndk-build for existing projects. To learn how
to include native code in your Android application, read <a href=
"/studio/projects/add-native-code.html">Add C and C++ Code to Your
Project</a>. To learn how to debug native code with lldb, see <a href=
"/studio/debug/index.html#debug-native">Debug Native Code</a>.
</li>

<li>New <strong><a href="/studio/intro/index.html#sample-code">Samples
Browser</a></strong> so you can easily look up Google Android sample code
from within Android Studio to jump start app development.
</li>

<li>New <strong>Merged Manifest Viewer</strong> to help you diagnose how your
manifest file merges with your app dependencies across project build
variants.
</li>

<li>The <strong>Run</strong> window now contains log messages for the current
running app. Note that you can configure the <a href=
"/studio/debug/am-logcat.html">logcat Monitor</a> display, but not the
<strong>Run</strong> window.
</li>

<li>New <strong><a href="/studio/run/emulator.html">Android
Emulator</a></strong> features:
  <ul>
    <li>Added new <strong>Virtual</strong> <strong>Sensors</strong> and
    <strong>Cellular</strong> &gt; <strong>Signal Strength</strong> controls.
    </li>
    <li>Added an <strong>LTE</strong> option to the <strong>Cellular</strong>
    &gt; <strong>Network type</strong> control.
    </li>
    <li>Added simulated vertical swipes for scrolling through vertical menus
    with a mouse wheel.
    </li>
  </ul>
</li>

<li>New <strong><a href="/studio/run/rundebugconfig.html">Run/Debug
Configuration</a></strong> features:
  <ul>
    <li>The <strong>Debugger</strong> tab of the Android App and Android
    Tests templates now contain several new options for debugging with LLDB.
    </li>
    <li>The <strong>Profiling</strong> tab of the Android App and Android
    Tests templates now contain a <strong>Capture GPU Commands</strong>
    option for enabling GPU tracing. You can display GPU traces in the GPU
    Debugger (a beta feature).
    </li>
    <li>The Android Tests template now has a <strong>Firebase Test Lab Device
    Matrix</strong> option for the <strong>Deployment Target</strong>.
    </li>
    <li>The Native Application template has been deprecated. If you use this
    template in a project, Android Studio automatically converts it to the
    Android App template.
    </li>
    <li>The Android Application template has been renamed to Android App.
    </li>
  </ul>
</li>

<li>Improved installation, configuration, performance, and UI features in the
<strong><a href="/studio/debug/am-gpu-debugger.html">GPU
Debugger</a></strong> (currently in beta).
</li>

<li>Android Studio now comes bundled with <strong>OpenJDK 8</strong>.
Existing projects still use the JDK specified in <strong>File &gt; Project
Structure &gt; SDK Location</strong>. You can switch to use the new bundled
JDK by clicking <strong>File &gt; Project Structure &gt; SDK
Location</strong> and checking the <strong>Use embedded JDK</strong>
checkbox.
</li>

<li>Added new <strong>help menus and buttons</strong> in the UI so you can
more easily find the online documentation.
</li>

שינויים

• עדכנו את בסיס הקוד של סביבת הפיתוח המשולבת מ-IntelliJ 15 ל-IntelliJ 2016.1
• כדי להשתמש ב-Instant Run, צריך להתקין את ערכת ה-SDK של הפלטפורמה שמתאימה לרמת ה-API של מכשיר היעד.
• התכונה 'הפעלה מיידית' מושבתת אוטומטית אם המשתמש מפעיל את האפליקציה בפרופיל עבודה או כמשתמש משני.
• נפתרו הרבה בעיות אמינות ב-Instant Run, שגרמו לכך שהשינויים לא נפרסו או שהאפליקציה קרסה:
  • חלק מנכסי האפליקציה לא נפרסו באפליקציה הפועלת. ( באג: ‎#213454)
  • קריסות של האפליקציה כשמשתמש עובר בין סשנים של הפעלה מיידית לבין סשנים רגילים, אם לא מוגדר serialVersionUID למחלקה Serializable. (באג: ‎#209006)
  • שינויים בסגנון לא משתקפים באמצעות Instant Run. (באג: ‎#210851)
  • הסשן של Instant Run לא אמין וגורם ל-FileNotFoundException. (באג: ‎#213083)
  • שינויים בפריטים מסוג Drawable לא משתקפים עד שמבצעים בנייה מחדש מלאה ב-KitKat. (באג: ‎#21530)
  • שינויים במשאבים לא משתקפים באמצעות Instant Run אם ב-sourceSets מותאמים אישית יש נתיבים מקוננים. (באג: ‎#219145)
  • החלפה חמה והחלפה חמה למחצה לא פועלות אם המחלקה שהשתנתה מכילה הערה עם ערך enum. (באג: ‎#209047)
  • שינויים בנתוני ההערות לא משתקפים באמצעות Instant Run. (באג: ‎#210089)
  • התכונה 'הפעלה מיידית' לא מזהה שינויים בקוד אם מבצעים שינויים מחוץ ל-IDE. (באג: ‎#213205)
  • הסשן של ההפעלה המיידית לא אמין בגלל חוסר התאמה של טוקן האבטחה. (באג: #211989
  • החלפה חמה נכשלת במכשירים שלא תומכים כראוי בהרצת תוכנה כמשתמש אחר. (באג: ‎#210875)
  • קריסת האפליקציה אחרי הפעלה מחדש של ההפעלה המיידית. (באג: #219744)
  • ‫ClassNotFoundException נצפה כשעוברים מ-Instant Run ל-Instant Debug. (באג: #215805)

<li>Improved performance for <strong>Gradle sync</strong> within the IDE,
especially for large projects.
</li>

<li>Improved build times for both full and incremental builds with new app
packaging code.
</li>

<li>Improved <strong>Jack compiler performance and features</strong>,
including support for annotation processors and dexing in process. To learn
more, read the <a href=
"/studio/releases/gradle-plugin.html#revisions">Android plugin for Gradle
2.2.0 release notes</a>.
</li>

<li>Removed the <strong>Scale</strong> AVD property from the AVD Manager.
</li>

<li>The Android Emulator <strong>-port</strong> and <strong>-ports</strong>
command-line options now report which ports and serial number the emulator
instance is using, and warn if there are any issues with the values you
provided.
</li>

<li>Improved the <strong><a href=
"/studio/write/create-java-class.html">Create New Class dialog</a></strong>
and the corresponding file templates. <strong>Note:</strong> If you've
previously customized the <strong>AnnotationType</strong>,
<strong>Class</strong>, <strong>Enum</strong>, <strong>Interface</strong>, or
<strong>Singleton</strong> file templates, you need to modify your templates
to comply with the new templates or you won’t be able to use the new fields
in the <strong>Create New Class</strong> dialog.
</li>

<li>Improved the <strong><a href=
"/studio/write/vector-asset-studio.html">Vector Asset Studio</a></strong>
user interface and added support for Adobe Photoshop Document (PSD) files.
</li>

<li>Improved the <strong><a href=
"/studio/write/image-asset-studio.html">Image Asset Studio</a></strong> user
interface.
</li>

<li>Improved the <strong>Theme Editor</strong>'s Resource Picker.
</li>

<li>Fixed memory leaks and reduced overall memory usage in Android Studio.
</li>

<li>Added a <strong>Background</strong> button in the <strong><a href=
"/studio/intro/update.html#sdk-manager">SDK Manager</a></strong> so you can
get back to work and install your packages in the background.
</li>

<li>Improved <strong><a href="/studio/intro/accessibility.html">Accessibility
features</a></strong>, including support for screen readers and keyboard
navigation.
</li>

<li>Enhanced <strong>Code Analysis</strong> includes code quality checks for
Java 8 language usage and more cross-file analysis.
</li>

<li>Several toolbar icons have changed.
</li>

‫2.1 (אפריל 2016)

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

‫2.1.3 (אוגוסט 2016)

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

כברירת מחדל, פרויקטים חדשים ב-Android Studio 2.1.3 משתמשים ב-Gradle 2.14.1. בפרויקטים קיימים, סביבת הפיתוח המשולבת (IDE) תציג בקשה לשדרוג ל-Gradle 2.14.1 ול-Android plugin ל-Gradle 2.1.3, שנדרש כשמשתמשים ב-Gradle 2.14.1 ובגרסאות מתקדמות יותר.

‫2.1.2 (יוני 2016)

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

• עדכונים ותיקוני באגים ב-Instant Run.
• שיפורים בביצועים של LLDB ובהתראות על קריסות.
• תוקנה רגרסיה בעדכון האבטחה של Android Studio 2.1.1 שגרמה לכשל ב-git rebase.

‫2.1.1 (מאי 2016)

עדכון של גרסת אבטחה.

פלטפורמת Android N מוסיפה תמיכה בתכונות של שפת Java 8, שדורשות קומפיילר ניסיוני חדש בשם Jack. הגרסה העדכנית של Jack נתמכת כרגע רק ב-Android Studio 2.1. לכן, אם רוצים להשתמש בתכונות של שפת Java 8, צריך להשתמש ב-Android Studio 2.1 כדי לבנות את האפליקציה.

הערה: הפעלה מיידית מושבתת כשמפעילים את מהדר Jack, כי כרגע הם לא תואמים.

למרות ש-Android Studio 2.1 יציב עכשיו, מהדר Jack עדיין ניסיוני, וצריך להפעיל אותו באמצעות המאפיין jackOptions בקובץ build.gradle.

בנוסף לשינויים לתמיכה בגרסת N Preview, ‏ Android Studio 2.1 כולל תיקוני באגים קלים ושיפורים נוספים:

• ניפוי הבאגים ב-C++ עם תמיכה ב-Java מופעל עכשיו כברירת מחדל כשמשתמשים במכשיר או באמולטור מסוג N ובוחרים במצב ניפוי באגים Native (בכרטיסייה Debugger של הגדרת ההרצה או ניפוי הבאגים).

כדי ליהנות משיפורים אחרים ב-build, כולל קומפילציה מצטברת של Java ו-dexing-in-process,צריך לעדכן את הפלאגין של Android ל-Gradle לגרסה 2.1.0.

‫2.0 (אפריל 2016)

הערה: אם אתם מפתחים לגרסת N Developer Preview, אתם צריכים להשתמש ב-Android Studio 2.1 Preview. ‫Android Studio 2.0 לא תומך בכל התכונות שנדרשות כדי לטרגט את גרסת N Preview.

הפעלה מיידית:

• מעכשיו, Android Studio פורס גרסאות build נקיות מהר יותר מאי פעם. בנוסף, העברת שינויים מצטברים בקוד לאמולטור או למכשיר פיזי מתבצעת עכשיו כמעט באופן מיידי. בודקים את העדכונים בלי לפרוס מחדש גרסת באגים חדשה, או במקרים רבים, בלי להפעיל מחדש את האפליקציה.
• התכונה 'הפעלה מיידית' תומכת בדחיפת השינויים הבאים לאפליקציה שפועלת:
  • שינויים בהטמעה של שיטת מופע קיימת או שיטה סטטית
  • שינויים במשאב קיים של אפליקציה
  • שינויים בקוד המבני, כמו חתימת שיטה או שדה סטטי (נדרש מכשיר יעד עם API ברמה 21 ומעלה).
• מידע נוסף על הפעלה מיידית

  הערה: התכונה 'הפעלה מיידית' נתמכת רק כשמפעילים את גרסת ה-debug של ה-build, משתמשים בתוסף Android ל-Gradle בגרסה 2.0.0 ואילך, ומגדירים את קובץ build.gradle ברמת המודול של האפליקציה לגרסה minSdkVersion 15 ואילך. כדי להשיג את הביצועים הכי טובים, מומלץ להגדיר את האפליקציה ל-minSdkVersion 21 ומעלה.

תוספות חדשות ל-Lint:

• בדיקה של הצהרות switch באמצעות מספרים שלמים עם הערות @IntDef כדי לוודא שכל הקבועים מטופלים. כדי להוסיף במהירות הצהרות חסרות, משתמשים בתפריט הנפתח של פעולת הכוונה ובוחרים באפשרות Add Missing @IntDef Constants (הוספת קבועים חסרים של @IntDef).
• דגלים לניסיונות שגויים להשתמש בהצבת מחרוזות כדי להוסיף מספרי גרסאות בקובץ build.gradle.
• דגלים לכיתות אנונימיות שמרחיבות את המחלקה Fragment.
• דגלים לקוד Native במיקומים לא בטוחים, כמו התיקיות res/ ו-asset/. הדגל הזה מעודד אחסון של קוד מקורי בתיקייה libs/, שאחר כך נארז בצורה מאובטחת בתיקייה data/app-lib/ של האפליקציה בזמן ההתקנה. ‫AOSP: #169950
• התרעות על שיחות לא בטוחות ל-Runtime.load() ושיחות ל-System.load(). ‫AOSP: #179980
• כדי למצוא ולהסיר משאבים שלא נמצאים בשימוש, בוחרים באפשרות Refactor > Remove Unused Resources (ארגון מחדש > הסרת משאבים שלא נמצאים בשימוש) בסרגל התפריטים. התכונה 'זיהוי משאבים לא בשימוש' תומכת עכשיו במשאבים שמופנים רק על ידי משאבים לא בשימוש, בהפניות בקבצים גולמיים כמו הפניות לתמונות .html, ובמאפיינים tools:keep ו-tools:discard שמשמשים את כלי הכיווץ של משאבי Gradle. בנוסף, התכונה מתחשבת במערכי מקור לא פעילים (כמו משאבים שמשמשים בטעמים אחרים של בנייה) ומטפלת בצורה נכונה בייבוא של שדות סטטיים.
• בודק אם הפניות משתמעות ל-API נתמכות בכל הפלטפורמות שמטורגטות על ידי minSdkVersion.
• סימון שימוש לא תקין בתגי RecyclerView ו-Parcelable.
• ‫@IntDef, ‏@IntRange ו-@Size בדיקות נבדקות עכשיו גם עבור מערכים של int וארגומנטים באורך משתנה.

שיפורים נוספים:

• הוא מותאם ל-Android Emulator 2.0, שהוא מהיר יותר מאי פעם, תומך במגוון רחב יותר של מכשירים וירטואליים וכולל ממשק משתמש משופר באופן משמעותי. מידע נוסף על האמולטור החדש זמין בנתוני הגרסה של SDK Tools.
• שיפורים במנהל המכשירים הווירטואליים של Android (AVD):
  • תמונות המערכת מסווגות עכשיו בכרטיסיות הבאות: מומלצות,‏ x86 ואחרות.
  • בהגדרות המתקדמות, אפשר להפעיל תמיכה בריבוי ליבות ולציין את מספר הליבות שבהן האמולטור יכול להשתמש.
  • בקטע 'הגדרות מתקדמות', אפשר לקבוע איך הגרפיקה תוצג באמולטור. לשם כך, בוחרים באחת מהאפשרויות הבאות:
    • חומרה: שימוש בכרטיס המסך של המחשב לרינדור מהיר יותר.
    • תוכנה: שימוש ברינדור מבוסס-תוכנה.
    • אוטומטי: מאפשר לאמולטור להחליט מהי האפשרות הטובה ביותר. זו הגדרת ברירת המחדל.
• שיפרנו את זמני האריזה של AAPT על ידי ציון יעד הפריסה לפני בניית האפליקציה. כך Android Studio יכול לארוז ביעילות רק את המשאבים שנדרשים למכשיר הספציפי.
• נוסף שילוב עם Cloud Test Lab כדי לספק בדיקות אפליקציות לפי דרישה, עם הנוחות והגמישות של שירות ענן. מידע נוסף על השימוש ב-Cloud Test Lab עם Android Studio
• הוספנו תצוגה מקדימה של כלי חדש לניפוי באגים ב-GPU. עכשיו אפשר להריץ את קוד OpenGL ES שלכם בשלבים כדי לבצע אופטימיזציה לאפליקציה או למשחק, במיוחד אם הם עתירי גרפיקה.
• נוספה בדיקה של יצירת אינדקס של אפליקציות Google. כדי להגדיל את נפח התנועה לאפליקציה, לגלות איזה תוכן באפליקציה נמצא בשימוש הכי נרחב ולמשוך משתמשים חדשים, כדאי להוסיף לאפליקציות תמיכה בכתובות URL, באינדוקס של האפליקציה ובפונקציית חיפוש. אתם יכולים לבדוק ולאמת כתובות URL באפליקציה שלכם, והכול ב-Android Studio. מידע נוסף זמין במאמר בנושא תמיכה בכתובות URL ובהוספה לאינדקס של אפליקציות ב-Android Studio.
• שדרוגים מהגרסה האחרונה של IntelliJ 15, כולל שיפורים בניתוח הקוד ובביצועים. במאמר מה חדש ב-IntelliJ מופיע תיאור מפורט של התכונות והשיפורים החדשים.
• ההשלמה האוטומטית בעורך XML מוסיפה עכשיו מרכאות כשמשלימים מאפיינים. כדי לבדוק אם האפשרות הזו מופעלת, פותחים את תיבת הדו-שיח הגדרה או העדפות, עוברים אל עורך > כללי > מקשי קיצור חכמים ומסמנים את התיבה לצד הוספת מרכאות לערך מאפיין בהשלמת מאפיין. בעיה: 195113
• עכשיו עורך ה-XML תומך בהשלמת קוד לביטויים של data binding.

גרסה 1.5.1 של Android Studio (דצמבר 2015)

תיקונים ושיפורים:

• תוקנה בעיה שגרמה לכשל בעיבוד בכלי לעריכת פריסות. בעיה: 194612
• נוספה האפשרות לשנות את מאפייני המניפסט בהתאם להגדרה.description בעיה: 194705
• שיפרנו את הניגודיות של עיצוב Darcula ב-Android Studio ב-Vector Asset Studio. בעיה: 191819
• נוספה תמיכה בכפתור עזרה ב-Vector Asset Studio.
• הוספנו תמיכה באופרטור % לקישור נתונים. בעיה: 194045
• תוקנה בעיה שבה הפעלת אפליקציה לניפוי באגים גרמה לניפוי הבאגים להתחבר למכשיר הלא נכון. בעיה: 195167
• תוקנה חריגת מצביע null שיכולה להתרחש כשמנסים להפעיל אפליקציה בתרחישים מסוימים.

גרסה 1.5.0 של Android Studio (נובמבר 2015)

תיקונים ושיפורים:

• הוספנו ל-Android Monitor יכולות חדשות לניתוח Memory Monitor. כשמציגים קובץ HPROF שצולם מהכלי הזה, התצוגה עכשיו מועילה יותר, כך שאפשר לאתר בעיות מהר יותר, כמו דליפות זיכרון. כדי להשתמש בכלי הזה, לוחצים על Android Monitor בתחתית החלון הראשי. ב-Android Monitor, לוחצים על הכרטיסייה Memory (זיכרון). בזמן שהמסך פועל, לוחצים על הסמל Dump Java Heap, ואז לוחצים על Captures בחלון הראשי ולוחצים לחיצה כפולה על הקובץ כדי להציג אותו. בצד שמאל, לוחצים על Capture Analysis (לכידת ניתוח). (אי אפשר להפעיל את Android Device Monitor ואת Android Monitor בו-זמנית).
• נוספה תמיכה חדשה בקישורי עומק ובקישורי אפליקציות. עורך הקוד יכול ליצור באופן אוטומטי מסנן intent לקישורי עומק בקובץ AndroidManifest.xml. הוא יכול גם ליצור קוד שיעזור לכם לשלב את App Indexing API בפעילות בקובץ Java. תכונת בדיקת קישורי עומק עוזרת לכם לוודא שקישור עומק מסוים יכול להפעיל אפליקציה. בכרטיסייה General (כללי) בתיבת הדו-שיח Run/Debug Configurations (הגדרות הפעלה/ניפוי באגים), אתם יכולים לציין אפשרויות להפעלת קישור עומק. אפשר גם לבדוק קריאות ל-App Indexing API בפעילות באמצעות התצוגה logcat של Android Monitor. בכלי lint ל-Android יש עכשיו אזהרות לגבי בעיות מסוימות שקשורות לקישורי עומק ול-API של הוספת אפליקציות לאינדקס.
• הוספנו את האפשרות להשתמש בכינויים כשמשלימים קוד של תצוגות מותאמות אישית בעורך הקוד.
• הוספנו תמיכה בעוד רכיבים של VectorDrawable ל-Vector Asset Studio לצורך תאימות לאחור. הכלי Vector Asset Studio יכול להשתמש באלמנטים האלה כדי להמיר נכסי וקטור לציור לתמונות רסטר מסוג PNG לשימוש ב-Android מגרסה 4.4 (רמת API‏ 20) ומטה.
• הוספנו lintבדיקות חדשות ל-Android TV ול-Android Auto כדי לספק לכם משוב מיידי ופרקטי ב-Android Studio, יחד עם כמה תיקונים מהירים. לדוגמה, ב-Android TV, הוא יכול לדווח על בעיות בהרשאות, בחומרה שלא נתמכת, ברכיב uses-feature ובבאנר חסר, ולספק פתרון מהיר לבעיות האלה. ב-Android Auto, הכלי יכול לאמת את השימוש הנכון בקובץ התיאור שמופנה אליו מקובץ AndroidManifest.xml, לדווח אם אין מסנן Intent עבור המחלקה MediaBrowserService ולזהות בעיות מסוימות בפעולות קוליות.
• הוספנו בדיקות חדשות של lint לגבי מקלטי שידור לא מאובטחים, שימושים במחלקות SSLCertificateSocketFactory ו-HostnameVerifier, וקריאות ל-File.setReadable() ול-File.setWritable(). הוא גם מזהה בדיקות לא תקינות של משאבי מניפסט, במיוחד משאבים שמשתנים בהתאם להגדרה.
• תיקנו מספר בעיות יציבות.

גרסה 1.4.1 של Android Studio (אוקטובר 2015)

תיקונים ושיפורים:

• תוקנה בעיה במטמון של מודל Gradle שיכולה לגרום לסנכרון מוגזם של Gradle כשמפעילים מחדש את ה-IDE.
• תוקנה בעיה של קיפאון בניפוי באגים של Native.
• תוקנה בעיה שחסמה משתמשים במערכת בקרת הגרסאות Subversion 1.9.
• תוקנה בעיה בתיבת הדו-שיח Device Chooser, שבה אחרי חיבור מכשיר לא מורשה אי אפשר היה יותר לבחור את האמולטור. בעיה: 189658
• תוקנה בעיה בדיווח על שגיאות תרגום שגויות בלוקאלים שיש להם מסווג אזור ותרגום באזור (אבל לא בלוקאל הבסיסי). בעיה: 188577
• תוקנה בעיית קיפאון בעורך העיצוב שקשורה לאינטראקציה שלו עם עורך הפריסה. בעיה: 188070
• תוקנה בעיה שבה טעינה מחדש של כלי העריכה של העיצוב וסכסוך עריכה גרמו לכך שהמאפיינים לא עודכנו כמו שצריך. בעיה: 187726
• שיפור בביצועים של כלי העיצוב.
• תוקנה בעיה שבה המערכת התעלמה מהמאפיין android:required בקובץ המניפסט. בעיה: 187665

גרסה 1.4.0 של Android Studio (ספטמבר 2015)

תיקונים ושיפורים:

• הוספנו את הכלי Vector Asset Studio לייבוא גרפיקה וקטורית, כמו סמלי Material וקבצי SVG. כדי להשתמש בכלי הזה, בתצוגת Android של חלון הפרויקט, לוחצים לחיצה ימנית על התיקייה res ובוחרים באפשרות New (חדש) > Vector Asset (נכס וקטורי).
• נוספו פונקציות חדשות ל-Android Monitor: GPU ו-Network. כדי להשתמש בכלי הזה, לוחצים על Android Monitor בתחתית החלון הראשי. אי אפשר להפעיל את Android Device Monitor ואת Android Monitor בו-זמנית.
• נוספה תצוגה מקדימה מוקדמת של כלי העריכה החדש של ערכות הנושא. כדי להשתמש בתכונה הזו, בוחרים באפשרות Tools > Android > Theme Editor.
• התבניות של Android עודכנו בספריית התמיכה בעיצוב. התבניות כוללות עכשיו תמיכה במפרט של Material Design, וגם בספריית התמיכה appcompat לצורך תאימות לאחור.

גרסה 1.3.2 של Android Studio (אוגוסט 2015)

תיקונים ושיפורים:

• הוספנו תמיכה ב-Android 6.0 (רמת API‏ 23), כולל סמלים חדשים ותמיכה ב-AVD Manager ליצירת מכשירים עם רמות דחיסות מסך חדשות.
• תוקנה חריגה שהתרחשה במהלך בדיקות עדכון. בעיה: 183068
• תוקנה בעיה שבה קואורדינטות לא פתורות של תצוגה יכלו לגרום לקריסה של כלי העריכה של הפריסה. בעיה: 178690
• תוקנה בעיה שקשורה לאזהרות על סוג משאב לא תקין. בעיה: 182433
• תוקנה בדיקת lint שסימנה משאבים כפרטיים באופן שגוי. בעיה: 183120

גרסה 1.3.1 של Android Studio (אוגוסט 2015)

תיקונים ושיפורים:

• תוקנה התמיכה ביצירת מכשיר וירטואלי של Android‏ (AVD) ב-Windows.
• אשף הפרויקטים עודכן כך שישתמש בשם הפרויקט שהוזן.
• הוספנו תמיכה שמאפשרת לאחסן את Android SDK בספרייה לקריאה בלבד.
• הפלאגין של Android ל-Gradle עודכן לגרסה 1.3.0.
• תוקנו בעיות בהפעלת סשן ניפוי באגים ממעטפת Unix של Android Debug Bridge‏ (adb).
• תוקנה ההודעה על שינוי השם של חבילת Java כך שיוצג שם החבילה הנכון.

גרסה 1.3.0 של Android Studio (יולי 2015)

תיקונים ושיפורים:

• נוספו אפשרויות להפעלת שירותים למפתחים, כמו Google AdMob ו-Analytics, באפליקציה מתוך Android Studio.
• הוספנו הערות נוספות, כמו @RequiresPermission,‏ @CheckResults ו-@MainThread.
• הוספנו את היכולת ליצור dump של ה-heap ב-Java ולנתח הקצאות של שרשורים מתוך Memory Monitor. אפשר גם להמיר קבצים בפורמט בינארי HPROF ספציפי ל-Android לפורמט HPROF רגיל מתוך Android Studio.
• שילבנו את SDK Manager ב-Android Studio כדי לפשט את הגישה לחבילות ולכלים, וכדי לספק התראות על עדכונים.

  הערה: אפשר עדיין להשתמש ב-SDK Manager העצמאי דרך שורת הפקודה, אבל מומלץ להשתמש בו רק להתקנות של SDK עצמאי.

• נוספה הפקודה finger במסוף האמולטור כדי לדמות אימות באמצעות טביעת אצבע.
• נוספה הצהרת משאב <public> כדי להגדיר משאבים בספרייה כמשאבים ציבוריים ופרטיים.

  הערה: נדרשת גרסה 1.3 ואילך של פלאגין Android ל-Gradle.

• הוספנו תמיכה בקישור נתונים כדי ליצור פריסות הצהרתיות שמקשרות את הלוגיקה של האפליקציה לרכיבי הפריסה.
• הוספנו תמיכה במודול APK נפרד לבדיקה כדי ליצור קובצי APK לבדיקה ב-Android Studio.
• עדכנו את AVD Manager עם אופטימיזציות של HAXM והתראות משופרות.
• הוספנו תמיכה באמולטורים של 64-bit ARM ו-MIPS עבור QEMU 2.1.
• הוספנו תיקונים מהירים כדי לפשט את פתרון האזהרות של Lint, כמו יצירה אוטומטית של הטמעה של Parcelable.
• נוספה תמיכה בתבניות פעילות להוספה מהירה של קטעי קוד.

גרסה 1.2.2 של Android Studio(יוני 2015)

תיקונים ושיפורים:

• תוקנו בעיות ב-build שגרמו לכך ש-builds לא הושלמו.

גרסה 1.2.1 של Android Studio (מאי 2015)

תיקונים ושיפורים:

• תוקנו בעיות קלות בביצועים ובתכונות.

גרסה 1.2.0 של Android Studio (אפריל 2015)

תיקונים ושיפורים:

• עדכנו את חלון זמן הריצה של Android כדי לכלול את הכלי Memory Monitor, והוספנו כרטיסייה למעקב אחרי ביצועי המעבד (CPU).
• הוספנו כרטיסייה בשם Captures בשוליים הימניים כדי להציג את קובצי הנתונים של הביצועים שקשורים לזיכרון ולמעבד, כמו מעקב אחר שיטת המעבד ותמונות מצב של ערימת הזיכרון (heap snapshot).
• תמיכה מורחבת בהערות עם הערות נוספות של מטא-נתונים ומאפיין מוסק המציין אם ערך יכול להיות ריק (nullability).
• שיפרנו את כלי עריכת התרגומים עם תמיכה נוספת ב-Best Current Practice (BCP) 47, שמשתמש בקודים של שפות ואזורים בני 3 אותיות.
• שילבנו תכונות של IntelliJ 14 ו-14.1 כדי לשפר את ניתוח הקוד ואת הביצועים:
• • ניפוי באגים משופר שמאפשר להציג ערכים מוטבעים של משתנים ואובייקטים של מקורות הפניה, וגם לבצע הערכה בתוך השורה של ביטויי למדה ואופרטורים.
  • נוסף מנגנון לזיהוי סגנון קוד בשביל גודל כרטיסיות וכניסות פיסקאות.
  • נוספו קבצים זמניים לניסויים בקוד וליצירת אב טיפוס ללא קובצי פרויקט.
  • נוספה האפשרות להוסיף בו-זמנית תגי פתיחה ותגי סגירה בקובצי HTML ו-XML.
  • נוסף כלי מובנה להידור לאחור של מחלקת Java, כדי שתוכלו לראות מה יש בספרייה שקוד המקור שלה לא זמין.

  במאמר מה חדש ב-IntelliJ מופיע תיאור מפורט של התכונות והשיפורים החדשים.

• הוספנו תצוגות פרויקט נוספות לטיוטות, קבצים של פרויקט, בעיות, ייצור ובדיקות כדי לשפר את ניהול הפרויקט והגישה אליו.
• שיפרנו את התפריט קובץ > הגדרות ואת תיבות הדו-שיח כדי לשפר את הגישה להגדרות ואת הניהול שלהן.
• הוספנו תמיכה במסכים עם דחיסות גבוהה של פיקסלים ב-Windows וב-Linux.
• הוספנו תמיכה במשאבים ברזולוציה של 280dpi בתיקייה res/drawable-280dpi/.

גרסה 1.1.0 של Android Studio (פברואר 2015)

תיקונים ושיפורים שונים:

• הוספנו תמיכה בתבנית של שעון Android Wear.
• שינינו את תהליך היצירה של פרויקטים ומודולים חדשים כך שיכלול תיקיות res/mipmap לסמלי אפליקציות ספציפיים לצפיפות. התיקיות האלה res/mipmap מחליפות את התיקיות res/drawable של סמלי מרכז האפליקציות.
• עדכנו את הסמלים במרכז האפליקציות כך שיהיה להם מראה של עיצוב חדשני תלת-ממדי, והוספנו סמל של xxxhdpi במרכז האפליקציות.
• הוספנו שיפורים לבדיקות Lint לשילובי אזורים ושפות, לסמלים של מרכז האפליקציות, לשמות של משאבים ולבעיות נפוצות אחרות בקוד.
• הוספנו תמיכה בתג שפה 47 של Best Current Practice (BCP).

גרסה 1.0.1 של Android Studio (דצמבר 2014)

תיקונים ושיפורים שונים:

• תוקנה בעיה בנעילת קובץ device.xml וב-AVD Manager.
• תוקן יומן האמולטור במערכות Windows.
• נפתרה בעיה שקשורה ליצירת מכשירי AVD עם Android Studio ו-Android SDK שמותקנים בכוננים שונים במערכות Windows.
• מגדיר את ערוץ העדכון שמוגדר כברירת מחדל להורדות חדשות כיציב. אם התקנתם את גרסה 1.0.0 של Android Studio ואתם רוצים לקבל עדכונים יציבים שמוכנים לשימוש בסביבת ייצור, אתם יכולים לעבור לערוץ העדכונים Stable דרך File > Settings > Updates.

גרסה 1.0 של Android Studio (דצמבר 2014)

גרסה ראשונית של Android Studio.

גרסה 0.8.14 של Android Studio (אוקטובר 2014)

הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.8.6 של Android Studio (אוגוסט 2014)

הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.8.0 של Android Studio (יוני 2014)

הוספנו תמיכה בפרויקטים של Android Wear.

הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.5.2 של Android Studio (מאי 2014)

• הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.4.6 של Android Studio (מרץ 2014)

• הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.4.2 של Android Studio (ינואר 2014)

• הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.3.2 של Android Studio (אוקטובר 2013)

• הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.

גרסה 0.2.x של Android Studio (יולי 2013)

• בוצע מיזוג של השינויים האחרונים בבסיס הקוד של IntelliJ. העדכון כולל תיקונים לבעיות שדווחו על ידי משתמשי Studio, כמו שינויים בגדלי הגופנים ב-Linux ובעיבוד הגופנים.
• הפלאגין של Android Gradle עודכן לגרסה 0.5.0.

  שימו לב: הגרסה החדשה לא תואמת לאחור. כשפותחים פרויקט שמשתמש בגרסה ישנה יותר של הפלאגין, מוצגת ב-Studio שגיאה עם הכיתוב Gradle <project_name> project refresh failed.

  העדכון של Gradle plug-in כולל את השינויים הבאים:

  • תוקן מודל IDE כך שיכיל את קובץ הפלט גם אם הוא מותאם אישית באמצעות DSL. בנוסף, בוצע תיקון ב-DSL כדי לקבל או להגדיר את קובץ הפלט באובייקט של הווריאציה, כך שלא צריך להשתמש ב-variant.packageApplication or variant.zipAlign
  • תוקן תהליך ההחלטה לגבי תלות, כך שהשילוב של (הגדרת ברירת מחדל, סוגי build, טעמים) נפתר יחד במקום בנפרד.
  • תוקנה תלות בבדיקות של פרויקט ספרייה כדי לכלול בצורה תקינה את כל התלויות של הספרייה עצמה.
  • תוקן מקרה שבו לשני יחסי תלות יש אותו שם עלה.
  • תוקנה בעיה שבה לא ניתן להחיל קובץ כללי Proguard על גרסאות שונות של האפליקציה.

  כל ההערות על הגרסאות של פלאגין Gradle זמינות כאן: http://tools.android.com/tech-docs/new-build-system.

• שגיאות Gradle מ-aapt כבר לא מצביעות על קובצי פלט שמוזגו בתיקייה build/, אלא מצביעות חזרה על מיקומי המקור האמיתיים.
• גרסאות Build מקבילות. עכשיו אפשר להשתמש ב-Gradle כדי לבצע בנייה מקבילה. חשוב לדעת שגרסאות build מקבילות נמצאות בשלב 'הכנה' (ראו מסמכי התיעוד של Gradle). תכונה זו מושבתת כברירת מחדל. כדי להפעיל את האפשרות הזו, עוברים אל העדפות > קומפיילר ומסמנים את התיבה Compile independent modules in parallel (קומפילציה של מודולים עצמאיים במקביל).
• המשכנו לעבוד על מאגר המשאבים החדש שמשמש לעיבוד פריסות, לקיפול משאבים בעורך ועוד:
  • תמיכה בסיסית בתלויות של הפרויקט בספריית ‎.aar (למשל, שימוש בספרייה ללא עותק מקומי של המקורות). עדיין לא פועל לאימות XML של משאבים ולניווט בכלי עריכה של מקורות.
  • זיהוי מעגליות בהפניות למשאבים.
  • האפשרות Quick Documentation (תיעוד מהיר) (F1), שמאפשרת לראות את כל התרגומים של המחרוזת מתחת לסימן ^, תציג עכשיו גם את כל שכבות-העל של המשאבים מהטעמים השונים של Gradle וסוגי ה-build, וגם מספריות. הם מופיעים בסדר הפוך של שכבות-על של משאבים, עם קו חוצה על הגרסאות של המחרוזת שמוסתרות.
  • בוצעו תיקונים לטיפול בעדכון המשאבים הממוזגים כשמערך התלויות של המודול משתנה.
  • תיקונים של עיבוד XML כדי לטפל בצורה נכונה בהצהרות של ישויות תווים ובתווים מיוחדים ב-XML וב-Unicode.
• הוספנו תמיכה בשמירת צילומי מסך בחלונות של התצוגה המקדימה של הפריסה ושל כלי העריכה של הפריסה.
• תיקוני באגים בתבניות.
• תיקוני באגים ב-Lint.
• ביצענו תיקונים שונים בדוחות קריסה. תודה, ונשמח לקבל עוד דיווחים על קריסות!

גרסה 0.1.x של Android Studio (מאי 2013)

• תיקוני באגים שונים, כולל תיקון של בעיה נפוצה בהתקנה ב-Windows.

גרסאות ישנות יותר של Android Gradle Plugin

‫3.6.0 (פברואר 2020)

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 5.6.4. מידע נוסף זמין בקטע בנושא עדכון Gradle.

• ‫SDK Build Tools 28.0.3 ואילך.

‫3.6.4 (יולי 2020)

העדכון הקטן הזה תומך בתאימות להגדרות ברירת מחדל חדשות ולתכונות חדשות של חבילות גלויות ב-Android 11.

פרטים נוספים זמינים בהערות הגרסה 4.0.1.

תכונות חדשות

הגרסה הזו של Android Gradle plugin כוללת את התכונות החדשות הבאות.

הצגת הקישור

הצגת הכריכה מספקת בטיחות בזמן ההידור כשמפנים לתצוגות בקוד. עכשיו אפשר להחליף את findViewById() בהפניה למחלקת הקישור שנוצרה באופן אוטומטי. כדי להתחיל להשתמש ב-View binding, צריך לכלול את השורה הבאה בקובץ build.gradle של כל מודול:

      android {
          viewBinding.enabled = true
      }
      

      android {
          viewBinding.enabled = true
      }
      

מידע נוסף זמין במאמר בנושא הצגת מסמכי התיעוד של View Binding.

תמיכה ב-Maven Publish Plugin

הפלאגין Android Gradle כולל תמיכה בפלאגין Maven Publish Gradle, שמאפשר לכם לפרסם פריטי build במאגר Apache Maven. הפלאגין Android Gradle יוצר רכיב לכל ארטיפקט של וריאנט בנייה במודול האפליקציה או הספרייה, שאפשר להשתמש בו כדי להתאים אישית פרסום במאגר Maven.

מידע נוסף זמין בדף בנושא שימוש בתוסף Maven Publish.

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

כשבונים את גרסת הניפוי באגים של האפליקציה, הפלאגין משתמש בכלי אריזה חדש שנקרא zipflinger כדי לבנות את ה-APK. הכלי החדש הזה אמור לשפר את מהירות הבנייה. אם כלי האריזה החדש לא פועל כמו שציפיתם, אתם יכולים לדווח על באג. אפשר לחזור לשימוש בכלי הישן לאריזה על ידי הוספת השורות הבאות לקובץ gradle.properties:

        android.useNewApkCreator=false
      

שיוך של בנייה מקורית

עכשיו אפשר לקבוע את משך הזמן שנדרש ל-Clang כדי לבנות ולקשר כל קובץ C/C++ בפרויקט. ‫Gradle יכול להפיק מעקב ב-Chrome שכולל חותמות זמן לאירועי הקומפיילר האלה, כדי שתוכלו להבין טוב יותר כמה זמן נדרש לבניית הפרויקט. כדי ליצור את קובץ השיוך הזה של הגרסה:

1. מוסיפים את הדגל -Pandroid.enableProfileJson=true כשמריצים build של Gradle. לדוגמה:

   gradlew assembleDebug -Pandroid.enableProfileJson=true

2. פותחים את דפדפן Chrome ומקלידים chrome://tracing בסרגל החיפוש.

3. לוחצים על הלחצן טעינה ועוברים אל <var>project-root</var>/build/android-profile כדי למצוא את הקובץ. שם הקובץ הוא profile-<var>timestamp</var>.json.gz.

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

שינויים בהתנהגות

כשמשתמשים בגרסה הזו של התוסף, יכול להיות שתיתקלו בשינויים הבאים בהתנהגות.

כברירת מחדל, ספריות מקוריות נארזות ללא דחיסה

כשמפתחים את האפליקציה, הפלאגין מגדיר עכשיו את extractNativeLibs ל-"false" כברירת מחדל. כלומר, ספריות ה-Native שלכם מיושרות לדף וארוזות ללא דחיסה. התוצאה היא גודל העלאה גדול יותר, אבל המשתמשים נהנים מהיתרונות הבאים:

• גודל ההתקנה של האפליקציה קטן יותר כי הפלטפורמה יכולה לגשת לספריות המקוריות ישירות מתוך ה-APK המותקן, בלי ליצור עותק של הספריות.
• גודל ההורדה קטן יותר כי הדחיסה ב-Play Store בדרך כלל טובה יותר כשכוללים ספריות מקוריות לא דחוסות ב-APK או ב-Android App Bundle.

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

        <application
          android:extractNativeLibs="true"
          ... >
        </application>
        
      

הערה: המאפיין extractNativeLibs manifest הוחלף באפשרות useLegacyPackaging DSL. מידע נוסף זמין בהערת הגרסה בנושא שימוש ב-DSL לאריזת ספריות מקוריות דחוסות.

גרסת ברירת המחדל של NDK

אם מורידים כמה גרסאות של NDK, התוסף Android Gradle בוחר עכשיו גרסת ברירת מחדל לשימוש בהידור של קובצי קוד המקור. בעבר, הפלאגין בחר בגרסה האחרונה שהורדה של NDK. כדי לשנות את ברירת המחדל שנבחרה על ידי התוסף, משתמשים במאפיין android.ndkVersion בקובץ build.gradle של המודול.

יצירת כיתות R פשוטה יותר

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

• מכיוון שהקומפיילר משתף מחלקות R עם תלות במודול במעלה הזרם, חשוב שכל מודול בפרויקט ישתמש בשם חבילה ייחודי.
• ההרשאות של מחלקת R בספרייה ליחסי תלות אחרים בפרויקט נקבעות לפי ההגדרה שמשמשת לכלול את הספרייה כיחס תלות. לדוגמה, אם Library A כוללת את Library B כתלות מסוג 'api', ל-Library A ולספריות אחרות שתלויות ב-Library A יש גישה למחלקה R של Library B. עם זאת, יכול להיות שלספריות אחרות לא תהיה גישה למחלקה R של ספרייה ב'. אם ספרייה א' משתמשת בהגדרת התלות implementation. מידע נוסף על הגדרות תלות

הסרת משאבים שחסרים בהגדרות ברירת המחדל

במודולים של ספריות, אם כוללים משאב לשפה שלא נכללת בקבוצת ברירת המחדל של המשאבים – לדוגמה, אם כוללים את hello_world כמשאב מחרוזת ב-/values-es/strings.xml אבל לא מגדירים את המשאב הזה ב-/values/strings.xml – הפלאגין Android Gradle כבר לא כולל את המשאב הזה כשמבצעים קומפילציה של הפרויקט. השינוי הזה בהתנהגות אמור להוביל לפחות חריגות בזמן ריצה של Resource Not Found ולשיפור במהירות הבנייה.

‫D8 מכבד עכשיו את מדיניות השמירה של CLASS לגבי הערות

כשמבצעים קומפילציה של האפליקציה, D8 מתחשב עכשיו במקרים שבהם הערות חלות על מדיניות שמירה של CLASS וההערות האלה כבר לא זמינות בזמן הריצה. ההתנהגות הזו קיימת גם כשמגדירים את ה-SDK לטירגוט של האפליקציה לרמת API‏ 23, שבעבר אפשרה גישה להערות האלה במהלך זמן הריצה כשמבצעים קומפילציה של האפליקציה באמצעות גרסאות ישנות יותר של פלאגין Android Gradle ו-D8.

שינויים אחרים בהתנהגות

• הפונקציה aaptOptions.noCompress כבר לא רגישה לאותיות רישיות בכל הפלטפורמות (גם ל-APK וגם לחבילות), והיא מתייחסת לנתיבים שבהם נעשה שימוש באותיות רישיות.

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

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

תיקוני באגים

הגרסה הזו של Android Gradle plugin כוללת את תיקוני הבאגים הבאים:

• עכשיו יש תמיכה בבדיקות יחידה של Robolectric במודולים של ספריות שנעשה בהם שימוש ב-data binding. מידע נוסף זמין בבעיה מספר 126775542.
• עכשיו אפשר להריץ משימות connectedAndroidTest בכמה מודולים בו-זמנית, כשמופעל מצב ההרצה המקבילית של Gradle‏ parallel.

בעיות מוכרות

בקטע הזה מתוארות בעיות ידועות שקיימות ב-Android Gradle Plugin 3.6.0.

ביצועים איטיים של משימת Android Lint

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

הבעיה מדווחת כבאג ב-IDEA ותיפתר ב-Android Gradle Plugin 4.0.

חסרה מחלקת מניפסט {:#agp-missing-manifest}

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

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

• מפנים להרשאות המותאמות אישית לפי השם המלא שלהן. לדוגמה, "com.example.myapp.permission.DEADLY_ACTIVITY".

• אפשר להגדיר קבועים משלכם, כמו שמוצג בהמשך:

              public final class CustomPermissions {
                public static final class permission {
                  public static final String DEADLY_ACTIVITY="com.example.myapp.permission.DEADLY_ACTIVITY";
                }
              }
              
            

‫3.5.0 (אוגוסט 2019)

‫Android Gradle Plugin 3.5.0, יחד עם Android Studio 3.5, היא גרסה מרכזית והתוצאה של Project Marble, שמתמקדת בשיפור שלושה תחומים עיקריים של כלי הפיתוח ל-Android: תקינות המערכת, ליטוש התכונות ותיקון באגים. חשוב לציין ששיפור מהירות בניית הפרויקט היה אחד מהדברים העיקריים שהתמקדנו בהם בעדכון הזה.

מידע על העדכונים האלה ועדכונים נוספים של Project Marble זמין בפוסט הזה בבלוג של Android Developers או בקטעים שבהמשך.

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• Gradle 5.4.1. מידע נוסף זמין בקטע בנושא עדכון Gradle.

• ‫SDK Build Tools 28.0.3 ואילך.

‫3.5.4 (יולי 2020)

העדכון הקטן הזה תומך בתאימות להגדרות ברירת מחדל חדשות ולתכונות חדשות של חבילות גלויות ב-Android 11.

פרטים נוספים זמינים בהערות הגרסה 4.0.1.

‫3.5.3 (דצמבר 2019)

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

‫3.5.2 (נובמבר 2019)

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

‫3.5.1 (אוקטובר 2019)

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

עיבוד מצטבר של הערות

מעבד ההערות Data Binding תומך בעיבוד מצטבר של הערות אם מגדירים את android.databinding.incremental=true בקובץ gradle.properties. האופטימיזציה הזו משפרת את הביצועים של בנייה מצטברת. רשימה מלאה של מעבדי הערות אופטימליים מופיעה בטבלה של מעבדי הערות מצטברות.

בנוסף, גרסה KAPT 1.3.30 ואילך תומכת גם במעבדי הערות מצטברים, שאפשר להפעיל אותם על ידי הוספת kapt.incremental.apt=true לקובץ gradle.properties.

בדיקות יחידה שניתנות לשמירה במטמון

כשמפעילים בדיקות יחידה כדי להשתמש במשאבים, בנכסים ובמניפסטים של Android על ידי הגדרת includeAndroidResources לערך true, הפלאגין Android Gradle יוצר קובץ הגדרות בדיקה שמכיל נתיבים מוחלטים, מה שפוגע ביכולת להעביר את המטמון. אתם יכולים להנחות את הפלאגין ליצור את הגדרת הבדיקה באמצעות נתיבים יחסיים, וכך לאפשר שמשימת AndroidUnitTest תהיה ניתנת לשמירה במטמון באופן מלא. כדי לעשות זאת, צריך לכלול את השורה הבאה בקובץ gradle.properties:

      android.testConfig.useRelativePath = true
    

בעיות מוכרות

• כשמשתמשים בפלאגין Kotlin Gradle בגרסה 1.3.31 או בגרסה מוקדמת יותר, יכול להיות שתופיע האזהרה הבאה כשמבצעים build או סנכרון של הפרויקט:

            WARNING: API 'variant.getPackageLibrary()' is obsolete and has been replaced
                    with 'variant.getPackageLibraryProvider()'.
            
          

  כדי לפתור את הבעיה הזו, צריך לשדרג את הפלאגין לגרסה 1.3.40 ואילך.

‫3.4.0 (אפריל 2019)

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 5.1.1 ואילך. מידע נוסף זמין בקטע בנושא עדכון Gradle.

  הערה: כשמשתמשים ב-Gradle 5.0 ומעלה, גודל ערימת הזיכרון של Gradle daemon כברירת מחדל יורד מ-‎1 GB ל-‎512 MB. יכול להיות שהדבר יוביל לרגרסיה בביצועי הבנייה. כדי לשנות את הגדרת ברירת המחדל הזו, מציינים את גודל הערימה של Gradle daemon בקובץ gradle.properties של הפרויקט.

• ‫SDK Build Tools 28.0.3 ואילך.

‫3.4.3 (יולי 2020)

העדכון הקטן הזה תומך בתאימות להגדרות ברירת מחדל חדשות ולתכונות חדשות של חבילות גלויות ב-Android 11.

פרטים נוספים זמינים בהערות הגרסה 4.0.1.

‫3.4.2 (יולי 2019)

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

‫3.4.1 (מאי 2019)

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

תכונות חדשות

• הגדרות חדשות של תלות בבדיקת lint: ההתנהגות של lintChecks השתנתה, והוצגה הגדרה חדשה של תלות, lintPublish, כדי לתת לכם יותר שליטה על בדיקות ה-lint שנארזות בספריות Android שלכם.

  • ‫lintChecks: זוהי הגדרה קיימת שצריך להשתמש בה לבדיקות Lint שרוצים להריץ רק כשמבצעים build של הפרויקט באופן מקומי. אם השתמשתם בעבר בהגדרת התלות lintChecks כדי לכלול בדיקות lint ב-AAR שפורסם, אתם צריכים להעביר את התלויות האלה להגדרה החדשה lintPublish שמתוארת בהמשך.
  • ‫lintPublish: משתמשים בהגדרה החדשה הזו בפרויקטים של ספריות לבדיקות lint שרוצים לכלול ב-AAR שפורסם, כמו שמוצג בהמשך. כלומר, הפרויקטים שמשתמשים בספרייה שלכם יפעילו גם את בדיקות ה-lint האלה.

  בדוגמת הקוד הבאה נעשה שימוש בשתי הגדרות התלות בפרויקט מקומי של ספריית Android.

  dependencies {
    // Executes lint checks from the ':lint' project at build time.
    lintChecks project(':lint')
    // Packages lint checks from the ':lintpublish' in the published AAR.
    lintPublish project(':lintpublish')
  }
          

  dependencies {
    // Executes lint checks from the ':lint' project at build time.
    lintChecks(project(":lint"))
    // Packages lint checks from the ':lintpublish' in the published AAR.
    lintPublish(project(":lintpublish"))
      }
          

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

שינויים בהתנהגות

• הוצאה משימוש של הפלאגין של התכונה 'אפליקציות אינסטנט ל-Android' אזהרה: אם אתם עדיין משתמשים בפלאגין com.android.feature כדי לבנות את האפליקציה ללא התקנה, תקבלו אזהרה על הוצאה משימוש בפלאגין Android Gradle 3.4.0. כדי לוודא שתוכלו להמשיך ליצור אפליקציה ללא התקנה בגרסאות עתידיות של הפלאגין, צריך להעביר את האפליקציה ללא התקנה לשימוש בפלאגין של תכונה דינמית. הפלאגין הזה מאפשר גם לפרסם את האפליקציה המותקנת ואת האפליקציה ללא התקנה מתוך קובץ Android App Bundle יחיד.

• הכלי R8 מופעל כברירת מחדל: הכלי R8 משלב את הפעולות הבאות בשלב אחד: desugaring,‏ shrinking,‏ obfuscating,‏ optimizing ו-dexing. התוצאה היא שיפורים משמעותיים בביצועי הבנייה. הגרסה R8 הושקה בתוסף Android Gradle 3.3.0 ועכשיו היא מופעלת כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות Android באמצעות תוסף 3.4.0 ואילך.

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

עכשיו, עם R8, כל הפעולות האלה – desugaring,‏ shrinking,‏ obfuscating,‏ optimizing ו-dexing ‏ (D8) – מתבצעות בשלב אחד, כפי שמוצג בהמשך.

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

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

      # Disables R8 for Android Library modules only.
      android.enableR8.libraries = false
      # Disables R8 for all modules.
      android.enableR8 = false
      
    

הערה: אם מגדירים את useProguard ל-false בקובץ build.gradle של מודול האפליקציה, פלאגין Android Gradle משתמש ב-R8 כדי לכווץ את קוד האפליקציה עבור סוג ה-build הזה, בלי קשר להשבתה של R8 בקובץ gradle.properties של הפרויקט.

• הוצאנו את ndkCompile משימוש: עכשיו מוצגת שגיאת בנייה אם מנסים להשתמש ב-ndkBuild כדי לקמפל את הספריות המקוריות. במקום זאת, צריך להשתמש ב-CMake או ב-ndk-build כדי להוסיף קוד C ו-C++‎ לפרויקט.

בעיות מוכרות

• בשלב הזה, לא נאכף שימוש נכון בשמות חבילות ייחודיים, אבל בגרסאות מאוחרות יותר של הפלאגין תהיה הקפדה רבה יותר על כך. בגרסה 3.4.0 של הפלאגין Gradle ל-Android, אפשר להוסיף את השורה הבאה לקובץ gradle.properties כדי לבדוק אם הפרויקט כולל שמות חבילות קבילים.

            android.uniquePackageNames = true
            
          

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

‫3.3.0 (ינואר 2019)

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 4.10.1 ואילך. מידע נוסף זמין בקטע בנושא עדכון Gradle.

  הערה: כשמשתמשים ב-Gradle 5.0 ואילך, גודל ברירת המחדל של ה-heap בזיכרון של דמון Gradle יורד מ-1GB ל-512MB. הדבר עלול לגרום לרגרסיה בביצועי ה-build. כדי לבטל את הגדרת ברירת המחדל הזו, מציינים את גודל הערימה של Gradle daemon בקובץ gradle.properties של הפרויקט.

• ‫SDK Build Tools 28.0.3 ואילך.

‫3.3.3 (יולי 2020)

העדכון הקטן הזה תומך בתאימות להגדרות ברירת מחדל חדשות ולתכונות חדשות של חבילות גלויות ב-Android 11.

פרטים נוספים זמינים בהערות הגרסה 4.0.1.

‫3.3.2 (מרץ 2019)

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

‫3.3.1 (פברואר 2019)

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

תכונות חדשות

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

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

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

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

  הערה: התכונה הזו תואמת ל-Gradle מגרסה 4.10.1 ואילך, למעט Gradle מגרסה 5.1, בגלל בעיה מספר 8194 ב-Gradle.

  • בפרויקטים שמשתמשים ב-Kapt (רוב הפרויקטים שמבוססים על Kotlin בלבד ופרויקטים היברידיים של Kotlin-Java): קומפילציה מצטברת של Java מופעלת, גם כשמשתמשים ב-data binding או בתוסף retro-lambda. העיבוד של ההערות על ידי משימת Kapt עדיין לא מצטבר.

  • לפרויקטים שלא משתמשים ב-Kapt (פרויקטים ב-Java בלבד): אם מעבדי האנוטציות שבהם אתם משתמשים תומכים בעיבוד מצטבר של אנוטציות, קומפילציית Java מצטברת מופעלת כברירת מחדל. כדי לעקוב אחרי ההטמעה של מעבד ההערות המצטבר, אפשר לעיין בבעיה מספר 5277 ב-Gradle.

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

    android.enableSeparateAnnotationProcessing=true
                

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

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

            android.debug.obsoleteApi=true
          

  אפשר גם להעביר את התג -Pandroid.debug.obsoleteApi=true משורת הפקודה כדי להפעיל אותו.

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

שינויים בהתנהגות

• הגדרת משימות עצלה: התוסף משתמש עכשיו בAPI החדש ליצירת משימות של Gradle כדי להימנע מאתחול והגדרה של משימות שלא נדרשות להשלמת הבנייה הנוכחית (או משימות שלא נמצאות בתרשים משימות ההפעלה). לדוגמה, אם יש לכם כמה וריאציות של Build, כמו וריאציות של Build מסוג release ו-debug, ואתם יוצרים את גרסת ה-debug של האפליקציה, הפלאגין לא יאתחל ולא יגדיר משימות עבור גרסת ה-release של האפליקציה.

  יכול להיות שעדיין תהיה חובה להגדיר את המשימה כשקוראים לשיטות ישנות מסוימות ב-Variants API, כמו variant.getJavaCompile(). כדי לוודא שהגרסה שלכם מותאמת להגדרת משימות עצלה, מפעילים שיטות חדשות שמחזירות במקום זאת אובייקט TaskProvider, כמו variant.getJavaCompileProvider().

  אם אתם מריצים משימות build בהתאמה אישית, כדאי לכם לקרוא על התאמה ל-API החדש ליצירת משימות של Gradle.

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

• יצירה מהירה יותר של מחלקת R לפרויקטים של ספריות: בעבר, הפלאגין Android Gradle היה יוצר קובץ R.java לכל אחת מהתלויות של הפרויקט, ואז קומפילציה של מחלקות ה-R האלה לצד המחלקות האחרות של האפליקציה. התוסף יוצר עכשיו קובץ JAR שמכיל את המחלקה R המהודרת של האפליקציה ישירות, בלי ליצור קודם מחלקות R.java ביניים. האופטימיזציה הזו עשויה לשפר משמעותית את ביצועי הבנייה בפרויקטים שכוללים הרבה פרויקטים משניים של ספריות ותלויות, ולשפר את מהירות האינדוקס ב-Android Studio.

• כשיוצרים Android App Bundle, קובצי ה-APK שנוצרים מחבילת האפליקציה הזו ומיועדים ל-Android 6.0 (רמת API‏ 23) ומעלה, כוללים עכשיו כברירת מחדל גרסאות לא דחוסות של הספריות המקוריות. האופטימיזציה הזו מונעת את הצורך של המכשיר ליצור עותק של הספרייה, וכך מקטינה את הגודל של האפליקציה בדיסק. אם אתם רוצים להשבית את האופטימיזציה הזו, מוסיפים את השורה הבאה לקובץ gradle.properties:

  android.bundle.enableUncompressedNativeLibs = false
          

• התוסף אוכף גרסאות מינימליות של כמה תוספים של צד שלישי.

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

  כדי להפעיל את האופטימיזציה הזו, צריך להשתמש ב-Android Studio מגרסה 3.3 ואילך עם Android Gradle Plugin מגרסה 3.3.0 ואילך. כשעומדים בדרישות האלה, סביבת הפיתוח המשולבת (IDE) מציעה להפעיל את האופטימיזציה הזו כשמסנכרנים את הפרויקט. כברירת מחדל, האופטימיזציה מופעלת גם בפרויקטים חדשים.

  כדי להפעיל את האופטימיזציה הזו באופן ידני, לוחצים על File > Settings > Experimental > Gradle (Android Studio > Preferences > Experimental > Gradle ב-Mac) ומסמנים את תיבת הסימון Only sync the active variant.

  הערה: האופטימיזציה הזו תומכת באופן מלא בפרויקטים שכוללים את השפות Java ו-C++, ויש לה תמיכה מסוימת ב-Kotlin. כשמפעילים את האופטימיזציה לפרויקטים עם תוכן Kotlin, סינכרון Gradle חוזר לשימוש בווריאציות מלאות באופן פנימי.

• הורדה אוטומטית של חבילות SDK חסרות: הרחבנו את הפונקציונליות הזו כדי לתמוך ב-NDK. מידע נוסף זמין במאמר בנושא הורדה אוטומטית של חבילות חסרות באמצעות Gradle.

תיקוני באגים

• ‫Android Gradle Plugin 3.3.0 מתקן את הבעיות הבאות:

  • תהליך ה-build קורא ל-android.support.v8.renderscript.RenderScript במקום לגרסת AndroidX, למרות שהכלי Jetifier מופעל
  • התנגשויות בגלל androidx-rs.jar כולל חבילה סטטית של annotation.AnyRes
  • כשמשתמשים ב-RenderScript, כבר לא צריך להגדיר ידנית את הגרסה של כלי ה-Build בקובצי build.gradle

‫3.2.0 (ספטמבר 2018)

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 4.6 ומעלה. מידע נוסף זמין בקטע בנושא עדכון Gradle.
• ‫SDK Build Tools 28.0.3 ואילך.

‫3.2.1 (אוקטובר 2018)

בעקבות העדכון הזה, אין יותר צורך לציין גרסה לכלי ה-Build של SDK. פלאגין Android Gradle משתמש עכשיו בגרסה 28.0.3 כברירת מחדל.

תכונות חדשות

• תמיכה ביצירת קובצי Android App Bundle: קובץ ה-App Bundle הוא פורמט חדש להעלאה שכולל את כל הקוד והמשאבים המהודרים של האפליקציה, ומעביר את יצירת ה-APK והחתימה שלו לחנות Google Play. אתם לא צריכים יותר ליצור, לחתום ולנהל כמה קובצי APK, והמשתמשים מקבלים הורדות קטנות יותר שעברו אופטימיזציה למכשיר שלהם. מידע נוסף זמין במאמר בנושא קובץ Android App Bundle.

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

• כלי להעברה ל-AndroidX: כשמשתמשים בפלאגין Android Gradle מגרסה 3.2.0 עם Android מגרסה 3.2 ואילך, אפשר להעביר את התלויות המקומיות והתלויות של Maven בפרויקט לשימוש בספריות AndroidX החדשות. כדי לעשות זאת, בוחרים באפשרות Refactor > Migrate to AndroidX (שינוי מבנה > העברה ל-AndroidX) מסרגל התפריטים. בנוסף, השימוש בכלי ההעברה הזה מגדיר את הדגלים הבאים לערך true בקובץ gradle.properties:

  • ‫android.useAndroidX: אם הערך הוא true, הפלאגין ל-Android משתמש בספריית AndroidX המתאימה במקום בספריית תמיכה. אם לא מציינים את הדגל הזה, התוסף מגדיר אותו כ-false כברירת מחדל.

  • ‫android.enableJetifier: אם מגדירים את הערך true, התוסף Android מעביר באופן אוטומטי ספריות קיימות של צד שלישי לשימוש ב-AndroidX על ידי כתיבה מחדש של הקבצים הבינאריים שלהן. אם לא מציינים את הדגל הזה, התוסף מגדיר אותו כ-false כברירת מחדל. אפשר להגדיר את הדגל הזה לערך true רק אם גם android.useAndroidX מוגדר לערך true, אחרת תתקבל שגיאת בנייה.

    מידע נוסף זמין במאמר סקירה כללית על AndroidX.

• כלי חדש לכיווץ קוד, R8: R8 הוא כלי חדש לכיווץ קוד ולהסתרת קוד שמחליף את ProGuard. כדי להתחיל להשתמש בגרסת הטרום-השקה של R8, צריך לכלול את השורות הבאות בקובץ gradle.properties של הפרויקט:

          android.enableR8 = true
          

          android.enableR8 = true
          

שינויים בהתנהגות

• ההגדרה Desugaring with D8 (הסרת סוכר באמצעות D8) מופעלת עכשיו כברירת מחדל.

• ‫AAPT2 זמין עכשיו במאגר Maven של Google. כדי להשתמש ב-AAPT2, מוודאים שהתלות google() מופיעה בקובץ build.gradle, כמו שמוצג בהמשך:

            buildscript {
                  repositories {
                      google() // here
                      jcenter()
                  }
                  dependencies {
                      classpath 'com.android.tools.build:gradle:3.2.0'
                  }
              }
              allprojects {
                  repositories {
                      google() // and here
                      jcenter()
              }
            

            buildscript {
                  repositories {
                      google() // here
                      jcenter()
                  }
                  dependencies {
                      classpath 'com.android.tools.build:gradle:3.2.0'
                  }
              }
              allprojects {
                  repositories {
                      google() // and here
                      jcenter()
              }
            

• התכונה Native multidex מופעלת עכשיו כברירת מחדל. בגרסאות קודמות של Android Studio, הפעלתם multidex מקורי כשפרסתם את גרסת ניפוי הבאגים של אפליקציה במכשיר עם Android ברמת API 21 ומעלה. מעכשיו, בין אם אתם פורסים לאפליקציה במכשיר או יוצרים APK לפרסום, הפלאגין Android Gradle מאפשר שימוש ב-multidex מקורי לכל המודולים שמוגדרים עם minSdkVersion=21 ומעלה.

• התוסף אוכף עכשיו גרסה מינימלית של תוסף protobuf ‏ (0.8.6), תוסף Kotlin ‏ (1.2.50) ותוסף Crashlytics ‏ (1.25.4).

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

תיקוני באגים

• עכשיו אפשר לשמור JavaCompile במטמון בפרויקטים עם קישור נתונים. (בעיה מספר 69243050)
• שיפור ההימנעות מהידור של מודולים בספרייה עם קישור נתונים. (בעיה מספר 77539932)
• אם השבתתם את האפשרות configure-on-demand בגרסאות קודמות בגלל שגיאות בלתי צפויות ב-build, עכשיו אתם יכולים להפעיל אותה מחדש. (בעיה מספר 77910727)

‫3.1.0 (מרץ 2018)

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 4.4 ומעלה.

  מידע נוסף זמין בקטע בנושא עדכון Gradle.

• ‫Build Tools 27.0.3 ומעלה.

  חשוב לזכור: כבר לא צריך לציין גרסה לכלי הבנייה באמצעות המאפיין android.buildToolsVersion – התוסף משתמש בגרסה המינימלית הנדרשת כברירת מחדל.

קומפיילר DEX חדש, ‏ D8

כברירת מחדל, Android Studio משתמש עכשיו במהדר DEX חדש שנקרא D8. קימפול DEX הוא תהליך של המרת בייטקוד .class לבייטקוד .dex עבור זמן הריצה של Android (או Dalvik, בגרסאות ישנות יותר של Android). בהשוואה לקומפיילר הקודם, שנקרא DX, הקומפיילר D8 מבצע קומפילציה מהר יותר ומפיק קובצי DEX קטנים יותר, וכל זאת תוך שמירה על ביצועים זהים או טובים יותר של זמן הריצה של האפליקציה.

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

      android.enableD8=false
    

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

      android.enableIncrementalDesugaring=false.
    

משתמשי גרסת Preview: אם אתם כבר משתמשים בגרסת Preview של D8, שימו לב שעכשיו היא מתבצעת הידור מול ספריות שכלולות בכלי ה-Build של SDK, ולא מול JDK. לכן, אם ניגשים לממשקי API שקיימים ב-JDK אבל לא בספריות של כלי ה-build של ה-SDK, מתקבלת שגיאת קומפילציה.

שינויים בהתנהגות

• כשיוצרים כמה חבילות APK שכל אחת מהן מטרגטת ממשק ABI שונה, המערכת כבר לא יוצרת חבילות APK לממשקי ה-ABI הבאים כברירת מחדל: mips, mips64 ו-armeabi.

  אם רוצים ליצור קובצי APK שמטרגטים את ממשקי ה-ABI האלה, צריך להשתמש ב-NDK r16b או בגרסה מוקדמת יותר ולציין את ממשקי ה-ABI בקובץ build.gradle, כמו שמוצג בהמשך:

            splits {
                abi {
                    include 'armeabi', 'mips', 'mips64'
                    ...
                }
            }
          

            splits {
                abi {
                    include("armeabi", "mips", "mips64")
                    ...
                }
            }
          

• התוסף ל-Android‏ build cache מסיר עכשיו רשומות במטמון שנוצרו לפני יותר מ-30 יום.

• העברת "auto" אל resConfig כבר לא בוחרת באופן אוטומטי משאבי מחרוזות לאריזה ב-APK. אם ממשיכים להשתמש ב-"auto", התוסף מאגד את כל משאבי המחרוזות שהאפליקציה ויחסי התלות שלה מספקים. לכן, במקום זאת, צריך לציין כל לוקאל שרוצים שהפלאגין יארוז ב-APK.

• מכיוון שמודולים מקומיים לא יכולים להיות תלויים ב-APK של בדיקת האפליקציה, הוספת תלויות לבדיקות המכשירים באמצעות ההגדרה androidTestApi במקום androidTestImplementation גורמת ל-Gradle להציג את האזהרה הבאה:

          WARNING: Configuration 'androidTestApi' is obsolete
          and has been replaced with 'androidTestImplementation'
          

          WARNING: Configuration 'androidTestApi' is obsolete
          and has been replaced with 'androidTestImplementation'
          

תיקונים

• תוקנה בעיה שבה Android Studio לא מזהה כראוי תלויות ב-composite builds.
• תוקנה בעיה שבה מוצגת שגיאת סנכרון של פרויקט כשמטעינים את הפלאגין של Android כמה פעמים בגרסה אחת – לדוגמה, כשכמה פרויקטים משניים כוללים את הפלאגין של Android בנתיב המחלקה של סקריפט הבנייה שלהם.

‫3.0.0 (אוקטובר 2017)

‫Android Gradle plugin 3.0.0 כולל מגוון שינויים שמטרתם לפתור בעיות ביצועים בפרויקטים גדולים.

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

גרסת הפלאגין של Android + גרסת Gradle	‫Android plugin 2.2.0 + Gradle 2.14.1	‫Android plugin 2.3.0 + Gradle 3.3	‫Android plugin 3.0.0 + Gradle 4.1
הגדרה (למשל, הפעלה של ./gradlew --help)	כ-2 דקות	‫~9 שניות	‫~2.5 שניות
שינוי של שורה אחת ב-Java (שינוי בהטמעה)	כ-2 דקות ו-15 שניות	‫~29 שניות	‫~6.4 שניות

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

אם לא חוויתם את שיפורי הביצועים שמתוארים למעלה, אפשר לדווח על באג ולצרף את נתוני המעקב של ה-build באמצעות Gradle Profiler.

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 4.1 או גרסה מתקדמת יותר. מידע נוסף זמין בקטע בנושא עדכון Gradle.
• ‫Build Tools 26.0.2 או גרסה מתקדמת יותר. בעקבות העדכון הזה, כבר לא צריך לציין גרסה לכלי הבנייה – התוסף משתמש בגרסה המינימלית הנדרשת כברירת מחדל. לכן, עכשיו אפשר להסיר את הנכס android.buildToolsVersion.

‫3.0.1 (נובמבר 2017)

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

אופטימיזציות

• מקביליות טובה יותר לפרויקטים מרובי מודולים באמצעות גרף משימות מפורט.
• כשמבצעים שינויים בהסתמכות, Gradle מבצעת בנייה מהירה יותר כי היא לא מבצעת קומפילציה מחדש של מודולים שאין להם גישה ל-API של ההסתמכות הזו. כדי להגביל את התלות של מודולים אחרים בממשקי API של מודולים מסוימים, צריך להשתמש בהגדרות התלות החדשות של Gradle:‏ implementation, ‏ api,‏ compileOnly ו-runtimeOnly.
• מהירות בנייה מצטברת מהירה יותר בגלל dexing לכל מחלקה. כל כיתה עוברת עכשיו קומפילציה לקובצי DEX נפרדים, ורק הכיתות שעברו שינוי עוברות מחדש DEX. בנוסף, צפוי שיפור במהירויות הבנייה של אפליקציות שבהן הערך של minSdkVersion הוא 20 או פחות, ושמשתמשות ב-legacy multi-dex.
• שיפור מהירויות הבנייה על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שמור במטמון. כדי ליהנות מהאופטימיזציה הזו, צריך קודם להפעיל את מטמון ה-build של Gradle.
• שיפור העיבוד של משאבים מצטברים באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלתם בבעיות במהלך השימוש ב-AAPT2, אפשר לדווח על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת android.enableAapt2=false בקובץ gradle.properties והפעלה מחדש של Gradle daemon על ידי הרצת ./gradlew --stop משורת הפקודה.

תכונות חדשות

• ניהול יחסי תלות עם מודעות לווריאציות. כשמפתחים וריאציה מסוימת של מודול, התוסף מתאים עכשיו באופן אוטומטי וריאציות של יחסי תלות במודול של ספרייה מקומית לווריאציה של המודול שמפתחים.
• כולל פלאגין חדש של מודול תכונות לתמיכה באפליקציות ללא התקנה ל-Android וב-Android Instant Apps SDK (שאפשר להוריד באמצעות SDK Manager). למידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, אפשר לקרוא את המאמר מבנה של אפליקציה מיידית עם כמה תכונות.
• תמיכה מובנית בשימוש בתכונות שפה מסוימות של Java 8 ובספריות Java 8. הכלי Jack יצא משימוש ואין יותר צורך בו. כדי להשתמש בתמיכה המשופרת ב-Java 8 שמוטמעת בשרשרת הכלים שמוגדרת כברירת מחדל, צריך להשבית קודם את Jack. מידע נוסף זמין במאמר בנושא שימוש בתכונות של שפת Java 8.

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

  • נוסף testOptions.execution כדי לקבוע אם להשתמש בתיאום בדיקות במכשיר. אם רוצים להשתמש ב-Android Test Orchestrator, צריך לציין את ANDROID_TEST_ORCHESTRATOR, כמו שמוצג בהמשך. כברירת מחדל, המאפיין הזה מוגדר כ-HOST, מה שמשבית את התיאום במכשיר וזו השיטה הרגילה להרצת בדיקות.

  Groovy

          android {
            testOptions {
              execution 'ANDROID_TEST_ORCHESTRATOR'
            }
          }
          

  Kotlin

          android {
            testOptions {
              execution = "ANDROID_TEST_ORCHESTRATOR"
            }
          }
          

• הגדרת תלות חדשה androidTestUtil מאפשרת לכם להתקין APK של כלי עזר לבדיקה לפני שמריצים את בדיקות המכשור, כמו Android Test Orchestrator:

  Groovy

          dependencies {
            androidTestUtil 'com.android.support.test:orchestrator:1.0.0'
            ...
          }
          

  Kotlin

          dependencies {
            androidTestUtil("com.android.support.test:orchestrator:1.0.0")
            ...
          }
          

• הוספנו את testOptions.unitTests.includeAndroidResources כדי לתמוך בבדיקות יחידה שדורשות משאבי Android, כמו Roboelectric. כשמגדירים את המאפיין הזה לערך true, הפלאגין מבצע מיזוג של משאבים, נכסים ומניפסטים לפני שהוא מריץ את בדיקות היחידה. לאחר מכן, הבדיקות יכולות לבדוק את com/android/tools/test_config.properties בנתיב המחלקה לגבי המפתחות הבאים:

  • ‫android_merged_assets: הנתיב המוחלט לספריית הנכסים הממוזגים.

    הערה: במודולים של ספריות, הנכסים הממוזגים לא מכילים את הנכסים של יחסי תלות (ראו בעיה מס' 65550419).

  • ‫android_merged_manifest: הנתיב המוחלט לקובץ המניפסט הממוזג.

  • ‫android_merged_resources: הנתיב המוחלט לספריית המשאבים הממוזגים, שמכילה את כל המשאבים מהמודול וכל התלויות שלו.

  • ‫android_custom_package: שם החבילה של המחלקה הסופית R. אם אתם משנים באופן דינמי את מזהה האפליקציה, יכול להיות ששם החבילה הזה לא יהיה זהה למאפיין package במניפסט של האפליקציה.

• תמיכה בגופנים כמשאבים (תכונה חדשה שהושקה בAndroid 8.0 (רמת API‏ 26)).
• תמיכה בחבילות APK ספציפיות לשפה עם Android Instant Apps SDK 1.1 ומעלה.

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

  Groovy

          android {
              ...
              externalNativeBuild {
                  // For ndk-build, instead use the ndkBuild block.
                  cmake {
                      ...
                      // Specifies a relative path for outputs from external native
                      // builds. You can specify any path that's not a subdirectory
                      // of your project's temporary build/ directory.
                      buildStagingDirectory "./outputs/cmake"
                  }
              }
          }
          

  Kotlin

          android {
              ...
              externalNativeBuild {
                  // For ndk-build, instead use the ndkBuild block.
                  cmake {
                      ...
                      // Specifies a relative path for outputs from external native
                      // builds. You can specify any path that's not a subdirectory
                      // of your project's temporary build/ directory.
                      buildStagingDirectory = "./outputs/cmake"
                  }
              }
          }
          

• מעכשיו אפשר להשתמש ב-CMake 3.7 ואילך כשיוצרים פרויקטים מקוריים מ-Android Studio.

• הגדרת תלות חדשה lintChecks מאפשרת ליצור קובץ JAR שמגדיר כללי lint מותאמים אישית, ולצרף אותו לפרויקטים של AAR ו-APK.

  כללי ה-lint המותאמים אישית צריכים להיות חלק מפרויקט נפרד שמפיק קובץ JAR יחיד וכולל רק תלות ב-compileOnly. מודולים אחרים של אפליקציות וספריות יכולים להסתמך על פרויקט lint באמצעות ההגדרה lintChecks:

  Groovy

          dependencies {
              // This tells the Gradle plugin to build ':lint-checks' into a lint.jar file
              // and package it with your module. If the module is an Android library,
              // other projects that depend on it automatically use the lint checks.
              // If the module is an app, lint includes these rules when analyzing the app.
              lintChecks project(':lint-checks')
          }
          

  Kotlin

          dependencies {
              // This tells the Gradle plugin to build ':lint-checks' into a lint.jar file
              // and package it with your module. If the module is an Android library,
              // other projects that depend on it automatically use the lint checks.
              // If the module is an app, lint includes these rules when analyzing the app.
              lintChecks(project(":lint-checks"))
          }
          

שינויים בהתנהגות

• פלאגין Android 3.0.0 מסיר ממשקי API מסוימים, והגרסה שלכם תפסיק לפעול אם אתם משתמשים בהם. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג outputFile() או להשתמש ב-processManifest.manifestOutputFile() כדי לקבל את קובץ המניפסט לכל וריאציה. מידע נוסף מופיע במאמר בנושא שינויים ב-API.
• אין יותר צורך לציין גרסה של כלי הבנייה (לכן אפשר להסיר את המאפיין android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש אוטומטית בגרסה המינימלית הנדרשת של כלי הבנייה לגרסה של פלאגין Android שבה אתם משתמשים.
• עכשיו אתם יכולים להפעיל או להשבית את דחיסת ה-PNG בחסימה של buildTypes כמו שמוצג למטה. הדחיסה של קובצי PNG מופעלת כברירת מחדל בכל הגרסאות, חוץ מגרסאות ניפוי הבאגים, כי היא מאריכה את זמן הבנייה של פרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני הבנייה של סוגי בנייה אחרים, צריך להשבית את דחיסת ה-PNG או להמיר את התמונות לפורמט WebP.

  Groovy

        android {
          buildTypes {
            release {
              // Disables PNG crunching for the release build type.
              crunchPngs false
            }
          }
        }
        

  Kotlin

        android {
          buildTypes {
            release {
              // Disables PNG crunching for the release build type.
              isCrunchPngs = false
            }
          }
        }
        

• התוסף ל-Android יוצר עכשיו באופן אוטומטי יעדים להרצה שמוגדרים בפרויקטים חיצוניים של CMake.
• עכשיו צריך להוסיף מעבדי הערות לנתיב המחלקות של המעבד באמצעות הגדרת התלות annotationProcessor.
• השימוש ב-ndkCompile שהוצא משימוש מוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד מקומי שרוצים לארוז ב-APK. מידע נוסף זמין במאמר העברה מ-ndkcompile.

‫3.0.0 (אוקטובר 2017)

‫Android Gradle plugin 3.0.0 כולל מגוון שינויים שמטרתם לפתור בעיות ביצועים בפרויקטים גדולים.

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

גרסת הפלאגין של Android + גרסת Gradle	‫Android plugin 2.2.0 + Gradle 2.14.1	‫Android plugin 2.3.0 + Gradle 3.3	‫Android plugin 3.0.0 + Gradle 4.1
הגדרה (למשל, הפעלה של ./gradlew --help)	כ-2 דקות	‫~9 שניות	‫~2.5 שניות
שינוי של שורה אחת ב-Java (שינוי בהטמעה)	כ-2 דקות ו-15 שניות	‫~29 שניות	‫~6.4 שניות

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

אם לא חוויתם את שיפורי הביצועים שמתוארים למעלה, אפשר לדווח על באג ולצרף את נתוני המעקב של ה-build באמצעות Gradle Profiler.

הגרסה הזו של הפלאגין ל-Android דורשת את הדברים הבאים:

• ‫Gradle 4.1 או גרסה מתקדמת יותר. מידע נוסף זמין בקטע בנושא עדכון Gradle.
• ‫Build Tools 26.0.2 או גרסה מתקדמת יותר. בעקבות העדכון הזה, כבר לא צריך לציין גרסה לכלי הבנייה – התוסף משתמש בגרסה המינימלית הנדרשת כברירת מחדל. לכן, עכשיו אפשר להסיר את הנכס android.buildToolsVersion.

‫3.0.1 (נובמבר 2017)

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

אופטימיזציות

• מקביליות טובה יותר לפרויקטים מרובי מודולים באמצעות גרף משימות מפורט.
• כשמבצעים שינויים בהסתמכות, Gradle מבצעת בנייה מהירה יותר כי היא לא מבצעת קומפילציה מחדש של מודולים שאין להם גישה ל-API של ההסתמכות הזו. כדי להגביל את התלות של מודולים אחרים בממשקי API של מודולים מסוימים, צריך להשתמש בהגדרות התלות החדשות של Gradle:‏ implementation, ‏ api,‏ compileOnly ו-runtimeOnly.
• מהירות בנייה מצטברת מהירה יותר בגלל dexing לכל מחלקה. כל כיתה עוברת עכשיו קומפילציה לקובצי DEX נפרדים, ורק הכיתות שעברו שינוי עוברות מחדש DEX. בנוסף, צפוי שיפור במהירויות הבנייה של אפליקציות שבהן הערך של minSdkVersion הוא 20 או פחות, ושמשתמשות ב-legacy multi-dex.
• שיפור מהירויות הבנייה על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שמור במטמון. כדי ליהנות מהאופטימיזציה הזו, צריך קודם להפעיל את מטמון ה-build של Gradle.
• שיפור העיבוד של משאבים מצטברים באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלתם בבעיות במהלך השימוש ב-AAPT2, אפשר לדווח על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת android.enableAapt2=false בקובץ gradle.properties והפעלה מחדש של Gradle daemon על ידי הרצת ./gradlew --stop משורת הפקודה.

תכונות חדשות

• ניהול יחסי תלות עם מודעות לווריאציות. כשמפתחים וריאציה מסוימת של מודול, התוסף מתאים עכשיו באופן אוטומטי וריאציות של יחסי תלות במודול של ספרייה מקומית לווריאציה של המודול שמפתחים.
• כולל פלאגין חדש של מודול תכונות לתמיכה באפליקציות ללא התקנה ל-Android וב-Android Instant Apps SDK (שאפשר להוריד באמצעות SDK Manager). למידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, אפשר לקרוא את המאמר מבנה של אפליקציה מיידית עם כמה תכונות.
• תמיכה מובנית בשימוש בתכונות שפה מסוימות של Java 8 ובספריות Java 8. הכלי Jack יצא משימוש ואין יותר צורך בו. כדי להשתמש בתמיכה המשופרת ב-Java 8 שמוטמעת בשרשרת הכלים שמוגדרת כברירת מחדל, צריך להשבית קודם את Jack. מידע נוסף זמין במאמר בנושא שימוש בתכונות של שפת Java 8.

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

  • נוסף testOptions.execution כדי לקבוע אם להשתמש בתיאום בדיקות במכשיר. אם רוצים להשתמש ב-Android Test Orchestrator, צריך לציין את ANDROID_TEST_ORCHESTRATOR, כמו שמוצג בהמשך. כברירת מחדל, המאפיין הזה מוגדר כ-HOST, מה שמשבית את התיאום במכשיר וזו השיטה הרגילה להרצת בדיקות.

  Groovy

          android {
            testOptions {
              execution 'ANDROID_TEST_ORCHESTRATOR'
            }
          }
          

  Kotlin

          android {
            testOptions {
              execution = "ANDROID_TEST_ORCHESTRATOR"
            }
          }
          

• הגדרת תלות חדשה androidTestUtil מאפשרת לכם להתקין APK של כלי עזר לבדיקה לפני שמריצים את בדיקות המכשור, כמו Android Test Orchestrator:

  Groovy

          dependencies {
            androidTestUtil 'com.android.support.test:orchestrator:1.0.0'
            ...
          }
          

  Kotlin

          dependencies {
            androidTestUtil("com.android.support.test:orchestrator:1.0.0")
            ...
          }
          

• הוספנו את testOptions.unitTests.includeAndroidResources כדי לתמוך בבדיקות יחידה שדורשות משאבי Android, כמו Roboelectric. כשמגדירים את המאפיין הזה לערך true, הפלאגין מבצע מיזוג של משאבים, נכסים ומניפסטים לפני שהוא מריץ את בדיקות היחידה. לאחר מכן, הבדיקות יכולות לבדוק את com/android/tools/test_config.properties בנתיב המחלקה לגבי המפתחות הבאים:

  • ‫android_merged_assets: הנתיב המוחלט לספריית הנכסים הממוזגים.

    הערה: במודולים של ספריות, הנכסים הממוזגים לא מכילים את הנכסים של יחסי תלות (ראו בעיה מס' 65550419).

  • ‫android_merged_manifest: הנתיב המוחלט לקובץ המניפסט הממוזג.

  • ‫android_merged_resources: הנתיב המוחלט לספריית המשאבים הממוזגים, שמכילה את כל המשאבים מהמודול וכל התלויות שלו.

  • ‫android_custom_package: שם החבילה של המחלקה הסופית R. אם אתם משנים באופן דינמי את מזהה האפליקציה, יכול להיות ששם החבילה הזה לא יהיה זהה למאפיין package במניפסט של האפליקציה.

• תמיכה בגופנים כמשאבים (תכונה חדשה שהושקה בAndroid 8.0 (רמת API‏ 26)).
• תמיכה בחבילות APK ספציפיות לשפה עם Android Instant Apps SDK 1.1 ומעלה.

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

  Groovy

          android {
              ...
              externalNativeBuild {
                  // For ndk-build, instead use the ndkBuild block.
                  cmake {
                      ...
                      // Specifies a relative path for outputs from external native
                      // builds. You can specify any path that's not a subdirectory
                      // of your project's temporary build/ directory.
                      buildStagingDirectory "./outputs/cmake"
                  }
              }
          }
          

  Kotlin

          android {
              ...
              externalNativeBuild {
                  // For ndk-build, instead use the ndkBuild block.
                  cmake {
                      ...
                      // Specifies a relative path for outputs from external native
                      // builds. You can specify any path that's not a subdirectory
                      // of your project's temporary build/ directory.
                      buildStagingDirectory = "./outputs/cmake"
                  }
              }
          }
          

• מעכשיו אפשר להשתמש ב-CMake 3.7 ואילך כשיוצרים פרויקטים מקוריים מ-Android Studio.

• הגדרת תלות חדשה lintChecks מאפשרת ליצור קובץ JAR שמגדיר כללי lint מותאמים אישית, ולצרף אותו לפרויקטים של AAR ו-APK.

  כללי ה-lint המותאמים אישית צריכים להיות חלק מפרויקט נפרד שמפיק קובץ JAR יחיד וכולל רק תלות ב-compileOnly. מודולים אחרים של אפליקציות וספריות יכולים להסתמך על פרויקט lint באמצעות ההגדרה lintChecks:

  Groovy

          dependencies {
              // This tells the Gradle plugin to build ':lint-checks' into a lint.jar file
              // and package it with your module. If the module is an Android library,
              // other projects that depend on it automatically use the lint checks.
              // If the module is an app, lint includes these rules when analyzing the app.
              lintChecks project(':lint-checks')
          }
          

  Kotlin

          dependencies {
              // This tells the Gradle plugin to build ':lint-checks' into a lint.jar file
              // and package it with your module. If the module is an Android library,
              // other projects that depend on it automatically use the lint checks.
              // If the module is an app, lint includes these rules when analyzing the app.
              lintChecks(project(":lint-checks"))
          }
          

שינויים בהתנהגות

• פלאגין Android 3.0.0 מסיר ממשקי API מסוימים, והגרסה שלכם תפסיק לפעול אם אתם משתמשים בהם. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג outputFile() או להשתמש ב-processManifest.manifestOutputFile() כדי לקבל את קובץ המניפסט לכל וריאציה. מידע נוסף מופיע במאמר בנושא שינויים ב-API.
• אין יותר צורך לציין גרסה של כלי הבנייה (לכן אפשר להסיר את המאפיין android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש אוטומטית בגרסה המינימלית הנדרשת של כלי הבנייה לגרסה של פלאגין Android שבה אתם משתמשים.
• עכשיו אתם יכולים להפעיל או להשבית את דחיסת ה-PNG בחסימה של buildTypes כמו שמוצג למטה. הדחיסה של קובצי PNG מופעלת כברירת מחדל בכל הגרסאות, חוץ מגרסאות ניפוי הבאגים, כי היא מאריכה את זמן הבנייה של פרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני הבנייה של סוגי בנייה אחרים, צריך להשבית את דחיסת ה-PNG או להמיר את התמונות לפורמט WebP.

  Groovy

        android {
          buildTypes {
            release {
              // Disables PNG crunching for the release build type.
              crunchPngs false
            }
          }
        }
        

  Kotlin

        android {
          buildTypes {
            release {
              // Disables PNG crunching for the release build type.
              isCrunchPngs = false
            }
          }
        }
        

• התוסף ל-Android יוצר עכשיו באופן אוטומטי יעדים להרצה שמוגדרים בפרויקטים חיצוניים של CMake.
• עכשיו צריך להוסיף מעבדי הערות לנתיב המחלקות של המעבד באמצעות הגדרת התלות annotationProcessor.
• השימוש ב-ndkCompile שהוצא משימוש מוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד מקומי שרוצים לארוז ב-APK. מידע נוסף זמין במאמר העברה מ-ndkcompile.

‫2.3.0 (פברואר 2017)

‫2.3.3 (יוני 2017)

זהו עדכון קל שמוסיף תאימות ל-Android Studio 2.3.3.

‫2.3.2 (מאי 2017)

זהו עדכון קל שמוסיף תאימות ל-Android Studio 2.3.2.

‫2.3.1 (אפריל 2017)

זהו עדכון קל לתוסף Android 2.3.0 שפותר בעיה שבה מכשירי Android פיזיים מסוימים לא פעלו כראוי עם Instant Run (ראו בעיה מס' 235879).

תלויות:

• ‫Gradle מגרסה 3.3 ואילך.
• ‫Build Tools 25.0.0 או גרסה מתקדמת יותר.

המינוי החדש:

• הגרסה משתמשת ב-Gradle 3.3, שכוללת שיפורים בביצועים ותכונות חדשות. פרטים נוספים זמינים בהערות המוצר של Gradle.
• מטמון build: מאחסן פלטים מסוימים שתוסף Android יוצר כשמבצעים build של הפרויקט (למשל, קובצי AAR לא ארוזים ותלות מרחוק שעברו dexing מראש). ה-builds הנקיים שלכם מהירים הרבה יותר כשמשתמשים במטמון, כי מערכת ה-build יכולה פשוט לעשות שימוש חוזר בקבצים האלה ששמורים במטמון במהלך ה-builds הבאים, במקום ליצור אותם מחדש. בפרויקטים שמשתמשים בתוסף Android בגרסה 2.3.0 ומעלה, נעשה שימוש במטמון של הבנייה כברירת מחדל. מידע נוסף זמין במאמר שיפור מהירות הבנייה באמצעות מטמון הבנייה.
  • כולל משימה של cleanBuildCache שמנקה את מטמון הבנייה.
  • אם אתם משתמשים בגרסת הניסוי של מטמון הבנייה (שנכללת בגרסאות קודמות של הפלאגין), כדאי לעדכן את הפלאגין לגרסה האחרונה.

שינויים:

• תמיכה בשינויים ב-Instant Run שכלולים ב-Android Studio 2.3.
• זמני ההגדרה של פרויקטים גדולים מאוד צריכים להיות מהירים משמעותית.
• תוקנו בעיות בהורדה אוטומטית של ספריית פריסת האילוצים.
• הפלאגין משתמש עכשיו בגרסה 5.3.2 של ProGuard.
• הגרסה כוללת הרבה תיקונים של באגים שדווחו. אם נתקלתם בבעיות, אתם מוזמנים להמשיך לדווח על באגים.

‫2.2.0 (ספטמבר 2016)

תלויות:

• ‫Gradle 2.14.1 ואילך.
• ‫Build Tools 23.0.2 או גרסה מתקדמת יותר.

המינוי החדש:

• משתמש ב-Gradle 2.14.1, שכולל שיפורים בביצועים ותכונות חדשות, ומתקן פגיעות באבטחה שמאפשרת העלאת הרשאות מקומיות כשמשתמשים ב-Gradle daemon. פרטים נוספים זמינים ב הערות המוצר של Gradle.
• באמצעות externalNativeBuild {} DSL, ‏ Gradle מאפשר עכשיו לקשר למקורות המקוריים ולבצע קומפילציה של ספריות מקוריות באמצעות CMake או ndk-build. אחרי שיוצרים את ספריות ה-Native, ‏ Gradle אורז אותן ב-APK. מידע נוסף על שימוש ב-CMake וב-ndk-build עם Gradle זמין במאמר הוספת קוד C ו-C++‎ לפרויקט.
• כשמריצים build משורת הפקודה, ‏ Gradle מנסה עכשיו להוריד באופן אוטומטי רכיבי SDK חסרים או עדכונים שהפרויקט תלוי בהם. מידע נוסף זמין במאמר בנושא הורדה אוטומטית של חבילות חסרות באמצעות Gradle.
• תכונה חדשה של שמירת נתונים במטמון מאפשרת ל-Gradle להאיץ את זמני הבנייה באמצעות dexing מראש, אחסון ושימוש חוזר בגרסאות של הספריות שעברו dexing מראש. במדריך בנושא Build Cache מפורט מידע נוסף על השימוש בתכונה הניסיונית הזו.
• שיפור הביצועים של הבנייה באמצעות אימוץ צינור אריזה חדש שמוגדר כברירת מחדל, שמטפל בדחיסה, בחתימה וביישור זיפ במשימה אחת. אפשר לחזור להשתמש בכלים הישנים יותר לאריזה על ידי הוספת android.useOldPackaging=true לקובץ gradle.properties. כשמשתמשים בכלי האריזה החדש, המשימה zipalignDebug לא זמינה. עם זאת, אפשר ליצור אחד בעצמכם על ידי הפעלת השיטה createZipAlignTask(String taskName, File inputFile, File outputFile).
• חתימת ה-APK מתבצעת עכשיו באמצעות APK Signature Scheme v2 בנוסף לחתימת JAR רגילה. כל הפלטפורמות של Android מקבלות את קובצי ה-APK שנוצרים. כל שינוי בקובצי ה-APK האלה אחרי החתימה מבטל את תוקף החתימות שלהם בגרסה 2 ומונע את ההתקנה במכשיר. כדי להשבית את התכונה הזו, מוסיפים את השורות הבאות לקובץ build.gradle ברמת המודול:

  Groovy

  android {
    ...
    signingConfigs {
      config {
        ...
        v2SigningEnabled false
      }
    }
  }
        

  Kotlin

  android {
    ...
    signingConfigs {
      create("config") {
        ...
        v2SigningEnabled = false
      }
    }
  }
        

• ב-build של multidex, אפשר עכשיו להשתמש בכללי ProGuard כדי לקבוע אילו מחלקות Gradle צריך לקמפל לקובץ ה-DEX הראשי של האפליקציה. מערכת Android טוענת קודם את קובץ ה-DEX הראשי כשמפעילים את האפליקציה, ולכן אפשר לתת עדיפות למחלקות מסוימות בהפעלה על ידי קומפילציה שלהן לקובץ ה-DEX הראשי. אחרי שיוצרים קובץ הגדרות של ProGuard במיוחד בשביל קובץ ה-DEX הראשי, מעבירים את הנתיב של קובץ ההגדרות ל-Gradle באמצעות buildTypes.multiDexKeepProguard. השימוש ב-DSL הזה שונה מהשימוש ב- buildTypes.proguardFiles, שמספק כללים כלליים של ProGuard לאפליקציה ולא מציין מחלקות לקובץ ה-DEX הראשי.
• נוסף תמיכה בדגל android:extractNativeLibs, שיכול לצמצם את גודל האפליקציה כשמתקינים אותה במכשיר. כשמגדירים את הדגל הזה לערך false באלמנט <application> במניפסט האפליקציה, Gradle אורז גרסאות לא דחוסות ומיושרות של ספריות ה-Native עם ה-APK. הפעולה הזו מונעת מ-PackageManager להעתיק את הספריות המקוריות מקובץ ה-APK למערכת הקבצים של המכשיר במהלך ההתקנה, ויש לה גם יתרון נוסף: היא מקטינה את גודל העדכונים של האפליקציה.
• עכשיו אפשר לציין versionNameSuffix ו- applicationIdSuffix לטעמים של מוצרים. (בעיה מספר 59614)

שינויים:

• ‫getDefaultProguardFile מחזירה עכשיו את קובצי ברירת המחדל של ProGuard שפלאגין Android ל-Gradle מספק, ולא משתמשת יותר בקובצי ProGuard ב-Android SDK.
• שיפורים בביצועים ובתכונות של מהדר Jack:
  • ‫Jack תומך עכשיו בכיסוי בדיקות של Jacoco כשמגדירים את testCoverageEnabled ל-true.
  • תמיכה משופרת במעבדי הערות. מעבדי הערות (Annotation) בנתיב המחלקות (classpath), כמו תלויות compile, מוחלים אוטומטית על הבנייה. אפשר גם לציין מעבד הערות ב-build ולהעביר ארגומנטים באמצעות ה-DSL‏ javaCompileOptions.annotationProcessorOptions {} בקובץ build.gradle ברמת המודול:

    Groovy

    android {
      ...
      defaultConfig {
        ...
        javaCompileOptions {
          annotationProcessorOptions {
            className 'com.example.MyProcessor'
            // Arguments are optional.
            arguments = [ foo : 'bar' ]
          }
        }
      }
    }
        

    Kotlin

    android {
      ...
      defaultConfig {
        ...
        javaCompileOptions {
          annotationProcessorOptions {
            className = "com.example.MyProcessor"
            // Arguments are optional.
            arguments(mapOf(foo to "bar"))
          }
        }
      }
    }
        

    אם רוצים להחיל מעבד הערות בזמן ההידור, אבל לא לכלול אותו בחבילת ה-APK, צריך להשתמש בannotationProcessor היקף התלות:

    Groovy

    dependencies {
        compile 'com.google.dagger:dagger:2.0'
        annotationProcessor 'com.google.dagger:dagger-compiler:2.0'
       // or use buildVariantAnnotationProcessor to target a specific build variant
    }
        

    Kotlin

    dependencies {
        implementation("com.google.dagger:dagger:2.0")
        annotationProcessor("com.google.dagger:dagger-compiler:2.0")
       // or use buildVariantAnnotationProcessor to target a specific build variant
    }
        

  כדי לראות רשימה של הפרמטרים שאפשר להגדיר, מריצים את הפקודה הבאה משורת הפקודה:

  java -jar /build-tools/jack.jar --help-properties
  

  • כברירת מחדל, אם גודל ה-heap של Gradle daemon הוא לפחות 1.5GB, ‏ Jack פועל עכשיו באותו תהליך כמו Gradle. כדי לשנות את גודל הערימה של ה-daemon, מוסיפים את השורה הבאה לקובץ gradle.properties:

    # This sets the daemon heap size to 1.5GB.
    org.gradle.jvmargs=-Xmx1536M
    

‫2.1.0 (אפריל 2016)

‫2.1.3 (אוגוסט 2016)

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

תלויות:

• ‫Gradle מגרסה 2.10 ואילך.
• ‫Build Tools 23.0.2 או גרסה מתקדמת יותר.

המינוי החדש:

• הוספנו תמיכה ב-N Developer Preview, ב-JDK 8 ובתכונות השפה Java 8 באמצעות ערכת הכלים Jack. מידע נוסף זמין במדריך לתצוגה מקדימה של Android N.

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

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

  Groovy

  android {
    ...
    compileOptions {
      incremental false
    }
  }

  Kotlin

  android {
    ...
    compileOptions {
      incremental = false
    }
  }

• הוספנו תמיכה ב-dexing-in-process, שמבצע dexing בתהליך הבנייה ולא בתהליכי VM חיצוניים נפרדים. השינוי הזה לא רק מקצר את משך הזמן של בנייה מצטברת, אלא גם מזרז את הבנייה המלאה. התכונה מופעלת כברירת מחדל בפרויקטים שבהם הגודל המקסימלי של הערימה של Gradle daemon מוגדר ל-2048MB לפחות. כדי לעשות את זה, צריך לכלול את השורות הבאות בקובץ gradle.properties של הפרויקט:

  ```none org.gradle.jvmargs = -Xmx2048m ```

  אם הגדרתם ערך ל- javaMaxHeapSize בקובץ build.gradle ברמת המודול, צריך להגדיר את org.gradle.jvmargs לערך של javaMaxHeapSize + 1024MB. לדוגמה, אם הגדרתם את javaMaxHeapSize ל-2048m, צריך להוסיף את השורה הבאה לקובץ gradle.properties של הפרויקט:

  ```none org.gradle.jvmargs = -Xmx3072m ```

  כדי להשבית את התהליך של יצירת קובץ DEX, מוסיפים את הקוד הבא לקובץ build.gradle ברמת המודול:

  Groovy

  android {
    ...
    dexOptions {
        dexInProcess false
    }
  }

  Kotlin

  android {
    ...
    dexOptions {
        dexInProcess = false
    }
  }

‫2.0.0 (אפריל 2016)

תלויות:

• ‫Gradle מגרסה 2.10 ואילך.
• ‫Build Tools 21.1.1 או גרסה מתקדמת יותר.

המינוי החדש:

• האפשרות הזו מפעילה את הפעלת האפליקציה באופן מיידי על ידי תמיכה בהחדרת קוד בייט, ודחיפת עדכונים של קוד ומשאבים לאפליקציה שפועלת באמולטור או במכשיר פיזי.
• נוספה תמיכה בבנייה מצטברת, גם כשהאפליקציה לא פועלת. זמני ה-build המלאים משתפרים על ידי העברת שינויים מצטברים דרך Android Debug Bridge למכשיר המחובר.
• הוספנו את maxProcessCount כדי לקבוע כמה תהליכי dex של עובדים יכולים להיות מופעלים בו-זמנית. הקוד הבא, בקובץ build.gradle ברמת המודול, מגדיר את המספר המקסימלי של תהליכים מקבילים ל-4:

  Groovy

  android {
    ...
    dexOptions {
      maxProcessCount = 4 // this is the default value
    }
  }

  Kotlin

  android {
    ...
    dexOptions {
      maxProcessCount = 4 // this is the default value
    }
  }

    </li>
  
    <li>Added an experimental code shrinker to support pre-dexing and reduce re-dexing
    of dependencies, which are not supported with Proguard. This improves the build
    speed of your debug build variant. Because the experimental shrinker does not
    support optimization and obfuscation, you should enable Proguard for your
    release builds. To enable the experimental shrinker for your debug builds, add
    the following to your module-level <code>build.gradle</code> file:
  

  Groovy

  android {
    ...
    buildTypes {
      debug {
        minifyEnabled true
        useProguard false
      }
      release {
        minifyEnabled true
        useProguard true // this is a default setting
      }
    }
  }

  Kotlin

  android {
    ...
    buildTypes {
      getByName("debug") {
        minifyEnabled = true
        useProguard = false
      }
      getByName("release") {
        minifyEnabled = true
        useProguard = true // this is a default setting
      }
    }
  }

    </li>
  
    <li>Added logging support and improved performance for the resource shrinker.
    The resource shrinker now logs all of its operations into a <code>resources.txt</code>
    file located in the same folder as the Proguard log files.
    </li>
  </ul>
  

שינוי בהתנהגות:

• כשמגדירים את minSdkVersion ל-18 ומעלה, חתימת ה-APK מתבצעת באמצעות SHA256.

  <li>DSA and ECDSA keys can now sign APK packages.

    <p class="note">
      <strong>Note:</strong> The <a href=
      "/training/articles/keystore.html">Android keystore</a> provider no
      longer supports <a href=
      "/about/versions/marshmallow/android-6.0-changes.html#behavior-keystore">
      DSA keys on Android 6.0</a> (API level 23) and higher.
    </p>

  </li>
</ul>

בעיות שתוקנו:

• נפתרה בעיה שגרמה לתלות כפולה ב-AAR בשתי הגדרות ה-build, גם בבדיקה וגם ב-build הראשי.

פלאגין Android ל-Gradle, גרסה 1.5.0 (נובמבר 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• שילבנו את הפלאגין Data Binding בפלאגין Android ל-Gradle. כדי להפעיל אותו, מוסיפים את הקוד הבא לכל קובץ build.gradle לכל פרויקט שמשתמש בתוסף:
android {
    dataBinding {
        enabled = true
    }
}
        

android {
    dataBinding {
        enabled = true
    }
}
        

• הוספנו Transform API חדש כדי לאפשר לתוספים של צד שלישי לשנות קובצי .class שעברו קומפילציה לפני שהם מומרים לקובצי .dex. ממשק Transform API מפשט את ההחדרה של מניפולציות מותאמות אישית של מחלקות, ומציע יותר גמישות לגבי מה שאפשר לשנות. כדי להוסיף טרנספורמציה לבנייה, יוצרים מחלקה חדשה שמטמיעה אחד מהממשקים של Transform ורושמים אותה ב-android.registerTransform(theTransform) או ב-android.registerTransform(theTransform, dependencies). אין צורך לקשר בין המשימות. חשוב לדעת את הפרטים הבאים על Transform API:
• טרנספורמציה יכולה לחול על אחד או יותר מהרכיבים הבאים: הפרויקט הנוכחי, פרויקטים משניים וספריות חיצוניות.
• צריך לרשום טרנספורמציה באופן גלובלי, כדי שהיא תחול על כל הווריאציות.
• עיבוד פנימי של קוד, באמצעות Java Code Coverage Library ‏ (JaCoCo),‏ ProGuard ו-MultiDex, מתבצע עכשיו באמצעות Transform API. עם זאת, ערכת הכלים Java Android Compiler Kit‏ (Jack) לא משתמשת ב-API הזה: רק נתיב הקוד javac/dx משתמש בו.
• ‫Gradle מבצע את הטרנספורמציות בסדר הזה: JaCoCo, פלאגינים של צד שלישי, ProGuard. סדר ההפעלה של תוספים של צד שלישי תואם לסדר שבו התוספים של הצד השלישי מוסיפים את ההמרות. מפתחים של תוספים של צד שלישי לא יכולים לשלוט בסדר ההפעלה של ההמרות באמצעות API.
• הוצא משימוש ה-getter‏ dex מהמחלקה ApplicationVariant. אי אפשר יותר לגשת למשימה Dex דרך Variant API כי עכשיו היא מתבצעת באמצעות טרנספורמציה. אין כרגע תחליף לשליטה בתהליך dex.
• תוקנה תמיכה מצטברת בנכסים.
• שיפרנו את התמיכה ב-MultiDex והפכנו אותה לזמינה לפרויקטים של בדיקות. בנוסף, הבדיקות כוללות עכשיו באופן אוטומטי את התלות com.android.support:multidex-instrumentation.
• נוספה האפשרות לגרום ל-Gradle build להיכשל בצורה תקינה ולדווח על הסיבה הבסיסית לשגיאה כש-Gradle build מפעיל משימות אסינכרוניות ויש תקלה בתהליך של worker.
• הוספנו תמיכה בהגדרת Application Binary Interface ‏ (ABI) ספציפי בווריאציות שמכילות כמה ממשקי ABI.
• הוספנו תמיכה ברשימה של מספרים סידוריים של מכשירים שמופרדים בפסיקים עבור משתנה הסביבה ANDROID_SERIAL כשמתקינים או מריצים בדיקות.
• תוקנה בעיה שגרמה לכשל בהתקנה במכשירים עם Android 5.0 (API ברמה 20) ומעלה כשהשם של קובץ ה-APK מכיל רווח.
• תוקנו בעיות שונות שקשורות לפלט השגיאות של Android Asset Packaging Tool‏ (AAPT).
• הוספנו תמיכה בהוספת מכשור מצטבר של JaCoCo כדי להאיץ את הבנייה המצטברת. הפלאגין של Android ל-Gradle מפעיל עכשיו ישירות את הכלי JaCoCo instrumenter. כדי לכפות שימוש בגרסה חדשה יותר של הכלי JaCoCo instrumenter, צריך להוסיף אותה כתלות בסקריפט build.
• תוקנה התמיכה ב-JaCoCo כך שהמערכת מתעלמת מקבצים שהם לא מחלקות.
• הוספנו תמיכה ב-vector drawable כדי ליצור קובצי PNG בזמן הבנייה לצורך תאימות לאחור. התוסף Android ל-Gradle יוצר קובצי PNG לכל ציור וקטורי שנמצא בספריית משאבים שלא מצוינת בה גרסת API, או שמצוין בה מאפיין android:minSdkVersion בערך 20 ומטה באלמנט <uses-sdk> במניפסט של האפליקציה. אפשר להגדיר את הצפיפות של קובצי PNG באמצעות המאפיין generatedDensities בקטעים defaultConfig או productFlavor בקובץ build.gradle.
• נוסף שיתוף של android.jar שניתן ליצור ממנו אובייקט לצורך בדיקה, שהתוסף יוצר רק פעם אחת ומשתמש בו לבדיקות יחידה. כמה מודולים, כמו app ו-lib, משתמשים בו עכשיו. כדי ליצור אותו מחדש, מוחקים את $rootDir/build.
• השתנה העיבוד של משאבי Java, והוא מתבצע לפני משימות ההסתרה במקום במהלך האריזה של ה-APK. השינוי הזה מאפשר למשימות ההסתרה להתאים את משאבי Java אחרי הסתרת החבילות.
• תוקנה בעיה בשימוש בקוד Java Native Interface ‏ (JNI) בפלאגין של ספריית הניסויים.
• נוספה האפשרות להגדיר את גרסת הפלטפורמה בנפרד מהמאפיין android:compileSdkVersion בתוסף של ספריית הניסויים.

פלאגין Android ל-Gradle, גרסה 1.3.1 (אוגוסט 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• תוקן באפשרות ZipAlign באג שגרם לכך שהפלט של המשימה הקודמת לא נצרך בצורה תקינה כשמשתמשים בשם קובץ מותאם אישית.
• תוקנה בעיה באריזת Renderscript עם NDK.
• המשכנו לתמוך במשימת ה-Build‏ createDebugCoverageReport.
• תוקנה תמיכה בשימוש מותאם אישית במאפיין archiveBaseName בקובץ ה-build‏ build.gradle.
• תוקנה האזהרה Invalid ResourceType lint שנגרמה כתוצאה מחיפוש הערות של שיטת פרמטרים כשמריצים את lint מחוץ ל-Android Studio.

פלאגין Android ל-Gradle, גרסה 1.3.0 (יולי 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• נוספה תמיכה במאפיין com.android.build.threadPoolSize כדי לשלוט בגודל מאגר השרשורים של משימות Android מתוך הקובץ gradle.properties או שורת הפקודה. בדוגמה הבאה, המאפיין הזה מוגדר ל-4.

          
          -Pcom.android.build.threadPoolSize=4
          
        

• מגדירים את התנהגות ה-build כברירת מחדל כך שקבצים מסוג LICENSE ו-LICENSE.txt לא ייכללו בקובצי ה-APK. כדי לכלול את הקבצים האלה ב-APK, צריך להסיר אותם מהמאפיין packagingOptions.excludes בקובץ build.gradle. לדוגמה:
  android {
        packagingOptions.excludes = []
      }
        

  android {
        packagingOptions.excludes.clear()
      }
      

• נוספה המשימה sourceSets לבדיקת קבוצת כל מקורות הנתונים הזמינים.
• תמיכה משופרת בבדיקות יחידה כדי לזהות תיקיות מקור של גרסאות build ושל כמה טעמים. לדוגמה, כדי לבדוק אפליקציה עם כמה טעמים flavor1 ו-flavorA עם סוג ה-build‏ Debug, קבוצות מקור הבדיקה הן:
  • בדיקה
  • testFlavor1
  • testFlavorA
  • testFlavor1FlavorA
  • testFlavor1FlavorADebug

  בבדיקות Android כבר יש זיהוי של תיקיות מקור מרובות.

• שיפור התמיכה בבדיקות יחידה:
  • מריצים את הפקודה javac במקורות הראשיים ובמקורות הבדיקה, גם אם המאפיין useJack מוגדר כ-true בקובץ ה-build.
  • לזהות נכון את התלות לכל סוג של בנייה.
• הוספנו תמיכה בהגדרת ארגומנטים של מפעיל בדיקות אינסטרומנטציה משורת הפקודה. לדוגמה:

  ./gradlew connectedCheck \
     -Pandroid.testInstrumentationRunnerArguments.size=medium \
     -Pandroid.testInstrumentationRunnerArguments.class=TestA,TestB
          

• הוספנו תמיכה בפרמטרים שרירותיים נוספים של Android Asset Packaging Tool‏ (AAPT) בקובץ build.gradle. לדוגמה:

  android {
      aaptOptions {
        additionalParameters "--custom_option", "value"
      }
  }
        

  android {
      aaptOptions {
        additionalParameters += listOf("--custom_option", "value")
      }
  }
        

• נוספה תמיכה ב מודול APK לבדיקה כמודול בדיקה נפרד, באמצעות המאפיינים targetProjectPath ו-targetVariant להגדרת נתיב ה-APK וגרסת היעד.

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

• הוספנו אימות של שמות משאבים לפני מיזוג משאבים.
• כשיוצרים חבילת AAR (Android ARchive) למודולים של ספריות, לא צריך לספק placeholder אוטומטי של @{applicationId} בהגדרות של מיזוג המניפסט. במקום זאת, אפשר להשתמש בplaceholder אחר, כמו @{libApplicationId}, ולספק לו ערך אם רוצים לכלול מזהי אפליקציות בספריית הארכיון.

פלאגין Android ל-Gradle, גרסה 1.2.0 (אפריל 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• תמיכה משופרת בהרצת בדיקות יחידה באמצעות Gradle.
  • נוספה תמיכה בהכללת משאבים בסגנון Java בנתיב המחלקה כשמריצים בדיקות יחידה ישירות מ-Gradle.
  • הוספנו תמיכה ביחסי תלות בבדיקות יחידה עבור פריטי מידע שנוצרו בתהליך פיתוח (Artifact) מסוג Android Archive ‏(AAR).
  • הוספנו תמיכה במאפיין unitTestVariants כדי שאפשר יהיה לשנות את הווריאציות של בדיקות היחידה באמצעות הקובץ build.gradle.
  • הוספנו את בלוק הקוד unitTest.all מתחת ל-testOptions כדי להגדיר משימות בהתאמה אישית לבדיקת יחידות. בדוגמת הקוד הבאה אפשר לראות איך מוסיפים הגדרות של בדיקות יחידה באמצעות האפשרות החדשה הזו:
    android {
      testOptions {
        unitTest.all {
          jvmArgs '-XX:MaxPermSize=256m' // Or any other gradle option.
        }
      }
    }

    android {
      testOptions {
        unitTest.all {
          jvmArgs += listOf("-XX:MaxPermSize=256m") // Or any other gradle option.
        }
      }
    }
                

  • תוקן הטיפול בסוגי enum ובשדות של מופעים ציבוריים באריזה של קובץ mockable-android.jar.
  • תוקנו תלויות של משימות בפרויקט של ספרייה, כך שמחלקות בדיקה עוברות קומפילציה מחדש אחרי שינויים.
• נוספה המאפיין testProguardFile apply כדי להחיל קבצים של ProGuard כשמבצעים מזעור של קובץ APK לבדיקה.
• הוספנו את המאפיין timeOut לבלוק הקוד adbOptions כדי להגדיר את זמן ההקלטה המקסימלי של המסך בממשק הגישור של Android.
• הוספנו תמיכה במשאבים ברזולוציה של 280dpi.
• שיפור הביצועים במהלך הערכת הפרויקט.

פלאגין Android ל-Gradle, גרסה 1.1.3 (מרץ 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• תוקנה בעיה שגרמה לכפילות של יחסי תלות באפליקציית בדיקה, מה שהוביל לכשל ב-ProGuard.
• תוקן יישום של Comparator שלא עמד בדרישות של חוזה ה-Comparator של JDK ויצר שגיאה ב-JDK 7.

פלאגין Android ל-Gradle, גרסה 1.1.2 (פברואר 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• נתיב מנורמל כשיוצרים קובץ JAR שאפשר להשתמש בו לצורך בדיקות יחידה.
• תוקנה ההגדרה archivesBaseName בקובץ build.gradle.
• תוקן הכשל של placeholder שלא נפתר במיזוג המניפסט כשמבצעים build של אפליקציית בדיקה של ספרייה.

פלאגין Android ל-Gradle, גרסה 1.1.1 (פברואר 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• שינוי וריאציות של build כך שרק וריאציות שמכילות טריגר של אפליקציית Wear יפעילו משימות build ספציפיות ל-Wear.
• בעיות שקשורות לתלות נכשלות בזמן הבנייה ולא בזמן הניפוי. ההתנהגות הזו מאפשרת לכם להריץ משימות אבחון (כמו 'תלויות') כדי לפתור את הקונפליקט.
• תוקנה השיטה android.getBootClasspath() כך שתחזיר ערך.

פלאגין Android ל-Gradle, גרסה 1.1.0 (פברואר 2015)

תלויות:

• ‫Gradle 2.2.1 ואילך.
• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• נוספה תמיכה חדשה בבדיקות יחידה
• הפעלנו בדיקות יחידה שירוצו ב-JVM המקומי מול גרסה מיוחדת של קובץ android.jar שתואמת למסגרות פופולריות של יצירת אובייקטים לסימולציה, למשל Mockito.
• נוספו משימות בדיקה חדשות testDebug,‏ testRelease ו-testMyFlavorDebug בשימוש ב-product flavors.
• נוספו תיקיות מקור חדשות שמזוהות כבדיקות יחידה: src/test/java/, src/testDebug/java/, src/testMyFlavor/java/.
• נוספו הגדרות חדשות בקובץ build.gradle להצהרה על תלות בבדיקות בלבד, למשל testCompile 'junit:junit:4.11',‏ testMyFlavorCompile 'some:library:1.0'.

  הערה: כרגע אין תאימות בין תלותיות של בדיקות בלבד לבין Jack (Java Android Compiler Kit).

• נוספה האפשרות android.testOptions.unitTests.returnDefaultValues לשליטה בהתנהגות של android.jar שניתן ליצור ממנו אובייקט לצורך בדיקה.
• הוחלף Test בשמות של משימות בדיקה ב-AndroidTest. לדוגמה, המשימה assembleDebugTest היא עכשיו המשימה assembleDebugAndroidTest. במשימות של בדיקות יחידה עדיין מופיע UnitTest בשם המשימה, לדוגמה assembleDebugUnitTest.
• שונה קובץ ההגדרות של ProGuard כך שהוא לא יחול יותר על קובץ ה-APK של הבדיקה. אם ההגדרה minification (הקטנת נפח) מופעלת, ProGuard מעבד את קובץ ה-APK של הבדיקה ומחיל רק את קובץ המיפוי שנוצר כשמבצעים minification לקובץ ה-APK הראשי.
• עדכון של ניהול התלות
  • תוקנו בעיות בשימוש בהיקפי provided ו-package.

    הערה: ההיקפים האלה לא תואמים לחבילות AAR (Android ARchive) ויגרמו לכך שגרסת build עם חבילות AAR תיכשל.

  • בוצע שינוי בפתרון התלות כדי להשוות בין התלויות של אפליקציה שנבדקת לבין אפליקציית הבדיקה. אם נמצא ארטיפקט עם אותה גרסה בשתי האפליקציות, הוא לא נכלל באפליקציית הבדיקה ונארז רק עם האפליקציה שנבדקת. אם נמצא ארטיפקט עם גרסה שונה בשתי האפליקציות, ה-build ייכשל.
• הוספנו תמיכה בanyDpi resource qualifier במיזוג משאבים.
• שיפרנו את מהירות ההערכה והסנכרון של סביבת הפיתוח המשולבת (IDE) בפרויקטים עם מספר גדול של מודולים של Android.

פלאגין Android ל-Gradle, גרסה 1.0.1 (ינואר 2015)

תלויות:

• ‫Gradle 2.2.1 עד 2.3.x.

  הערה: הגרסה הזו של פלאגין Android ל-Gradle לא תואמת ל-Gradle 2.4 ומעלה.

• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• תוקנה בעיה שגרמה לתקלה ב-Gradle build בזמן גישה למודול extractReleaseAnnotations. (בעיה מספר 81638).
• תוקנה בעיה שקשורה להעברת ההגדרה Disable אל --no-optimize בבייטקוד ( bytecode) ‏Dalvik Executable ‏(dex). (בעיה מספר 82662).
• תוקנו בעיות במיזוג המניפסטים כשמייבאים ספריות עם targetSdkVersion קטן מ-16.
• תוקנה בעיה בסדר הצפיפות כשמשתמשים ב-Android Studio עם JDK 8.

פלאגין Android ל-Gradle, גרסה 1.0.0 (דצמבר 2014)

תלויות:

• ‫Gradle 2.2.1 עד 2.3.x.

  הערה: הגרסה הזו של פלאגין Android ל-Gradle לא תואמת ל-Gradle 2.4 ומעלה.

• ‫Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• הגרסה הראשונה של הפלאגין.