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

3.6 (פברואר 2020)

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

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

כלים לעיצוב

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

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

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

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

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

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

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

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

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

מנהל המשאבים

מנהל המשאבים כולל את העדכונים הבאים:

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

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

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

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

הצגת הקישור

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

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

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

  android {
      buildFeatures.viewBinding = true
  }
  

  android {
      buildFeatures.viewBinding = true
  }
  

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

עכשיו אפשר להוסיף כיתה ולאחר מכן לפרוס את שינוי הקוד באפליקציה שפועלת. לשם כך, לוחצים על Apply Code Changes (החלת שינויי הקוד) או על Apply Changes and Restart Activity (החלת השינויים והפעלה מחדש של הפעילות).

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

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

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

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

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

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

הסרת האובסוסקציה של בייטקוד של שיטות וסיווגים ב-APK Analyzer

כשמשתמשים ב-APK Analyzer כדי לבדוק קובצי DEX, אפשר לבצע את הפעולות הבאות כדי לבטל את הערפול של קוד בייט של שיטות וסיווגים:

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

כלים מקומיים

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

תמיכה ב-Kotlin

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

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

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

  

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

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

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

שיפורים נוספים ב-JNI

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אמולטורים

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

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

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

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

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

כדי להגדיר את המיקום של המהדמנים למיקום שבחרתם במפה, לוחצים על הלחצן Set location (הגדרת מיקום) בפינה השמאלית התחתונה של החלון Extended controls (אמצעי בקרה מורחבים).

.

מסלולים

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

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

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

.

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

תמיכה במספר מסכים

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

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

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

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

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

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

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

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

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

כשיוצרים פרויקט חדש באמצעות Android Studio, עכשיו אפשר לבחור מתוך שלושה תבניות בכרטיסייה Automotive באשף Create New Project: No Activity,‏ Media service ו-Messaging service. בפרויקטים קיימים, אפשר להוסיף תמיכה במכשירי Android Automotive על ידי בחירה באפשרות קובץ > חדש > מודול חדש בסרגל התפריטים, ואז באפשרות 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 על 768 פיקסלים.

.

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

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

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

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

Win32 הוצא משימוש

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

מידע נוסף זמין בבלוג בנושא ביטול התמיכה ב-Windows 32-bit

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

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

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

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

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

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

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. במיוחד, אנחנו רוצים להודות לאנשים הבאים שדיווחו על באגים:

3.5 (אוגוסט 2019)

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

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

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

Project Marble: בריאות המערכת

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

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

מעכשיו, אם מערכת Android Studio תזהה שאפשר לשפר את הביצועים על ידי הגדלת נפח ה-RAM המקסימלי שמערכת ההפעלה צריכה להקצות לתהליכים של Android Studio, כמו IDE הליבה, הדימון של Gradle והדימון של Kotlin, תופיע הודעה. אפשר לאשר את ההגדרות המומלצות בלחיצה על הקישור לפעולה בהתראה, או לשנות את ההגדרות האלה באופן ידני. לשם כך, בוחרים באפשרות File > Settings (או Android Studio > Preferences ב-macOS), ואז מאתרים את הקטע Memory Settings בקטע Appearance & Behavior > System Settings. מידע נוסף זמין במאמר גודל אשכול מקסימלי.

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

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

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

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

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

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

Project Marble: שיפור התכונות

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

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

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

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

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

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

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

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

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

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

פלט משופר של שגיאות build

בחלון Build יש עכשיו דיווח משופר על שגיאות, למשל קישור לקובץ ולשורה של השגיאה שדווחה, בתהליכי ה-build הבאים:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

למידע נוסף על השינויים האלה, ראו Project Marble ב-Android Studio: עורך פריסה.

קישור נתונים

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

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

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

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

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

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

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

מידע נוסף זמין במאמר שינוי גרסת build.

החלונית Build Variants עם בחירה של וריאנט יחיד לפי ABI.

גרסאות מקבילות של NDK

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

אם בפרויקט שלכם נעשה שימוש ב-Android Gradle plugin מגרסה 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:

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

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 בגרסה 3.5.0

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

תורמים לקהילה

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

3.4 (אפריל 2019)

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

IntelliJ IDEA 2018.3.4

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

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

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

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

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

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

משתנים

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

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

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

מודולים

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

יחסי תלות

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

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

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

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

וריאנטים של build

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

הצעות

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

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

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

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

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

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

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

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

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

ב-R8 משולבים הסרת סוכר, צמצום, ערפול, אופטימיזציה והסרה של קוד מיותר (dexing) – והתוצאה היא שיפורים משמעותיים בביצועי ה-build. R8 הוצג בפלאגין Android Gradle 3.3.0, והוא מופעל עכשיו כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות ל-Android באמצעות הפלאגין 3.4.0 ואילך.

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

עכשיו, ב-R8, תהליכי הסרת הסוכר, הצמצום, הטשטוש, האופטימיזציה וההמרה ל-dex (D8) מתבצעים בשלב אחד, כפי שמתואר בהמשך.

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

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

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

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

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

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

