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

3.6 (פברואר 2020)

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

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

כלי עיצוב

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

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

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

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

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

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

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

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

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

מנהל המשאבים

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

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

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

עדכונים לפלאגין של 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
  }
  

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

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

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

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

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

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

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

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

פענוח קוד מעורפל של המחלקה והשיטה בבייטקוד (bytecode) ב-APK

כשמשתמשים בכלי לניתוח APK כדי ניתן לבדוק קובצי DEX, אפשר לבצע פענוח קוד מעורפל (deobfuscate) של המחלקה וה-method bytecode באופן הבא:

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

כלים מקורי

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

התמיכה של Kotlin

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אמולטורים

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

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

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

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

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

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

.

מסלולים

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

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

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

.

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

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

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

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

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

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

4. צריך לבחור באחד מיחסי הגובה-רוחב שהוגדרו מראש

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

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

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

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

כשיוצרים פרויקט חדש באמצעות Android Studio, אפשר עכשיו לבחור מבין האפשרויות הבאות שלוש תבניות בכרטיסייה כלי רכב בכרטיסייה יצירת פרויקט חדש אשף: ללא פעילות, שירות מדיה ושירות העברת הודעות. עבור בפרויקטים קיימים, אפשר להוסיף תמיכה במכשירי Android Automotive על ידי בחירה באפשרות קובץ > חדש > מודול חדש מסרגל התפריטים, ובוחרים מודול לרכב. האשף Create New Module ינחה אתכם באמצעות יצירה של מודול חדש באמצעות אחד מפרויקטים של Android Automotive תבניות.

.

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

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

.

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

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

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

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

מערכת Win32 הוצאה משימוש

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

למידע נוסף, אפשר לקרוא את הבלוג של Windows עם הפחתה של 32 ביט

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

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

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

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

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

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

IntelliJ IDEA 2019.2

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

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

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

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

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

3.5 (אוגוסט 2019)

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

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

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

שיש בפרויקט: תקינות המערכת

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

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

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

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

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

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

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

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

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

Project שיש: ליטוש פיצ'רים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

עורך פריסות

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

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

הגבלת קשרי גומלין עבור רכיב בממשק המשתמש שנבחר.

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

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

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

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

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

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

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

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

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

קישור נתונים

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

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

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

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

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

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

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

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

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

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

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

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

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

תמיכה ב-ChromeOS

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

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

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

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

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

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

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

IntelliJ IDEA 2019.1

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

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

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

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

מה חדש בפלאגין של 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 רעיונות לפיתוח גרסת 2018.3.4.

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

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

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

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

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

משתנים

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

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

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

מודולים

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

יחסי תלות

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

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

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

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

בניית וריאציות

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

הצעות

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

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

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

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

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

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

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

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

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

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

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

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

הספריות ש-Android Studio מעוניין למחוק מפורטות למטה:

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

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

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

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

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

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

עדכונים לגבי Profiler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הצגת טקסט מעוצב עבור מטענים ייעודיים של חיבור (payloads) של חיבור ב-Network profiler

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

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

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

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

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

תמיכה ב-Clang-Tidy

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

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

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

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

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