שיפורים בכלי לעריכת פריסות {:#layout-editor}

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

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

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

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

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

3.3 (ינואר 2019)

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

IntelliJ IDEA 2018.2.2

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

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

בנתוני הגרסה של הפלאגין של Android Gradle מפורט מה חדש בו.

עורך הניווט

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

למידע נוסף, ראו הטמעת ניווט באמצעות רכיב ארכיטקטורת הניווט.

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

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

אלה הספריות שמערכת 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, הוא מהיר יותר באופן משמעותי – בפרויקטים גדולים יותר, הבדיקה עשויה לפעול פי ארבעה מהר יותר.

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

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

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

עדכונים של כלי לניתוח ביצועים (profiler)

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

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

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

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

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

בתפריט הנפתח Allocation Tracking אפשר לבחור מבין המצבים הבאים:

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

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

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

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

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

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

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

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

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

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

הצגת טקסט מעוצב של עומסי עבודה של חיבורים ב-Network Profiler

בעבר, הכלי לניתוח רשתות הציג רק טקסט גולמי מטען שימושי של חיבורים. ב-Android Studio 3.3, סוגי טקסט מסוימים מקבלים עכשיו פורמט כברירת מחדל, כולל JSON, ‏ XML ו-HTML. בכרטיסיות Response ו-Request, לוחצים על הקישור View Parsed כדי להציג טקסט בפורמט, ולוחצים על הקישור View Source כדי להציג טקסט גולמי.

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

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

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

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

תמיכה ב-Clang-Tidy

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

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

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

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

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

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

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

CMake גרסה 3.10.2

גרסת CMake 3.10.2 נכללת עכשיו ב-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 Instant. במילים אחרות, עכשיו אפשר ליצור ולפרוס גם אפליקציות מותקנות וגם אפליקציות ללא התקנה מתוך פרויקט אחד ב-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>
    
  

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

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

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

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

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

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

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

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

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

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

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

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

3.2 (ספטמבר 2018)

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

מה חדש ב-Assistant

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

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

Android Jetpack

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

עורך הניווט

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

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

למידע נוסף, אפשר לעיין במסמכי התיעוד של Navigation Editor.

מיגרציה ל-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.

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

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

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

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

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

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

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

פרוסות

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

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

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

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

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.

סשנים

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

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

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

ב-CPU Profiler, בוחרים את ההגדרה החדשה System Trace כדי לבדוק את פעילות הליבה והפעילות של השרשור במערכת של המכשיר. הגדרת המעקב הזו מבוססת על 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 של אשכול זיכרון

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

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

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

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

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

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

ייצוא של מעקב אחר מעבדים

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

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

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

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

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

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

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

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

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

הכלי לניתוח צריכת אנרגיה

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

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

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

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

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

בדיקת Lint

ב-Android Studio 3.2 יש הרבה תכונות חדשות ומשופרות לבדיקת שגיאות בקוד.

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

בדיקות Lint לשילוב בין Java ל-Kotlin

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות Lint ל-Slices

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

יעד Gradle חדש

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

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

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

אזהרה אם מריצים איתור שגיאות בקוד (lint) בגרסה חדשה

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

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

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

קל יותר למצוא את מזהי הבעיות

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

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

Data Binding V2

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

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

ב-Android Studio 3.1, שילבנו את שלב הסרת הסוכר מהקוד בכלי D8 בתור תכונה ניסיונית, כדי לקצר את זמן ה-build הכולל. ב-Android Studio 3.2, הסרת הסוכר באמצעות 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 לעיצוב מחדש של קוד כדי להחיל סגנונות קוד על סקריפטים של build ב-CMake.
• פירוק מבנה בטוח: הכלים המובנים לפירוק מבנה ב-IDE בודקים עכשיו גם אם אתם משנים את השם של קבצים או מוחקים אותם, והם מתייחסים לסקריפטים של ה-build ב-CMake.

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

כשמשתמשים בחלון 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 Connection Assistant החדש מספק הוראות מפורטות שיעזרו לכם להגדיר מכשיר ולהשתמש בו דרך החיבור של Android Debug Bridge‏ (ADB).

כדי להפעיל את האסיסטנט, בוחרים באפשרות כלים > Connection Assistant.

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

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

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

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

פרטים נוספים זמינים במאמר Snapshots.

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

3.1 (מרץ 2018)

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

תכנות/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, עמודות, פרמטרים של שאילתות, כינויים, שאילתות משנה ותנאים מסוג 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.

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

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

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

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

קומפיילר ו-Gradle

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

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

למהדר DEX החדש יש כמה יתרונות, כולל:

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

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

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

        android.enableD8=true
      

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

הסרה של סוכר תחבירי באופן מצטבר

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

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

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

        android.enableIncrementalDesugaring=false
      

חלון פלט פשוט יותר

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

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

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

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

C++ ו-LLDB

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

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

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

• הוספת פורמטרים ('pretty printers') למבנים נתונים נוספים של C++ מאפשרת לקרוא בקלות רבה יותר את הפלט של LLDB.

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הכרטיסייה 'בקשה' בכלי לניתוחי רשת

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

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

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

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

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

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

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

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

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

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

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

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

הפעלה והרצה מיידית

שיפרנו את העקביות של ההתנהגות של האפשרות Use same selection for future launches בתיבת הדו-שיח Select deployment target. אם האפשרות Use same selection מופעלת, תיפתח תיבת הדו-שיח Select deployment target רק בפעם הראשונה שתשתמשו בפקודה Run, עד שהמכשיר שנבחר לא יהיה מחובר יותר.

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

מכשיר הדמיה

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

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

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

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

תפריטים מפורטים יותר, מקשי קיצור והודעות מועילות

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

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

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

התפריט כלים > Android הוסר. פקודות שהיו בעבר בתפריט הזה הועברו.

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

Device Monitor זמין משורת הפקודה

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

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

3.0 (אוקטובר 2017)

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

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

פלאגין Android ל-Gradle 3.0.0

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

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

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

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

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

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

אם אתם מוכנים לשדרג לפלאגין החדש, תוכלו לעיין במאמר מעבר לפלאגין Android ל-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 באמצעות האשף ליצירת פרויקטים חדשים.

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

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

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

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

Android Profiler

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

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

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

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

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

כלי לניתוח ביצועי ה-CPU

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

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

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

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

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

הכלי לניתוח הרשת

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

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

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

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

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

למידע נוסף, ראו יצירת פרופילים וניפוי באגים ב-APK שנוצר מראש.

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

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

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

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

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

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

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

כשתהיו מוכנים לבדוק את אפליקציית ה-Instant, תוכלו ליצור ולהריץ את המודול של אפליקציית ה-Instant במכשיר מחובר. לשם כך, צריך לציין את כתובת ה-URL של אפליקציית ה-Instant באפשרויות ההפעלה של הגדרות ההרצה: בוחרים באפשרות הפעלה > עריכת הגדרות, בוחרים את המודול של אפליקציית ה-Instant ומגדירים את כתובת ה-URL בקטע אפשרויות הפעלה.

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

מודולים של Android Things

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

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

אשף הסמלים המותאמים

Image Asset Studio תומך עכשיו בקובצי drawable וקובצי וקטור ומאפשר ליצור סמלי מרכז אפליקציות מותאמים ל-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

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

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

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

Android App Links Assistant

הכלי 'Assistant לקישורים לאפליקציות' עודכן עם היכולות החדשות הבאות:

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

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

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

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

עכשיו יש ב-Android Studio תמיכה בתג מיוחד בקובץ המניפסט שמאפשר לבדוק את כתובות ה-URL של מסנני הכוונה. אלו אותם תגים שהכלי 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 לבדיקה לא עומדת בהגדרה של מסנן הכוונה, תוצג שגיאת איתור שגיאות בקוד. שגיאה כזו עדיין מאפשרת ליצור גרסאות ניפוי באגים, אבל היא תגרום לשגיאות בגרסאות ה-build של המוצר.

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

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

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

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

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

הכלי לניתוח APK

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

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

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

מידע נוסף זמין במאמר ניתוח הגרסה היציבה באמצעות APK Analyzer.

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

Android Studio משתמש עכשיו במאגר Maven של Google כברירת מחדל, במקום להסתמך על Android SDK Manager כדי לקבל עדכונים ל-Android Support Library, ל-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, טיפים למשתנים, הדגשה סמנטית, נקודות עצירה שניתן לגרור, תוצאות מיידיות בחיפוש ועוד.
• נוספו בדיקות איתור שגיאות קוד חדשות רבות.
• כדאי לעיין גם בעדכונים האחרונים של Android Emulator.

2.3 (מרץ 2017)

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

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

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

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

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

שינויים

• עדכנו את קוד ה-IDE מ-IntelliJ 15 ל-IntelliJ 2016.1
• עכשיו צריך להתקין את ערכת ה-SDK של הפלטפורמה שתואמת לרמת ה-API של מכשיר היעד כדי להשתמש ב-Instant Run.
• Instant Run יושבת באופן אוטומטי אם המשתמש מפעיל את האפליקציה בפרופיל עבודה או כמשתמש משני.
• תוקנו הרבה בעיות מהימנות ב-Instant Run שבהן השינויים לא נפרסו או שהאפליקציה קרסה:
  • חלק מנכסי האפליקציה לא נפרסו באפליקציה שפועלת. ( באג: #213454)
  • האפליקציה קורסת כשהמשתמש עובר בין סשנים של Instant Run לסשנים שלא כוללים Instant Run, שבהם לא מוגדרת serialVersionUID בכיתה Serializable. (באג:‏ #209006)
  • שינויים בסגנון לא משתקפים ב-Instant Run. (באג: #210851)
  • סשן Instant Run לא מהימן וגורם לשגיאה מסוג FileNotFoundException. (באג:‏ #213083)
  • שינויים ב-drawables לא משתקפים עד שמבצעים בנייה מחדש מלאה ל-KitKat. (באג: #21530)
  • שינויים במשאבים לא משתקפים ב-Instant Run כש-sourceSets מותאמים אישית מכילים נתיבים בתצוגת עץ. (באג:‏ #219145)
  • החלפה חמה וחמה-יחסית לא פועלות אם הכיתה שהשתנתה מכילה הערה עם ערך של enum. (באג: #209047)
  • שינויים בנתוני ההערות לא משתקפים ב-Instant Run. (באג:‏ #210089)
  • אם מבצעים שינויים בקוד מחוץ לסביבת הפיתוח המשולבת, Instant Run לא מזהה אותם. (באג:‏ #213205)
  • סשן ההרצה המיידית לא מהימן בגלל חוסר התאמה באסימון האבטחה. (באג: #211989
  • החלפה קרה נכשלת במכשירים שלא תומכים כראוי ב-run-as. (באג: #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 Preview.

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

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

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

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

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

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

2.0 (אפריל 2016)

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

Instant Run:

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

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

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

• בדיקה של הצהרות switch באמצעות מספרים שלמים עם הערות של @IntDef כדי לוודא שכל הקבועים מטופלים. כדי להוסיף במהירות הצהרות חסרות, משתמשים בתפריט הנפתח של פעולת הכוונה ובוחרים באפשרות Add Missing @IntDef Constants.
• דגלים לניסיונות שגויים להשתמש בהוספת מחרוזות (interpolation) כדי להוסיף מספרי גרסאות לקובץ 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, תוך התחשבות בקבוצות מקור לא פעילות (כמו משאבים שמשמשים בטעמים אחרים של build) וטיפול נכון בייבוא שדות סטטיים.
• בדיקה אם יש תמיכה בהפניות סמויות ל-API בכל הפלטפורמות שנכללות בטירגוט של minSdkVersion.
• סימון של שימוש לא תקין ב-RecyclerView וב-Parcelable.
• בבדיקה של @IntDef,‏ @IntRange ו-@Size נבדקות עכשיו גם מערכי int ו-varargs.

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

• אופטימיזציה ל-Android Emulator 2.0, שהוא מהיר יותר מאי פעם, תומך במגוון רחב יותר של מכשירים וירטואליים ומציע ממשק משתמש משופר באופן משמעותי. מידע נוסף על הסימולטור החדש זמין בנתוני הגרסה של SDK Tools.
• שיפורים במנהל המכשירים הווירטואליים של Android:
  • קובצי האימג' של המערכות מסווגים עכשיו בכרטיסיות הבאות: מומלצים, x86 ו-אחר.
  • בהגדרות המתקדמות אפשר להפעיל תמיכה במספר ליבות ולציין את מספר הליבות שבהן אפשר להשתמש במהלך ההדמיה.
  • בקטע 'הגדרות מתקדמות', בוחרים באחת מהאפשרויות הבאות כדי לקבוע איך הגרפיקה תומרן במהלך ההרצה במהדורת האדמין:
    • חומרה: שימוש בכרטיס הגרפי של המחשב כדי לקבל רינדור מהיר יותר.
    • תוכנה: שימוש ברינדור מבוסס-תוכנה.
    • Auto: האפשרות הזו מאפשרת למהדר להחליט מהי האפשרות הטובה ביותר. זוהי הגדרת ברירת המחדל.
• שיפור זמני האריזה של 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 תומך עכשיו בהשלמת קוד לביטויים של קישור נתונים.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Android Studio v1.2.2‏(יוני 2015)

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

• תוקנו בעיות ב-build שחסמו את השלמת ה-builds.

Android Studio v1.2.1‏ (מאי 2015)

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

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

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

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

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

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

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

Android Studio v1.1.0 (פברואר 2015)

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

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

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

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

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

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

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

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

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

Android Studio v0.8.6 (אוגוסט 2014)

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

Android Studio v0.8.0 (יוני 2014)

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

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

Android Studio v0.5.2 (מאי 2014)

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

Android Studio v0.4.6 (מרץ 2014)

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

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

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

Android Studio v0.3.2 (אוקטובר 2013)

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

Android Studio v0.2.x (יולי 2013)

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

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

  הפלאגין המעודכן של Gradle כולל את השינויים הבאים:

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

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

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

Android Studio v0.1.x‏ (מאי 2013)

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

3.6.0 (פברואר 2020)

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

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

• SDK Build Tools 28.0.3 ואילך.

תכונות חדשות

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

הצגת הקישור

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

      android {
          viewBinding.enabled = true
      }
      

      android {
          viewBinding.enabled = true
      }
      

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

תמיכה בפלאגין Maven Publish

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

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

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

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

        android.useNewApkCreator=false
      

שיוך של build מקורי

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

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

   gradlew assembleDebug -Pandroid.enableProfileJson=true

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

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

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

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

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

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

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

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

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

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

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

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

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

יצירת קלאס R פשוטה

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

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

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

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

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

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

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

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

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

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

תיקוני באגים

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

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

בעיות מוכרות

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

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

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

הבעיה דווחה כבאג ב-IDEA ותטופל ב-Android Gradle Plugin 4.0.

חסר סוג מניפסט {:#agp-missing-manifest}

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

יצירת הכיתה של המניפסט לא תקינה בפלאגין של Android Gradle בגרסה 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: תקינות המערכת, שיפור התכונות ותיקון באגים. חשוב לציין ששיפור מהירות ה-build של פרויקטים היה אחד מהנושאים המרכזיים של העדכון הזה.

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

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

• Gradle 5.4.1. מידע נוסף זמין בקטע עדכון Gradle.

• SDK Build Tools 28.0.3 ואילך.

עיבוד אנוטציות מצטבר

מעבד התווית של Data Binding תומך בעיבוד מצטבר של תווית אם מגדירים את הערך android.databinding.incremental=true בקובץ gradle.properties. האופטימיזציה הזו מובילה לשיפור הביצועים של גרסאות build מצטברות. רשימה מלאה של מעבדי הערות שעברו אופטימיזציה מופיעה בטבלה של מעבדי הערות מצטברים.

בנוסף, 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 יורד מ-1GB ל-512MB. כתוצאה מכך, יכול להיות שתהיה רגרסיה בביצועי ה-build. כדי לשנות את הגדרת ברירת המחדל הזו, צריך לציין את גודל האשפה של הדימון של Gradle בקובץ gradle.properties של הפרויקט.

• SDK Build Tools 28.0.3 ואילך.

תכונות חדשות

• הגדרות אישיות חדשות של יחסי תלות לבדיקות איתור שגיאות בקוד: ההתנהגות של lintChecks השתנתה והוספה הגדרת תלות חדשה, lintPublish, כדי לתת לכם יותר שליטה על בדיקות איתור השגיאות שיארזו בספריות של Android.

  • lintChecks: זוהי הגדרה קיימת שצריך להשתמש בה לבדיקות איתור שגיאות בקוד (lint) שרוצים להריץ רק כשמפתחים את הפרויקט באופן מקומי. אם השתמשתם בעבר בהגדרת התלות lintChecks כדי לכלול בדיקות איתור שגיאות בקוד ב-AAR שפורסם, תצטרכו להעביר את יחסי התלות האלה ולהשתמש במקום זאת בהגדרה החדשה של lintPublish שמתוארת בהמשך.
  • lintPublish: משתמשים בהגדרה החדשה הזו בפרויקטים של ספריות לבדיקות איתור שגיאות בקוד שרוצים לכלול ב-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 משלב הסרה של סוכר, דחיסה, ערפול, אופטימיזציה והסרה של קוד מיותר (dexing) בשלב אחד, וכתוצאה מכך יש שיפורים בולטים בביצועי ה-build. R8 הוצג בפלאגין Android Gradle 3.3.0, והוא מופעל עכשיו כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות ל-Android באמצעות הפלאגין 3.4.0 ואילך.

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

עכשיו, ב-R8, תהליכי הסרת הסוכר, הצמצום, הטשטוש, האופטימיזציה וההמרה ל-dex (D8) מתבצעים בשלב אחד, כפי שמתואר בהמשך.

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

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

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

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

• ndkCompile הוצא משימוש: עכשיו מופיעה שגיאת build אם מנסים להשתמש ב-ndkBuild כדי לקמפל את הספריות הילידיות. במקום זאת, צריך להשתמש ב-CMake או ב-ndk-build כדי להוסיף קוד C ו-C++ לפרויקט.

בעיות מוכרות

• בשלב זה אנחנו לא אוכפים את השימוש הנכון בשמות חבילות ייחודיים, אבל נהיה מחמירים יותר בגרסאות מאוחרות יותר של הפלאגין. ב-Android Plugin Gradle בגרסה 3.4.0, אפשר להוסיף את השורה הבאה לקובץ gradle.properties כדי לבדוק אם הפרויקט מצהיר על שמות חבילות קבילים.

            android.uniquePackageNames = true
            
          

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

3.3.0 (ינואר 2019)

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

• Gradle 4.10.1 ואילך. מידע נוסף זמין בקטע עדכון Gradle.

  הערה: כשמשתמשים ב-Gradle 5.0 ואילך, גודל ברירת המחדל של אשכול הזיכרון של הדימון של Gradle יורד מ-1GB ל-512MB. כתוצאה מכך, יכול להיות שתהיה רגרסיה בביצועי ה-build. כדי לשנות את הגדרת ברירת המחדל הזו, צריך לציין את גודל האשפה של הדימון של Gradle בקובץ gradle.properties של הפרויקט.

• SDK Build Tools 28.0.3 ואילך.

תכונות חדשות

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

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

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

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

  הערה: התכונה הזו תואמת ל-Gradle מגרסה 4.10.1 ואילך, מלבד Gradle 5.1 בגלל בעיה ב-Gradle מספר 8194.

  • בפרויקטים שמשתמשים ב-Kapt (רוב הפרויקטים ב-Kotlin בלבד ופרויקטים היברידיים של Kotlin-Java): הידור Java מצטבר מופעל, גם אם משתמשים בקישור נתונים או בפלאגין retro-lambda. עיבוד ההערות על ידי המשימה Kapt עדיין לא מצטבר.

  • בפרויקטים שלא משתמשים ב-Kapt (פרויקטים של Java בלבד): אם כל מעבדי התווית שבהם אתם משתמשים תומכים בעיבוד מצטבר של תווית, הידור מצטבר של Java מופעל כברירת מחדל. כדי לעקוב אחרי השימוש המצטבר במעבד התווית, אפשר לעיין בבעיה 5277 ב-Gradle.

    עם זאת, אם מעבד אחד או יותר של הערות לא תומך ב-builds מצטברים, הידור Java מצטבר לא יופעל. במקום זאת, אפשר לכלול את הדגל הבא בקובץ gradle.properties:

    android.enableSeparateAnnotationProcessing=true
                

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

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

            android.debug.obsoleteApi=true
          

  אפשר גם להפעיל את הדגל על ידי העברת הערך -Pandroid.debug.obsoleteApi=true משורת הפקודה.

• אפשר להריץ בדיקות של מכשירי מדידה במודולים של תכונות משורת הפקודה.

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

• הגדרת משימות בזמנן: הפלאגין משתמש עכשיו ב-Gradle’s new task creation API כדי להימנע מהפעלה והגדרה של משימות שלא נדרשות להשלמת ה-build הנוכחי (או משימות שלא נמצאות בתרשים המשימות לביצוע). לדוגמה, אם יש לכם כמה וריאנטים של גרסאות build, כמו וריאנטים של גרסאות build מסוג 'release' ו-'debug', ואתם יוצרים את הגרסה 'debug' של האפליקציה, הפלאגין ימנע את האיפוס וההגדרה של המשימות לגרסה 'release' של האפליקציה.

  קריאה לשיטות מסוימות מדור קודם ב-Variants API, כמו variant.getJavaCompile(), עדיין עשויה לאלץ הגדרת משימות. כדי לוודא שה-build עבר אופטימיזציה להגדרת משימות מושתהות, צריך להפעיל שיטות חדשות שמחזירות אובייקט TaskProvider במקום זאת, כמו variant.getJavaCompileProvider().

  אם אתם מבצעים משימות build בהתאמה אישית, כדאי לקרוא את המאמר בנושא התאמה ל-API החדש ליצירת משימות של Gradle.

• כשמגדירים את useProguard false לסוג build נתון, הפלאגין משתמש עכשיו ב-R8 במקום ב-ProGuard כדי לכווץ ולערפל את הקוד והמשאבים של האפליקציה. מידע נוסף על R8 זמין בפוסט הזה בבלוג של Android Developers.

• יצירה מהירה יותר של כיתות R בפרויקטים של ספריות: בעבר, הפלאגין של Android Gradle יצר קובץ R.java לכל אחת מהתלות של הפרויקט, ולאחר מכן תיעד את כיתות ה-R האלה לצד הכיתות האחרות של האפליקציה. הפלאגין יוצר עכשיו קובץ JAR שמכיל את הכיתה המתומצת של R באפליקציה ישירות, בלי ליצור קודם כיתות ביניים מסוג R.java. האופטימיזציה הזו עשויה לשפר משמעותית את ביצועי ה-build בפרויקטים שכוללים הרבה ספריות, יחסי תלות ופרויקטים משניים, וגם לשפר את מהירות ההוספה לאינדקס ב-Android Studio.

• כשמפתחים Android App Bundle, חבילות ה-APK שנוצרות מחבילת האפליקציות הזו ומטורגטות ל-Android 6.0 (רמת API ‏23) ואילך כוללות עכשיו כברירת מחדל גרסאות לא דחוסות של הספריות המקומיות. האופטימיזציה הזו מונעת מהמכשיר ליצור עותק של הספרייה, וכך מקטינה את הגודל של האפליקציה בדיסק. אם אתם מעדיפים להשבית את האופטימיזציה הזו, צריך להוסיף את הקטע הבא לקובץ gradle.properties:

  android.bundle.enableUncompressedNativeLibs = false
          

• הפלאגין אוכף גרסאות מינימום של פלאגינים מסוימים של צד שלישי.

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

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

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

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

• הורדה אוטומטית של חבילות SDK חסרות: הפונקציונליות הזו הורחבה לתמיכה ב-NDK. מידע נוסף זמין במאמר הורדה אוטומטית של חבילות חסרות באמצעות Gradle.

תיקוני באגים

• בגרסה 3.3.0 של הפלאגין של Android Gradle תוקנו הבעיות הבאות:

  • תהליך ה-build קורא ל-android.support.v8.renderscript.RenderScript במקום לגרסת AndroidX, למרות ש-Jetifier מופעל
  • התנגשויות עקב androidx-rs.jar, כולל annotation.AnyRes בחבילה סטטית
  • כשמשתמשים ב-RenderScript, כבר לא צריך להגדיר את הגרסה של Build Tools באופן ידני בקובצי build.gradle

3.2.0 (ספטמבר 2018)

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

• Gradle 4.6 ואילך. מידע נוסף זמין בקטע עדכון Gradle.
• SDK Build Tools 28.0.3 ואילך.

תכונות חדשות

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

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

• כלי העברה ל-AndroidX: כשמשתמשים בפלאגין Android Gradle 3.2.0 עם Android מגרסה 3.2 ואילך, אפשר להעביר את יחסי התלות המקומיים וה-Maven של הפרויקט כך שישתמשו בספריות החדשות של AndroidX. לשם כך, בוחרים באפשרות Refactor > Migrate to AndroidX בסרגל התפריטים. השימוש בכלי ההעברה הזה מגדיר גם את הדגלים הבאים ל-true בקובץ gradle.properties:

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

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

    מידע נוסף זמין בסקירה הכללית על AndroidX.

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

          android.enableR8 = true
          

          android.enableR8 = true
          

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

• הסרת הסוכר עם 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()
              }
            

• 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, אוכף עכשיו שימוש רק באותיות, בספרות ובקווים תחתונים כשמציינים שם של מודול. לדוגמה, אם שם מודול התכונה כולל מקפים, תוצג הודעת שגיאה ב-build. ההתנהגות הזו תואמת להתנהגות של הפלאגין של התכונות הדינמיות.

תיקוני באגים

• עכשיו אפשר לשמור ב-cache את JavaCompile בפרויקטים עם קישור נתונים. (בעיה מס' 69243050)
• מניעת הידור טובה יותר של מודולים בספרייה עם קישור נתונים. (בעיה מס' 77539932)
• עכשיו אפשר להפעיל מחדש את configure-on-demand אם השבתתם אותו בגרסאות קודמות בגלל שגיאות בלתי צפויות ב-build. (בעיה מס' 77910727)

3.1.0 (מרץ 2018)

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

• Gradle 4.4 ואילך.

  מידע נוסף זמין בקטע עדכון Gradle.

• Build Tools 27.0.3 ואילך.

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

D8 – קומפילטור DEX חדש

כברירת מחדל, Android Studio משתמש עכשיו במהדר DEX חדש שנקרא D8. הידור DEX הוא התהליך של המרת קוד בינארי של .class לקוד בינארי של .dex עבור Android Runtime (או Dalvik, לגרסאות ישנות יותר של Android). בהשוואה למהדר הקודם, שנקרא DX, המהדר D8 מקמפל מהר יותר ומפיק קובצי DEX קטנים יותר, תוך שמירה על ביצועים זהים או טובים יותר בסביבת זמן הריצה של האפליקציה.

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

      android.enableD8=false
    

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

      android.enableIncrementalDesugaring=false.
    

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

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

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

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

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

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

• מטמון ה-build של הפלאגין ל-Android מסיר עכשיו רשומות מטמון מלפני יותר מ-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 לא מזהה בצורה נכונה יחסי תלות ב-builds מורכבים.
• תיקון לבעיה שבה מופיעה שגיאה בסנכרון הפרויקט בזמן טעינת הפלאגין של Android כמה פעמים ב-build יחיד. לדוגמה, כשמספר פרויקטים משניים כוללים כל אחד את הפלאגין של Android ב-classpath של buildscript.

3.0.0 (אוקטובר 2017)

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

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

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

אם לא ראיתם את שיפורי הביצועים שמפורטים למעלה, תוכלו לשלוח באג ולצרף נתיב של ה-build באמצעות Gradle Profiler.

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

• Gradle 4.1 ואילך. מידע נוסף זמין בקטע עדכון Gradle.
• Build Tools 26.0.2 ואילך. בעקבות העדכון הזה, כבר לא צריך לציין גרסה לכלי ה-build – הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל. עכשיו אפשר להסיר את הנכס android.buildToolsVersion.

פעולות אופטימיזציה

• תכונה שמאפשרת ביצוע משימות במקביל בפרויקטים עם כמה מודולים באמצעות תרשים משימות מפורט.
• כשמבצעים שינויים ביחסי התלות, Gradle מבצע גרסאות build מהר יותר על ידי כך שלא מקמפל מחדש מודולים שאין להם גישה ל-API של יחסי התלות האלה. כדי להגביל את יחסי התלות שמאפשרים דליפת ממשקי API למודול אחר, צריך להשתמש בהגדרות החדשות של יחסי התלות ב-Gradle: implementation, ‏ api,‏ compileOnly ו-runtimeOnly.
• מהירות פיתוח מצטבר מהירה יותר עקב דיקסון לכל כיתה. עכשיו כל כיתה מתומללת לקובצי DEX נפרדים, ורק הכיתות ששונו עוברות שוב תהליך DEX. בנוסף, מהירות ה-build צפויה להשתפר באפליקציות שהגדרת minSdkVersion שלהן היא 20 או פחות, והן משתמשות ב-multi-dex מדור קודם.
• שיפור מהירויות ה-build על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שנשמר במטמון. כדי ליהנות מהאופטימיזציה הזו, קודם צריך להפעיל את המטמון של ה-build ב-Gradle.
• עיבוד משאבים מצטבר משופר באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלת בבעיות בזמן השימוש ב-AAPT2, אפשר לדווח על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת android.enableAapt2=false בקובץ gradle.properties והפעלה מחדש של הדימון של Gradle באמצעות הפקודה ./gradlew --stop בשורת הפקודה.

תכונות חדשות

• ניהול יחסי תלות שמתחשב בגרסת הווריאנט. כשמפתחים וריאנט מסוים של מודול, הפלאגין מתאים עכשיו באופן אוטומטי בין וריאציות של יחסי התלות של מודולים בספריות מקומיות לבין הווריאנט של המודול שאתם מפתחים.
• כולל פלאגין חדש של מודול תכונות לתמיכה ב-Android Instant Apps וב-Android Instant Apps SDK (אפשר להוריד אותו באמצעות מנהל ה-SDK). למידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, קראו את המאמר המבנה של אפליקציה מיידית עם כמה תכונות.
• תמיכה מובנית בשימוש בתכונות מסוימות של שפת Java 8 ובספריות של Java 8. Jack הוצא משימוש ועכשיו הוא לא נדרש, ולכן צריך להשבית את Jack כדי להשתמש בתמיכה המשופרת ב-Java 8 שמובנית בכלי הפיתוח שמוגדרים כברירת מחדל. למידע נוסף, ראו שימוש בתכונות השפה של 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 ב-classpath עבור המפתחות הבאים:

  • 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 ואילך.

• עכשיו אפשר לשנות את ספריית הפלט של הפרויקט החיצוני ל-build מקורי, כפי שמתואר בהמשך:

  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 שמגדיר כללי איתור שגיאות מותאמים אישית, ולארז אותו בפרויקטים של AAR ו-APK.

  כללי ה-lint המותאמים אישית צריכים להיות שייכים לפרויקט נפרד שמפיק קובץ JAR יחיד וכולל רק יחסי תלות של compileOnly. לאחר מכן, מודולים אחרים של אפליקציות וספריות יכולים להסתמך על הפרויקט שלכם לזיהוי שגיאות באמצעות ההגדרה של 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 מסוימים, וה-build יתקלקל אם תשתמשו בהם. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג outputFile() או להשתמש ב-processManifest.manifestOutputFile() כדי לקבל את קובץ המניפסט של כל וריאנט. מידע נוסף זמין במאמר שינויים ב-API.
• לא צריך יותר לציין גרסה לכלים ל-build (כך שאפשר עכשיו להסיר את נכס android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש באופן אוטומטי בגרסה המינימלית הנדרשת של כלי ה-build לגרסה של הפלאגין ל-Android שבה אתם משתמשים.
• עכשיו אפשר להפעיל או להשבית את דחיסת ה-PNG בבלוק buildTypes, כפי שמתואר בהמשך. דחיסת PNG מופעלת כברירת מחדל בכל גרסאות ה-build, מלבד גרסאות build לצורך ניפוי באגים, כי היא מאריכה את זמני ה-build בפרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני ה-build בסוגי build אחרים, צריך להשבית את דחיסת ה-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.
• עכשיו צריך להוסיף מעבדי אנוטציות לנתיב ה-class של המעבד באמצעות הגדרת התלות annotationProcessor.
• השימוש ב-ndkCompile שהוצא משימוש מוגבל עכשיו יותר. במקום זאת, מומלץ לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד מקומי שרוצים לארוז ב-APK. מידע נוסף זמין במאמר מעבר מ-ndkcompile.

3.0.0 (אוקטובר 2017)

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

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

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

אם לא ראיתם את שיפורי הביצועים שמפורטים למעלה, תוכלו לשלוח באג ולצרף נתיב של ה-build באמצעות Gradle Profiler.

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

• Gradle 4.1 ואילך. מידע נוסף זמין בקטע עדכון Gradle.
• Build Tools 26.0.2 ואילך. בעקבות העדכון הזה, כבר לא צריך לציין גרסה לכלי ה-build – הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל. עכשיו אפשר להסיר את הנכס android.buildToolsVersion.

פעולות אופטימיזציה

• תכונה שמאפשרת ביצוע משימות במקביל בפרויקטים עם כמה מודולים באמצעות תרשים משימות מפורט.
• כשמבצעים שינויים ביחסי התלות, Gradle מבצע גרסאות build מהר יותר על ידי כך שלא מקמפל מחדש מודולים שאין להם גישה ל-API של יחסי התלות האלה. כדי להגביל את יחסי התלות שמאפשרים דליפת ממשקי API למודול אחר, צריך להשתמש בהגדרות החדשות של יחסי התלות ב-Gradle: implementation, ‏ api,‏ compileOnly ו-runtimeOnly.
• מהירות פיתוח מצטבר מהירה יותר עקב דיקסון לכל כיתה. כל כיתה מתורגמת עכשיו לקובצי DEX נפרדים, ורק הכיתות ששונו עוברות שוב תהליך DEX. בנוסף, מהירות ה-build צפויה להשתפר באפליקציות שהגדרת minSdkVersion שלהן היא 20 או פחות, והן משתמשות ב-multi-dex מדור קודם.
• שיפור מהירויות ה-build על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שנשמר במטמון. כדי ליהנות מהאופטימיזציה הזו, קודם צריך להפעיל את המטמון של ה-build ב-Gradle.
• עיבוד משאבים מצטבר משופר באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלת בבעיות בזמן השימוש ב-AAPT2, אפשר לדווח על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת android.enableAapt2=false בקובץ gradle.properties והפעלה מחדש של הדימון של Gradle באמצעות הפקודה ./gradlew --stop בשורת הפקודה.

תכונות חדשות

• ניהול יחסי תלות שמתחשב בגרסת הווריאנט. כשמפתחים וריאנט מסוים של מודול, הפלאגין מתאים עכשיו באופן אוטומטי בין וריאציות של יחסי התלות של מודולים בספריות מקומיות לבין הווריאנט של המודול שאתם מפתחים.
• כולל פלאגין חדש של מודול תכונות לתמיכה ב-Android Instant Apps וב-Android Instant Apps SDK (אפשר להוריד אותו באמצעות מנהל ה-SDK). למידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, קראו את המאמר המבנה של אפליקציה מיידית עם כמה תכונות.
• תמיכה מובנית בשימוש בתכונות מסוימות של שפת Java 8 ובספריות של Java 8. Jack הוצא משימוש ועכשיו הוא לא נדרש, ולכן צריך להשבית את Jack כדי להשתמש בתמיכה המשופרת ב-Java 8 שמובנית בכלי הפיתוח שמוגדרים כברירת מחדל. למידע נוסף, ראו שימוש בתכונות השפה של 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 ב-classpath עבור המפתחות הבאים:

  • 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 ואילך.

• עכשיו אפשר לשנות את ספריית הפלט של הפרויקט החיצוני ל-build מקורי, כפי שמתואר בהמשך:

  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 שמגדיר כללי איתור שגיאות מותאמים אישית, ולארז אותו בפרויקטים של AAR ו-APK.

  כללי ה-lint המותאמים אישית צריכים להיות שייכים לפרויקט נפרד שמפיק קובץ JAR יחיד וכולל רק יחסי תלות של compileOnly. לאחר מכן, מודולים אחרים של אפליקציות וספריות יכולים להסתמך על הפרויקט שלכם לזיהוי שגיאות באמצעות ההגדרה של 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 מסוימים, וה-build יתקלקל אם תשתמשו בהם. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג outputFile() או להשתמש ב-processManifest.manifestOutputFile() כדי לקבל את קובץ המניפסט של כל וריאנט. מידע נוסף זמין במאמר שינויים ב-API.
• לא צריך יותר לציין גרסה לכלים ל-build (כך שאפשר עכשיו להסיר את נכס android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש באופן אוטומטי בגרסה המינימלית הנדרשת של כלי ה-build לגרסה של הפלאגין ל-Android שבה אתם משתמשים.
• עכשיו אפשר להפעיל או להשבית את דחיסת ה-PNG בבלוק buildTypes, כפי שמתואר בהמשך. דחיסת PNG מופעלת כברירת מחדל בכל גרסאות ה-build, מלבד גרסאות build לצורך ניפוי באגים, כי היא מאריכה את זמני ה-build בפרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני ה-build בסוגי build אחרים, צריך להשבית את דחיסת ה-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.
• עכשיו צריך להוסיף מעבדי אנוטציות לנתיב ה-class של המעבד באמצעות הגדרת התלות annotationProcessor.
• השימוש ב-ndkCompile שהוצא משימוש מוגבל עכשיו יותר. במקום זאת, מומלץ לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד מקומי שרוצים לארוז ב-APK. מידע נוסף זמין במאמר מעבר מ-ndkcompile.

2.3.0 (פברואר 2017)

יחסי תלות:

• Gradle מגרסה 3.3 ואילך.
• Build Tools 25.0.0 ואילך.

המינוי החדש:

• נעשה שימוש ב-Gradle 3.3, שכולל שיפורים בביצועים ותכונות חדשות. לפרטים נוספים, קראו את הערות המוצר של Gradle.
• Build cache: מאחסן פלט מסוים שנוצר על ידי הפלאגין של Android בזמן ה-build של הפרויקט (למשל קבצים מסוג AAR ללא אריזה ותלות מרוחקת שעברה עיבוד מראש). ה-builds הנקיים שלכם יהיו מהירים יותר כשמשתמשים במטמון, כי מערכת ה-build יכולה פשוט לעשות שימוש חוזר בקבצים האלה ששמורים במטמון במהלך ה-builds הבאים, במקום ליצור אותם מחדש. פרויקטים שמשתמשים בפלאגין Android בגרסה 2.3.0 ואילך משתמשים במטמון ה-build כברירת מחדל. מידע נוסף זמין במאמר שיפור מהירות ה-build באמצעות Build Cache.
  • כולל משימה cleanBuildCache שמבצעת ניקוי של מטמון ה-build.
  • אם אתם משתמשים בגרסה הניסיונית של build cache (שכלולה בגרסאות קודמות של הפלאגין), עליכם לעדכן את הפלאגין לגרסה האחרונה.

השינויים:

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

2.2.0 (ספטמבר 2016)

יחסי תלות:

• Gradle 2.14.1 ואילך.
• Build Tools 23.0.2 ואילך.

המינוי החדש:

• נעשה שימוש ב-Gradle 2.14.1, שכולל שיפורים בביצועים ותכונות חדשות, ותוקן בו נקודת חולשה באבטחה שמאפשרת הסלמת הרשאות מקומית כשמשתמשים ב-Gradle daemon. לפרטים נוספים, קראו את הערות המוצר של Gradle.
• באמצעות ה-DSL של externalNativeBuild {}, עכשיו אפשר לקשר ב-Gradle למקורות המקומיים ולקמפל ספריות מקומיות באמצעות CMake או ndk-build. אחרי היצירה של הספריות המקומיות, Gradle מקפל אותן בתוך קובץ ה-APK. מידע נוסף על השימוש ב-CMake וב-ndk-build עם Gradle זמין במאמר הוספת קוד C ו-C++ לפרויקט.
• כשמריצים build משורת הפקודה, Gradle מנסה עכשיו להוריד באופן אוטומטי את העדכונים או הרכיבים החסרים של ה-SDK שהפרויקט שלכם תלוי בהם. מידע נוסף זמין במאמר הורדה אוטומטית של חבילות חסרות באמצעות Gradle.
• תכונה ניסיונית חדשה של שמירת נתונים במטמון מאפשרת ל-Gradle לקצר את זמני ה-build על ידי ביצוע דקס מראש, אחסון של הגרסאות שעבר דקס מראש של הספריות ושימוש חוזר בהן. למידע נוסף על השימוש בתכונה הניסיונית הזו, תוכלו לקרוא את המדריך יצירת מטמון.
• שיפור ביצועי ה-build באמצעות צינור עיבוד נתונים חדש של ברירת המחדל לחבילות, שמטפל בקריפטוגרפיה, בחתימה ובהתאמת zip במשימה אחת. כדי לחזור לשימוש בכלי האריזה הקודמים, צריך להוסיף את 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 עם ספריות DEX מרובות, עכשיו אפשר להשתמש בכללי ProGuard כדי לקבוע אילו שיעורים Gradle צריך לקמפל לקובץ ה-DEX הראשי של האפליקציה. מכיוון שמערכת Android טוענת קודם את קובץ ה-DEX הראשי כשמפעילים את האפליקציה, אפשר לתת עדיפות לכיתות מסוימות בזמן ההפעלה על ידי הידור שלהן בקובץ ה-DEX הראשי. אחרי שיוצרים קובץ תצורה של ProGuard במיוחד לקובץ ה-DEX הראשי, מעבירים את הנתיב של קובץ התצורה ל-Gradle באמצעות buildTypes.multiDexKeepProguard. השימוש ב-DSL הזה שונה מהשימוש ב- buildTypes.proguardFiles, שמספק כללי ProGuard כלליים לאפליקציה ולא מציין כיתות לקובץ ה-DEX הראשי.
• נוספה תמיכה בדגל android:extractNativeLibs, שיכול לצמצם את גודל האפליקציה בזמן ההתקנה שלה במכשיר. כשמגדירים את הדגל הזה ל-false באלמנט <application> במניפסט של האפליקציה, Gradle מקפל גרסאות לא דחוסות וממוזלות של הספריות המקומיות עם קובץ ה-APK. כך PackageManager לא מעתיק את הספריות המקומיות מה-APK למערכת הקבצים של המכשיר במהלך ההתקנה, וגם היתרון הנוסף הוא שהעדכונים של האפליקציה קטנים יותר.
• עכשיו אפשר לציין את הערכים versionNameSuffix ו- applicationIdSuffix לגרסאות של מוצרים. (בעיה 59614)

השינויים:

• הפונקציה getDefaultProguardFile מחזירה עכשיו את קובצי ברירת המחדל של ProGuard שמספק הפלאגין של Android ל-Gradle, ולא משתמשת יותר בקבצים שב-Android SDK.
• שיפורים בביצועים ובתכונות של המהדר של Jack:
  • Jack תומך עכשיו ב-Jacoco test coverage כשמגדירים את testCoverageEnabled ל-true.
  • תמיכה משופרת במעבדי הערות. מעבדי הערות ב-classpath, כמו יחסי תלות של compile, מוחלים באופן אוטומטי על ה-build. אפשר גם לציין מעבד הערות ב-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
  

  • כברירת מחדל, אם גודל האשפה של הדימון של Gradle הוא לפחות 1.5GB, ‏ Jack פועל עכשיו באותו תהליך כמו Gradle. כדי לשנות את גודל האשפה של הדימון, מוסיפים את הטקסט הבא לקובץ gradle.properties:

    # This sets the daemon heap size to 1.5GB.
    org.gradle.jvmargs=-Xmx1536M
    

2.1.0 (אפריל 2016)

יחסי תלות:

• Gradle מגרסה 2.10 ואילך.
• Build Tools 23.0.2 ואילך.

המינוי החדש:

• הוספנו תמיכה ב-N Developer Preview, ב-JDK 8 ובתכונות השפה של Java 8 באמצעות ערכת הכלים של Jack. מידע נוסף זמין במדריך N Preview.

  הערה: Instant Run לא פועל כרגע עם Jack, והוא יושבת כשמשתמשים בכלי הפיתוח החדש. צריך להשתמש ב-Jack רק אם אתם מפתחים עבור תצוגה מקדימה של N ורוצים להשתמש בתכונות השפה הנתמכות של Java 8.

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

  Groovy

  android {
    ...
    compileOptions {
      incremental false
    }
  }
  

  Kotlin

  android {
    ...
    compileOptions {
      incremental = false
    }
  }
  

• הוספנו תמיכה ב-dexing-in-process, שמבצע dexing בתוך תהליך ה-build ולא בתהליכי VM חיצוניים נפרדים. כך לא רק שגירסאות build מצטברות נוצרות מהר יותר, אלא גם גרסאות build מלאות. התכונה מופעלת כברירת מחדל בפרויקטים שבהם הגדרתם את הגודל המקסימלי של אשכול ה-Gradle ל-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 ```

  כדי להשבית את ה-dexing-in-process, מוסיפים את הקוד הבא לקובץ build.gradle ברמת המודול:

  Groovy

  android {
    ...
    dexOptions {
        dexInProcess false
    }
  }
  

  Kotlin

  android {
    ...
    dexOptions {
        dexInProcess = false
    }
  }
  

2.0.0 (אפריל 2016)

יחסי תלות:

• Gradle מגרסה 2.10 ואילך.
• Build Tools 21.1.1 ואילך.

המינוי החדש:

• מאפשרת להפעיל את Instant Run על ידי תמיכה בהזרקת קוד בייט, והעברת עדכוני קוד ומשאבים לאפליקציה שפועלת במהלך ההדמיה או במכשיר פיזי.
• הוספנו תמיכה בגרסאות build מצטברות, גם כשהאפליקציה לא פועלת. כדי לשפר את זמני ה-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 הראשית והבדיקה.

פלאגין 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 מאפשר להחדיר מניפולציות מותאמות אישית של כיתות בצורה פשוטה יותר, תוך מתן גמישות רבה יותר לגבי הדברים שאפשר לבצע בהם מניפולציה. כדי להוסיף טרנספורמציה ל-build, יוצרים כיתה חדשה שמטמיעה אחת מהממשקים של 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.
• נוספה היכולת לגרום לכשל תקין ב-build של Gradle ולדווח על הגורם לשגיאה הבסיסית, כש-build של Gradle מפעיל משימות אסינכררוניות ויש כשל בתהליך העבודה.
• הוספנו תמיכה בהגדרה של ממשק בינארי של אפליקציה (ABI) ספציפי בגרסאות שמכילות כמה ממשקי ABI.
• הוספנו תמיכה ברשימה של מספרים סידוריים של מכשירים שמופרדים בפסיקים למשתנה הסביבה ANDROID_SERIAL בזמן התקנה או הפעלה של בדיקות.
• תוקנה בעיה של כשל התקנה במכשירים עם Android מגרסה 5.0 (API ברמה 20) ואילך, כששם קובץ ה-APK מכיל רווח.
• תוקנו בעיות שונות שקשורות לפלט השגיאות של Android Asset Packaging Tool‏ (AAPT).
• הוספנו תמיכה במדידה מצטברת של JaCoCo ליצירת גרסאות build מצטברות מהר יותר. הפלאגין של Android ל-Gradle מפעיל עכשיו את הכלי של JaCoCo ישירות. כדי לאלץ גרסה חדשה יותר של הכלי לניתוח קוד של JaCoCo, צריך להוסיף אותו כיחסי תלות של סקריפט build.
• תיקנו את התמיכה ב-JaCoCo כך שהיא תתעלם מקבצים שאינם כיתות.
• הוספנו תמיכה בתמונות וקטוריות שניתן לצייר כדי ליצור קובצי PNG בזמן ה-build, לצורך תאימות לאחור. הפלאגין של Android ל-Gradle יוצר קובצי PNG לכל קובץ drawable וקטורי שנמצא בספריית משאבים שלא צוינה בו גרסה של 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 כך שתחרוג מקבצי APK את הקבצים LICENSE ו-LICENSE.txt. כדי לכלול את הקבצים האלה בקובץ APK, צריך להסיר אותם מהנכס packagingOptions.excludes בקובץ build.gradle. לדוגמה:

  android {
        packagingOptions.excludes = []
      }
        

  android {
        packagingOptions.excludes.clear()
      }
      

• נוספה המשימה sourceSets לבדיקה של כל קבוצות המקור הזמינות.
• תמיכה משופרת בבדיקות יחידה לזיהוי תיקיות מקור של גרסאות build וטעמים שונים. לדוגמה, כדי לבדוק אפליקציה עם כמה גרסאות (flavors) – flavor1 ו-flavorA – עם סוג build‏ Debug, קבוצות מקורות הבדיקה הן:
  • בדיקה
  • testFlavor1
  • testFlavorA
  • testFlavor1FlavorA
  • testFlavor1FlavorADebug

  הבדיקות של Android כבר זיהו תיקיות מקור עם כמה גרסאות.

• תמיכה משופרת בבדיקות יחידה:
  • מריצים את javac במקורות הראשיים ובמקורות הבדיקה, גם אם הערך של המאפיין useJack מוגדר כ-true בקובץ ה-build.
  • זיהוי נכון של יחסי התלות לכל סוג 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 בנתיב ה-classpath כשמריצים בדיקות יחידה ישירות מ-Gradle.
  • הוספנו תמיכה ביחסי תלות של בדיקות יחידה לארטיפקטים של 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.
        }
      }
    }
                

  • תוקן הטיפול ב-enums ובשדות של מכונות ציבוריות באריזה של הקובץ mockable-android.jar.
  • תוקנו יחסי התלות של המשימות בפרויקט הספרייה, כך שאפשר יהיה לבצע הידור מחדש של כיתות הבדיקה אחרי שינויים.
• הוספנו את המאפיין testProguardFile כדי להחיל קובצי ProGuard כשמקטינים חבילה של APK לבדיקה.
• הוספנו את המאפיין timeOut לבלוק הקוד adbOptions כדי להגדיר את משך ההקלטה המקסימלי של מסך Android Debug Bridge.
• נוספה תמיכה במשאבים ברזולוציה של 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 במיזוג המניפסטים במהלך היצירה של אפליקציית בדיקה של ספרייה.

פלאגין Android ל-Gradle, גרסה 1.1.1 (פברואר 2015)

יחסי תלות:

• Gradle מגרסה 2.2.1 ואילך.
• Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• שינינו את הווריאציות של ה-build כך שרק וריאציות שמארזות אפליקציה ל-Wear יפעילו משימות build ספציפיות ל-Wear.
• שינינו את האופן שבו המערכת מתייחסת לבעיות שקשורות ליחסי תלות, כך שהן יכשלו בזמן ה-build ולא בזמן ניפוי הבאגים. כך תוכלו להריץ משימות אבחון (כמו 'יחסי תלות') כדי לפתור את הבעיה.
• תוקנה השיטה android.getBootClasspath() כך שתחזיר ערך.

פלאגין Android ל-Gradle, גרסה 1.1.0 (פברואר 2015)

יחסי תלות:

• Gradle מגרסה 2.2.1 ואילך.
• Build Tools מגרסה 21.1.1 ואילך.

הערות כלליות:

• נוספה תמיכה בבדיקה יחידה חדשה
• הפעלת בדיקות יחידה ב-JVM המקומי מול גרסה מיוחדת של הקובץ android.jar שתואמת למסגרות פופולריות של מודלים מדומים, למשל Mockito.
• נוספו משימות בדיקה חדשות, testDebug,‏ testRelease ו-testMyFlavorDebug, לשימוש בטעמי מוצרים.
• נוספו תיקיות מקור חדשות שזוהו כבדיקות יחידה: 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 לבדיקה. אם הגדרת המינימיזציה מופעלת, ProGuard מעבד את קובץ ה-APK לבדיקה ומחיל רק את קובץ המיפוי שנוצר במהלך המינימיזציה של קובץ ה-APK הראשי.
• ניהול יחסי התלות עודכן
  • תוקנו בעיות באמצעות ההיקפים provided ו-package.

    הערה: ההיקפים האלה לא תואמים לחבילות AAR ‏(Android ARchive), והם יגרמו לכישלון של גרסה זמינה (build) עם חבילות AAR.

  • פתרון מותאם של יחסי התלות כדי להשוות בין יחסי התלות של האפליקציה שנבדקת לבין האפליקציה לבדיקה. אם נמצא פריט גרפי באותה גרסה בשתי האפליקציות, הוא לא נכלל באפליקציה לבדיקה וארוז רק עם האפליקציה שנבדקת. אם נמצא פריט גרפי עם גרסה שונה בשתי האפליקציות, ה-build נכשל.
• הוספנו תמיכה ב-anyDpi מגדיר משאבים במיזוג משאבים.
• שיפור מהירות ההערכה והסנכרון של סביבת הפיתוח המשולבת (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 failure כשנכנסים למודול extractReleaseAnnotations. (בעיה 81638).
• תוקנה בעיה ב-Disable שגורמת להעברת ההגדרה --no-optimize לקוד הבינארי של קובץ ההפעלה (dex) של Dalvik. (בעיה 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 ואילך.

הערות כלליות:

• הגרסה הראשונית של הפלאגין.