• תמיכה בחריגים (חריגים)
• תמיכה במידע סוג זמן ריצה (-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 cmake_minimum_required() הפקודה.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3.2 (ספטמבר 2018)

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

מה חדש ב-Assistant

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

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

Jetpack ל-Android

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

עורך ניווט

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

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

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

העברה ל-AndroidX

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

מערכת Android Studio 3.2 תעזור לך בתהליך הזה באמצעות תכונת העברה חדשה.

כדי להעביר פרויקט קיים ל-AndroidX, בוחרים באפשרות Refactor > העברה אל 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 כשמשתמשים הפקודה העברה אל AndroidX.

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

קובץ Android App Bundle

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

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

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

כדי לבנות חבילה, בוחרים Build > בניית חבילות / חבילות APK > יצירת חבילות.

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

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

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

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

פרוסות

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

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

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

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

Kotlin 1.2.61

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

IntelliJ IDEA 2018.1.6

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

כלי לניתוח ביצועים של Android

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

סשנים

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

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

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

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

במהלך השימוש בתצורת המעקב הזו אפשר לסמן באופן חזותי קוד חשוב בציר הזמן של כלי הפרופיל באמצעות אינסטרומנטציה של קוד C/C++ את Native Tracing API או את קוד Java עם Trace.

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

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

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

ייבוא, ייצוא ובדיקה של קובצי תמונת מצב של הזיכרון (heap dump)

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

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

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

תיעוד הפעילות של המעבד (CPU) במהלך הפעלת האפליקציה

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

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

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

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

כדי לייצא מעקב אחרי תיעוד הפעילות של המעבד (CPU), צריך לבצע את הפעולות הבאות:

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

ייבוא ובדיקה של קובצי מעקב של המעבד (CPU)

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

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

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

תיעוד הפעילות של המעבד (CPU) באמצעות Debug API

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

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

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

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

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

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

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

הבדיקה של איתור השגיאות בקוד

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

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

בדיקות לאיתור שגיאות בקוד (lint) ליכולת פעולה הדדית של Java/Kotlin

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות לאיתור שגיאות בקוד (lint) של פרוסות

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

יעד חדש של Gradle

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

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

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

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

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

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

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

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

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

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

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

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

הסרת סוכר D8

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

כיווץ קוד חדש

R8 הוא כלי חדש לכיווץ קוד וערפול קוד (obfuscation) שמחליף את ProGuard. שלך יכול להתחיל להשתמש בגרסת טרום-השקה (Preview) של 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, כמו:

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

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

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

אם כבר לכלול קוד C/C++ וספריות בפרויקט, פותחים את החלון Project (פרויקט) בצד שמאל של סביבת הפיתוח המשולבת (IDE) על ידי בחירה באפשרות תצוגה > Windows בכלי > פרויקט מהתפריט הראשי ובוחרים באפשרות 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 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.

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

ההעדפה הגדרה על פי דרישה הוסרה מ-Android Studio.

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

עוזר דיגיטלי לחיבור ADB

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

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

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

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

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

אמצעי הבקרה לשמירה, לטעינה ולניהול של תמונות מצב של AVD נמצאים עכשיו בכרטיסייה 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, אפשר לנצל את היתרונות של עריכת SQL:

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

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

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

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

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

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

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

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

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

מהדר וגרידל

D8 הוא ה-DEX ברירת המחדל מהדר

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

המהדר החדש הזה של DEX מגיע עם כמה יתרונות, הבאים:

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

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

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

        android.enableD8=true
      

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

מצטבר תהליך הסרה של סוכרים

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

הסרת סוכרים מהמרות סוכר תחבירי לצורה שהמהדר יכול לעבד בצורה יעילה יותר.

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

        android.enableIncrementalDesugaring=false
      

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

Gradle Console הוחלף ב-Build חלון עם הכרטיסיות סנכרון ו-Build.

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

עדכונים והוספה לאינדקס בכמות גדולה בו-זמניות

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

C++ ו-LLDB

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

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

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

• הוספה של כלים לעיצוב (מדפסות יפות) למבני נתונים נוספים של 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 כולל קוטלין גרסה 1.2.30.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הכרטיסייה 'בקשות' ב-Network Profiler

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

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

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

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

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

נוספו לסוקר הפריסה כולל פונקציונליות מסוימת שסופקו בעבר על ידי הכלים 'מציג ההיררכיה' ו-Pixel Perfect:

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

עורך פריסות

Palette ב- עורך פריסות קיבלה הרבה שיפורים:

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

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

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

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

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

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

מכשיר הדמיה

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

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

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

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

עוד הסברים קצרים, מקשי קיצור והודעות מועילות

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

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

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

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

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

מוניטור המכשיר זמין משורת הפקודה

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

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

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

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

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

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

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

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

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

הכלי לניתוח ביצועי Android

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

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

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

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

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

הכלי לניתוח ביצועי המעבד (CPU)

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

מידע נוסף מופיע במדריך בנושא הכלי לניתוח ביצועי ה-CPU.

הכלי לניתוח זיכרון

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מודולים של Android Things

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

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

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

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

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

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

למידע נוסף, אפשר לקרוא את סמלים מותאמים.

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

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

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

כלי להוספת אפליקציות לאינדקס ב-Firebase

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

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

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

כלי הקישורים לאפליקציות ל-Android

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

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

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

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

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

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

עורך פריסות

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

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

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

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

כלי לניתוח APK

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

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

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

למידע נוסף, ראו ניתוח ה-build באמצעות כלי הניתוח של APK.

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

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

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

      allprojects {
          repositories {
              google()
          }
      }
    
    

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

שינויים נוספים

• ניפוי באגים במקור באמצעות Android Studio כבר לא תומך ב-Windows בגרסת 32 ביט. בחרנו להתמקד בפלטפורמות אחרות כי מעט מאוד מפתחים משתמשים בפלטפורמה הזאת. אם אתם משתמשים ב-Windows בגרסת 32 סיביות ואתם מתכננים לנפות באגים בגרסה המקורית מומלץ להמשיך להשתמש ב-Android Studio 2.3.
• סביבת הפיתוח המשולבת (IDE) הבסיסית שודרגה ל- IntelliJ 2017.1.2, שמוסיפה כמה תכונות חדשות 2016.3 וכן 2017.1, כמו ארגון קוד מחדש של שפות ב-Java 8, רמזים לפרמטרים, הדגשה סמנטית נקודות עצירה (breakpoint) שניתן לגרור, תוצאות מיידיות בחיפוש ועוד הרבה יותר.
• נוספו הרבה בדיקות חדשות לאיתור שגיאות בקוד.
• כדאי לבדוק גם את העדכונים האחרונים של 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>

שינויים

• ה-codebase של סביבת הפיתוח המשולב (IDE) עודכן מ-IntelliJ 15 ל-IntelliJ 16.1
• עכשיו, כדי להפעיל את התכונה 'הפעלה מיידית' נדרשת הפלטפורמה של ה-SDK שתואמת ליעד רמת ה-API של המכשיר שיש להתקין.
• ההפעלה המיידית תושבת באופן אוטומטי אם המשתמש מפעיל את האפליקציה בכפוף פרופיל עבודה או משתמש משני.
• תוקנו בעיות אמינות רבות עבור הפעלה מיידית כאשר היו שינויים שלא נפרסו, אחרת האפליקציה תקרוס:
  • חלק מנכסי האפליקציה לא נפרסו באפליקציה הפעילה. ( באג: #213454)
  • האפליקציה קורסת כשמשתמש עובר בין 'הפעלה מיידית' ל'הפעלה ללא התקנה' הרצת סשנים שבהם למחלקה הניתנת להתאמה אישית אין currentVersionUID מוגדר. (באג: #209006)
  • שינויי סגנון לא באים לידי ביטוי בהפעלה מיידית. (באג: #210851)
  • סשן 'הפעלה מיידית' לא מהימן וגורם ל-FileNotFoundError. (באג: #213083)
  • שינויים בפריטים שניתנים להזזה לא יבואו לידי ביטוי עד לביצוע בנייה מחדש מלאה בשביל KitKat. (באג: #21530)
  • שינויים במשאבים לא באים לידי ביטוי בהפעלה מיידית כאשר מתבצעת התאמה אישית ערכות sourceSet מכילות נתיבים מקוננים. (באג: #219145)
  • החלפה חמה וחמה לא פועלות אם הכיתה שהשתנתה מכילה הערה עם ערך enum. (באג: #209047)
  • שינויים בנתוני הערות שאינם משתקפים בתכונה 'הפעלה מיידית'. (באג: #210089)
  • התכונה 'הפעלה מיידית' לא קולטת שינויים בקוד אם מבצעים שינויים מחוץ ל- בסביבת הפיתוח המשולבת (IDE). (באג: #213205)
  • סשן 'הפעלה מיידית' לא אמין בגלל אסימון אבטחה שאינו תואם. (באג: #211989
  • החלפה קרה נכשלת במכשירים שלא תומכים כראוי במצב 'ריצה'. (באג: #210875)
  • האפליקציה קורסת לאחר הפעלה מחדש של ההפעלה המיידית. (באג: #219744)
  • זוהה ClassNotFoundהצג כשעוברים מהפעלה מיידית אל ניפוי באגים מיידי. (באג: #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.

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

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

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

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

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

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

2.0 (אפריל 2016)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  הערה: חובה פלאגין של Android ל-Gradle מגרסה 1.3 ואילך.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Android Studio v0.4.2 (ינואר 2014)

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

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

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

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

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

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

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

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

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

• שגיאות Gradle מ-aapt לא מצביעות יותר על קובצי פלט ממוזגים ב-build או בתיקייה. להפנות בחזרה למיקומי המקור האמיתיים.
• פיתוח גרסאות מקבילות. עכשיו אפשר להשתמש בגרסאות ה-build המקבילות של Gradle. לתשומת ליבכם: גרסאות build מקבילות נמצאות בתהליך (עיינו במאמר Gradle תיעוד.) תכונה זו מושבתת כברירת מחדל. כדי להפעיל אותו, צריך לעבור אל העדפות > Compiler ומסמנים את התיבה Compile מודולים עצמאיים במקביל.
• עבודה נוספת על מאגר המשאבים החדש המשמש לעיבוד פריסה, משאב כיווץ של העורך ועוד:
  • תמיכה בסיסית ביחסי תלות של ספריות .aar (למשל, שימוש בספרייה ללא עותק מקומי של את המקורות). עדיין לא פועלת לאימות XML של משאבים ולניווט בעורכי המקור.
  • זיהוי מחזור בהפניות למשאבים.
  • מסמכי תיעוד מהירים (F1), שבהם ניתן להציג את כל התרגומים של המחרוזת מתחת לקארה, עכשיו גם תציג את כל שכבות-העל של המשאבים מסוגי ה-build וטעמים השונים של Gradle, וגם ספריות. הם מופיעים בסדר הפוך של שכבת-על של משאבים, עם קו חוצה גרסאות המסיכות.
  • תיקונים לטיפול בעדכון המשאבים שמוזגו כאשר קבוצה של יחסי תלות של מודול שינוי.
  • תיקונים לרינדור XML כדי לטפל כראוי בהצהרות של ישויות תווים וב-XML ו-unicode לביצוע בריחה.
• שמירת תמיכה בצילום מסך בתצוגה המקדימה של הפריסה ובחלונות של עורך הפריסה.
• תיקוני באגים בתבניות.
• תיקוני באגים בקודים.
• תיקונים שונים בדוחות קריסה. תודה. אפשר להמשיך לשלוח דוחות קריסה.

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

קישור תצוגה

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

      android {
          viewBinding.enabled = true
      }
      

      android {
          viewBinding.enabled = true
      }
      

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

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

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

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

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

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

        android.useNewApkCreator=false
      

שיוך (Attribution) של build מותאם

עכשיו אפשר לקבוע כמה זמן לוקח ל-Clang מקשרים כל קובץ C/C++ בפרויקט. אפשר להפיק פלט ממעקב של Chrome שמכיל חותמות זמן של אירועי המהדר (compiler), להבין את הזמן שנדרש לבניית הפרויקט שלכם. ליצירת פלט של ה-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

אפשר לראות את נתוני השיוך (Attribution) של מודעות מותאמות בחלק העליון של Viewer:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תיקוני באגים

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

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

בעיות מוכרות

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

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

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

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

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

• גרדל 5.4.1. למידע נוסף, אפשר לקרוא את הקטע על עדכון של Gradle.

• כלים לבניית SDK 28.0.3 ואילך.

עיבוד הערות מצטברות

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

בנוסף, גם KAPT 1.3.30 ואילך תומך בהערות מצטברות מעבדים, כדי להפעיל אותם על ידי הכללת kapt.incremental.apt=true את קובץ gradle.properties שלך.

בדיקות יחידה (MSA) שניתנות לשמירה

כשמפעילים בדיקות יחידה (unit testing) כדי להשתמש במשאבים, בנכסים וב-Android מניפסטים באמצעות הגדרה includeAndroidResources אל true, הפלאגין Android Gradle יוצר קובץ תצורה לבדיקה שמכיל נתיבים מוחלטים, שמפריעים את יכולת הזיהוי של המטמון. אפשר להורות את הפלאגין כדי ליצור את תצורת הבדיקה באמצעות נתיבים יחסיים, מאפשר לשמור במטמון את המשימה AndroidUnitTest באופן מלא, עד כולל את הדבר הבא בקובץ gradle.properties שלך:

      android.testConfig.useRelativePath = true
    

בעיות מוכרות

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

            WARNING: API 'variant.getPackageLibrary()' is obsolete and has been replaced
                    with 'variant.getPackageLibraryProvider()'.
            
          

  כדי לפתור את הבעיה הבעיה הזו, לשדרג את הפלאגין לגרסה 1.3.40 ואילך.

3.4.0 (אפריל 2019)

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

• גרדל 5.1.1 ומעלה. למידע נוסף, אפשר לקרוא את הקטע על עדכון של Gradle.

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

• כלים לבניית SDK 28.0.3 ואילך.

תכונות חדשות

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

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

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

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

עכשיו, עם R8, הסרת סוכרים, כיווץ, ערפול קוד (obfuscation), אופטימיזציה והסרה של שדות (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 הוצאה משימוש: עכשיו אתם מקבלים אם תנסה להשתמש ב-ndkBuild כדי להדר של ספריות מקוריות. במקום זאת, צריך להשתמש ב-CMake או ב-ndk-build כדי להוסיף קוד C ו-C++ project.

בעיות מוכרות

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

            android.uniquePackageNames = true
            
          

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

3.3.0 (ינואר 2019)

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

• גרדל 4.10.1 ואילך. למידע נוסף, אפשר לקרוא את הקטע על עדכון של Gradle.

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

• SDK Build Tools מגרסה 28.0.3 ואילך.

תכונות חדשות

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

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

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

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

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

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

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

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

    android.enableSeparateAnnotationProcessing=true
                

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

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

            android.debug.obsoleteApi=true
          

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

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

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

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

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

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

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

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

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

  android.bundle.enableUncompressedNativeLibs = false
          

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

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

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

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

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

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

תיקוני באגים

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

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

3.2.0 (ספטמבר 2018)

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

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

תכונות חדשות

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

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

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

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

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

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

• קוד חדש לכיווץ קוד, R8: R8 הוא כלי חדש לכיווץ קוד וערפול קוד (obfuscation) שמחליפה את ProGuard. ניתן להתחיל להשתמש בגרסת טרום-השקה (Preview) של 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 גם כשפורסים את גרסת ניפוי הבאגים של האפליקציה במכשיר שמותקנת בו רמת API של Android 21 ומעלה. ולא משנה אם אתם פורסים למכשיר או לפיתוח APK להפצה, הפלאגין Android Gradle מפעילה Multidex מקורי בכל המודולים שהגדירו minSdkVersion=21 ומעלה.

• הפלאגין אוכף עכשיו גרסה מינימלית של הפלאגין protobuf (0.8.6), הפלאגין Kotlin (1.2.50) והפלאגין Crashlytics (1.25.4).

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

תיקוני באגים

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

3.1.0 (מרץ 2018)

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

• גרדל 4.4 ואילך.

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

• כלי בנייה 27.0.3 ואילך.

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

מהדר DEX חדש, D8

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

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

      android.enableD8=false
    

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

      android.enableIncrementalDesugaring=false.
    

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

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

• כשיוצרים כמה חבילות 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")
                    ...
                }
            }
          

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

3.0.0 (אוקטובר 2017)

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

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

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

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

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

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

אופטימיזציות

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

תכונות חדשות

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

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

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

  Groovy

          android {
            testOptions {
              execution 'ANDROID_TEST_ORCHESTRATOR'
            }
          }
          

  Kotlin

          android {
            testOptions {
              execution = "ANDROID_TEST_ORCHESTRATOR"
            }
          }
          

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

  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 אל לתמוך בבדיקות יחידות (unit testing) שמחייבות משאבי Android, כמו רובואלקטרי. כשתגדירו את זה למאפיין true, הפלאגין מבצע משאב, נכס למיזוג מניפסטים לפני הרצת בדיקות היחידה. לאחר מכן הבדיקות יש לבדוק את com/android/tools/test_config.properties ב classpath למפתחות הבאים:

  • android_merged_assets: הנתיב המוחלט אל את ספריית הנכסים הממוזגים.

    הערה: במודולים של ספריות, הנכסים שמוזגו יהיו זהים לא מכילות את הנכסים של יחסי התלות ( בעיה #65550419).

  • android_merged_manifest: הנתיב המוחלט אל קובץ מניפסט שמוזג.

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

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

• תמיכה בגופנים משאבים (תכונה חדשה שהושקה ב- Android 8.0 (רמת API 26)).
• תמיכה בחבילות APK ספציפיות לשפה באמצעות ב-Android 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.

  הכללים בהתאמה אישית לאיתור שגיאות בקוד חייבים להשתייך לפרויקט נפרד שמפיק פלט 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 שלך לא פועל. אם משתמשים בהם. לדוגמה, כבר לא תוכלו להשתמש ב-וריאנטs API כדי גישה ל-outputFile() אובייקטים או שימוש ב- processManifest.manifestOutputFile() לקבלת קובץ המניפסט לכל וריאנט. מידע נוסף זמין במאמר הבא: שינויים ב-API.
• כבר לא צריך לציין גרסה לכלי ה-build (לכן עכשיו אפשר להסיר את הנכס android.buildToolsVersion). על ידי כברירת מחדל, הפלאגין משתמש באופן אוטומטי בכלי ה-build המינימליים הנדרשים בגרסת הפלאגין של Android שבה משתמשים.
• הפעלת/השבתה של דחיסת קובצי PNG ב-buildTypes כמו שמתואר בהמשך. דחיסת קובצי PNG מופעלת כברירת מחדל בכל גרסאות ה-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.
• עליך לבצע עכשיו הוספת הערה מעבדים לנתיב הכיתה של המעבד באמצעות תצורת תלות של 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 26.0.2 ומעלה. לאחר העדכון הזה, כבר לא צריך לציין גרסה עבור כלי ה-build — הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל. לכן אפשר להסיר את הנכס android.buildToolsVersion.

אופטימיזציות

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

תכונות חדשות

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

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

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

  Groovy

          android {
            testOptions {
              execution 'ANDROID_TEST_ORCHESTRATOR'
            }
          }
          

  Kotlin

          android {
            testOptions {
              execution = "ANDROID_TEST_ORCHESTRATOR"
            }
          }
          

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

  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 אל לתמוך בבדיקות יחידות (unit testing) שמחייבות משאבי Android, כמו רובואלקטרי. כשתגדירו את זה למאפיין true, הפלאגין מבצע משאב, נכס למיזוג מניפסטים לפני הרצת בדיקות היחידה. לאחר מכן הבדיקות יש לבדוק את com/android/tools/test_config.properties ב classpath למפתחות הבאים:

  • android_merged_assets: הנתיב המוחלט אל את ספריית הנכסים הממוזגים.

    הערה: במודולים של ספריות, הנכסים שמוזגו יהיו זהים לא מכילות את הנכסים של יחסי התלות ( בעיה #65550419).

  • android_merged_manifest: הנתיב המוחלט אל קובץ מניפסט שמוזג.

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

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

• תמיכה בגופנים משאבים (תכונה חדשה שהושקה ב- Android 8.0 (רמת API 26)).
• תמיכה בחבילות APK ספציפיות לשפה באמצעות ב-Android 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.

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

2.3.0 (פברואר 2017)

יחסי תלות:

• Gradle 3.3 ומעלה.
• כלי Build גרסה 25.0.0 ומעלה.

המינוי החדש:

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

השינויים:

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

2.2.0 (ספטמבר 2016)

יחסי תלות:

• Gradle מגרסה 2.14.1 ואילך.
• כלי build בגרסה 23.0.2 ומעלה.

המינוי החדש:

• נעשה שימוש ב-Gradle גרסה 2.14.1, שכוללת שיפורי ביצועים ותכונות חדשות, ותיקון פרצת אבטחה שמאפשרת הסלמת הרשאות מקומית (privilege escalation) כשמשתמשים בדימון (daemon) של Gradle. לקבלת מידע נוסף פרטים נוספים, עיינו במאמר נתוני הגרסה של Gradle
• באמצעות externalNativeBuild {} DSL, Gradle מאפשר עכשיו לקשר למקורות המקוריים שלכם וליצור ספריות מקוריות באמצעות CMake או ndk-build. אחרי שיצרתם את הספריות המקוריות, Gradle חבילות אותן ל-APK. למידע נוסף על השימוש ב-CMake ndk-build with Gradle, לקרוא את המאמר הוספת קוד C ו-C++ פרויקט.
• כאשר מפעילים build משורת הפקודה, Gradle מנסה להוריד אוטומטית רכיבים או עדכונים חסרים ב-SDK שהפרויקט תלוי בהם. מידע נוסף זמין במאמר הורדה אוטומטית חסרות חבילות עם Gradle.
• תכונה ניסיונית חדשה לשמירה במטמון מאפשרת ל-Gradle לזרז את גרסת ה-build על ידי עיבוד מראש, אחסון ושימוש חוזר בגרסאות ששולמו מראש של הספריות. כדי לקבל מידע נוסף על השימוש בתכונה הניסיונית הזו, לקרוא את גרסת ה-Build מדריך לשמירה במטמון.
• שיפור ביצועי ה-build על ידי שימוש במארז חדש שמוגדר כברירת מחדל צינור עיבוד נתונים שמטפל בדחיסת קבצים, חתימה ויצירת ZIP במשימה אחת. שלך יכולים לחזור להשתמש בכלי האריזה הישנים על ידי הוספת android.useOldPackaging=true אל קובץ gradle.properties. בזמן השימוש באריזה החדשה כלי, המשימה zipalignDebug לא זמינה. אבל, לפעמים תוכלו ליצור חשבון בעצמכם אמצעי תשלום אחד (createZipAlignTask(String taskName, File inputFile, File outputFile)).
• חתימת ה-APK משתמשת עכשיו בסכמת חתימת APK גרסה 2 בנוסף לחתימת JAR המסורתית. כל פלטפורמות Android מקבלות את חבילות ה-APK שהתקבלו. כל שינוי בחבילות ה-APK האלה לאחר החתימה מבטל את התוקף שלהן חתימות V2 ומונעות התקנה במכשיר. כדי להשבית את התכונה הזו, מוסיפים את הפרטים הבאים לקובץ build.gradle ברמת המודול:

  Groovy

  android {
    ...
    signingConfigs {
      config {
        ...
        v2SigningEnabled false
      }
    }
  }
        

  Kotlin

  android {
    ...
    signingConfigs {
      create("config") {
        ...
        v2SigningEnabled = false
      }
    }
  }
        

• עכשיו אפשר להשתמש בכללי ProGuard עבור גרסאות build מרובות כדי לקבוע אילו הכיתות ש-Gradle צריך להדר בקובץ ה-DEX הראשי של האפליקציה. כי מערכת Android טוענת קודם את קובץ ה-DEX הראשי כשמפעילים את האפליקציה, יכול לתת עדיפות לכיתות מסוימות בסטארט-אפ על ידי הידור שלהן בקובץ ה-DEX הראשי חדש. לאחר שתיצרו קובץ תצורה של ProGuard במיוחד עבור מעבירים את הנתיב של קובץ התצורה אל 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 תומך עכשיו בכיסוי הבדיקה של Jacoco בזמן ההגדרה testCoverageEnabled עד true.
  • תמיכה משופרת במעבדי הערות. הערה מעבדים בנתיב הכיתה, כמו כל compile של יחסי התלות מוחלים באופן אוטומטי על ה-build. אפשר לציין גם מעבד הערות ב-build וב ארגומנטים באמצעות הפונקציה javaCompileOptions.annotationProcessorOptions {} DSL ב קובץ 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.5 לפחות GB, ג'ק פועל עכשיו באותו תהליך כמו Gradle. כדי לכוונן גודל ערימה של דימון (daemon), צריך להוסיף את הערכים הבאים ל קובץ gradle.properties:

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

2.1.0 (אפריל 2016)

יחסי תלות:

• Gradle מגרסה 2.10 ואילך.
• כלי build בגרסה 23.0.2 ומעלה.

המינוי החדש:

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

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

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

  Groovy

  android {
    ...
    compileOptions {
      incremental false
    }
  }
  

  Kotlin

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

• נוספה תמיכה בתהליך הסרה של שיטות (dexing) בתהליך שמבצע דקירה בתוך ה-build במקום בתהליך נפרד של מכונה וירטואלית. זה לא רק גורם פיתוחים מצטברים מהירים יותר, אבל גם מאיצים את גרסאות ה-build המלאות. התכונה היא מופעלת כברירת מחדל בפרויקטים שבהם הוגדרה כמות הערימה המקסימלית של דימון (daemon) של Gradle בגודל של 2,048MB לפחות. כדי לעשות את זה, צריך לכלול ב- קובץ gradle.properties של הפרויקט:

  ```ללא org.gradle.jvmargs = -Xmx2048m ```

  אם הגדרתם ערך עבור javaMaxHeapSize ב-build.gradle ברמת המודול צריך להגדיר את org.gradle.jvmargs לערך של javaMaxHeapSize + 1,024MB. לדוגמה, אם הגדרתם javaMaxHeapSize ל-"2048m", עליך להוסיף את הפרטים הבאים קובץ gradle.properties של הפרויקט:

  ```ללא org.gradle.jvmargs = -Xmx3072m ```

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

  Groovy

  android {
    ...
    dexOptions {
        dexInProcess false
    }
  }
  

  Kotlin

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

2.0.0 (אפריל 2016)

יחסי תלות:

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

המינוי החדש:

• מפעיל הפעלה מיידית על ידי תמיכה בהחדרת בייטקוד ודחיפה של עדכוני קוד ומשאבים האפליקציה שפועלת באמולטור או במכשיר פיזי.
• נוספה תמיכה בגרסאות 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 (JaCoCo), ProGuard, ו-MultiDex, שמשתמשים עכשיו ב-Transform API. עם זאת, ערכת מהדר (Compiler Kit) של Java ל-Android (Jack) לא משתמש ב-API הזה, רק נתיב הקוד javac/dx משתמש בו.
• Gradle מבצעת את הטרנספורמציות בסדר הזה: JaCoCo, יישומי פלאגין של צד שלישי, ProGuard. סדר הביצוע של יישומי פלאגין של צד שלישי תואם לסדר שבו השינויים מתבצעים נוספו על ידי יישומי פלאגין של צד שלישי. מפתחי יישומי פלאגין של צד שלישי לא יכולים לשלוט בביצוע את סדר ההמרות דרך API.
• הוצא משימוש את הפקודה dex מהמחלקה ApplicationVariant. אין לך יותר גישה למשימה Dex דרך גרסת ה-API של הווריאנט כי היא עכשיו באמצעות טרנספורמציה. יש ואין כרגע תחליף לשליטה בתהליך הדקס.
• תמיכה מצטברת בנכסים.
• תמיכה משופרת ב-MultiDex כי היא זמינה לפרויקטים של בדיקה, וגם בבדיקות האלה יופיע עכשיו באופן אוטומטי com.android.support:multidex-instrumentation של יחסי התלות.
• נוספה היכולת להיכשל כראוי ב-build של Gradle ולדווח על סיבת השגיאה הבסיסית כשה-build של Gradle מפעיל משימות אסינכרוניות ויש כשל ב-worker תהליך האימות.
• נוספה תמיכה בהגדרה של Application Binary Interface (ABI) ספציפית בווריאנטים שכוללים כמה ממשקי ABI.
• נוספה תמיכה ברשימה מופרדת בפסיקים של מספרים סידוריים עבור משתנה הסביבה של ANDROID_SERIAL כשמתקינים או מפעילים בדיקות.
• תוקן כשל בהתקנה במכשירים שבהם פועל Android 5.0 (רמת API 20) ואילך כשיש רווח בשם ה-APK.
• תוקנו בעיות שונות שקשורות לפלט השגיאה של הכלי לאריזה של נכסי Android (AAPT).
• נוספה תמיכה באינסטרומנטציה מצטברת של JaCoCo לגרסאות build מצטברות מהירות יותר. הפלאגין של Android ל-Gradle מפעיל עכשיו את האינסטרומנטציה של JaCoCo באופן ישיר. כדי לאלץ גרסה חדשה יותר של האינסטרומנטלית של JaCoCo, צריך להוסיף אותה כתלות בסקריפט build.
• תוקנה תמיכה ב-JaCoCo ומתעלמת מקבצים שהם לא מחלקות.
• נוספה תמיכה בהעברה וקטורית של קובץ PNG בזמן ה-build לצורך תאימות לאחור. הפלאגין של Android ל-Gradle יוצר קובצי PNG לכל פריט גרפי וקטורי שניתן להזזה שנמצא במשאב שלא מציינת גרסת API או מציינת במאפיין android:minSdkVersion של 20 ומטה רכיב <uses-sdk> בקובץ המניפסט של האפליקציה. אפשר להגדיר את הדחיסות של קובץ PNG לפי באמצעות המאפיין generatedDensities בdefaultConfig או productFlavor קטעים של קובץ build.gradle.
• נוסף שיתוף של android.jar שניתן לדמות, שהפלאגין יוצר רק פעם אחת ומשמש לבדיקת יחידה. מספר מודולים, כמו app ו- lib, עכשיו אפשר לשתף אותו. צריך למחוק את $rootDir/build כדי ליצור אותו מחדש.
• שינינו את העיבוד של משאבי Java כך שיופיע לפני משימות הערפול (obfuscation) במקום במהלך האריזה של ה-APK. השינוי הזה מאפשר למשימות הערפול קוד (obfuscation) כדי להתאים את משאבי Java בעקבות ערפול קוד (obfuscation) של חבילות.
• תוקנה בעיה בשימוש בקוד Java Native Interface (JNI) בספרייה הניסיונית יישומי פלאגין.
• נוספה היכולת להגדיר את גרסת הפלטפורמה בנפרד מאפיין android:compileSdkVersion בספרייה הניסיונית יישומי פלאגין.

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

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

• המשימה ZipZip תוקנה כמו שצריך להשתמש בשם קובץ מותאם אישית, כדי ליצור את הפלט של המשימה הקודמת.
• Renderscript מתוקן באריזה עם ה-NDK.
• תמיכה שוטפת במשימת ה-build של createDebugCoverageReport.
• תוקנה תמיכה בשימוש מותאם אישית ב-archiveBaseName את המאפיין הזה בקובץ ה-build של build.gradle.
• בוצע תיקון של Invalid ResourceType האזהרה lint נגרמה על ידי שיטת הפרמטר חיפוש הערות בזמן ההרצה איתור שגיאות בקוד מחוץ ל-Android Studio.

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

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

• נוספה תמיכה ב-com.android.build.threadPoolSize מאפיין כדי לקבוע את הגודל של מאגר שרשורי המשימות Android את הקובץ gradle.properties או את שורת הפקודה. בדוגמה הבאה המאפיין מוגדר ל-4.

          
          -Pcom.android.build.threadPoolSize=4
          
        

• הגדרת התנהגות ברירת המחדל של ה-build להחרגה של LICENSE ו-LICENSE.txt קבצים מ-APKs. כדי לכלול את הקבצים האלה ב-APK, צריך להסיר את הקבצים האלה המאפיין packagingOptions.excludes בקובץ build.gradle. לדוגמה:

  android {
        packagingOptions.excludes = []
      }
        

  android {
        packagingOptions.excludes.clear()
      }
      

• המשימה sourceSets נוספה כדי לבדוק את הקבוצה של כל קבוצות המקור הזמינות.
• תמיכה מתקדמת בבדיקת יחידות, לזיהוי ריבוי טעמים ליצור תיקיות מקור של וריאנטים. לדוגמה, כדי לבדוק אפליקציה שכוללת כמה טעמים 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 (AAPT) בקובץ build.gradle. לדוגמה:

  android {
      aaptOptions {
        additionalParameters "--custom_option", "value"
      }
  }
        

  android {
      aaptOptions {
        additionalParameters += listOf("--custom_option", "value")
      }
  }
        

• נוספה תמיכה עבור לבדיקת מודול ה-APK כמודול בדיקה נפרד, באמצעות מאפיינים targetProjectPath ו-targetVariant להגדרת ה-APK הווריאנט של הנתיב והיעד.

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

• נוסף אימות של שם המשאב לפני מיזוג המשאבים.
• כשבונים חבילת AAR (Android ARchive) למודולים של ספרייה, אין לספק placeholder אוטומטי של @{applicationId} בשדה הגדרות של מיזוג מניפסט. במקום זאת, צריך להשתמש ב-placeholder אחר, כמו @{libApplicationId} או לספק ערך עבורו אם רוצים לכלול מזהי אפליקציות בספריית הארכיון.

פלאגין של Android ל-Gradle, גרסה 1.2.0 (אפריל 2015)

יחסי תלות:

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

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

• תמיכה מתקדמת בהרצת בדיקות יחידה עם Gradle.
  • נוספה תמיכה להכללת משאבים בסגנון Java בנתיב הכיתה כשמריצים בדיקות יחידה ישירות מ-Gradle.
  • נוספה תמיכה בתלות בבדיקת יחידה עבור Android Archive (AAR) ארטיפקטים.
  • נוספה תמיכה בנכס unitTestVariants כך שניתן לשנות וריאנטים של בדיקת יחידה באמצעות קובץ build.gradle.
  • בלוק הקוד של unitTest.all נוסף בקטע testOptions כדי להגדיר משימות בהתאמה אישית ליחידה לבדיקה. הקוד לדוגמה הבא מראה איך להוסיף בדיקת יחידה. הגדרות אישיות באמצעות האפשרות החדשה הזו:

    android {
      testOptions {
        unitTest.all {
          jvmArgs '-XX:MaxPermSize=256m' // Or any other gradle option.
        }
      }
    }
    

    android {
      testOptions {
        unitTest.all {
          jvmArgs += listOf("-XX:MaxPermSize=256m") // Or any other gradle option.
        }
      }
    }
                

  • תיקנו את הטיפול בשדות טיפוסים בני מנייה (enum) ובשדות של מכונות ציבוריות האריזה של הקובץ mockable-android.jar.
  • יחסי תלות קבועים של פרויקט בספרייה, לכן מחלקות בדיקה להדר מחדש אחרי השינויים.
• נוסף הנכס testProguardFile להחלה קובצי ProGuard בעת הקטנה של APK לבדיקה
• הנכס timeOut נוסף אל adbOptions בלוק קוד להגדרת זמן ההקלטה המקסימלי מסך Android Debug Bridge מוקלטת.
• נוספה תמיכה במשאבים של 280 DPI.
• ביצועים משופרים במהלך הערכת הפרויקט.

פלאגין של Android ל-Gradle, גרסה 1.1.3 (מרץ 2015)

יחסי תלות:

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

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

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

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

• נוספה תמיכה בבדיקת יחידה חדשה
• Enabled (מופעלת) יחידה בדיקות להרצה ב-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) ערכה).

• הוספת את android.testOptions.unitTests.returnDefaultValues אפשרות לשלוט בהתנהגות של android.jar שניתן לדמות.
• השם Test בשמות של משימות הבדיקה הוחלף ב- AndroidTest. לדוגמה, משימה אחת (assembleDebugTest) בוצעה עכשיו משימה אחת (assembleDebugAndroidTest). משימות של בדיקות יחידה (unit testing) עדיין כוללים את המילה UnitTest בשם המשימה. לדוגמה, assembleDebugUnitTest.
• ProGuard שונה קובצי תצורה לא יחולו יותר על חבילת ה-APK לבדיקה. אם המיקום ההקטנה מופעלת, ProGuard מעבד את ה-APK לבדיקה מחילה רק את קובץ המיפוי שנוצר בתהליך ההקטנה את ה-APK הראשי.
• עדכון של ניהול יחסי התלות
  • תוקנו בעיות באמצעות provided ו package היקפים.

    הערה: ההיקפים האלה לא תואמת לחבילות AAR (Android ARchive), לגרום ליצירה עם חבילות AAR להיכשל.

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

פלאגין של Android ל-Gradle, גרסה 1.0.1 (ינואר 2015)

יחסי תלות:

• Gradle 2.2.1 עד 2.3.x.

  הערה: הגרסה הזו של Android ל-Gradle לא תואם ל-Gradle 2.4 גבוהה יותר.

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

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

• תוקנה בעיה ב-build של Gradle במהלך גישה מודול extractReleaseAnnotations. (גיליון 81638).
• תוקנה הבעיה שגרמה ל-Disable להעביר את ההגדרה --no-optimize ל-Dalvik Executable (dex) bytecode. (בעיה 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 ואילך.

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

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