בהמשך מופיעים נתוני הגרסה של Android Studio מגרסה 3.6 ומטה, ושל פלאגין Android Gradle מגרסה 3.6.0 ומטה.
גרסאות קודמות של Android Studio
3.6 (פברואר 2020)
Android Studio 3.6 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
אנחנו רוצים גם להודות לכל הצעות התוכן מהקהילה שעזרו לנו עם הגרסה הזו.
3.6.3 (אפריל 2020)
העדכון הקטן הזה כולל תיקוני באגים שונים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
3.6.2 (מרץ 2020)
העדכון הקטן הזה כולל תיקוני באגים שונים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
3.6.1 (פברואר 2020)
העדכון הקטן הזה כולל תיקוני באגים שונים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
כלי עיצוב
הגרסה הזו של Android Studio כוללת עדכונים לכמה כלי עיצוב, כולל Layout Editor ו-Resource Manager.
תצוגה מפוצלת וזום בעורכי עיצוב

הגרסה הזו כוללת את העדכונים הבאים בכלי העריכה החזותיים:
-
עורכי עיצוב, כמו Layout Editor ו-Navigation Editor, מספקים עכשיו תצוגת Split שמאפשרת לראות את התצוגות Design ו-Code של ממשק המשתמש בו-זמנית. בפינה השמאלית העליונה של חלון העריכה, יש עכשיו שלושה כפתורים
למעבר בין אפשרויות התצוגה:-
כדי להפעיל את התצוגה המפוצלת, לוחצים על הסמל פיצול
.
-
כדי להפעיל את תצוגת המקור של XML, לוחצים על סמל המקור
.
-
כדי להפעיל את תצוגת העיצוב, לוחצים על סמל העיצוב
.
-
כדי להפעיל את התצוגה המפוצלת, לוחצים על הסמל פיצול
-
אמצעי הבקרה לשינוי מרחק התצוגה ולהזזה בתוך עורכי העיצוב עברו ללוח צף בפינה השמאלית התחתונה של חלון העורך.
מידע נוסף זמין במאמר יצירת ממשק משתמש באמצעות Layout Editor.
הכרטיסייה "משאבים" בכלי לבחירת צבעים
כדי לעזור לכם לעדכן במהירות את הערכים של משאבי הצבע באפליקציה כשאתם משתמשים בכלי לבחירת צבעים ב-XML או בכלי העיצוב, ה-IDE מאכלס עכשיו את הערכים של משאבי הצבע בשבילכם.

מנהל המשאבים
מנהל המשאבים כולל את העדכונים הבאים:
- עכשיו מנהל המשאבים תומך ברוב סוגי המשאבים.
- כשמחפשים משאב, מנהל המשאבים מציג עכשיו תוצאות מכל המודולים של הפרויקט. בעבר, החיפושים הניבו תוצאות רק מהמודול שנבחר.
- כפתור הסינון מאפשר לכם לראות משאבים ממודולים מקומיים תלויים, מספריות חיצוניות ומ-Android framework. אפשר גם להשתמש במסנן כדי להציג מאפייני נושא.
- עכשיו אפשר לשנות את השם של המשאבים במהלך תהליך הייבוא, בלחיצה בתוך תיבת הטקסט שמעל המשאב.
מידע נוסף זמין במאמר ניהול משאבי ממשק המשתמש של האפליקציה באמצעות מנהל המשאבים.
עדכונים לפלאגין של Android Gradle
הגרסה העדכנית של הפלאגין של Android Gradle כוללת עדכונים רבים, כולל אופטימיזציות למהירות ה-build, תמיכה בפלאגין לפרסום ב-Maven ותמיכה ב-View Binding. מידע נוסף זמין בהערות המוצר המלאות.
כריכת תצוגה (View binding)
כריכת תצוגה מאפשרת לכם לכתוב בקלות רבה יותר קוד שמקיים אינטראקציה עם תצוגות, על ידי יצירת מחלקת כריכה לכל קובץ פריסה ב-XML. המחלקות האלה מכילות הפניות ישירות לכל התצוגות שיש להן מזהה בפריסה המתאימה.
מכיוון שהיא מחליפה את findViewById(), כריכת תצוגה מבטלת את הסיכון לחריגות מצביע null שנובעות ממזהה תצוגה לא חוקי.
כדי להפעיל את כריכת התצוגה, צריך להשתמש בפלאגין של Android Gradle בגרסה 3.6.0 ואילך, ולכלול את הקוד הבא בקובץ build.gradle של כל מודול:
מגניב
android { buildFeatures.viewBinding = true }
Kotlin
android { buildFeatures.viewBinding = true }
החלת השינויים
עכשיו אתם יכולים להוסיף מחלקה ואז לפרוס את השינוי בקוד באפליקציה שפועלת. כדי לעשות את זה, לוחצים על Apply Code Changes או על Apply Changes and Restart Activity .
מידע נוסף על ההבדל בין שתי הפעולות האלה זמין במאמר החלת שינויים.
אפשרות בתפריט Refactor להפעלת תמיכה באפליקציות ללא התקנה
אחרי שיוצרים את פרויקט האפליקציה, אפשר להפעיל את המודול הבסיסי כגרסה ללא התקנה בכל שלב:
- בסרגל התפריטים, לוחצים על View > Tool Windows > Project כדי לפתוח את החלונית Project.
- לוחצים לחיצה ימנית על מודול הבסיס, שבדרך כלל נקרא app, ובוחרים באפשרות Refactor > Enable Instant Apps Support.
- בתיבת הדו-שיח שמופיעה, בוחרים את מודול הבסיס מהתפריט הנפתח.
- לוחצים על אישור.
הערה: האפשרות להפעיל את מודול האפליקציה הבסיסי כגרסה ללא התקנה מאשף Create New Project הוסרה.
מידע נוסף זמין במאמר סקירה כללית של Google Play ללא התקנה.
ביטול ערפול קוד (deobfuscation) של בייטקוד של מחלקות ושיטות בכלי לניתוח APK
כשמשתמשים בהכלי לניתוח APK כדי לבדוק קובצי DEX, אפשר לפענח קוד מעורפל (deobfuscate) של בייטקוד (bytecode) של מחלקות ושיטות באופן הבא:
- בסרגל התפריטים, בוחרים באפשרות Build > Analyze APK (פיתוח > ניתוח APK).
- בתיבת הדו-שיח שמופיעה, עוברים ל-APK שרוצים לבדוק ובוחרים אותו.
- לוחצים על פתיחה.
- בכלי לניתוח APK, בוחרים את קובץ ה-DEX שרוצים לבדוק.
- במנהל קובצי ה-DEX, טוענים את קובץ המיפויים של ProGuard ל-APK שמנתחים.
- לוחצים לחיצה ימנית על המחלקה או השיטה שרוצים לבדוק ובוחרים באפשרות Show bytecode.
כלים מובנים
העדכונים הבאים תומכים בפיתוח נייטיב (C/C++) ב-Android Studio.
תמיכה ב-Kotlin
התכונות הבאות של NDK ב-Android Studio, שבעבר נתמכו ב-Java, נתמכות עכשיו גם ב-Kotlin:
-
אפשר לעבור מהצהרת JNI לפונקציית ההטמעה התואמת ב-C/C++. כדי לראות את המיפוי הזה, מעבירים את העכבר מעל סמן הפריט של C או C++ ליד מספר השורה בקובץ קוד המקור המנוהל.
-
יצירה אוטומטית של פונקציית הטמעה של stub להצהרת JNI. קודם מגדירים את הצהרת ה-JNI ואז מקלידים "jni" או את שם השיטה בקובץ C/C++ כדי להפעיל.

-
פונקציות הטמעה מקוריות שלא בשימוש מודגשות כאזהרה בקוד המקור. הצהרות JNI עם הטמעות חסרות מודגשות גם הן כשגיאה.
-
כשמשנים את השם (refactor) של פונקציית הטמעה מקורית, כל הצהרות ה-JNI התואמות מתעדכנות. שינוי שם של הצהרת JNI כדי לעדכן את פונקציית ההטמעה המקורית.
-
בדיקת חתימה להטמעות JNI שקשורות באופן משתמע.
שיפורים אחרים ב-JNI
עורך הקוד ב-Android Studio תומך עכשיו בתהליך עבודה חלק יותר לפיתוח JNI, כולל רמזים משופרים לסוגים, השלמה אוטומטית, בדיקות ושינוי מבנה הקוד (refactoring).
טעינה מחדש של קובצי APK לספריות Native {:#3.6-reload-apk}
כבר לא צריך ליצור פרויקט חדש כשקובץ ה-APK בפרויקט מתעדכן מחוץ ל-IDE. Android Studio מזהה שינויים ב-APK ומאפשר לייבא אותו מחדש.

צירוף מקורות של חבילות APK שמכילות רק קוד Kotlin
עכשיו אפשר לצרף מקורות APK חיצוניים של Kotlin בלבד כשמבצעים פרופיילינג וניפוי באגים של קובצי APK שנוצרו מראש. מידע נוסף זמין במאמר צירוף מקורות Kotlin/Java.
זיהוי דליפות ב-Memory Profiler
כשמנתחים תמונת מצב של הזיכרון ב-Memory Profiler, אפשר עכשיו לסנן נתוני פרופיילינג שלפי Android Studio עשויים להצביע על דליפות זיכרון במופעים של Activity ו-Fragment באפליקציה.
סוגי הנתונים שהמסנן מציג כוללים:
-
מופעים של
Activityשנהרסו אבל עדיין יש אליהם הפניות. -
Fragmentמופעים שאין להםFragmentManagerחוקי אבל עדיין יש הפניה אליהם.
צירוף מקורות של חבילות APK שמכילות רק קוד Kotlin
עכשיו אפשר לצרף מקורות APK חיצוניים של Kotlin בלבד כשמבצעים פרופיילינג וניפוי באגים של קובצי APK שנוצרו מראש. מידע נוסף זמין במאמר צירוף מקורות Kotlin/Java.
זיהוי דליפות ב-Memory Profiler
כשמנתחים תמונת מצב של הזיכרון ב-Memory Profiler, אפשר עכשיו לסנן נתוני פרופיילינג שלפי Android Studio עשויים להצביע על דליפות זיכרון במופעים של Activity ו-Fragment באפליקציה.
סוגי הנתונים שהמסנן מציג כוללים:
-
מופעים של
Activityשנהרסו אבל עדיין יש אליהם הפניות. -
Fragmentמופעים שאין להםFragmentManagerחוקי אבל עדיין יש הפניה אליהם.
במצבים מסוימים, כמו אלה שבהמשך, המסנן עלול להניב תוצאות חיוביות מוטעות:
- נוצר
Fragmentאבל עדיין לא נעשה בו שימוש. - מתבצעת שמירה במטמון של
Fragment, אבל לא כחלק מ-FragmentTransaction.
כדי להשתמש בתכונה הזו, קודם צריך ליצור תמונת מצב של הזיכרון או לייבא קובץ dump ל-Android Studio. כדי להציג את הפרגמנטים והפעילויות שעלולים לגרום לדליפת זיכרון, מסמנים את התיבה Activity/Fragment Leaks בחלונית של תמונת המצב של הזיכרון ב-Memory Profiler.
סינון של תמונת מצב של הזיכרון כדי לאתר דליפות זיכרון.
אמולטורים
ב-Android Studio 3.6 אפשר לנצל כמה עדכונים שנכללים ב-אמולטור Android מגרסה 29.2.7 ואילך, כפי שמתואר בהמשך.
תמיכה משופרת במיקום
בגרסה 29.2.7 ומעלה של אמולטור Android יש תמיכה נוספת בהדמיה של קואורדינטות GPS ומידע על מסלולים. כשפותחים את הפקדים המורחבים של האמולטורים, האפשרויות בכרטיסייה Location מאורגנות עכשיו בשתי כרטיסיות: Single points ו-Routes.
נקודות בודדות
בכרטיסייה Single points, אתם יכולים להשתמש בתצוגת האינטרנט של מפות Google כדי לחפש נקודות עניין, בדיוק כמו שאתם עושים כשאתם משתמשים במפות Google בטלפון או בדפדפן. כשמחפשים מיקום במפה או לוחצים עליו, אפשר לשמור אותו על ידי בחירה באפשרות "שמירת נקודה" ליד החלק התחתון של המפה. כל המיקומים השמורים מופיעים בצד שמאל של החלון Extended controls.
כדי להגדיר את המיקום של האמולטור למיקום שבחרתם במפה, לוחצים על הכפתור Set location ליד הפינה הימנית התחתונה של החלון Extended controls.
.
מסלולים
בדומה לכרטיסייה Single points, הכרטיסייה Routes מספקת תצוגת אינטרנט של מפות Google שבה אפשר ליצור מסלול בין שני מיקומים או יותר. כדי ליצור ולשמור מסלול:
- בתצוגת המפה, משתמשים בשדה הטקסט כדי לחפש את היעד הראשון במסלול.
- בוחרים את המיקום מתוצאות החיפוש.
- לוחצים על הכפתור Navigate.
- בוחרים במפה את נקודת ההתחלה של המסלול.
- (אופציונלי) לוחצים על הוספת יעד כדי להוסיף עוד עצירות למסלול.
- כדי לשמור את המסלול, לוחצים על שמירת המסלול בתצוגת המפה.
- מזינים שם לנתיב ולוחצים על שמירה.
כדי לדמות את האמולטור שעוקב אחרי המסלול ששמרתם, בוחרים את המסלול מהרשימה Saved routes ולוחצים על Play route ליד הפינה הימנית התחתונה של החלון Extended controls. כדי להפסיק את הסימולציה, לוחצים על עצירת המסלול.
.
כדי לדמות את האמולטור באופן רציף במסלול שצוין, מפעילים את המתג לצד Repeat playback. כדי לשנות את מהירות התנועה של האמולטור במסלול שצוין, בוחרים אפשרות בתפריט הנפתח Playback speed.
תמיכה בתצוגה מרובת מסכים
עכשיו אפשר לפרוס את האפליקציה בכמה מסכים באמולטור Android, שתומכים במאפיינים שניתנים להתאמה אישית ויכולים לעזור לכם לבדוק אפליקציות שתומכות בריבוי חלונות ובריבוי מסכים. כשהמכשיר הווירטואלי פועל, אפשר להוסיף עד שני מסכים נוספים באופן הבא:
-
פותחים את Extended controls ועוברים לכרטיסייה Displays.
-
כדי להוסיף עוד מסך, לוחצים על הוספת מסך משני.
-
בתפריט הנפתח בקטע מסכים משניים, מבצעים אחת מהפעולות הבאות:
-
בוחרים באחד מיחסי הגובה-רוחב המוגדרים מראש.
-
בוחרים באפשרות בהתאמה אישית ומגדירים את הגובה, הרוחב וה-DPI של התצוגה בהתאמה אישית.
-
(אופציונלי) לוחצים על הוספת מסך משני כדי להוסיף מסך שלישי.
-
לוחצים על Apply changes כדי להוסיף את המסכים שצוינו למכשיר הווירטואלי שפועל.

מכשירים וירטואליים חדשים ותבניות פרויקטים ל-Android Automotive OS
כשיוצרים פרויקט חדש באמצעות Android Studio, אפשר עכשיו לבחור מבין שלוש תבניות בכרטיסייה Automotive באשף Create New Project: No Activity, Media service ו-Messaging service. בפרויקטים קיימים, כדי להוסיף תמיכה במכשירי Android Automotive, לוחצים על File > New > New Module בסרגל התפריטים ובוחרים באפשרות Automotive Module. האשף Create New Module ידריך אתכם בתהליך היצירה של מודול חדש באמצעות אחת מהתבניות של פרויקט Android Automotive.
.
בנוסף, עכשיו אתם יכולים ליצור מכשיר וירטואלי של Android (AVD) למכשירי Android Automotive OS. כדי לעשות את זה, בוחרים באחת מהאפשרויות הבאות בכרטיסייה Automotive באשף Virtual Device Configuration.
- Polestar 2: יוצרים AVD שמדמה את מערכת המולטימדיה של Polestar 2.
- רכב (1024p לרוחב): יוצרים AVD למערכות מולטימדיה גנריות של Android Automotive בגודל 1024x768 פיקסלים.
.
הורדות של SDK שניתן להמשיך
כשמורידים רכיבים וכלים של SDK באמצעות SDK Manager, עכשיו אפשר להמשיך ב-Android Studio הורדות שהופסקו (למשל, בגלל בעיה ברשת) במקום להתחיל את ההורדה מחדש. השיפור הזה עוזר במיוחד בהורדות גדולות, כמו אמולטור Android או קובצי אימג' של המערכת, כשהחיבור לאינטרנט לא יציב.
בנוסף, אם יש משימה של הורדת SDK שפועלת ברקע, אפשר עכשיו להשהות או להמשיך את ההורדה באמצעות הפקדים בשורת הסטטוס.
משימת הורדה ברקע בשורת הסטטוס עם אמצעי בקרה חדשים שמאפשרים להשהות או להמשיך את ההורדה.
Win32 הוצא משימוש
גרסת 32-ביט של Android Studio ל-Windows לא תקבל יותר עדכונים אחרי דצמבר 2019, ולא תקבל יותר תמיכה אחרי דצמבר 2020. אתם יכולים להמשיך להשתמש ב-Android Studio. עם זאת, כדי לקבל עדכונים נוספים, צריך לשדרג את תחנת העבודה לגרסת 64 ביט של Windows.
מידע נוסף זמין בפוסט בבלוג על הוצאה משימוש של Windows בגרסת 32 ביט
אפשרות חדשה לאופטימיזציה של זמן הסנכרון של Gradle
בגרסאות קודמות, Android Studio אחזר את הרשימה של כל המשימות של Gradle במהלך הסנכרון של Gradle. בפרויקטים גדולים, אחזור רשימת המשימות עלול לגרום לזמני סנכרון איטיים.
כדי לשפר את הביצועים של Gradle Sync, עוברים אל File > Settings > Experimental ובוחרים באפשרות Do not build Gradle task list during Gradle sync.
כשמפעילים את האפשרות הזו, Android Studio מדלג על יצירת רשימת המשימות במהלך הסנכרון, וכך מאפשר ל-Gradle Sync להשלים את הפעולה מהר יותר ומשפר את מהירות התגובה של ממשק המשתמש. חשוב לזכור שכאשר ה-IDE מדלג על בניית רשימת המשימות, רשימות המשימות בחלונית Gradle ריקות, וההשלמה האוטומטית של שמות המשימות בקובצי ה-build לא פועלת.
מיקום חדש להחלפת מצב אופליין של Gradle
כדי להפעיל או להשבית את מצב אופליין של Gradle, קודם בוחרים באפשרות View > חלונות של הכלים > Gradle בסרגל התפריטים. לאחר מכן, בחלק העליון של החלון Gradle, לוחצים על Toggle Offline Mode
.
IntelliJ IDEA 2019.2
סביבת הפיתוח המשולבת (IDE) המרכזית של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2019.2.
למידע נוסף על השיפורים מגרסאות אחרות של IntelliJ שנכללים באופן מצטבר בגרסה 2019.2, אפשר לעיין בדפים הבאים:
הצעות תוכן מהקהילה
תודה לכל חברי הקהילה שעזרו לנו לגלות באגים ודרכים אחרות לשפר את Android Studio 3.6. אנחנו רוצים להודות במיוחד לאנשים הבאים שדיווחו על באגים:
|
|
|
|
3.5 (אוגוסט 2019)
Android Studio 3.5 היא גרסה ראשית שנוצרה במסגרת Project Marble. החל מהגרסה Android Studio 3.3, יוזמת Project Marble התפרסה על פני כמה גרסאות שמתמקדות בשיפור שלושה תחומים עיקריים של סביבת הפיתוח המשולבת (IDE): תקינות המערכת, שיפור התכונות ותיקון באגים.
מידע נוסף על העדכונים האלה ועל עדכונים אחרים של Project Marble זמין בפוסט בבלוג של Android Developers או בקטעים הבאים.
אנחנו רוצים גם להודות לכל הצעות התוכן מהקהילה שעזרו לנו עם הגרסה הזו.
3.5.3 (דצמבר 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים.
3.5.2 (נובמבר 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
3.5.1 (אוקטובר 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
Project Marble: תקינות המערכת
בקטע הזה מתוארים השינויים ב-Android Studio 3.5 שמתמקדים בשיפור תקינות המערכת.
הגדרות מומלצות לזיכרון
עכשיו Android Studio מודיעה לכם אם היא מזהה שאפשר לשפר את הביצועים על ידי הגדלת הכמות המקסימלית של זיכרון RAM שמערכת ההפעלה צריכה להקצות לתהליכים של Android Studio, כמו הליבה של סביבת הפיתוח המשולבת (IDE), Gradle daemon ו-Kotlin daemon. אתם יכולים לאשר את ההגדרות המומלצות בלחיצה על קישור הפעולה שבהתראה, או לשנות את ההגדרות האלה באופן ידני: בוחרים באפשרות File > Settings (או Android Studio > Preferences ב-macOS), ואז מאתרים את הקטע Memory Settings בקטע Appearance & Behavior > System Settings. מידע נוסף זמין במאמר גודל הערימה המקסימלי.
התראה על הגדרות הזיכרון המומלצות.
דוח שימוש בזיכרון
לפעמים קשה לשחזר ולדווח על בעיות בזיכרון ב-Android Studio. כדי לפתור את הבעיה הזו, ב-Android Studio אפשר ליצור דוח שימוש בזיכרון. לשם כך, לוחצים על Help > Analyze Memory Usage בסרגל התפריטים. כשעושים את זה, סביבת הפיתוח המשולבת (IDE) מסירה באופן מקומי את המידע האישי מהנתונים, ואז שואלת אם אתם רוצים לשלוח אותם לצוות של Android Studio כדי לעזור בזיהוי המקור של בעיות הזיכרון. מידע נוסף זמין במאמר הפעלת דוח שימוש בזיכרון.
דוח שימוש בזיכרון.
Windows: אופטימיזציה של קלט/פלט (I/O) של קובצי אנטי-וירוס
עכשיו Android Studio בודק באופן אוטומטי אם ספריות מסוימות של פרויקטים מוחרגות מסריקת אנטי-וירוס בזמן אמת. אם אפשר לבצע שינויים כדי לשפר את ביצועי ה-build, תקבלו התראה מ-Android Studio עם הוראות לאופטימיזציה של הגדרות האנטי-וירוס. מידע נוסף זמין במאמר צמצום ההשפעה של תוכנת האנטי-וירוס על מהירות ה-build.
Project Marble: שיפור התכונות
בקטע הזה מתוארים השינויים ב-Android Studio 3.5 שמתמקדים בשיפור התכונות הקיימות.
החלת השינויים
התכונה Apply Changes מאפשרת להעביר שינויים בקוד ובמשאבים לאפליקציה שפועלת בלי להפעיל אותה מחדש, ובמקרים מסוימים בלי להפעיל מחדש את הפעילות הנוכחית. התכונה Apply Changes מיישמת גישה חדשה לגמרי לשמירת המצב של האפליקציה. בניגוד ל-Instant Run, שמשכתב את הבייטקוד של ה-APK, התכונה Apply Changes מגדירה מחדש את המחלקות תוך כדי תנועה, על ידי שימוש במכשור זמן הריצה שנתמך ב-Android 8.0 (רמת API 26) ומעלה.
מידע נוסף זמין במאמר בנושא החלת שינויים.
הלחצנים בסרגל הכלים של Apply Changes.
תהליך פריסת האפליקציה
ב-IDE יש תפריט נפתח חדש שמאפשר לבחור במהירות את המכשיר שבו רוצים לפרוס את האפליקציה. התפריט הזה כולל גם אפשרות חדשה שמאפשרת להפעיל את האפליקציה בכמה מכשירים בו-זמנית.
תפריט נפתח לבחירת מכשיר יעד.
שיפור בסנכרון של Gradle ובזיהוי המטמון
עכשיו סביבת הפיתוח המשולבת (IDE) מזהה טוב יותר מתי Gradle מנקה מדי פעם את המטמון של ה-build כדי לצמצם את צריכת הדיסק הקשיח. בגרסאות קודמות, המצב הזה גרם ל-IDE לדווח על יחסי תלות חסרים ולסנכרון של Gradle להיכשל. עכשיו, סביבת הפיתוח המשולבת פשוט מורידה יחסי תלות לפי הצורך כדי לוודא שהסנכרון של Gradle יושלם בהצלחה.
פלט משופר של שגיאות ב-Build
בחלון Build
יש עכשיו Error Reporting משופר, כמו קישור לקובץ ולשורה של השגיאה שדווחה, בתהליכי ה-build הבאים:
- הידור וקישור של AAPT
- R8 ו-ProGuard
- דקסינג
- מיזוג משאבים
- ניתוח קובץ XML
- קומפילציה של Javac, Kotlinc ו-CMake
שדרוגים של פרויקטים
חוויית עדכון משופרת שמספקת יותר מידע ופעולות שיעזרו לכם לעדכן את ה-IDE ואת הפלאגין של Android Gradle. לדוגמה, שגיאות נוספות בסנכרון וביצירה כוללות פעולות שיעזרו לכם לצמצם את השגיאות בזמן העדכון.
חשוב לזכור שאפשר לעדכן את ה-IDE בנפרד מרכיבים אחרים, כמו הפלאגין של Android Gradle. לכן, אפשר לעדכן את ה-IDE ברגע שגרסה חדשה יותר זמינה, ולעדכן רכיבים אחרים מאוחר יותר.
Layout Editor
ב-Android Studio 3.5 יש כמה שיפורים בתצוגה החזותית, בניהול ובאינטראקציה של הפריסה.
כשעובדים עם ConstraintLayout, בקטע Constraints החדש בחלונית Attributes מופיעים יחסי האילוצים של רכיב ממשק המשתמש שנבחר. אפשר לבחור אילוץ ממשטח העיצוב או מרשימת האילוצים כדי להדגיש את האילוץ בשני האזורים.
קשרי אילוצים של רכיב בממשק המשתמש שנבחר.
באופן דומה, עכשיו אפשר למחוק אילוץ על ידי בחירה שלו ולחיצה על המקש Delete. אפשר גם למחוק אילוץ על ידי לחיצה על המקש Control (Command ב-macOS) ולחיצה על עוגן האילוץ. שימו לב: כשלוחצים לחיצה ארוכה על המקש Control או Command ומעבירים את העכבר מעל עוגן, כל האילוצים שמשויכים אליו הופכים לאדומים כדי לציין שאפשר ללחוץ עליהם כדי למחוק אותם.
כשבוחרים תצוגה, אפשר ליצור אילוץ בלחיצה על כל אחד מסמלי ה-+ בקטע Constraint Widget בחלונית Attributes, כמו שמוצג בתמונה הבאה. כשיוצרים אילוץ חדש, עורך הפריסה בוחר ומדגיש את האילוץ, ומספק משוב חזותי מיידי על מה שהוספתם.
שימוש בווידג'ט האילוצים כדי ליצור אילוצים .
כשיוצרים אילוץ, ב-Layout Editor מוצגות עכשיו רק נקודות העיגון שאפשר להגדיר להן אילוץ. בעבר, Layout Editor הדגיש את כל נקודות העיגון בכל התצוגות, גם אם לא היה אפשר להגדיר להן אילוצים. בנוסף, שכבת-על כחולה מדגישה עכשיו את יעד האילוץ. ההדגשה הזו שימושית במיוחד כשמנסים להגביל לרכיב שחופף לרכיב אחר.
יצירת אילוץ לרכיב חופף ב-Android Studio 3.4.
יצירת אילוץ לרכיב חופף ב-Android Studio 3.5.
בנוסף לעדכונים שלמעלה, Android Studio 3.5 כולל גם את השיפורים הבאים ב-Layout Editor:
- הווידג'ט Constraint והתפריט הנפתח של שולי ברירת המחדל מאפשרים עכשיו להשתמש במשאבי מאפיינים לשוליים.
- בסרגל הכלים של Layout Editor, רשימת המכשירים שקובעים את הגודל של משטח העיצוב עודכנה. בנוסף, שיפרנו את ההתנהגות של ההצמדה בזמן שינוי הגודל, ונקודות האחיזה לשינוי הגודל במשטח העיצוב תמיד גלויות עכשיו. כשמשנים את הגודל, מופיעות שכבות-על חדשות שמציגות גדלים נפוצים של מכשירים.
- ל-Layout Editor יש ערכת צבעים חדשה שמשפרת את העקביות ומפחיתה את הניגודיות בין הרכיבים, הטקסט והאילוצים.
- מצב Blueprint כולל עכשיו תמיכה בטקסט לחלק מהרכיבים שבהם הטקסט לא הוצג.
מידע נוסף על השינויים האלה זמין במאמר Android Studio Project Marble: Layout Editor.
קישור נתונים
בנוסף להוספת תמיכה בעיבוד מצטבר של הערות לכריכת נתונים, סביבת הפיתוח המשולבת משפרת את התכונות והביצועים של העורך החכם כשיוצרים ביטויים של כריכת נתונים ב-XML.
ביצועי עורך הקוד ב-Android Studio 3.4.
שיפור הביצועים של עריכת הקוד ב-Android Studio 3.5.
תמיכה משופרת בפרויקטים של C/C++
Android Studio 3.5 כוללת כמה שינויים שמשפרים את התמיכה בפרויקטים ב-C וב-C++.
שיפורים בחלונית Build Variants לסנכרון של וריאנט יחיד
עכשיו אפשר לציין גם את וריאנט ה-build הפעיל וגם את ממשק ה-ABI הפעיל בחלונית Build Variants. התכונה הזו מפשטת את תצורת ה-build לכל מודול ויכולה גם לשפר את ביצועי הסנכרון של Gradle.
מידע נוסף זמין במאמר שינוי וריאנט ה-build.
החלונית Build Variants עם בחירה של וריאנט 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
למידע על החידושים בגרסה 3.5.0 של הפלאגין של Android Gradle, כמו תמיכה משופרת בעיבוד אנוטציות מצטבר ובבדיקות יחידה שניתנות לשמירה במטמון, קראו את נתוני הגרסה.
הצעות תוכן מהקהילה
תודה לכל חברי הקהילה שעזרו לנו לגלות באגים ודרכים אחרות לשפר את Android Studio 3.5. אנחנו רוצים להודות במיוחד לאנשים הבאים שדיווחו על באגים ברמות P0 ו-P1:
|
|
|
3.4 (אפריל 2019)
Android Studio 3.4 היא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
3.4.2 (יולי 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
3.4.1 (מאי 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
בעיות מוכרות בגרסה 3.4.0
הגדרת הפרופיל מושבתת כשפורסים את האפליקציה במכשיר עם גרסת בטא של Android Q.
- כשמשתמשים ב-Data Binding Library,
יכול להיות ש-
LiveDataListener.onChanged()ייכשל עם NPE. תיקון לבעיה הזו ייכלל ב-Android Studio 3.4.1, והוא כבר זמין בגרסת טרום-ההשקה (Preview) העדכנית של Android Studio 3.5. (בעיה מספר 122066788)
IntelliJ IDEA 2018.3.4
סביבת הפיתוח המשולבת (IDE) של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.3.4.
עדכונים לגרסה 3.4.0 של הפלאגין של Android Gradle
למידע על החידושים בגרסה 3.4.0 של הפלאגין של Android Gradle, קראו את נתוני הגרסה.
תיבת דו-שיח למבנה פרויקט חדש
תיבת הדו-שיח החדשה Project Structure Dialog (PSD) מאפשרת לעדכן בקלות יחסי תלות ולהגדיר היבטים שונים של הפרויקט, כמו מודולים, וריאנטים של build, הגדרות חתימה ומשתני build.
כדי לפתוח את ה-PSD, בוחרים באפשרות File > Project Structure (קובץ > מבנה הפרויקט) בסרגל התפריטים. אפשר גם לפתוח את ה-PSD על ידי לחיצה על Ctrl+Shift+Alt+S ב-Windows וב-Linux, או על Command+; (נקודה ופסיק) ב-macOS. בהמשך מופיעים תיאורים של כמה מהסעיפים החדשים והמעודכנים של ה-PSD.
משתנים
בקטע החדש של המשתנים ב-PSD אפשר ליצור ולנהל משתני build, כמו אלה ששומרים על עקביות של מספרי הגרסאות של יחסי התלות בפרויקט.

- אפשר לראות ולערוך במהירות משתני build שכבר קיימים בסקריפטים של ה-build ב-Gradle בפרויקט.
- אפשר להוסיף משתני build חדשים ברמת הפרויקט או המודול ישירות מתיבת הדו-שיח Project Structure.
הערה: אם קובצי תצורת ה-build הקיימים מקצים ערכים באמצעות סקריפטים מורכבים של Groovy, יכול להיות שלא תוכלו לערוך את הערכים האלה באמצעות ה-PSD. בנוסף, אי אפשר לערוך קובצי build שכתובים ב-Kotlin באמצעות ה-PSD.
מודולים
בקטע Modules אפשר להגדיר מאפיינים שחלים על כל וריאנט ה-build במודול קיים, או להוסיף מודולים חדשים לפרויקט. לדוגמה, כאן אפשר להגדיר מאפיינים של defaultConfig או לנהל הגדרות חתימה.
פניות קשורות
כדי לבדוק ולהציג כל תלות בתרשים התלויות של הפרויקט, כפי ש-Gradle פותר אותה במהלך סנכרון הפרויקט, פועלים לפי השלבים הבאים:
- בחלונית השמאלית של ה-PSD, בוחרים באפשרות Dependencies.
- בחלונית Modules, בוחרים מודול שרוצים לבדוק את יחסי התלות שנפתרו.
- בצד ימין של ה-PSD, פותחים את החלונית Resolved Dependencies, שמוצגת למטה.

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

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

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

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

- הצגת משאבים: אתם יכולים לראות תצוגה מקדימה של פריסות, צבעים ורכיבים שניתן להציג כדי למצוא במהירות את המשאבים שאתם צריכים.
- ייבוא בכמות גדולה: אפשר לייבא כמה פריטים גרפיים שניתנים להזזה בבת אחת. לשם כך, גוררים ומשחררים אותם בחלון של הכלי מנהל המשאבים או משתמשים באשף Import drawables. כדי לגשת לאשף, לוחצים על הכפתור (+) בפינה הימנית העליונה של חלון של הכלי, ואז בוחרים באפשרות Import Drawables בתפריט הנפתח.
-
המרת קובצי SVG לאובייקטים מסוג
VectorDrawable: אתם יכולים להשתמש באשף Import Drawables כדי להמיר את תמונות ה-SVG לאובייקטים מסוגVectorDrawable. - גרירה ושחרור של נכסים: בחלון של הכלי Resource Manager, אתם יכולים לגרור ולשחרר פריטים שניתנים להצגה גם בתצוגת העיצוב וגם בתצוגת ה-XML של Layout Editor.
- הצגת גרסאות חלופיות: עכשיו אפשר לראות גרסאות חלופיות של המשאבים בלחיצה כפולה על משאב בחלון Tool. בתצוגה הזו מופיעות הגרסאות השונות שיצרתם והמאפיינים שנכללו.
- תצוגת משבצות ותצוגת רשימה: אתם יכולים לשנות את התצוגה בחלון של הכלי כדי לראות את המשאבים בסידורים שונים.
מידע נוסף זמין במדריך בנושא ניהול משאבי אפליקציות.
בדיקת מזהי build במהלך יצירת פרופיל וניפוי באגים של קובצי APK
כשאתם מספקים קובצי סמלים לניפוי באגים לספריות המשותפות של .so ב-APK, מערכת Android Studio מוודאת שמזהה ה-build של קובצי הסמלים שסיפקתם תואם למזהה ה-build של הספריות של .so ב-APK.
אם אתם יוצרים את ספריות ה-Native ב-APK עם מזהה build, Android Studio בודק אם מזהה ה-build בקובצי הסמלים תואם למזהה ה-build בספריות ה-Native, ודוחה את קובצי הסמלים אם אין התאמה. אם לא בניתם עם מזהה build, ציון קובצי סמלים שגויים עלול לגרום לבעיות בניפוי באגים.
R8 מופעל כברירת מחדל
R8 משלב תהליך הסרה של סוכר תחבירי, כיווץ, ערפול קוד, אופטימיזציה ו-dexing בשלב אחד, וכך משפר באופן משמעותי את ביצועי ה-build. R8 הושק בפלאגין של Android Gradle בגרסה 3.3.0, ועכשיו הוא מופעל כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות Android שמשתמשים בפלאגין בגרסה 3.4.0 ואילך.
בתמונה הבאה מוצגת סקירה כללית של תהליך ההידור לפני שהוצג R8.

עכשיו, עם R8, תהליך הסרה של סוכר תחבירי, כיווץ, ערפול קוד (obfuscation), אופטימיזציה ו-dexing (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 של הפרויקט.
עכשיו Navigation Editor תומך בכל סוגי הארגומנטים
כל סוגי הארגומנטים שנתמכים ברכיב הניווט נתמכים עכשיו גם בעורך הניווט. מידע נוסף על הסוגים הנתמכים זמין במאמר העברת נתונים בין יעדים.
שיפורים בכלי לעריכת פריסות {:#layout-editor}
החלונית Attributes ב-Layout Editor עברה שינוי והפכה לדף אחד עם קטעים שאפשר להרחיב כדי לראות את המאפיינים שאפשר להגדיר. בחלונית Attributes יש גם את העדכונים הבאים:
- בקטע החדש Declared Attributes מפורטים המאפיינים שצוינו בקובץ הפריסה, ואפשר להוסיף מאפיינים חדשים במהירות.
- בחלונית Attributes יש עכשיו גם אינדיקטורים לצד כל מאפיין. הם מלאים אם הערך של המאפיין הוא הפניה למשאב, וריקים אם לא.
- מאפיינים עם שגיאות או אזהרות מודגשים עכשיו. הדגשות באדום מציינות שגיאות (לדוגמה, כשמשתמשים בערכי פריסה לא חוקיים) והדגשות בכתום מציינות אזהרות (לדוגמה, כשמשתמשים בערכים בתוך הקוד).
פעולת כוונה חדשה לייבוא מהיר של יחסי תלות
אם תתחילו להשתמש במחלקות מסוימות של Jetpack ו-Firebase בקוד, פעולת כוונה חדשה תציע להוסיף לפרויקט את התלות הנדרשת בספריית Gradle, אם עדיין לא עשיתם זאת. לדוגמה, אם אתם מפנים למחלקה WorkManager בלי לייבא קודם את התלות הנדרשת android.arch.work:work-runtime, פעולת כוונה תאפשר לכם לעשות זאת בקלות בלחיצה אחת, כפי שמוצג בהמשך.

במיוחד, מכיוון ש-Jetpack ארזה מחדש את ספריית התמיכה בחבילות נפרדות שקל יותר לנהל ולעדכן, פעולת הכוונה הזו עוזרת לכם להוסיף במהירות רק את יחסי התלות שאתם צריכים לרכיבי Jetpack שבהם אתם רוצים להשתמש.
3.3 (ינואר 2019)
Android Studio 3.3 הוא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
3.3.2 (מרץ 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים בולטים, קראו את הפוסט הקשור בבלוג של עדכוני הגרסאות.
3.3.1 (פברואר 2019)
העדכון הקטן הזה כולל תיקוני באגים שונים ושיפורי ביצועים.
IntelliJ IDEA 2018.2.2
סביבת הפיתוח המשולבת (IDE) המרכזית של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.2.2.
עדכונים לפלאגין של Android Gradle
למידע על החידושים בפלאגין של Android Gradle, קראו את נתוני הגרסה שלו.
עורך הניווט
בעזרת Navigation Editor אפשר להמחיש במהירות את הניווט באפליקציה וליצור אותו באמצעות רכיב ארכיטקטורת הניווט.

מידע נוסף זמין במאמר הטמעת ניווט באמצעות רכיב ארכיטקטורת הניווט.
מחיקת ספריות של Android Studio שלא בשימוש
כשמפעילים גרסה ראשית של Android Studio בפעם הראשונה, המערכת מחפשת ספריות שמכילות מטמונים, הגדרות, אינדקסים ויומנים של גרסאות של Android Studio שלא נמצאה להן התקנה תואמת. בתיבת הדו-שיח Delete Unused Android Studio Directories מוצגים המיקומים, הגדלים והמועדים האחרונים שבהם בוצעו שינויים בספריות האלה, ואפשר למחוק אותן.
הספריות ש-Android Studio שוקל למחוק מפורטות בהמשך:
- Linux:
~/.AndroidStudio[Preview]X.Y - Mac:
~/Library/{Preferences, Caches, Logs, Application Support}/AndroidStudio[Preview]X.Y - ב-Windows:
%USER%.AndroidStudio[Preview]X.Y

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

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

בתפריט הנפתח Allocation Tracking, אפשר לבחור מבין המצבים הבאים:
-
מלא: מתעד את כל הקצאות הזיכרון של האובייקטים. שימו לב שאם יש לכם אפליקציה שמקצה הרבה אובייקטים, יכול להיות שתראו בעיות משמעותיות בביצועים בזמן יצירת הפרופיל.
-
דגימה: דגימה תקופתית של הקצאות זיכרון לאובייקטים. זוהי התנהגות ברירת המחדל, והיא משפיעה פחות על ביצועי האפליקציה בזמן יצירת הפרופיל. יכול להיות שתיתקלו בבעיות בביצועים באפליקציות שמקצות הרבה אובייקטים בפרק זמן קצר.
-
מושבת: משבית את הקצאת הזיכרון. אם המצב הזה לא נבחר, הוא מופעל באופן אוטומטי בזמן הקלטת המעבד (CPU) וחוזר להגדרה הקודמת כשההקלטה מסתיימת. אפשר לשנות את ההתנהגות הזו בתיבת הדו-שיח של הגדרות ההקלטה של המעבד.
המעקב משפיע גם על אובייקטים של Java וגם על הפניות JNI.
בדיקת נתוני רינדור הפריימים
ב-CPU Profiler, עכשיו אתם יכולים לבדוק כמה זמן לוקח לאפליקציית Java לעבד כל פריים בשרשור ה-UI הראשי וב-RenderThread. הנתונים האלה יכולים לעזור לכם לחקור צווארי בקבוק שגורמים לבעיות בביצועים של ממשק המשתמש ולקצב פריימים נמוך. לדוגמה, כל פריים שעיבוד התמונה שלו נמשך יותר מ-16 אלפיות השנייה, שזה הזמן שנדרש כדי לשמור על קצב פריימים חלק, מוצג באדום.
כדי לראות את נתוני הרינדור של הפריימים, מתעדים את נתוני המעקב באמצעות הגדרה שמאפשרת לעקוב אחרי קריאות למערכת. אחרי הקלטת המעקב, מחפשים מידע על כל פריים לאורך ציר הזמן של ההקלטה בקטע שנקרא FRAMES, כמו שמוצג בהמשך.

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

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

מידע נוסף זמין במאמר בדיקת התנועה ברשת באמצעות הכלי לניתוח הרשת.
הורדה אוטומטית של רכיבי SDK
כשהפרויקט שלכם צריך רכיב SDK מפלטפורמות ה-SDK, מ-NDK או מ-CMake, עכשיו Gradle מנסה להוריד באופן אוטומטי את החבילות הנדרשות, כל עוד אישרתם בעבר את כל הסכמי הרישיון הקשורים באמצעות SDK Manager.
מידע נוסף זמין במאמר הורדה אוטומטית של חבילות חסרות באמצעות Gradle.
תמיכה ב-Clang-Tidy
עכשיו Android Studio כולל תמיכה בניתוח קוד סטטי באמצעות Clang-Tidy לפרויקטים שכוללים קוד Native. כדי להפעיל תמיכה ב-Clang-Tidy, צריך לעדכן את ה-NDK לגרסה r18 ואילך.
כדי להפעיל או להפעיל מחדש את הבדיקות, פותחים את תיבת הדו-שיח Settings או Preferences ועוברים אל Editor > Inspections > C/C++ > General > Clang-Tidy. כשבוחרים את הבדיקה הזו בתיבת הדו-שיח Settings או Preferences, אפשר גם לראות את רשימת הבדיקות של Clang-Tidy שמופעלות ומושבתות בקטע Option בחלונית הימנית ביותר. כדי להפעיל בדיקות נוספות, מוסיפים אותן לרשימה ולוחצים על אישור.
כדי להגדיר את Clang-Tidy עם אפשרויות נוספות, לוחצים על Configure Clang-Tidy Checks Options ומוסיפים אותן בתיבת הדו-שיח שנפתחת.
הסרת אפשרויות להתאמה אישית של C++
האפשרויות הבאות הוסרו מתיבת הדו-שיח Customize C++ Support:
- תמיכה בחריגים (-fexceptions)
- תמיכה במידע על סוגי נתונים בזמן ריצה (-ftti)
ההתנהגויות המתאימות מופעלות בכל הפרויקטים שנוצרים באמצעות Android Studio.
CMake בגרסה 3.10.2
גרסה 3.10.2 של CMake כלולה עכשיו ב-SDK Manager. שימו לב ש-Gradle עדיין משתמש בגרסה 3.6.0 כברירת מחדל.
כדי לציין גרסת CMake שבה Gradle ישתמש, מוסיפים את מה שמופיע כאן למטה לקובץ build.gradle של המודול:
android {
...
externalNativeBuild {
cmake {
...
version "3.10.2"
}
}
}
מידע נוסף על הגדרת CMake ב-build.gradle זמין במאמר הגדרה ידנית של Gradle.
תחביר חדש של "+" לציון גרסאות CMake מינימליות
כשמציינים גרסה של CMake בקובץ build.gradle של המודול הראשי, אפשר עכשיו להוסיף "+" כדי להתאים את ההתנהגות של הפקודה cmake_minimum_required() של CMake.
זהירות: לא מומלץ להשתמש בתחביר "+" עם יחסי תלות אחרים של build, כי יחסי תלות דינמיים יכולים לגרום לעדכוני גרסאות לא צפויים ולקושי בפתרון הבדלים בין גרסאות.
קובצי Android App Bundle תומכים עכשיו באפליקציות ללא התקנה
עכשיו אפשר ליצור ב-Android Studio קובצי Android App Bundle עם תמיכה מלאה ב-Google Play ללא התקנה. במילים אחרות, עכשיו אפשר לפתח ולפרוס גם אפליקציות להתקנה וגם אפליקציות ללא התקנה מפרויקט אחד ב-Android Studio, ולכלול אותן בקובץ Android App Bundle אחד.
אם אתם יוצרים פרויקט חדש ב-Android Studio באמצעות תיבת הדו-שיח Create New Project (יצירת פרויקט חדש), הקפידו לסמן את התיבה לצד Configure your project > This project will support instant apps (הגדרת הפרויקט > הפרויקט הזה יתמוך באפליקציות ללא התקנה). לאחר מכן, Android Studio יוצר פרויקט חדש של אפליקציה כרגיל, אבל כולל את המאפיינים הבאים במניפסט כדי להוסיף תמיכה באפליקציה ללא התקנה למודול הבסיס של האפליקציה:
<manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
<dist:module dist:instant="true" />
...
</manifest>
אחר כך אפשר ליצור מודול של תכונות בגרסה ללא התקנה. כדי לעשות את זה, בוחרים באפשרות קובץ > חדש > מודול חדש בסרגל התפריטים, ואז בוחרים באפשרות מודול של תכונות דינמיות בגרסה ללא התקנה בתיבת הדו-שיח יצירת מודול חדש. חשוב לזכור שיצירת המודול הזה גם הופכת את מודול הבסיס של האפליקציה לגרסה ללא התקנה.
כדי לפרוס את האפליקציה במכשיר מקומי כחוויה מיידית, עורכים את הגדרות ההפעלה ומסמנים את התיבה לצד כללי > פריסה כאפליקציה ללא התקנה.
סנכרון פרויקט עם וריאנט יחיד
סנכרון הפרויקט עם תצורת ה-build הוא שלב חשוב שמאפשר ל-Android Studio להבין את מבנה הפרויקט. עם זאת, התהליך הזה יכול להימשך זמן רב בפרויקטים גדולים. אם בפרויקט שלכם יש כמה וריאנטים של build, אתם יכולים עכשיו לבצע אופטימיזציה של סנכרוני הפרויקט על ידי הגבלתם רק לווריאנט build שבחרתם כרגע.
כדי להפעיל את האופטימיזציה הזו, צריך להשתמש ב-Android Studio מגרסה 3.3 ואילך עם הפלאגין של Android Gradle מגרסה 3.3.0 ואילך. אם אתם עומדים בדרישות האלה, סביבת הפיתוח המשולבת תבקש מכם להפעיל את האופטימיזציה הזו כשתסנכרנו את הפרויקט. האופטימיזציה מופעלת כברירת מחדל גם בפרויקטים חדשים.
כדי להפעיל את האופטימיזציה הזו באופן ידני, לוחצים על File > Settings > Experimental > Gradle (Android Studio > Preferences > Experimental > Gradle ב-Mac) ומסמנים את התיבה Only sync the active variant.
הערה: האופטימיזציה הזו תומכת כרגע בפרויקטים שכוללים רק את שפת התכנות Java. לדוגמה, אם סביבת הפיתוח המשולבת מזהה קוד Kotlin או C++ בפרויקט, היא לא מפעילה את האופטימיזציה הזו באופן אוטומטי, ואתם לא צריכים להפעיל אותה באופן ידני.
מידע נוסף זמין במאמר הפעלת סנכרון של פרויקט עם וריאנט יחיד.
שליחת משוב מהיר
אם בחרתם לשתף נתוני שימוש כדי לעזור לשפר את Android Studio, תראו את שני הסמלים החדשים האלה בשורת הסטטוס בתחתית החלון של ה-IDE:
פשוט לוחצים על הסמל שהכי מתאים לחוויה הנוכחית שלכם עם סביבת הפיתוח המשולבת. כשאתם עושים את זה, סביבת הפיתוח המשולבת שולחת נתוני שימוש שמאפשרים לצוות של Android Studio להבין טוב יותר את דעתכם. במקרים מסוימים, למשל אם תציינו חוויה שלילית עם סביבת הפיתוח, תוכלו לשלוח משוב נוסף.
אם עדיין לא עשיתם את זה, אתם יכולים להפעיל את שיתוף נתוני השימוש: פותחים את תיבת הדו-שיח Settings (ב-Mac, Preferences), עוברים אל Appearance & Behavior > System Settings > Data Sharing ומסמנים את האפשרות Send usage statistics to Google.
3.2 (ספטמבר 2018)
Android Studio 3.2 הוא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
3.2.1 (אוקטובר 2018)
העדכון הזה ל-Android Studio 3.2 כולל את השינויים והתיקונים הבאים:
- גרסת Kotlin המצורפת היא עכשיו 1.2.71.
- גרסת ברירת המחדל של כלי ה-build היא עכשיו 28.0.3.
- בספריית הניווט, שמות סוגי הארגומנטים השתנו מ-
typeל-argType. - הבאגים הבאים תוקנו:
- כשמשתמשים בספריית Data Binding, שמות של משתנים עם קווים תחתונים גרמו לשגיאות קומפילציה.
- CMake גרם לכשל ב-IntelliSense ובתכונות אחרות של CLion.
- הוספת
SliceProviderגרמה לשגיאות קומפילציה בפרויקטים שלא השתמשו בספריותandroidx.*. - חלק מבדיקות היחידה של Kotlin לא הופעלו.
- בעיה בקישור הנתונים גרמה ל-
PsiInvalidElementAccessException. - רכיבי
<merge>גרמו לפעמים לקריסה של Layout Editor.
בעיות מוכרות בגרסה 3.2.0
הערה: הבעיות האלה נפתרו ב-Android Studio מגרסה 3.2.1 ואילך.
אנחנו ממליצים מאוד לא להשתמש ב-Kotlin בגרסה 1.2.70.
גרסה 1.2.61 של Kotlin מתקנת באג שעלול לגרום ל-Android Studio להיתקע, אבל גרסה 1.2.70 של Kotlin לא כוללת את התיקון הזה.
עם זאת, גרסאות Kotlin 1.2.71 ואילך כוללות את התיקון הזה.
-
בדרך כלל לא צריך לציין את גרסת כלי ה-build, אבל כשמשתמשים בפלאגין של Android Gradle בגרסה 3.2.0 עם
renderscriptSupportModeEnabledשמוגדר ל-true, צריך לכלול את הקוד הבא בקובץbuild.gradleשל כל מודול:android.buildToolsVersion "28.0.3"
What's New Assistant
עוזר אישי חדש מעדכן אתכם לגבי השינויים האחרונים ב-Android Studio.
העוזר הדיגיטלי נפתח כשמפעילים את Android Studio אחרי התקנה חדשה או עדכון, אם הוא מזהה שיש מידע חדש להציג. אפשר גם לפתוח את Assistant על ידי בחירה באפשרות Help > What's new in Android Studio (עזרה > מה חדש ב-Android Studio).
Android Jetpack
Android Jetpack עוזר להאיץ את הפיתוח ל-Android באמצעות רכיבים, כלים והנחיות שמבטלים משימות שחוזרות על עצמן ומאפשרים לכם ליצור במהירות ובקלות אפליקציות איכותיות שניתן לבדוק. Android Studio כולל את העדכונים הבאים לתמיכה ב-Jetpack. מידע נוסף זמין במסמכי התיעוד של Jetpack.
עורך הניווט
עורך הניווט החדש משתלב עם רכיבי הניווט של Android Jetpack כדי לספק תצוגה גרפית ליצירת מבנה הניווט של האפליקציה. עורך הניווט מפשט את העיצוב וההטמעה של הניווט בין יעדים בתוך האפליקציה.
ב-Android Studio 3.2, עורך הניווט הוא תכונה ניסיונית. כדי להפעיל את Navigation Editor, לוחצים על File > Settings (Android Studio > Preferences ב-Mac), בוחרים בקטגוריה Experimental בחלונית הימנית, מסמנים את התיבה לצד Enable Navigation Editor ומפעילים מחדש את Android Studio.
מידע נוסף זמין במסמכי התיעוד של Navigation Editor.
העברה ל-AndroidX
כחלק מ-Jetpack, אנחנו מעבירים את ספריות התמיכה של Android לספריית תוספים חדשה של Android באמצעות מרחב השמות androidx. מידע נוסף זמין בסקירה הכללית על AndroidX.
ב-Android Studio 3.2 יש תכונת העברה חדשה שעוזרת בתהליך הזה.
כדי להעביר פרויקט קיים ל-AndroidX, בוחרים באפשרות Refactor > Migrate to AndroidX. אם יש לכם יחסי תלות של Maven שלא הועברו למרחב השמות של AndroidX, מערכת ה-build של Android Studio גם ממירה באופן אוטומטי את יחסי התלות האלה של הפרויקט.
הפלאגין של Android Gradle מספק את הדגלים הגלובליים הבאים שאפשר להגדיר בקובץ gradle.properties:
-
android.useAndroidX: כשהערך של הדגל הזה מוגדר כ-true, זה מציין שאתם רוצים להתחיל להשתמש ב-AndroidX מעכשיו והלאה. אם הדגל לא קיים, Android Studio פועל כאילו הדגל מוגדר כ-false. -
android.enableJetifier: כשהערך של הדגל הזה מוגדר כ-true, זה מציין שאתם רוצים לקבל תמיכה בכלים (מהפלאגין של Android Gradle) כדי להמיר באופן אוטומטי ספריות קיימות של צד שלישי כאילו הן נכתבו ל-AndroidX. אם הדגל לא קיים, Android Studio פועל כאילו הדגל מוגדר כ-false.
שני הדגלים מוגדרים כ-true כשמשתמשים בפקודה Migrate to AndroidX.
אם אתם רוצים להתחיל להשתמש בספריות AndroidX באופן מיידי ואין לכם צורך להמיר ספריות קיימות של צד שלישי, אתם יכולים להגדיר את הדגל android.useAndroidX לערך true ואת הדגל android.enableJetifier לערך false.
קובץ Android App Bundle
קובץ Android App Bundle הוא פורמט העלאה חדש שכולל את כל הקוד והמשאבים המקומפלים של האפליקציה, אבל דוחה את היצירה והחתימה של ה-APK לחנות Google Play.
מודל הצגת האפליקציות החדש של Google Play משתמש ב-App Bundle כדי ליצור ולהציג חבילות APK שעברו אופטימיזציה לתצורת המכשיר של כל משתמש. כך כל משתמש מוריד רק את הקוד והמשאבים שנדרשים כדי להפעיל את האפליקציה. לא צריך יותר ליצור, לחתום ולנהל כמה חבילות APK, והמשתמשים מקבלים הורדות קטנות יותר שעברו אופטימיזציה.
בנוסף, אתם יכולים להוסיף מודולים של תכונות לפרויקט של האפליקציה ולכלול אותם ב-App Bundle. לאחר מכן, המשתמשים יוכלו להוריד ולהתקין את התכונות של האפליקציה לפי דרישה.
כדי ליצור חבילה, בוחרים באפשרות Build > Build Bundle(s) / APK(s) > Build Bundle(s) (יצירה > יצירת חבילות / קובצי APK > יצירת חבילות).
מידע נוסף, כולל הוראות ליצירה ולניתוח של קובץ Android App Bundle, זמין במאמר Android App Bundle.
נתונים לדוגמה ב-Layout Editor
בהרבה פריסות ב-Android יש נתונים בזמן ריצה, שיכולים להקשות על ההמחשה של המראה והתחושה של הפריסה בשלב העיצוב של פיתוח האפליקציה. עכשיו
אפשר לראות בקלות תצוגה מקדימה של התצוגה ב-Layout Editor, שמלאה
בנתונים לדוגמה. כשמוסיפים תצוגה, מופיע לחצן
מתחת לתצוגה בחלון Design. לוחצים על הלחצן הזה כדי להגדיר את מאפייני התצוגה בזמן העיצוב. אתם יכולים לבחור מתוך מגוון תבניות של נתונים לדוגמה, ולציין את מספר הפריטים לדוגמה שיוצגו בתצוגה.
כדי לנסות להשתמש בנתונים לדוגמה, מוסיפים
RecyclerView
לפריסה חדשה, לוחצים על הלחצן של מאפייני זמן העיצוב
מתחת לתצוגה, ובוחרים אפשרות מקרוסלת התבניות של הנתונים לדוגמה.
פרוסות
Slices מספקים דרך חדשה להטמיע חלקים מהפונקציונליות של האפליקציה בממשקי משתמש אחרים ב-Android. לדוגמה, Slices מאפשרים להציג תכונות האפליקציה ותוכן בהצעות חיפוש של חיפוש Google.
ב-Android Studio 3.2 יש תבנית מובנית שעוזרת להרחיב את האפליקציה באמצעות ממשקי ה-API החדשים של Slice Provider, וגם בדיקות חדשות של איתור שגיאות בקוד (lint) כדי לוודא שאתם פועלים לפי השיטות המומלצות כשאתם יוצרים את הסלייסים.
כדי להתחיל, לוחצים לחיצה ימנית על תיקיית הפרויקט ובוחרים באפשרות New > Other > Slice Provider.
כדי לקבל מידע נוסף, כולל איך לבדוק את האינטראקציות שלכם עם Slices, קראו את המדריך לתחילת העבודה עם Slices.
Kotlin בגרסה 1.2.61
Android Studio 3.2 כולל את Kotlin 1.2.61, וה-Android SDK החדש משתלב טוב יותר עם Kotlin. מידע נוסף זמין בבלוג למפתחי Android.
IntelliJ IDEA 2018.1.6
סביבת הפיתוח המשולבת (IDE) המרכזית של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2018.1.6.
כלי הפרופיילינג של Android
נסו את התכונות החדשות הבאות של Android Profiler ב-Android Studio 3.2.
פעילויות באתר
עכשיו אפשר לשמור את נתוני הכלי ליצירת פרופילים כסשנים כדי לחזור אליהם ולבדוק אותם מאוחר יותר. הכלי לניתוח ביצועים שומר את נתוני הסשן עד שמפעילים מחדש את ה-IDE.
כשמתעדים method או מצלמים תמונת מצב של הזיכרון, סביבת הפיתוח המשולבת מוסיפה את הנתונים האלה (יחד עם הפעילות ברשת של האפליקציה) כרשומה נפרדת לסשן הנוכחי, ואפשר לעבור בקלות בין ההקלטות כדי להשוות בין הנתונים.
איסוף עקבות המערכת
ב-CPU Profiler, בוחרים את ההגדרה החדשה של עקבות המערכת כדי לבדוק את פעילות ה-CPU והשרשורים במערכת של המכשיר. הגדרת המעקב הזו מבוססת על
systrace
והיא שימושית לבדיקת בעיות ברמת המערכת, כמו בעיות בממשק המשתמש.
כשמשתמשים בהגדרת המעקב הזו, אפשר לסמן באופן חזותי שגרות קוד חשובות בציר הזמן של כלי הניתוח. לשם כך, צריך להוסיף לקוד C/C++ את ממשק ה-API המקורי למעקב או להוסיף לקוד Java את המחלקה Trace.
בדיקת הפניות JNI ב-Memory Profiler
אם פורסים את האפליקציה במכשיר עם Android 8.0 (רמת API 26) ומעלה, אפשר עכשיו לבדוק את הקצאות הזיכרון לקוד JNI של האפליקציה באמצעות Memory Profiler.
בזמן שהאפליקציה פועלת, בוחרים חלק מציר הזמן שרוצים לבדוק ובוחרים באפשרות JNI heap בתפריט הנפתח שמעל רשימת המחלקות, כמו שמוצג בהמשך. לאחר מכן, אפשר לבדוק אובייקטים בערימה כרגיל וללחוץ לחיצה כפולה על אובייקטים בכרטיסייה Allocation Call Stack כדי לראות איפה ההפניות ל-JNI מוקצות ומשוחררות בקוד.
ייבוא, ייצוא ובדיקה של קובצי תמונת מצב של הזיכרון
עכשיו אפשר לייבא, לייצא ולבדוק קובצי תמונת מצב של הזיכרון (heap dump) ב-.hprof שנוצרו באמצעות Memory Profiler.
מייבאים את הקובץ .hprof: לוחצים על Start new profiler session
בחלונית Sessions של ה-profiler ובוחרים באפשרות Load from file. אחר כך אפשר לבדוק את הנתונים שלו ב-Memory Profiler, כמו כל תמונת מצב אחרת של הזיכרון.
כדי לשמור את הנתונים של תמונת המצב של הזיכרון ולבדוק אותם מאוחר יותר, לוחצים על הכפתור ייצוא של תמונת המצב של הזיכרון משמאל לרשומה תמונת המצב של הזיכרון בחלונית סשנים. בתיבת הדו-שיח Export As שמופיעה, שומרים את הקובץ עם הסיומת .hprof.
תיעוד פעילות המעבד (CPU) בזמן הפעלת האפליקציה
עכשיו אפשר לתעד את פעילות המעבד (CPU) במהלך הפעלת האפליקציה, באופן הבא:
- בתפריט הראשי, לוחצים על Run > Edit Configurations.
- בכרטיסייה Profiling של הגדרת ההרצה הרצויה, מסמנים את התיבה לצד Start recording a method trace on startup.
- בתפריט הנפתח, בוחרים את ההגדרה של הקלטת המעבד (CPU) שבה רוצים להשתמש.
- פורסים את האפליקציה במכשיר עם Android 8.0 (רמת API 26) ומעלה על ידי בחירה באפשרות Run > Profile.
ייצוא של מעקבי מעבד (CPU)
אחרי שמתעדים את פעילות המעבד (CPU) באמצעות CPU Profiler, אפשר לייצא את הנתונים כקובץ .trace כדי לשתף אותם עם אחרים או לבדוק אותם מאוחר יותר.
כדי לייצא מעקב אחרי שתיעדתם את פעילות המעבד (CPU):
- לוחצים לחיצה ימנית על ההקלטה שרוצים לייצא מציר הזמן של המעבד.
- בתפריט הנפתח, בוחרים באפשרות ייצוא המעקב.
- עוברים למיקום שבו רוצים לשמור את הקובץ ולוחצים על שמירה.
ייבוא ובדיקה של קובצי מעקב של המעבד (CPU)
עכשיו אפשר לייבא ולבדוק קובצי .trace שנוצרו באמצעות Debug API או CPU Profiler. (כרגע אי אפשר לייבא הקלטות של עקבות המערכת).
מייבאים את קובץ פרטי ההעברה בלחיצה על Start new profiler session
בחלונית Sessions של כלי הניתוח, ואז בוחרים באפשרות Load from file. לאחר מכן תוכלו לבדוק את הנתונים שלו ב-CPU Profiler בדומה לאופן שבו אתם עושים זאת בדרך כלל, עם החריגים הבאים:
- פעילות המעבד (CPU) לא מיוצגת בציר הזמן של המעבד (CPU).
- ציר הזמן של פעילות השרשור מציין רק איפה נתוני המעקב זמינים לכל שרשור, ולא את המצבים בפועל של השרשור (כמו פועל, בהמתנה או במצב שינה).
תיעוד פעילות המעבד (CPU) באמצעות Debug API
עכשיו אפשר להתחיל ולהפסיק את ההקלטה של פעילות ה-CPU ב-CPU Profiler על ידי הוספת Debug API לאפליקציה. אחרי שפורסים את האפליקציה במכשיר, כלי הניתוח מתחיל באופן אוטומטי לתעד את פעילות המעבד (CPU) כשהאפליקציה קוראת ל-startMethodTracing(String tracePath), ומפסיק לתעד כשהאפליקציה קוראת ל-stopMethodTracing(). בזמן תיעוד פעילות ה-CPU שמופעלת באמצעות ה-API הזה, ב-CPU Profiler מוצגת האפשרות Debug API בתור הגדרת התיעוד של ה-CPU שנבחרה.
Energy Profiler
ב-Energy Profiler מוצגת המחשה חזותית של צריכת האנרגיה המשוערת של האפליקציה, וגם אירועי מערכת שמשפיעים על צריכת האנרגיה, כמו נעילות מצב פעולה, התראות ומשימות.
ה-Energy Profiler מופיע כשורה חדשה בתחתית החלון Profiler כשמפעילים את האפליקציה במכשיר מחובר או באמולטור Android עם Android מגרסה 8.0 (API 26) ומעלה.
לוחצים על השורה Energy כדי להגדיל את התצוגה של Energy Profiler. מציבים את סמן העכבר מעל עמודה בציר הזמן כדי לראות פירוט של צריכת האנרגיה לפי משאבי מעבד, רשת ומיקום (GPS), וגם אירועי מערכת רלוונטיים.
אירועי מערכת שמשפיעים על צריכת האנרגיה מצוינים בציר הזמן System, מתחת לציר הזמן Energy. כשבוחרים טווח תאריכים בציר הזמן Energy, הפרטים של אירועי המערכת בטווח התאריכים שצוין מוצגים בחלונית האירועים.
כדי לראות את סטאק הביצוע ופרטים אחרים של אירוע מערכת, כמו wakelock, בוחרים אותו בחלונית האירועים. כדי לעבור לקוד שאחראי לאירוע מערכת, לוחצים לחיצה כפולה על הרשומה בסטאק הביצוע.
בדיקת Lint
גרסה 3.2 של Android Studio כוללת הרבה תכונות חדשות ומשופרות לבדיקת lint.
בדיקות ה-lint החדשות עוזרות לכם למצוא ולזהות בעיות נפוצות בקוד, החל מאזהרות לגבי בעיות פוטנציאליות בשימושיות ועד לשגיאות בעדיפות גבוהה לגבי נקודות חולשה פוטנציאליות באבטחה.
בדיקות Lint ליכולת פעולה הדדית של Java/Kotlin
כדי לוודא שקוד ה-Java פועל היטב עם קוד ה-Kotlin, בדיקות Lint חדשות אוכפות את השיטות המומלצות שמתוארות במדריך ליכולת פעולה הדדית של Kotlin. דוגמאות לבדיקות האלה כוללות חיפוש של הערות Nullability, שימוש במילות מפתח קשיחות של Kotlin והצבת פרמטרים של lambda בסוף.
כדי להפעיל את הבדיקות האלה, לוחצים על File > Settings (Android Studio > Preferences ב-Mac) כדי לפתוח את תיבת הדו-שיח Settings, עוברים לקטע Editor > Inspections > Android > Lint > Interoperability > Kotlin Interoperability ובוחרים את הכללים שרוצים להפעיל.
כדי להפעיל את הבדיקות האלה לגרסאות build של שורת הפקודה, מוסיפים את מה שמופיע כאן למטה לקובץ build.gradle:
android {
lintOptions {
check 'Interoperability'
}
}
בדיקות Lint ל-Slices
בדיקות חדשות של Lint לפרוסות עוזרות לוודא שאתם יוצרים פרוסות בצורה נכונה. לדוגמה, בדיקות Lint מזהירות אתכם אם לא הקציתם פעולה ראשית ל-Slice.
יעד Gradle חדש
משתמשים במשימת Gradle החדשה lintFix כדי להחיל את כל ההצעות לתיקון הבטוחות שהוצעו בבדיקת ה-lint ישירות על קוד המקור. דוגמה לבדיקת איתור שגיאות בקוד שמציעה תיקון בטוח ליישום היא SyntheticAccessor.
עדכוני מטא-נתונים
עדכנו מטא-נתונים שונים, כמו בדיקת ההמרה של השירות, כדי שבדיקות ה-lint יפעלו עם Android 9 (רמת API 28).
אזהרה אם מריצים בדיקת איתור שגיאות בקוד (lint) על וריאנט חדש
עכשיו Lint מתעד את הגרסה והווריאנט שבהם מתועד ערך הבסיס, ומזהיר אתכם אם אתם מריצים אותו על וריאנט שונה מזה שבו נוצר ערך הבסיס.
שיפורים בבדיקות ה-lint הקיימות
גרסה 3.2 של Android Studio כוללת שיפורים רבים לבדיקות ה-lint הקיימות. לדוגמה, בדיקות מחזור המשאבים חלות עכשיו על סוגי משאבים נוספים, וגלאי התרגום יכול למצוא תרגומים חסרים תוך כדי עבודה, בתוך העורך.
מזהי בעיות שקל יותר למצוא
מזהי הבעיות מוצגים עכשיו במקומות נוספים, כולל בחלון Inspection Results. כך קל יותר למצוא את המידע שצריך כדי להפעיל או להשבית בדיקות ספציפיות באמצעות lintOptions ב-build.gradle.
מידע נוסף זמין במאמר הגדרת אפשרויות של Lint באמצעות Gradle.
Data Binding V2
Data Binding V2 מופעל עכשיו כברירת מחדל ותואם לגרסה 1. כלומר, אם יש לכם תלויות של הפרויקט בספרייה שקימפלתם באמצעות גרסה 1, אתם יכולים להשתמש בהן בפרויקטים שמשתמשים ב-Data Binding בגרסה 2. עם זאת, שימו לב שבפרויקטים שמשתמשים בגרסה 1 אי אפשר להשתמש ביחסי תלות שקומפלו באמצעות גרסה 2.
הסרה של סוכר תחבירי ב-D8
ב-Android Studio 3.1, שילבנו את שלב הסרת הסוכר התחבירי בכלי D8 כתכונה ניסיונית, וכך צמצמנו את זמן ה-build הכולל. ב-Android Studio 3.2, תהליך הסרת הסוכר התחבירי באמצעות D8 מופעל כברירת מחדל.
כלי חדש לכיווץ קוד
R8 הוא כלי חדש לצמצום קוד ולערפול קוד שמחליף את 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 ב-CMake, כמו:
- הדגשת תחביר והשלמת קוד: סביבת הפיתוח המשולבת (IDE) מדגישה עכשיו פקודות CMake נפוצות ומציעה השלמת קוד בשבילן. אפשר גם לעבור לקובץ בלחיצה עליו תוך כדי לחיצה על מקש Control (או Command ב-Mac).
- עיצוב מחדש של קוד: עכשיו אתם יכולים להשתמש באפשרות של IntelliJ לעיצוב מחדש של קוד כדי להחיל סגנונות קוד על סקריפטים של גרסאות build ב-CMake.
- שכתוב קוד בטוח: הכלים המובנים לשכתוב קוד ב-IDE בודקים עכשיו גם אם משנים את השם של קבצים או מוחקים קבצים שמפנים אליהם בסקריפטים של ה-build ב-CMake.
ניווט בקובצי כותרת חיצוניים
בגרסאות קודמות של Android Studio, כשמשתמשים בחלון Project, אפשר לנווט רק בקובצי הכותרת ששייכים לספריות שנוצרו מפרויקט מקומי, ולבדוק רק אותם. בגרסה הזו אפשר גם להציג ולבדוק קובצי כותרת שנכללים ביחסי תלות חיצוניים של ספריית C/C++ שמייבאים לפרויקט האפליקציה.
אם כבר כללתם קוד ותוכנות בסיסיות של C/C++ בפרויקט, פתחו את החלון Project בצד שמאל של סביבת הפיתוח המשולבת (IDE) על ידי בחירה באפשרות View > חלון של הכלי > Project מהתפריט הראשי, ובחרו באפשרות Android מהתפריט הנפתח. בספרייה cpp, כל הכותרות שנמצאות בהיקף של פרויקט האפליקציה מאורגנות מתחת לצומת include לכל אחד מהיחסי התלות של ספריית C/C++ המקומית, כפי שמוצג בהמשך.
Multidex מקורי מופעל כברירת מחדל
בגרסאות קודמות של Android Studio, אפשר היה להפעיל multidex מקורי כשפורסים את גרסת ניפוי הבאגים של אפליקציה במכשיר עם Android API ברמה 21 ומעלה. עכשיו, לא משנה אם אתם פורסים במכשיר או יוצרים קובץ APK להפצה, הפלאגין של Android ל-Gradle מאפשר multidex מקורי לכל המודולים שמוגדרים ל-minSdkVersion=21 ומעלה.
AAPT2 הועבר למאגר Maven של Google
החל מגרסה 3.2 של Android Studio, המקור של AAPT2 (Android Asset Packaging Tool 2) הוא מאגר Maven של Google.
כדי להשתמש ב-AAPT2, צריך לוודא שיש תלות ב-google() בקובץ build.gradle, כמו שמוצג כאן:
buildscript { repositories { google() // here jcenter() } dependencies { classpath 'com.android.tools.build:gradle:3.2.0' } } allprojects { repositories { google() // and here jcenter() } }
buildscript { repositories { google() // here jcenter() } dependencies { classpath("com.android.tools.build:gradle:3.2.0") } } allprojects { repositories { google() // and here jcenter() } }
הגרסה החדשה של AAPT2 מתקנת הרבה בעיות, כולל טיפול משופר בתווים שאינם ASCII ב-Windows.
הסרת ההגדרות האישיות לפי דרישה
ההעדפה Configure on demand הוסרה מ-Android Studio.
Android Studio כבר לא מעביר את הארגומנט --configure-on-demand ל-Gradle.
עוזר אישי לחיבור ADB
עוזר ההתחברות החדש של ADB מספק הוראות מפורטות שיעזרו לכם להגדיר מכשיר ולהשתמש בו באמצעות חיבור ממשק הגישור של Android (ADB).
כדי להפעיל את העוזר, בוחרים באפשרות Tools > Connection Assistant.
ב-ADB Connection Assistant יש הוראות, אמצעי בקרה בהקשר ורשימה של מכשירים מחוברים בסדרה של דפים בחלונית Assistant.
שיפורים באמולטור
עכשיו אתם יכולים לשמור ולטעון תמונות מצב של מכשיר Android וירטואלי (AVD) בכל שלב באמולטור Android, וכך להחזיר במהירות ובקלות מכשיר מדומה למצב ידוע לצורך בדיקה. כשעורכים AVD באמצעות AVD Manager, אפשר לציין איזו תמונת מצב של AVD תיטען כשה-AVD יתחיל לפעול.
אמצעי הבקרה לשמירה, לטעינה ולניהול של קובצי Snapshot של AVD נמצאים עכשיו בכרטיסייה Snapshots בחלון Extended controls של הסימולטור.
פרטים נוספים זמינים במאמר תמונות מצב.
למידע נוסף על מה שחדש ומה שהשתנה באמולטור, קראו את נתוני הגרסה של האמולטור.
3.1 (מרץ 2018)
Android Studio 3.1.0 הוא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
3.1.4 (אוגוסט 2018)
העדכון הזה ל-Android Studio 3.1 כולל את השינויים והתיקונים הבאים:
- גרסת Kotlin המצורפת היא עכשיו 1.2.50.
-
פרויקטים חדשים נוצרים עם
kotlin-stdlib-jdk* artifacts, ולא עם פריטי מידע שנוצרו ב-kotlin-stdlib-jre*, שהוצאו משימוש. - שיפרנו את הניתוח של כללי ProGuard ב-R8.
- הבאגים הבאים תוקנו:
-
ניסיון להריץ את המחלקה הראשית של Kotlin נכשל עם השגיאה:
"Error: Could not find or load main class..." - R8 נכנס ללולאה אינסופית בזמן ביצוע אופטימיזציות מסוימות.
- כשמשתמשים בפקודה Rerun failed tests בחלון Run, לפעמים מופיעה בטעות ההודעה "No tests were found".
-
D8 לא טיפל נכון במופעים של
invoke-virtual, מה שגרם לקריסה עםVerifyError:invoke-super/virtual can't be used on private method -
המהדר של קישור הנתונים היה תלוי בגרסה ישנה של
com.android.tools:annotations. הקומפיילר משתמש עכשיו בהערות של הכלים מפרויקט הבסיס, אם הן זמינות. - Android Studio קרס במהלך מעברים בין מקטעים בזמן שימוש בכלי הפרופיילינג.
- הכלי לניפוי באגים קרס במהלך ניפוי באגים בפריסה עם תיבת טקסט.
- D8 לא הצליח לקרוא קובצי ZIP מסוימים עם תווים מיוחדים.
3.1.3 (יוני 2018)
העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:
- דליפות זיכרון גרמו ל-Android Studio לפעול לאט ולא להגיב אחרי שימוש ב-Layout Editor. העדכון הזה כולל תיקונים לרוב הבעיות האלה. אנחנו מתכוונים להוציא בקרוב עדכון נוסף כדי לטפל בדליפות זיכרון נוספות.
- חלק מהאפליקציות שנוצרו באמצעות D8 קרסו בחלק מהטאבלטים של Verizon Ellipsis.
-
ההתקנה של אפליקציות שנוצרו באמצעות D8 נכשלה עם השגיאה
INSTALL_FAILED_DEXOPTבמכשירים עם Android בגרסה 5.0 או 5.1 (רמת API 21 או 22). - חלק מהאפליקציות שהשתמשו בספריית OkHttp ונוצרו באמצעות D8 קרסו במכשירים עם Android 4.4 (רמת API 19).
-
לפעמים Android Studio לא הצליח להתחיל, עם
ProcessCanceledExceptionבמהלך אתחול הכיתה עבורcom.intellij.psi.jsp.JspElementType.
3.1.2 (אפריל 2018)
העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:
- במקרים מסוימים, Android Studio נתקע ללא הגבלת זמן במהלך היציאה.
-
תהליכי build שהוגדרו עם קבוצות מקורות נכשלו עם ההודעה הבאה כשהתכונה "הרצה מיידית" הופעלה:
"The SourceSet name is not recognized by the Android Gradle Plugin." - כשהתכונה "הרצה מיידית" הופעלה, גרסאות build של פרויקטים חדשים ב-Kotlin נכשלו כשהופעלו על ידי הפקודה Run.
-
במהלך העריכה של הקובץ
build.gradle, לפעמים היה עיכוב ניכר בין הקלדת תו לבין הופעת התו במסך. -
בפרויקטים מסוימים עם מספר גדול של מודולים או יחסי תלות חיצוניים, אירעו כשלים ב-build במהלך dexing, והוצגה הודעת השגיאה הבאה:
"RejectedExecutionException: Thread limit exceeded replacing blocked worker" - החישוב של רשימת ה-DEX הראשית של D8 לא הביא בחשבון כמה קריאות רפלקטיביות.
העדכון הזה כולל גם שינויים שמאפשרים להריץ בדיקות lint מ-Gradle הרבה יותר מהר בתרחישים מסוימים.
3.1.1 (אפריל 2018)
העדכון הזה ל-Android Studio 3.1 כולל תיקונים לבאגים הבאים:
-
במקרים מסוימים, כשפרויקט שנוצר ב-Android Studio 3.0 נפתח בפעם הראשונה ב-Android Studio 3.1, המשימה Gradle-aware Make הוסרה מהאזור Before launch (לפני ההפעלה) ב-Run/Debug Configurations (הגדרות הרצה/ניפוי באגים). כתוצאה מכך, פרויקטים לא נבנו כשלוחצים על הלחצן Run או Debug, מה שגרם לכשלים כמו פריסה של קובצי APK שגויים וקריסות כשמשתמשים ב-Instant Run.
כדי לפתור את הבעיה, ב-Android Studio 3.1.1 נוספה המשימה Gradle-aware Make להגדרת ההרצה של פרויקטים שבהם חסר הרכיב הזה. השינוי הזה מתרחש אחרי הסנכרון הראשון של Gradle כשהפרויקט נטען.
- הכלי לניפוי באגים קרס כשניפה באגים בפריסה עם תיבת טקסט, אם הופעל פרופיילינג מתקדם.
- Android Studio קפא אחרי שלחצתם על Build Variants (וריאנטים של גרסאות build).
- קובצי AAR (ארכיון Android) חולצו פעמיים, פעם אחת במהלך תהליך הסנכרון של Gradle ופעם אחת במהלך תהליך ה-build של Gradle.
- חסרים רכיבים בחלק מהפריטים הגרפיים הווקטוריים שניתנים לשרטוט שיובאו מקובצי SVG.
-
האזהרה לגבי הוצאה משימוש של הגדרת התלות
compileעודכנה עם הנחיות טובות יותר לגבי ההגדרותimplementationו-api. לפרטים על מעבר משימוש בהגדרהcompile, עיינו במסמכי התיעוד של הגדרות התלות החדשות.
תכנות/IDE
IntelliJ 2017.3.3
סביבת הפיתוח המשולבת (IDE) המרכזית של Android Studio עודכנה עם שיפורים מ-IntelliJ IDEA דרך גרסה 2017.3.3. השיפורים כוללים ניתוח טוב יותר של זרימת הבקרה לאוספים ולמחרוזות, הסקת מסקנות משופרת לגבי מאפיין המציין אם ערך יכול להיות ריק (nullability), תיקונים מהירים חדשים ועוד הרבה יותר.
לפרטים נוספים, קראו את נתוני הגרסה של JetBrains לגרסאות 2017.2 ו-2017.3 של IntelliJ IDEA, וגם את נתוני הגרסה של JetBrains לעדכונים של תיקוני באגים.
שיפורים בעריכת SQL באמצעות Room
כשמשתמשים בספריית מסד הנתונים Room, אפשר ליהנות מכמה שיפורים בעריכת SQL:
- השלמת הקוד ב-
Queryמזהה טבלאות (ישויות), עמודות, פרמטרים של שאילתות, שמות סודיים, איחודים, שאילתות משנה וסעיפי WITH ב-SQL. - הדגשת תחביר SQL פועלת עכשיו.
- אתם יכולים ללחוץ לחיצה ימנית על שם של טבלה ב-SQL ולשנות את השם שלה, מה שגם משכתב את הקוד התואם ב-Java או ב-Kotlin (כולל, לדוגמה, סוג ההחזרה של השאילתה). שינוי השם פועל גם בכיוון ההפוך, כך ששינוי שם של מחלקה או שדה ב-Java משכתב את קוד ה-SQL התואם.
- השימושים ב-SQL מוצגים כשמשתמשים באפשרות Find usages (לוחצים לחיצה ימנית ובוחרים באפשרות Find usages בתפריט ההקשר).
- כדי לנווט להצהרה של ישות SQL בקוד Java או Kotlin, אפשר ללחוץ על Control (או Command ב-Mac) תוך כדי לחיצה על הישות.
למידע על שימוש ב-SQL עם Room, ראו שמירת נתונים במסד נתונים מקומי באמצעות Room.
עדכונים לגבי קישור נתונים
העדכון הזה כולל כמה שיפורים בקישור נתונים:
-
עכשיו אפשר להשתמש באובייקט
LiveDataכשדה שניתן לצפייה בביטויים של קישור נתונים. ה-classViewDataBindingכולל עכשיו method חדש שלsetLifecycle()שמשמש לצפייה באובייקטים שלLiveData. -
ה-class
ObservableFieldיכול עכשיו לקבל אובייקטים אחרים שלObservableב-constructor שלו. -
אתם יכולים לראות תצוגה מקדימה של מהדר מצטבר חדש למחלקות של קישור הנתונים. במאמר Data Binding Compiler V2 מפורטים פרטים על המהדר החדש והוראות להפעלתו.
היתרונות של המהדר החדש כוללים:
-
מחלקות
ViewBindingנוצרות על ידי הפלאגין של Android ל-Gradle לפני הקומפיילר של Java. - הספריות שומרות את מחלקות הקישור שנוצרו כשהאפליקציה עוברת הידור, במקום ליצור אותן מחדש בכל פעם. כך אפשר לשפר משמעותית את הביצועים בפרויקטים עם כמה מודולים.
-
מחלקות
קומפיילר ו-Gradle
D8 הוא קומפיילר ברירת המחדל של DEX
הקומפיילר D8 משמש עכשיו כברירת מחדל ליצירת קוד בייט של DEX.
הקומפיילר החדש של DEX מביא איתו כמה יתרונות, כולל:
- הוספה מהירה יותר לאינדקס
- שימוש מופחת בזיכרון
- יצירת קוד משופרת (הקצאת רישום טובה יותר, טבלאות מחרוזות חכמות יותר)
- חוויית ניפוי באגים משופרת כשעוברים על הקוד
כדי ליהנות מהיתרונות האלה, לא צריך לבצע שינויים בקוד או בתהליך העבודה של הפיתוח, אלא אם השבתתם בעבר באופן ידני את המהדר D8.
אם הגדרתם את android.enableD8 ל-false ב-gradle.properties, צריך למחוק את הדגל הזה או להגדיר אותו ל-true:
android.enableD8=true
פרטים נוספים זמינים במאמר מהדר DEX חדש.
הסרה מצטברת של סוכר תחבירי
בפרויקטים שמשתמשים בתכונות של שפת Java 8, הסרת סוכר תחבירי מצטברת מופעלת כברירת מחדל, מה שיכול לשפר את זמני ה-build.
תהליך ההסרה של סוכר תחבירי ממיר סוכר תחבירי לצורה שהקומפיילר יכול לעבד בצורה יעילה יותר.
כדי להשבית את התהליך המצטבר של הסרת סוכר תחבירי, צריך לציין את הפרטים הבאים בקובץ gradle.properties של הפרויקט:
android.enableIncrementalDesugaring=false
חלון פלט פשוט יותר
מסוף Gradle הוחלף בחלון Build, שכולל את הכרטיסיות Sync ו-Build.
במאמר מעקב אחרי תהליך ה-build מוסבר איך משתמשים בחלון Build החדש והפשוט.
עדכונים של חבילות ובו-זמניות של הוספה לאינדקס
תהליכי הסנכרון של Gradle והוספת האינדקס של IDE יעילים הרבה יותר עכשיו, ומקצרים את הזמן שמתבזבז על פעולות מיותרות של הוספת אינדקס.
C++ ו-LLDB
ביצענו שיפורים רבים באיכות ובביצועים בשלבי התכנות, הסנכרון, ה-build וניפוי הבאגים של פיתוח ב-C++. השיפורים כוללים:
-
אם אתם עובדים עם פרויקטים גדולים ב-C++, אתם אמורים לראות שיפור משמעותי בצמצום הזמן שנדרש ליצירת סמלים. בנוסף, זמן הסנכרון של פרויקטים גדולים מתקצר משמעותית.
-
שיפרנו את הביצועים של בנייה וסנכרון באמצעות CMake על ידי שימוש חוזר אגרסיבי יותר בתוצאות שנשמרו במטמון.
-
הוספת מעצבים ("pretty printers") למבני נתונים נוספים של C++ מקלה על קריאת הפלט של LLDB.
-
LLDB פועל עכשיו רק ב-Android מגרסה 4.1 (רמת API 16) ואילך.
הערה: ניפוי באגים מקורי באמצעות Android Studio 3.0 ואילך לא פועל ב-Windows בגרסת 32 ביט. אם אתם משתמשים ב-Windows בגרסת 32 ביט וצריכים לנפות באגים בקוד Native, השתמשו ב-Android Studio 2.3.
Kotlin
Kotlin שודרג לגרסה 1.2.30
גרסה 3.1 של Android Studio כוללת את גרסה 1.2.30 של Kotlin.
עכשיו קוד Kotlin מנותח באמצעות בדיקת lint בשורת הפקודה
הפעלת lint משורת הפקודה מנתחת עכשיו את מחלקות Kotlin.
בכל פרויקט שבו רוצים להריץ את lint, צריך לכלול את מאגר ה-Maven של Google בקובץ build.gradle ברמה העליונה. מאגר Maven כבר כלול בפרויקטים שנוצרו ב-Android Studio מגרסה 3.0 ואילך.
כלים לשיפור הביצועים
דגימת תהליכי C++ מקוריים באמצעות CPU Profiler
הכלי CPU Profiler כולל עכשיו הגדרת ברירת מחדל לתיעוד דגימות של מעקבים אחרי השרשורים המקוריים של האפליקציה. כדי להשתמש בהגדרה הזו, פורסים את האפליקציה במכשיר עם Android בגרסה 8.0 (רמת API 26) ומעלה, ואז בוחרים באפשרות Sampled (Native) בתפריט הנפתח של הגדרות ההקלטה ב-CPU Profiler. אחרי זה, מתעדים ובודקים מעקב כרגיל.
כדי לשנות את הגדרות ברירת המחדל, כמו מרווח הדגימה, אתם יכולים ליצור הגדרות אישיות להקלטה.
כדי לחזור למעקב אחרי ה-threads של Java, בוחרים באחת מההגדרות Sampled (Java) או Instrumented (Java).
סינון של מעקבי מעבד (CPU), תוצאות של הקצאת זיכרון ותמונות מצב של הזיכרון
הכלים CPU Profiler ו-Memory Profiler כוללים תכונת חיפוש שמאפשרת לסנן תוצאות מהקלטה של תיעוד method, הקצאות זיכרון או תמונת מצב של הזיכרון.
כדי לחפש, לוחצים על Filter
בפינה הימנית העליונה של החלונית, מקלידים את השאילתה ולוחצים על Enter.
טיפ: אפשר גם לפתוח את שדה החיפוש על ידי לחיצה על Control + F (או Command + F ב-Mac).
בכרטיסייה Flame Chart של CPU Profiler, סטאקים של ביצוע שכוללים שיטות שקשורות לשאילתת החיפוש מודגשים ומועברים לצד השמאלי של התרשים.
מידע נוסף על סינון לפי שם של שיטה, מחלקה או חבילה זמין במאמר תיעוד ובדיקה של מעקבי שיטות.
הכרטיסייה Request (בקשה) בכלי לניתוח הרשת
הכלי לניתוח הרשת כולל עכשיו את הכרטיסייה Request, שמספקת פרטים על בקשות לאחזור מהרשת במהלך ציר הזמן שנבחר. בגרסאות קודמות, הכלי לניתוח הרשת סיפק רק מידע על תגובות מהרשת.
תצוגת השרשורים בכלי לניתוח הרשת
אחרי שבוחרים חלק מציר הזמן בכלי לניתוח הרשת, אפשר לבחור אחת מהכרטיסיות הבאות כדי לראות פרטים נוספים על הפעילות ברשת במהלך מסגרת הזמן הזו:
- Connection View: מספק את אותו מידע כמו בגרסאות הקודמות של Android Studio – מציג רשימה של קבצים שנשלחו או התקבלו במהלך החלק שנבחר בציר הזמן בכל השרשורים של המעבד (CPU) באפליקציה. בכל בקשה אפשר לבדוק את הגודל, הסוג, הסטטוס ומשך השידור.
- תצוגת שרשורים: מציגה את הפעילות ברשת של כל אחד מהשרשורים של המעבד (CPU) באפליקציה. התצוגה הזו מאפשרת לכם לבדוק אילו מהשרשורים של האפליקציה אחראים לכל בקשה לאחזור מהרשת.
Layout Inspector
הכלי Layout Inspector קיבל תכונות חדשות, כולל פונקציונליות שסופקה בעבר על ידי הכלים Hierarchy Viewer ו-Pixel Perfect שהוצאו משימוש:
- כפתורי זום ומקשי קיצור לניווט ולבדיקת פריסות
- שכבת-על של רשת עזר
- אפשרות לטעון תמונת רפרנס ולהשתמש בה כשכבת-על (שימושי להשוואה בין הפריסה לבין מוקאפ של ממשק המשתמש)
- עיבוד תצוגה מקדימה של עץ משנה כדי לבודד תצוגה בפריסה מורכבת
Layout Editor
החלונית Palette ב-Layout Editor שופרה בכמה דרכים:
- ארגון מחדש של קטגוריות לתצוגות ולפריסות.
- קטגוריה חדשה בשם Common לתצוגות ולפריסות, שאפשר להוסיף אליה פריטים באמצעות הפקודה Favorite.
- חיפוש משופר של תצוגות ופריסות.
- פקודות חדשות לפתיחת מסמכי תיעוד של תצוגה או רכיב פריסה ספציפיים.
אתם יכולים להשתמש בפקודה החדשה Convert view ב-Component tree או בעורך העיצוב כדי להמיר תצוגה או פריסה לסוג אחר של תצוגה או פריסה.
עכשיו אפשר ליצור בקלות אילוצים לפריטים שקרובים לתצוגה שנבחרה באמצעות הלחצנים החדשים ליצירת חיבור
במפקח התצוגה בחלק העליון של החלון Attributes.
הרצה והרצה מיידית
ההתנהגות של האפשרות Use same selection for future launches בתיבת הדו-שיח Select deployment target עקבית יותר. אם האפשרות Use same selection מופעלת, תיבת הדו-שיח Select deployment target נפתחת רק בפעם הראשונה שמשתמשים בפקודה Run, עד שהמכשיר שנבחר כבר לא מחובר.
כשמטרגטים מכשיר עם Android 8.0 (רמת API 26) ומעלה, אפשר להשתמש ב-Instant Run כדי לפרוס שינויים במשאבים בלי להפעיל מחדש את האפליקציה. זה אפשרי כי המשאבים כלולים ב-APK מפוצל.
מכשיר הדמיה
לפרטים על מה שחדש ומה שהשתנה באמולטור מאז Android Studio 3.0, עיינו בנתוני הגרסה של אמולטור Android מגרסה 27.0.2 עד גרסה 27.1.12.
השיפורים העיקריים כוללים:
- תמונות מצב של אתחול מהיר לשמירת מצב האמולטור ולהפעלה מהירה יותר, עם אפשרות להשתמש בפקודה Save now כדי לשמור מצב התחלה בהתאמה אישית.
- מסך אמולטור ללא חלון.
- תמונות מערכת ל-Android 8.0 (רמת API 26), ל-Android 8.1 (רמת API 27) ולגרסת תצוגה מקדימה למפתחים של Android P.
שיפורים בממשק המשתמש ובחוויית המשתמש
יותר הסברים קצרים, מקשי קיצור והודעות מועילות
הוספנו הסברים קצרים ושכבות-על של הודעות מועילות בהרבה מקומות ב-Android Studio.
כדי לראות את מקשי הקיצור של פקודות רבות, פשוט מחזיקים את סמן העכבר מעל כפתור עד שמופיע הסבר קצר.
התפריט "כלים" > Android הוסר
התפריט Tools > Android הוסר. הפקודות שהיו בעבר בתפריט הזה הועברו.
- הרבה פקודות הועברו ישירות לתפריט כלים.
- הפקודה Sync project with gradle files עברה לתפריט File.
- הפקודה Device Monitor הוסרה, כמו שמתואר בהמשך.
Device Monitor זמין משורת הפקודה
ב-Android Studio 3.1, ל-Device Monitor יש תפקיד פחות משמעותי מאשר בגרסאות קודמות. במקרים רבים, הפונקציונליות שזמינה דרך Device Monitor מסופקת עכשיו על ידי כלים חדשים ומשופרים.
במסמכי התיעוד של Device Monitor מוסבר איך להפעיל את Device Monitor משורת הפקודה, ומפורטים הכלים שזמינים דרך Device Monitor.
3.0 (אוקטובר 2017)
Android Studio 3.0.0 הוא גרסה מרכזית שכוללת מגוון של תכונות ושיפורים חדשים.
משתמשי macOS: אם אתם מעדכנים גרסה ישנה יותר של Android Studio, יכול להיות שתופיע תיבת דו-שיח של שגיאת עדכון עם ההודעה "Some conflicts were found in the installation area" (נמצאו כמה התנגשויות באזור ההתקנה). פשוט מתעלמים מהשגיאה הזו ולוחצים על Cancel (ביטול) כדי להמשיך בהתקנה.
3.0.1 (נובמבר 2017)
זהו עדכון קטן ל-Android Studio 3.0 שכולל תיקוני באגים כלליים ושיפורי ביצועים.
פלאגין Android ל-Gradle גרסה 3.0.0
פלאגין Android ל-Gradle החדש כולל מגוון שיפורים ותכונות חדשות, אבל הוא בעיקר משפר את ביצועי ה-build בפרויקטים עם מספר גדול של מודולים. כשמשתמשים בפלאגין החדש בפרויקטים גדולים, אלה השינויים שצפויים:
- זמני תצורת build מהירים יותר בזכות פתרון חדש של תלות מושהית.
- רזולוציית תלות שמותאמת לווריאציות רק לפרויקטים ולווריאציות שאתם יוצרים.
- זמני בנייה מצטברים מהירים יותר כשמחילים שינויים פשוטים על הקוד או על המשאבים.
הערה: השיפורים האלה דרשו שינויים משמעותיים שמשבשים חלק מההתנהגויות, ה-DSL וממשקי ה-API של הפלאגין. שדרוג לגרסה 3.0.0 עשוי לדרוש שינויים בקובצי ה-build וביישומי הפלאגין של Gradle.
הגרסה הזו כוללת גם את הדברים הבאים:
- תמיכה ב-Android 8.0.
- תמיכה ביצירת קובצי APK נפרדים על סמך משאבי שפה.
- תמיכה בספריות של Java 8 ובתכונות של שפת Java 8 (ללא מהדר Jack).
- תמיכה ב-Android Test Support Library 1.0 (כלי Android Test Utility ו-תזמור בדיקות ל-Android).
- שיפור מהירויות ה-build של ndk-build ו-cmake.
- מהירות משופרת של סנכרון Gradle.
- AAPT2 מופעל עכשיו כברירת מחדל.
- השימוש ב-
ndkCompileמוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד Native שרוצים לארוז ב-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 File) או ליצור פרויקט חדש עם Kotlin באמצעות אשף הפרויקטים החדשים.
כדי להתחיל, קראו איך להוסיף את Kotlin לפרויקט.
תמיכה בתכונות של שפת Java 8
עכשיו אתם יכולים להשתמש בתכונות מסוימות של שפת Java 8 ולהשתמש בספריות שנוצרו באמצעות Java 8. אין יותר צורך ב-Jack, וקודם צריך להשבית את Jack כדי להשתמש בתמיכה המשופרת ב-Java 8 שמובנית ב-toolchain שמוגדר כברירת מחדל.
כדי לעדכן את הפרויקט כך שיתמוך ב-toolchain החדש של שפת Java 8, מעדכנים את Source Compatibility (תאימות מקור) ואת Target Compatibility (תאימות יעד) ל-1.8 בתיבת הדו-שיח Project Structure (מבנה הפרויקט) (לוחצים על File > Project Structure). איך משתמשים בתכונות של שפת Java 8
Android Profiler
הכלי החדש Android Profiler מחליף את הכלי Android Monitor ומספק חבילת כלים חדשה למדידת השימוש של האפליקציה במעבד (CPU), בזיכרון וברשת בזמן אמת. אתם יכולים לבצע מעקב אחר שיטות מבוססות-דגימה כדי לתזמן את הרצת הקוד, לתעד תמונות מצב של הזיכרון, להציג הקצאות זיכרון ולבדוק את הפרטים של קבצים שמועברים ברשת.
כדי לפתוח אותו, לוחצים על View > Tool Windows > Android Profiler (תצוגה > חלונות של כלים > Android Profiler) (או לוחצים על Android Profiler בסרגל הכלים).
ציר הזמן של האירועים בחלק העליון של החלון מציג אירועי מגע, לחיצות על מקשים ושינויים בפעילות, כדי שיהיה לכם יותר הקשר להבנת אירועי ביצועים אחרים בציר הזמן.
הערה: גם התצוגה של Logcat עברה לחלון נפרד (בעבר היא הייתה בתוך Android Monitor, שהוסר).
בציר הזמן של הסקירה הכללית של Android Profiler, לוחצים על צירי הזמן של CPU, MEMORY או NETWORK כדי לגשת לכלי הפרופיילינג המתאימים.
CPU Profiler
הכלי CPU Profiler עוזר לנתח את השימוש בשרשור המעבד (CPU) של האפליקציה על ידי הפעלת מעקב אחר דגימה או מעקב אחר מכשיר. אחר כך אפשר לפתור בעיות בביצועי המעבד באמצעות מגוון תצוגות נתונים ומסננים.
מידע נוסף זמין במדריך ל-CPU Profiler.
Memory Profiler
הכלי Memory Profiler עוזר לזהות דליפות זיכרון והעמסת זיכרון שעלולות לגרום לקיטועים, לקפיאות ואפילו לקריסות של האפליקציה. הוא מציג תרשים בזמן אמת של השימוש בזיכרון של האפליקציה, מאפשר לצלם תמונת מצב של הזיכרון, לאלץ איסוף אשפה ולעקוב אחרי הקצאות זיכרון.
מידע נוסף זמין במדריך של Memory Profiler.
הכלי לניתוח הרשת
הכלי לניתוח הרשת מאפשר לכם לעקוב אחרי הפעילות ברשת של האפליקציה, לבדוק את המטען הייעודי (payload) של כל בקשה לאחזור מהרשת ולקשר חזרה לקוד שיצר את הבקשה לאחזור מהרשת.
מידע נוסף זמין במדריך של הכלי לניתוח הרשת.
יצירת פרופיל וניפוי באגים של APK
עכשיו אפשר ליצור פרופיל ולנפות באגים בכל קובץ APK ב-Android Studio בלי ליצור אותו מפרויקט ב-Android Studio, כל עוד קובץ ה-APK נוצר כדי לאפשר ניפוי באגים ויש לכם גישה לסמלי ניפוי הבאגים ולקובצי המקור.
כדי להתחיל, לוחצים על Profile or debug APK במסך הפתיחה של Android Studio. לחלופין, אם כבר יש לכם פרויקט פתוח, לוחצים על File > Profile or debug APK בסרגל התפריטים. כך מוצגים קובצי ה-APK שנפרקו, אבל לא מתבצע הידור לאחור של הקוד. לכן, כדי להוסיף נקודות עצירה (breakpoint) בצורה תקינה ולראות דוחות קריסות, צריך לצרף קובצי מקור של Java וסמלי ניפוי באגים מקוריים.
מידע נוסף זמין במאמר יצירת פרופיל וניפוי באגים של קובצי APK מוגדרים מראש.
סייר קבצים במכשיר
סייר הקבצים החדש במכשיר מאפשר לבדוק את מערכת הקבצים של המכשיר המחובר ולהעביר קבצים בין המכשיר למחשב. הכלי הזה מחליף את הכלי של מערכת הקבצים שזמין ב-DDMS.
כדי לפתוח אותו, לוחצים על View > Tool Windows > Device File Explorer.
מידע נוסף זמין במדריך של סייר הקבצים במכשיר.
תמיכה באפליקציות ללא התקנה
התמיכה החדשה באפליקציות ללא התקנה ל-Android מאפשרת ליצור אפליקציות ללא התקנה בפרויקט באמצעות שני סוגים חדשים של מודולים: מודולים של אפליקציות ללא התקנה ומודולים של תכונות (כדי להשתמש בהם צריך להתקין את Instant Apps Development SDK).
Android Studio כולל גם פעולת refactoring חדשה ליצירת מודולים, שעוזרת להוסיף תמיכה באפליקציות ללא התקנה בפרויקט קיים. לדוגמה, אם רוצים לשנות את מבנה הקוד של הפרויקט כדי להציב כמה מחלקות במודול של תכונות של אפליקציה ללא התקנה, בוחרים את המחלקות בחלון Project ולוחצים על Refactor > Modularize. בתיבת הדו-שיח שמופיעה, בוחרים את המודול שאליו רוצים להעביר את הכיתות ולוחצים על אישור.
כשתהיו מוכנים לבדוק את האפליקציה ללא התקנה, תוכלו ליצור ולהפעיל את המודול של האפליקציה ללא התקנה במכשיר מחובר. לשם כך, צריך לציין את כתובת ה-URL של האפליקציה ללא התקנה באפשרויות ההפעלה של הגדרות ההרצה: בוחרים באפשרות Run > Edit Configurations, בוחרים את המודול של האפליקציה ללא התקנה ומגדירים את כתובת ה-URL בקטע Launch Options.
מידע נוסף זמין במאמר אפליקציות ללא התקנה ל-Android.
מודולים של Android Things
תבניות חדשות של Android Things באשפים "פרויקט חדש" ו"מודול חדש" שיעזרו לכם להתחיל לפתח למכשירי IoT שמבוססים על Android.
מידע נוסף זמין במאמר איך יוצרים פרויקט Android Things.
אשף הסמלים הניתנים להתאמה
Image Asset Studio תומך עכשיו בפריטים גרפיים וקטוריים שניתנים לשרטוט ומאפשר ליצור סמלי מרכז אפליקציות דינמיים ל-Android 8.0, ובמקביל ליצור סמלים רגילים ("סמלים מדור קודם") למכשירים ישנים יותר.
כדי להתחיל, לוחצים לחיצה ימנית על התיקייה res בפרויקט, ואז לוחצים על New > נכס תמונות. בחלון Asset Studio, בוחרים באפשרות סמלי מרכז האפליקציות (מותאמים ומדור קודם) בתור סוג הסמל.
הערה: כדי להשתמש בסמלים דינמיים של מרכז האפליקציות, צריך להגדיר את compileSdkVersion לערך 26 ומעלה.
מידע נוסף זמין במאמר בנושא סמלים הניתנים להתאמה.
תמיכה במשאבי גופנים
כדי לתמוך במשאבי הגופנים החדשים ב-Android 8.0, ב-Android Studio יש כלי לבחירת משאבי גופנים שעוזר לכלול גופנים באפליקציה או להגדיר את הפרויקט כך שיוריד את הגופנים במכשיר (אם הם זמינים). ב-Layout Editor אפשר גם לראות תצוגה מקדימה של הגופנים בפריסה.
כדי לנסות גופנים שניתנים להורדה, צריך לוודא שבמכשיר או באמולטור פועלת גרסה 11.2.63 ומעלה של Google Play Services. מידע נוסף זמין במאמר גופנים שניתנים להורדה.
Firebase App Indexing Assistant
הוספנו ל-Firebase Assistant מדריך חדש לבדיקת הוספת אפליקציות לאינדקס. כדי לפתוח את Assistant, בוחרים באפשרות Tools > Firebase (כלים > Firebase). לאחר מכן בוחרים באפשרות הוספת אפליקציות לאינדקס > בדיקת הוספת אפליקציות לאינדקס.
המדריך כולל לחצנים חדשים לבדיקת ההוספה לאינדקס של התוכן הציבורי והאישי:
- בשלב 2, לוחצים על תצוגה מקדימה של תוצאות החיפוש כדי לוודא שכתובות ה-URL מופיעות בתוצאות החיפוש ב-Google.
- בשלב 3, לוחצים על Check for errors כדי לוודא שהאובייקטים שניתנים להוספה לאינדקס באפליקציה נוספו לאינדקס התוכן האישי.
Android App Links Assistant
הוספנו ל-App Links Assistant את היכולות החדשות הבאות:
-
הוסיפו בדיקות של כתובות URL לכל מיפוי של כתובת URL כדי לוודא שמסנני ה-Intent מטפלים בכתובות URL אמיתיות.
אפשר גם להגדיר את בדיקות כתובות ה-URL האלה באופן ידני באמצעות התג
<tools:validation>שמתואר בהמשך. -
יוצרים קובץ Digital Asset Links עם רשומת האובייקט המתאימה כדי לתמוך ב-Google Smart Lock, ומוסיפים את התג
asset_statements<meta-data>התואם לקובץ המניפסט.
כלי לאימות מסנן Intent של כתובת URL
עכשיו Android Studio תומך בתג מיוחד בקובץ המניפסט שמאפשר לבדוק את כתובות ה-URL של מסנן ה-Intent. אלה אותם תגים שהכלי App Links Assistant יכול ליצור בשבילכם.
כדי להצהיר על כתובת URL לבדיקה של מסנן Intent, מוסיפים רכיב <tools:validation> לצד הרכיב <intent-filter> המתאים. לדוגמה:
<activity ...>
<intent-filter>
...
</intent-filter>
<tools:validation testUrl="https://www.example.com/recipe/1138" />
</activity>
חשוב לכלול גם את xmlns:tools="http://schemas.android.com/tools" בתג <manifest>.
אם אחת מכתובות ה-URL לבדיקה לא עוברת את הגדרת מסנן ה-Intent, מופיעה שגיאת lint. שגיאה כזו עדיין מאפשרת ליצור גרסאות build לניפוי באגים, אבל היא תגרום לכשל בגרסאות ה-build להפצה.
Layout Editor
ה-Layout Editor עודכן עם כמה שיפורים, כולל:
- פריסה וסמלים חדשים בסרגל הכלים.
- פריסה מעודכנת בעץ הרכיבים.
- שיפור בהוספת תצוגות באמצעות גרירה ושחרור.
- חלונית שגיאות חדשה מתחת לעורך, שבה מוצגות כל הבעיות עם הצעות לתיקון (אם יש כאלה).
- שיפורים שונים בממשק המשתמש לפיתוח באמצעות
ConstraintLayout, כולל:- תמיכה חדשה ביצירת מחסומים.
- תמיכה חדשה ביצירת קבוצות: בסרגל הכלים, בוחרים באפשרות Guidelines > Add Group (נדרשת גרסת ConstraintLayout 1.1.0 beta 2 ואילך)
- ממשק משתמש חדש ליצירת שרשראות: בוחרים כמה תצוגות, לוחצים לחיצה ימנית ובוחרים באפשרות Chain.
Layout Inspector
הכלי Layout Inspector כולל שיפורים שמקלים על ניפוי באגים בפריסות של האפליקציה, כולל קיבוץ מאפיינים לקטגוריות נפוצות ופונקציונליות חיפוש חדשה בחלוניות View Tree ו-Properties.
הכלי לניתוח APK
עכשיו אפשר להשתמש בכלי לניתוח APK משורת הפקודה באמצעות הכלי apkanalyzer.
גם הכלי לניתוח APK עודכן, והוא כולל את השיפורים הבאים:
- בקובצי APK שנוצרו באמצעות ProGuard, אפשר לטעון קובצי מיפוי של ProGuard שמוסיפים יכולות למציג ה-DEX, כולל:
- צמתים מודגשים כדי לציין שאין להסיר את הצמתים כשמכווצים את הקוד.
- כפתור להצגת צמתים שהוסרו במהלך תהליך הכיווץ.
- כפתור שמשחזר את השמות המקוריים של הצמתים בתצוגת העץ, שהוסתרו על ידי ProGuard.
- עכשיו מוצגת ב-DEX Viewer ההשפעה המשוערת של כל חבילה, מחלקה ושיטה על הגודל.
- אפשרויות סינון חדשות בחלק העליון להצגה ולהסתרה של שדות ושיטות.
- בתצוגת העץ, צמתים שהם הפניות שלא מוגדרות בקובץ ה-DEX מופיעים בכתב נטוי.
מידע נוסף זמין במאמר ניתוח ה-build באמצעות הכלי לניתוח APK.
גרסת טרום-השקה (Preview) של קומפיילר D8 DEX
Android Studio 3.0 כולל קומפיילר DEX חדש ואופציונלי שנקרא D8. D8 יחליף בסופו של דבר את המהדר DX, אבל אתם יכולים להצטרף לשימוש במהדר D8 החדש כבר עכשיו.
הידור DEX משפיע ישירות על זמן ה-build של האפליקציה, על גודל הקובץ .dex ועל הביצועים בזמן הריצה. כשמשווים בין המקמפל החדש D8 לבין המקמפל הנוכחי DX, D8 מקמפל מהר יותר ויוצר קובצי .dex קטנים יותר, תוך שמירה על ביצועים זהים או טובים יותר של זמן הריצה של האפליקציה.
כדי לנסות את זה, צריך להגדיר את הפרטים הבאים בקובץ gradle.properties של הפרויקט:
android.enableD8=true
מידע נוסף זמין בפוסט בבלוג על המהדר D8.
מאגר Maven של Google
עכשיו Android Studio משתמש במאגר Maven של Google כברירת מחדל, במקום להסתמך על Android SDK Manager כדי לקבל עדכונים לספריית התמיכה של Android, ל-Google Play Services, ל-Firebase ולתלויות אחרות. כך קל יותר לעדכן את הספריות, במיוחד כשמשתמשים במערכת של שילוב רציף (CI).
כברירת מחדל, כל הפרויקטים החדשים כוללים עכשיו את מאגר ה-Maven של Google. כדי לעדכן את הפרויקט הקיים, מוסיפים את google() בבלוק repositories של קובץ build.gradle ברמה העליונה:
allprojects {
repositories {
google()
}
}
מידע נוסף על מאגר Maven של Google
שינויים אחרים
- ניפוי באגים מקורי באמצעות Android Studio כבר לא נתמך ב-Windows בגרסת 32 ביט. בחרנו להתמקד בפלטפורמות אחרות כי מעט מאוד מפתחים משתמשים בפלטפורמה הזו. אם אתם משתמשים ב-Windows בגרסת 32 ביט ומתכננים לנפות באגים בקוד Native, כדאי להמשיך להשתמש ב-Android Studio 2.3.
- שדרוג סביבת הפיתוח המשולבת (IDE) הבסיסית ל-IntelliJ 2017.1.2, שמוסיפה כמה תכונות חדשות מ-2016.3 ומ-2017.1, כמו refactoring של שפת Java 8, רמזים לפרמטרים, הדגשה סמנטית, נקודות עצירה שניתן לגרור, תוצאות מיידיות בחיפוש ועוד הרבה יותר.
- נוספו הרבה בדיקות lint חדשות.
- כדאי גם לעיין בעדכונים האחרונים של אמולטור Android.
2.3 (מרץ 2017)
Android Studio 2.3.0 היא בעיקר גרסה של תיקוני באגים ויציבות, אבל היא כוללת גם כמה תכונות חדשות.
2.3.3 (יוני 2017)
זהו עדכון קטן שמוסיף תמיכה ב-Android O (רמת API 26).
2.3.2 (אפריל 2017)
זהו עדכון קל ל-Android Studio 2.3, שכולל את השינויים הבאים:
- עדכונים ל-AVD Manager כדי לתמוך ב-Google Play בקובצי אימג' של המערכת.
- תיקוני באגים ב-builds של NDK כשמשתמשים ב-NDK בגרסה R14 ואילך.
כדאי גם לעיין בעדכונים התואמים של אמולטור Android בגרסה 26.0.3.
2.3.1 (אפריל 2017)
זהו עדכון קטן ל-Android Studio 2.3 שמתקן בעיה שבה מכשירי Android פיזיים מסוימים לא פעלו כראוי עם Instant Run (ראו בעיה מס' 235879).
<h3 class="hide-from-toc">
New
</h3>
<div class="video-wrapper-left">
<iframe class="devsite-embedded-youtube-video" data-video-id="VFyKclKBGf0"
data-autohide="1" data-showinfo="0" frameborder="0" allowfullscreen>
</iframe>
</div>
<ul>
<li>Android Studio can now convert PNG, BMP, JPG, and static GIF files to
WebP format. WebP is an image file format from Google that provides lossy
compression (like JPEG) as well as transparency (like PNG) but can provide
better compression than either JPEG or PNG. For more information, see
<a href="/studio/write/convert-webp.html">Convert images to WebP in Android
Studio</a>.
</li>
<li>The new <a href="/studio/write/app-link-indexing.html">App Links
Assistant</a> simplifies the process of adding Android App Links to your app
into a step-by-step wizard. Android App Links are HTTP URLs that bring users
directly to specific content in your Android app.
</li>
<li>The Layout Editor now includes support for two new ConstraintLayout
features:
<ul>
<li>Define a view size based on an aspect ratio.
</li>
<li>Create packed, spread, and weighted linear groups with constraint
chains.
</li>
</ul>
For more information, see <a href=
"/training/constraint-layout/index.html">Build a Responsive UI with
ConstraintLayout</a>.
</li>
<li>The Layout Editor also now lets you create a list of <a href=
"/studio/views/layout-editor#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 >
New > 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<T>)">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&q=target%3D2.3+status%3DReleased&colspec=ID+Status+Priority+Owner+Summary+Stars+Reporter+Opened&cells=tiles">
See all bug fixes in 2.3.0.</a>
</p>
<p class="note">
<b>Known issue:</b> Some device manufacturers block apps from automatically
launching after being installed on the device. When deploying your app to a
physical device using Android Studio 2.3, this restriction breaks the
intended behavior of Instant Run and causes the following error output:
<code>Error: Not found; no service started</code>. To avoid this issue,
either <a href="/studio/run/emulator.html">use the emulator</a> or enable
automatic launching for your app in your device's settings. The procedure
for doing this is different for each device, so check the instructions
provided by the manufacturer. To learn more about this issue, see
<a href="https://code.google.com/p/android/issues/detail?id=235879">Issue
#235879</a>.
</p>
2.2 (ספטמבר 2016)
2.2.3 (דצמבר 2016)
<p>
This is a minor update to Android Studio 2.2. It includes a bug fixes
focused around gradle, the core IDE, and lint.
</p>
<p>
Highlighted build changes:
</p>
<ul>
<li>ProGuard version rollback. Due to a <a href=
"https://sourceforge.net/p/proguard/bugs/625/">correctness issue</a>
discovered in ProGuard 5.3.1, we have rolled back to ProGuard 5.2.1. We
have worked with the ProGuard team on getting a fix quickly, and we expect
to roll forward to ProGuard 5.3.2 in Android Studio 2.3 Canary 3.
</li>
<li>Bug fix for <code>aaptOptions</code> <code>IgnoreAssetsPattern</code>
not working properly (<a href="http://b.android.com/224167">issue
224167</a>)
</li>
<li>Bug fix for Gradle autodownload for Constraint Layout library
(<a href="https://code.google.com/p/android/issues/detail?id=212128">issue
212128</a>)
</li>
<li>Bug fix for a JDK8/Kotlin compiler + dx issue (<a href=
"http://b.android.com/227729">issue 227729</a>)
</li>
</ul>
<p>
<a href=
"https://code.google.com/p/android/issues/list?can=1&q=target%3D2.2.3+status%3AReleased+&colspec=ID+Status+Priority+Owner+Summary+Stars+Reporter+Opened&cells=tiles">
See all bug fixes in 2.2.3</a>.
</p>
2.2.2 (אוקטובר 2016)
<p>
This is a minor update to Android Studio 2.2. It includes a number of small
changes and bug fixes, including:
</p>
<ul>
<li>When reporting Instant Run issues through the IDE, the report now also
includes logcat output for <code>InstantRun</code> events. To help us
improve Instant Run, please <a href=
"/studio/run/index.html#submit-feedback">enable extra logging and report
any issues</a>.
</li>
<li>A number of small bug fixes for Gradle.
</li>
<li>A fix for problems with generating multiple APKs.
</li>
</ul>
2.2.1 (אוקטובר 2016)
<p>
This is a minor update to Android Studio 2.2. It includes several bug fixes
and a new feature to enable extra logging to help us troubleshoot Instant
Run issues—to help us improve Instant Run, please <a href=
"/studio/run/index.html#submit-feedback">enable extra logging and report
any issues</a>.
</p>
חדש
- Layout Editor חדש לגמרי עם כלים שנוצרו במיוחד כדי לתמוך ב-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> > <strong>Signal Strength</strong> controls.
</li>
<li>Added an <strong>LTE</strong> option to the <strong>Cellular</strong>
> <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 > Project
Structure > SDK Location</strong>. You can switch to use the new bundled
JDK by clicking <strong>File > Project Structure > SDK
Location</strong> and checking the <strong>Use embedded JDK</strong>
checkbox.
</li>
<li>Added new <strong>help menus and buttons</strong> in the UI so you can
more easily find the online documentation.
</li>
שינויים
- בסיס הקוד של IDE עודכן מ-IntelliJ 15 ל-IntelliJ 2016.1
- כדי להשתמש ב-Instant Run, צריך להתקין את ה-SDK של הפלטפורמה שתואם לרמת ה-API של מכשיר היעד.
- התכונה "הפעלה מיידית" תושבת באופן אוטומטי אם המשתמש מפעיל את האפליקציה בפרופיל עבודה או כמשתמש משני.
- תוקנו הרבה בעיות אמינות ב-Instant Run שבהן השינויים לא נפרסו או שהאפליקציה קרסה:
- חלק מנכסי האפליקציה לא נפרסו באפליקציה הפועלת. (באג: #213454)
- האפליקציה קורסת כשהמשתמש עובר בין סשנים של הפעלה מיידית וסשנים ללא הפעלה מיידית, שבהם למחלקה מסוג Serializable לא מוגדר serialVersionUID. (באג: #209006)
- שינויים בסגנון לא משתקפים בהפעלה מיידית. (באג: #210851)
- הסשן של Instant Run לא אמין וגורם ל-FileNotFoundException. (באג: #213083)
- שינויים בפריטים שניתן לשרטט לא יבואו לידי ביטוי עד שתתבצע בנייה מחדש מלאה ב-KitKat. (באג: #21530)
- שינויים במשאבים לא משתקפים ב-Instant Run כש-sourceSets בהתאמה אישית מכילים נתיבים בתצוגת עץ. (באג: #219145)
- החלפה חמה ופושרת לא פועלת אם המחלקה שהשתנתה מכילה הערה עם ערך enum. (באג: #209047)
- שינויים בנתוני ההערות לא משתקפים בהפעלה מיידית. (באג: #210089)
- התכונה "הרצה מיידית" לא מזהה שינויים בקוד אם מבצעים אותם מחוץ ל-IDE. (באג: #213205)
- הסשן של ההפעלה המיידית לא אמין בגלל אי-התאמה של טוקן האבטחה. (באג: #211989
- החלפה קרה נכשלת במכשירים שלא תומכים כראוי ב-run-as. (באג: #210875)
- האפליקציה קרסה אחרי הפעלה מחדש של Instant Run. (באג: #219744)
- ClassNotFoundException observed when switching from Instant Run to Instant Debug. (באג: #215805)
<li>Improved performance for <strong>Gradle sync</strong> within the IDE,
especially for large projects.
</li>
<li>Improved build times for both full and incremental builds with new app
packaging code.
</li>
<li>Improved <strong>Jack compiler performance and features</strong>,
including support for annotation processors and dexing in process. To learn
more, read the <a href=
"/studio/releases/gradle-plugin.html#revisions">Android plugin for Gradle
2.2.0 release notes</a>.
</li>
<li>Removed the <strong>Scale</strong> AVD property from the AVD Manager.
</li>
<li>The Android Emulator <strong>-port</strong> and <strong>-ports</strong>
command-line options now report which ports and serial number the emulator
instance is using, and warn if there are any issues with the values you
provided.
</li>
<li>Improved the <strong><a href=
"/studio/write/create-java-class.html">Create New Class dialog</a></strong>
and the corresponding file templates. <strong>Note:</strong> If you've
previously customized the <strong>AnnotationType</strong>,
<strong>Class</strong>, <strong>Enum</strong>, <strong>Interface</strong>, or
<strong>Singleton</strong> file templates, you need to modify your templates
to comply with the new templates or you won’t be able to use the new fields
in the <strong>Create New Class</strong> dialog.
</li>
<li>Improved the <strong><a href=
"/studio/write/vector-asset-studio.html">Vector Asset Studio</a></strong>
user interface and added support for Adobe Photoshop Document (PSD) files.
</li>
<li>Improved the <strong><a href=
"/studio/write/image-asset-studio.html">Image Asset Studio</a></strong> user
interface.
</li>
<li>Improved the <strong>Theme Editor</strong>'s Resource Picker.
</li>
<li>Fixed memory leaks and reduced overall memory usage in Android Studio.
</li>
<li>Added a <strong>Background</strong> button in the <strong><a href=
"/studio/intro/update.html#sdk-manager">SDK Manager</a></strong> so you can
get back to work and install your packages in the background.
</li>
<li>Improved <strong><a href="/studio/intro/accessibility.html">Accessibility
features</a></strong>, including support for screen readers and keyboard
navigation.
</li>
<li>Enhanced <strong>Code Analysis</strong> includes code quality checks for
Java 8 language usage and more cross-file analysis.
</li>
<li>Several toolbar icons have changed.
</li>
2.1 (אפריל 2016)
השינויים העיקריים בעדכון הזה מספקים תמיכה בפיתוח באמצעות גרסת טרום-ההשקה (Preview) של Android N.
2.1.3 (אוגוסט 2016)
העדכון הזה מוסיף תאימות ל-Gradle 2.14.1, שכולל שיפורים בביצועים, תכונות חדשות ותיקון אבטחה חשוב. פרטים נוספים זמינים בנתוני הגרסה של Gradle.
כברירת מחדל, פרויקטים חדשים ב-Android Studio 2.1.3 משתמשים ב-Gradle 2.14.1. בפרויקטים קיימים, סביבת הפיתוח המשולבת (IDE) מבקשת לשדרג ל-Gradle 2.14.1 ולפלאגין Android ל-Gradle 2.1.3, שנדרש כשמשתמשים ב-Gradle 2.14.1 ואילך.
2.1.2 (יוני 2016)
העדכון הזה כולל כמה שינויים קטנים ותיקוני באגים:
- עדכונים ותיקוני באגים בהרצה מיידית.
- שיפורים בביצועים של LLDB ובהתראות על קריסות.
- תוקנה רגרסיה בעדכון האבטחה של Android Studio 2.1.1 שגרמה לכשל ב-
git rebase.
2.1.1 (מאי 2016)
עדכון אבטחה.
פלטפורמת Android N מוסיפה תמיכה בתכונות של שפת Java 8, שדורשות קומפיילר ניסיוני חדש בשם Jack. הגרסה העדכנית של Jack נתמכת כרגע רק ב-Android Studio 2.1. לכן, אם אתם רוצים להשתמש בתכונות של שפת Java 8, אתם צריכים להשתמש ב-Android Studio 2.1 כדי לפתח את האפליקציה.
הערה: Instant Run מושבת כשמפעילים את מהדר Jack, כי הם לא תואמים כרגע.
למרות ש-Android Studio 2.1 יציב עכשיו, המהדר של Jack עדיין ניסיוני וצריך להפעיל אותו באמצעות המאפיין jackOptions בקובץ build.gradle.
חוץ מהשינויים לתמיכה בגרסת טרום-ההשקה של N, גרסה 2.1 של Android Studio כוללת תיקוני באגים קלים ואת השיפורים הבאים:
- כלי ניפוי הבאגים של Java-aware C++ מופעל עכשיו כברירת מחדל כשמשתמשים במכשיר או באמולטור N ובוחרים במצב ניפוי באגים מקורי (בכרטיסייה כלי ניפוי באגים בהגדרת ההרצה/ניפוי הבאגים).
כדי ליהנות משיפורים נוספים ב-build, כולל קומפילציה מצטברת של Java ו-dexing-in-process,צריך לעדכן את פלאגין Android ל-Gradle לגרסה 2.1.0.
2.0 (אפריל 2016)
הערה: אם אתם מפתחים לגרסת תצוגה מקדימה למפתחים של N, אתם צריכים להשתמש בגרסת תצוגה מקדימה למפתחים של Android Studio 2.1. גרסה 2.0 של Android Studio לא תומכת בכל התכונות שנדרשות כדי לטרגט את גרסת טרום-ההשקה של N.
הרצה מיידית:
- עכשיו Android Studio פורס גרסאות build נקיות מהר יותר מאי פעם. בנוסף, דחיפת שינויים מצטברים בקוד לאמולטור או למכשיר פיזי מתבצעת עכשיו כמעט באופן מיידי. בודקים את העדכונים בלי לפרוס מחדש גרסת build לניפוי באגים, ובמקרים רבים, בלי להפעיל מחדש את האפליקציה.
- התכונה "הרצה מיידית" תומכת בהעברת השינויים הבאים לאפליקציה פועלת:
- שינויים בהטמעה של שיטת מופע קיימת או שיטה סטטית קיימת
- שינויים במשאב קיים של אפליקציה
- שינויים בקוד המבני, כמו חתימת שיטה או שדה סטטי (נדרש מכשיר יעד עם API ברמה 21 ומעלה).
- מידע נוסף על Instant Run
הערה: התכונה "הרצה מיידית" נתמכת רק כשפורסים את וריאנט ה-build לניפוי באגים, משתמשים בפלאגין Android ל-Gradle בגרסה 2.0.0 ואילך, ומגדירים את הקובץ
build.gradleברמת המודול של האפליקציה ל-minSdkVersion 15ואילך. כדי ליהנות מהביצועים הכי טובים, כדאי להגדיר את האפליקציה לגרסהminSdkVersion 21ומעלה.
תוספות חדשות ל-Lint:
- בדיקה של הצהרות
switchבאמצעות מספרים שלמים עם הערות@IntDefכדי לוודא שכל הקבועים מטופלים. כדי להוסיף במהירות הצהרות חסרות, משתמשים בתפריט הנפתח של פעולת הכוונה ובוחרים באפשרות Add Missing @IntDef Constants. - מסמן ניסיונות שגויים להשתמש בהשלמת מחרוזות כדי להוסיף מספרי גרסאות בקובץ
build.gradle. - דגלים למחלקות אנונימיות שמרחיבות את המחלקה
Fragment. - מסמן קוד Native במיקומים לא בטוחים, כמו התיקיות
res/ו-asset/. הדגל הזה מעודד אחסון של קוד Native בתיקייהlibs/, שנארזת באופן מאובטח בתיקייהdata/app-lib/של האפליקציה בזמן ההתקנה. AOSP: #169950 - סימון שיחות לא בטוחות ל-
Runtime.load()ול-System.load(). AOSP: #179980 - כדי למצוא ולהסיר משאבים שלא בשימוש, בוחרים באפשרות Refactor > Remove Unused Resources בסרגל התפריטים. התכונה "זיהוי משאבים שלא בשימוש" תומכת עכשיו במשאבים שמשאבים אחרים שלא בשימוש מפנים אליהם, בהפניות בקובצי Raw כמו הפניות לתמונות מסוג
.html, ובמאפיינים מסוגtools:keepו-tools:discardשמשמשים את הכלי לצמצום משאבים של Gradle. בנוסף, התכונה מביאה בחשבון קבוצות מקורות לא פעילות (כמו משאבים שמשמשים בגרסאות build אחרות) ומטפלת כראוי בייבוא של שדות סטטיים. - בדיקה שהפניות משתמעות ל-API נתמכות בכל הפלטפורמות שמטורגטות על ידי
minSdkVersion. - מסמן שימוש לא תקין ב-
RecyclerViewוב-Parcelable. @IntDef,@IntRange, and@Sizeinspections are now also checked forintarrays and varargs.
שיפורים נוספים:
- הוא עבר אופטימיזציה ל-אמולטור Android 2.0, שמהיר יותר מאי פעם, תומך במגוון רחב יותר של מכשירים וירטואליים וכולל ממשק משתמש משופר באופן משמעותי. מידע נוסף על האמולטור החדש זמין בנתוני הגרסה של כלי ה-SDK.
- שיפורים במנהל המכשירים הווירטואליים של Android:
- תמונות המערכת מסווגות עכשיו בכרטיסיות הבאות: Recommended, x86 ו-Other.
- בהגדרות המתקדמות, אפשר להפעיל תמיכה בריבוי ליבות ולציין את מספר הליבות שהאמולטור יכול להשתמש בהן.
- בקטע Advanced settings, אתם יכולים לקבוע איך הגרפיקה תעובד באמולטור. לשם כך, בוחרים באחת מהאפשרויות הבאות:
- חומרה: שימוש בכרטיס המסך של המחשב כדי להאיץ את העיבוד.
- תוכנה: שימוש ברינדור מבוסס-תוכנה.
- אוטומטי: האמולטור יבחר את האפשרות הטובה ביותר. זוהי הגדרת ברירת המחדל.
- זמני האריזה של AAPT שופרו על ידי ציון יעד הפריסה לפני שהאפליקציה נוצרת. כך Android Studio יכול לארוז ביעילות רק את המשאבים שנדרשים למכשיר שצוין.
- הוספנו שילוב של Cloud Test Lab כדי לספק בדיקות של אפליקציות על פי דרישה, עם הנוחות והיכולת להתרחב של שירות בענן. איך משתמשים ב-Cloud Test Lab עם Android Studio
- הוספנו תצוגה מקדימה של מנפה הבאגים החדש של ה-GPU. באפליקציות שכוללות הרבה גרפיקה, עכשיו אפשר לעבור באופן חזותי על קוד OpenGL ES כדי לבצע אופטימיזציה של האפליקציה או המשחק.
- נוספה בדיקה של הוספת אפליקציות לאינדקס של Google. כדי להגדיל את נפח התנועה לאפליקציה, לגלות באילו תכנים באפליקציה משתמשים הכי הרבה ולמשוך משתמשים חדשים, כדאי להוסיף לאפליקציות תמיכה בכתובות URL, הוספת אפליקציות לאינדקס ופונקציונליות חיפוש. בודקים ומאמתים את כתובות ה-URL באפליקציה, והכול ב-Android Studio. כתובות URL נתמכות והוספת אפליקציות לאינדקס ב-Android Studio
- שדרוגים מהגרסה האחרונה של IntelliJ 15, כולל שיפורים בניתוח הקוד ובביצועים. במאמר מה חדש ב-IntelliJ מופיע תיאור מפורט של התכונות והשיפורים החדשים.
- ההשלמה האוטומטית של עורך ה-XML מוסיפה עכשיו מירכאות כשמשלימים מאפיינים. כדי לבדוק אם האפשרות הזו מופעלת, פותחים את תיבת הדו-שיח Setting או Preferences, עוברים אל Editor > General > Smart Keys ומסמנים את התיבה לצד Add quotes for attribute value on attribute completion. בעיה: 195113
- עורך ה-XML תומך עכשיו בהשלמת קוד לביטויים של קישור נתונים.
גרסה 1.5.1 של Android Studio (דצמבר 2015)
תיקונים ושיפורים:
- תוקנה בעיה שגרמה לכשל בעיבוד ב-Layout Editor. בעיה: 194612
- הוספנו את האפשרות לשנות את מאפייני המניפסט של
descriptionלפי ההגדרות האישיות. בעיה: 194705 - שיפרנו את הניגודיות של העיצוב Darcula ב-Android Studio ב-Vector Asset Studio. בעיה: 191819
- הוספנו תמיכה בכפתור Help ב-Vector Asset Studio.
- הוספנו תמיכה באופרטור
%לקישור נתונים. בעיה: 194045 - תוקן מקרה שבו הפעלת אפליקציה לניפוי באגים גרמה לכך שכלי ניפוי הבאגים התחבר למכשיר הלא נכון. בעיה: 195167
- תוקנה חריגת מצביע null שיכולה להתרחש כשמנסים להפעיל אפליקציה בתרחישים מסוימים.
גרסה 1.5.0 של Android Studio (נובמבר 2015)
תיקונים ושיפורים:
- הוספנו ל-Android Monitor יכולות חדשות לניתוח נתונים של Memory Monitor. כשמציגים קובץ HPROF שנוצר מהמעקב הזה, התצוגה עכשיו מועילה יותר, כך שאפשר לאתר בעיות כמו דליפות זיכרון במהירות רבה יותר. כדי להשתמש בכלי הזה, לוחצים על Android Monitor בתחתית החלון הראשי. ב-Android Monitor, לוחצים על הכרטיסייה Memory. בזמן שהכלי פועל, לוחצים על הסמל Dump Java Heap, ואז לוחצים על Captures בחלון הראשי ולוחצים לחיצה כפולה על הקובץ כדי להציג אותו. בצד שמאל, לוחצים על Capture Analysis. (אי אפשר להפעיל את Android Device Monitor ואת Android Monitor בו-זמנית).
- נוספה תמיכה בקישורי עומק חדשים ובקישורים לאפליקציות. עורך הקוד יכול ליצור באופן אוטומטי מסנן Intent לקישורי עומק בקובץ
AndroidManifest.xml. הוא גם יכול ליצור קוד שיעזור לכם לשלב את ה-API של הוספת אפליקציות לאינדקס בפעילות בקובץ Java. תכונה לבדיקת קישורי עומק עוזרת לוודא שקישור עומק מסוים יכול להפעיל אפליקציה. בכרטיסייה General בתיבת הדו-שיח Run/Debug Configurations, אפשר לציין אפשרויות להפעלת קישורי עומק. אתם יכולים גם לבדוק קריאות ל-API של הוספת אפליקציות לאינדקס בפעילות באמצעות התצוגה logcat של Android Monitor. הכליlintל-Android כולל עכשיו אזהרות לגבי בעיות מסוימות שקשורות לקישורי עומק ול-API של הוספת אפליקציות לאינדקס. - הוספנו את האפשרות להשתמש בשמות מקוצרים כשמשלימים קוד של תצוגות מותאמות אישית בעורך הקוד.
- הוספנו תמיכה ברכיבי
VectorDrawableנוספים ב-Vector Asset Studio כדי לאפשר תאימות לדורות קודמים. Vector Asset Studio יכול להשתמש ברכיבים האלה כדי להמיר פריטים גרפיים וקטוריים שניתנים לשרטוט לתמונות רסטר בפורמט PNG, לשימוש ב-Android מגרסה 4.4 (רמת API 20) ומטה. - הוספנו בדיקות
lintחדשות ל-Android TV ול-Android Auto כדי לתת לכם משוב מיידי ופרקטי ב-Android Studio, וגם כמה תיקונים מהירים. לדוגמה, ב-Android TV, הוא יכול לדווח על בעיות שקשורות להרשאות, לחומרה לא נתמכת, לרכיבuses-featureולבאנרים חסרים, ולספק פתרון מהיר. ב-Android Auto, הכלי יכול לאמת את השימוש הנכון בקובץ התיאור שאליו מפנה קובץ ה-AndroidManifest.xml, לדווח אם אין מסנן Intent למחלקהMediaBrowserServiceולזהות בעיות מסוימות בפעולות הקוליות. - נוספו בדיקות
lintחדשות למקלטי שידור לא מאובטחים, שימושים במחלקותSSLCertificateSocketFactoryו-HostnameVerifier, וקריאות ל-File.setReadable()ול-File.setWritable(). הוא גם מזהה חיפושים לא תקינים של משאבים במניפסט, במיוחד של משאבים שמשתנים בהתאם להגדרות האישיות. - תוקנו כמה בעיות יציבות.
גרסה 1.4.1 של Android Studio (אוקטובר 2015)
תיקונים ושיפורים:
- תוקנה בעיה בשמירת מודל Gradle במטמון, שעלולה לגרום לסנכרון מוגזם של Gradle כשה-IDE מופעל מחדש.
- תוקנה בעיה של מבוי סתום בניפוי באגים מקורי.
- תוקנה בעיה שחסמה משתמשים במערכת לניהול גרסאות Subversion 1.9.
- תוקנה בעיה בתיבת הדו-שיח Device Chooser (בחירת מכשיר), שבה אחרי חיבור מכשיר לא מורשה, לא הייתה יותר אפשרות לבחור את האמולטור. בעיה: 189658
- תוקן דיווח שגוי על שגיאות תרגום בלוקאלים שיש להם מגדיר אזור ותרגום באזור (אבל לא בלוקאל הבסיסי). בעיה: 188577
- תוקנה בעיה של מבוי סתום ב-Theme Editor שקשורה לאינטראקציה שלו עם Layout Editor. בעיה: 188070
- תוקנה בעיה שבה טעינה מחדש של עורך העיצובים וקונפליקט בעריכה גרמו לכך שהמאפיינים לא עודכנו כמו שצריך. בעיה: 187726
- ביצועים משופרים של עורך העיצובים.
- תוקנה בעיה שבה המערכת התעלמה מהמאפיין
android:requiredבמניפסט. בעיה: 187665
גרסה 1.4.0 של Android Studio (ספטמבר 2015)
תיקונים ושיפורים:
- הוספנו את הכלי Vector Asset Studio לייבוא פרטי גרפיקה וקטורית, כמו סמלים של Material Design וקובצי SVG. כדי להשתמש בכלי הזה, בתצוגת Android של החלון Project, לוחצים לחיצה ימנית על התיקייה res ובוחרים באפשרות New > נכס וקטורי.
- הוספנו פונקציות חדשות ל-Android Monitor, ל-GPU ולרשת. כדי להשתמש בכלים האלה, לוחצים על Android Monitor בתחתית החלון הראשי. אי אפשר להפעיל את Android Device Monitor במקביל ל-Android Monitor.
- הוספנו גרסת טרום-השקה מוקדמת של עורך העיצובים החדש. כדי להשתמש בתכונה הזו, בוחרים באפשרות Tools > Android > Theme Editor.
- עדכנו את התבניות של Android עבור Design Support Library. התבניות כוללות עכשיו תמיכה במפרט של Material Design, וגם בספריית התמיכה של
appcompatלתאימות לדורות קודמים.
גרסה 1.3.2 של Android Studio (אוגוסט 2015)
תיקונים ושיפורים:
- נוספה תמיכה ב-Android 6.0 (רמת API 23), כולל סמלים חדשים ותמיכה של AVD Manager ביצירת מכשירים עם צפיפויות מסך חדשות.
- תוקנה חריגה שהתרחשה במהלך בדיקות עדכונים. בעיה: 183068
- תוקנה בעיה שבה קואורדינטות תצוגה לא פתורות עלולות לגרום לקריסה של Layout Editor. בעיה: 178690
- תוקנה בעיה שקשורה לאזהרות לגבי סוג משאב לא תקין. בעיה: 182433
- תוקנה בדיקת ה-lint שסימנה בטעות משאבים כפרטיים. בעיה: 183120
גרסה 1.3.1 של Android Studio (אוגוסט 2015)
תיקונים ושיפורים:
- תוקנה התמיכה ביצירת מכשיר וירטואלי של Android (AVD) ל-Android Wear ב-Windows.
- אשף הפרויקטים עודכן כך שישתמש בשם הפרויקט שהוזן.
- נוספה תמיכה שמאפשרת לאחסן את Android SDK בספרייה לקריאה בלבד.
- גרסת הפלאגין של Android ל-Gradle עודכנה ל-1.3.0.
- תוקנו בעיות שקשורות להפעלת סשן ניפוי באגים ממעטפת Unix של ממשק הגישור של Android (adb).
- תוקנה ההודעה על שינוי השם של חבילת Java כך שיוצג שם החבילה הנכון.
גרסה 1.3.0 של Android Studio (יולי 2015)
תיקונים ושיפורים:
- הוספנו אפשרויות להפעיל שירותים למפתחים, כמו Google AdMob ו-Analytics, באפליקציה שלכם מתוך Android Studio.
- הוספנו הערות נוספות, כמו
@RequiresPermission,@CheckResultsו-@MainThread. - הוספנו את היכולת ליצור תמונות מצב של הזיכרון מ-Java ולנתח הקצאות של שרשורים מ-Memory Monitor. אפשר גם להמיר קובצי HPROF בפורמט בינארי שספציפיים ל-Android לפורמט HPROF רגיל מתוך Android Studio.
- שילבנו את SDK Manager ב-Android Studio כדי לפשט את הגישה לחבילות ולכלים ולספק התראות על עדכונים.
הערה: עדיין אפשר להשתמש ב-SDK Manager העצמאי משורת הפקודה, אבל מומלץ להשתמש בו רק בהתקנות של SDK עצמאי.
- הוספנו את הפקודה
fingerלמסוף האמולטור כדי לדמות אימות באמצעות טביעת אצבע. - הוספנו הצהרת משאבים מסוג
<public>כדי להגדיר משאבי ספרייה כמשאבים גלויים לכולם ופרטיים.הערה: נדרש פלאגין Android ל-Gradle בגרסה 1.3 ואילך.
- הוספנו תמיכה בקישור נתונים כדי ליצור פריסות הצהרתיות שמקשרות את הלוגיקה של האפליקציה לרכיבי הפריסה.
- נוספה תמיכה במודול נפרד של קובצי APK לבדיקה כדי ליצור קובצי APK לבדיקה ב-Android Studio.
- עדכנו את AVD Manager עם אופטימיזציות של HAXM והתראות משופרות.
- הוספנו תמיכה באמולטור ARM ו-MIPS של 64 ביט ל-QEMU 2.1.
- פישוט הפתרון של אזהרות Lint על ידי הוספת תיקונים מהירים, כמו יצירה אוטומטית של הטמעת Parcelable.
- הוספנו תמיכה בתבניות פעילות להוספה מהירה של קטעי קוד.
גרסה 1.2.2 של Android Studio (יוני 2015)
תיקונים ושיפורים:
- תוקנו בעיות ב-build שמנעו את השלמת ה-builds.
Android Studio גרסה 1.2.1 (מאי 2015)
תיקונים ושיפורים:
- תוקנו בעיות קלות בביצועים ובתכונות.
גרסה 1.2.0 של Android Studio (אפריל 2015)
תיקונים ושיפורים:
- עדכנו את חלון זמן הריצה של Android כדי לכלול את הכלי Memory Monitor, והוספנו כרטיסייה למעקב אחרי ביצועי המעבד (CPU).
- הוספנו כרטיסייה בשם Captures בשוליים הימניים כדי להציג את קובצי הנתונים של הביצועים שקשורים לזיכרון ולמעבד, כמו מעקב אחר שיטת המעבד ותמונות מצב של ערימת הזיכרון (heap snapshot).
- תמיכה מורחבת בהערות עם הערות נוספות של מטא-נתונים ומאפיין מוסק המציין אם ערך יכול להיות ריק (nullability).
- שיפרנו את עורך התרגומים והוספנו תמיכה ב-Best Current Practice (BCP) 47, שמשתמש בקודי שפה ואזור בני 3 אותיות.
- תכונות משולבות של IntelliJ 14 ו-14.1 לשיפור ניתוח הקוד והביצועים:
-
- ניפוי באגים משופר שמאפשר להציג ערכים מוטבעים של משתנים ואובייקטים של מקורות הפניה, וגם לבצע הערכה בתוך השורה של ביטויי למדה ואופרטורים.
- נוסף מנגנון לזיהוי סגנון קוד בשביל גודל כרטיסיות וכניסות פיסקאות.
- הוספנו קובצי טיוטה לניסויים בקוד וליצירת אב טיפוס בלי קובצי פרויקט.
- הוספנו הוספה בו-זמנית של תגי פתיחה וסגירה בקובצי HTML ו-XML.
- נוסף כלי מובנה להידור לאחור של מחלקת Java, כדי שתוכלו לראות מה יש בספרייה שקוד המקור שלה לא זמין.
במאמר מה חדש ב-IntelliJ מופיע תיאור מפורט של התכונות והשיפורים החדשים.
- הוספנו עוד תצוגות פרויקט ל-Scratches, Project Files, Problems, Production ו-Tests כדי לשפר את ניהול הפרויקטים והגישה אליהם.
- שיפרנו את התפריט ותיבות הדו-שיח של קובץ > הגדרות כדי שיהיה קל יותר לגשת להגדרות ולנהל אותן.
- הוספנו תמיכה במסכים עם דחיסות גבוהה של פיקסלים ב-Windows וב-Linux.
- הוספנו תמיכה במשאבים ברזולוציה של 280dpi בתיקייה
res/drawable-280dpi/.
גרסה 1.1.0 של Android Studio (פברואר 2015)
תיקונים ושיפורים שונים:
- הוספנו תמיכה בתבנית השעון של Android Wear.
- שינינו את היצירה של פרויקטים ומודולים חדשים כך שתכלול תיקיות
res/mipmapלסמלי מרכז האפליקציות שמותאמים לצפיפות ספציפית. התיקיות האלה (res/mipmap) מחליפות את התיקיותres/drawableשל סמלי מרכז האפליקציות. - עדכנו את סמלי מרכז האפליקציות כך שיהיה להם מראה של Material Design והוספנו סמל מרכז האפליקציות של
xxxhdpi. - הוספנו ושיפרנו בדיקות Lint לשילובי אזורים ושפות, סמלי מרכז האפליקציות, שמות של משאבים ובעיות נפוצות אחרות בקוד.
- הוספנו תמיכה בתג שפה 47 של Best Current Practice (BCP).
גרסה 1.0.1 של Android Studio (דצמבר 2014)
תיקונים ושיפורים שונים:
- תוקנה בעיה בנעילת הקובץ device.xml וב-AVD Manager.
- תוקן יומן האמולטור במערכות Windows.
- תוקנה בעיה ביצירת מכשירי AVD כש-Android Studio ו-Android SDK מותקנים בכוננים שונים במערכות Windows.
- ערוץ העדכון שמוגדר כברירת מחדל להורדות חדשות נקבע כיציב. אם התקנתם את גרסה 1.0.0 של Android Studio ואתם רוצים לקבל עדכונים של גרסה יציבה שמוכנה לייצור, אתם יכולים לעבור לערוץ העדכונים Stable (יציב) דרך File (קובץ) > Settings (הגדרות) > Updates (עדכונים).
גרסה 1.0 של Android Studio (דצמבר 2014)
הגרסה הראשונה של Android Studio.
גרסה 0.8.14 של Android Studio (אוקטובר 2014)
הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.8.6 של Android Studio (אוגוסט 2014)
הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.8.0 של Android Studio (יוני 2014)
הוספנו תמיכה בפרויקטים של Android Wear.
הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.5.2 של Android Studio (מאי 2014)
- הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.4.6 של Android Studio (מרץ 2014)
- הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.4.2 של Android Studio (ינואר 2014)
- הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.3.2 של Android Studio (אוקטובר 2013)
- הרשימה המלאה של השינויים מופיעה בכתובת tools.android.com.
גרסה 0.2.x של Android Studio (יולי 2013)
- מיזוג השינויים האחרונים בבסיס הקוד של IntelliJ. כולל תיקונים לבעיות שדווחו על ידי משתמשי Studio, כמו שינויים בגודל הגופן וברינדור הגופן ב-Linux.
- הפלאגין של Android Gradle עודכן לגרסה 0.5.0.
זהירות: הגרסה החדשה הזו לא תואמת לדורות קודמים. כשפותחים פרויקט שמשתמש בגרסה ישנה יותר של הפלאגין, ב-Studio מוצגת השגיאה Gradle <project_name> project refresh failed.
הפלאגין המעודכן של Gradle כולל את השינויים הבאים:
- תוקן מודל IDE כך שיכיל את קובץ הפלט גם אם הוא מותאם אישית דרך ה-DSL. בנוסף,
תוקן ה-DSL כדי לקבל/להגדיר את קובץ הפלט באובייקט הווריאנט, כך שלא צריך
להשתמש ב-
variant.packageApplication or variant.zipAlign - תוקן פתרון התלות כך שפתרנו את השילוב של (הגדרת ברירת המחדל, סוגי ה-build, הטעמים) ביחד במקום בנפרד.
- תוקנה תלות לבדיקות של פרויקט ספרייה כדי לכלול כראוי את כל התלויות של הספרייה עצמה.
- תוקן מקרה שבו לשני רכיבי תלות יש שם עלה זהה.
- תוקנה בעיה שבה לא ניתן להחיל קובץ כללים של Proguard על גרסאות.
כל נתוני הגרסה של הפלאגין של Gradle זמינים כאן: http://tools.android.com/tech-docs/new-build-system.
- תוקן מודל IDE כך שיכיל את קובץ הפלט גם אם הוא מותאם אישית דרך ה-DSL. בנוסף,
תוקן ה-DSL כדי לקבל/להגדיר את קובץ הפלט באובייקט הווריאנט, כך שלא צריך
להשתמש ב-
- שגיאות Gradle מ-aapt לא מפנות יותר לקובצי פלט ממוזגים בתיקייה build/, אלא מפנות חזרה למיקומי המקור האמיתיים.
- גרסאות Build מקבילות. עכשיו אפשר להשתמש ב-builds מקבילים של Gradle. חשוב לדעת ש-builds מקבילים נמצאים בשלב "incubation" (ראו המסמכים של Gradle). כברירת מחדל, תכונה זו מושבתת. כדי להפעיל אותה, עוברים אל Preferences > Compiler ומסמנים את התיבה Compile independent modules in parallel.
- עבודה נוספת על מאגר המשאבים החדש שמשמש לעיבוד פריסה, קיפול משאבים בעורך ועוד:
- תמיכה בסיסית בתלויות של הפרויקט בספריית .aar (למשל, שימוש בספרייה בלי עותק מקומי של המקורות). עדיין לא עובד לאימות XML של משאבים ולניווט בעורכי מקור.
- זיהוי מעגליות בהפניות למשאבים.
- התכונה Quick Documentation (F1), שיכולה להציג את כל התרגומים של המחרוזת מתחת לסמן טקסט, תציג עכשיו גם את כל שכבות-העל של המשאבים מהגרסאות השונות וסוגי ה-build של Gradle, וגם תוכנות בסיסיות. הן מופיעות בסדר הפוך של שכבת-על של משאבים, עם קו חוצה על הגרסאות של המחרוזת שמוסתרות.
- תיקונים לטיפול בעדכון המשאבים הממוזגים כשקבוצת יחסי התלות של המודולים משתנה.
- תיקונים בעיבוד XML כדי לטפל כראוי בהצהרות על ישויות תווים ובתווי בריחה (escape) ב-XML וב-Unicode.
- תמיכה בשמירת צילומי מסך של חלונות התצוגה המקדימה של הפריסה ועורך הפריסה.
- תיקוני באגים בתבניות.
- תיקוני באגים ב-Lint.
- ביצענו תיקונים שונים בדוחות הקריסה. תודה, והמשיכו לשלוח דוחות קריסה!
גרסה 0.1.x של Android Studio (מאי 2013)
- תיקוני באגים שונים, כולל תיקון לבעיה נפוצה בהתקנה ב-Windows.
גרסאות קודמות של הפלאגין של Android Gradle
3.6.0 (פברואר 2020)
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
-
Gradle 5.6.4. מידע נוסף זמין בקטע בנושא עדכון Gradle.
-
SDK Build Tools 28.0.3 ואילך.
העדכון הקטן הזה תומך בתאימות עם הגדרות ברירת מחדל ותכונות חדשות של הרשאות גישה לחבילה ב-Android 11.
פרטים נוספים זמינים בנתוני הגרסה של 4.0.1.
תכונות חדשות
הגרסה הזו של הפלאגין של Android Gradle כוללת את התכונות החדשות הבאות.
View Binding
קישור תצוגה מספק בטיחות בזמן הידור כשמפנים לתצוגות בקוד. עכשיו אפשר להחליף את findViewById() בהפניה למחלקת הקישור שנוצרה באופן אוטומטי. כדי להתחיל להשתמש בקישור תצוגה, צריך לכלול את הקוד הבא בקובץ build.gradle של כל מודול:
android { viewBinding.enabled = true }
android { viewBinding.enabled = true }
מידע נוסף זמין במסמכי התיעוד של View Binding.
תמיכה בפלאגין Maven Publish
הפלאגין של Android Gradle כולל תמיכה בפלאגין Maven Publish Gradle, שמאפשר לפרסם פריטי build במאגר של Apache Maven. הפלאגין של Android Gradle יוצר רכיב לכל פריט של וריאנט build במודול של האפליקציה או הספרייה, שבו אפשר להשתמש כדי להתאים אישית פרסום למאגר Maven.
מידע נוסף זמין בדף בנושא שימוש בפלאגין Maven Publish.
כלי חדש ליצירת חבילות התקנה כברירת מחדל
כשמפתחים את גרסת ניפוי הבאגים של האפליקציה, הפלאגין משתמש בכלי אריזה חדש שנקרא zipflinger כדי ליצור את ה-APK. הכלי החדש הזה אמור לשפר את מהירות ה-build. אם כלי האריזה החדש לא פועל כמו שציפית, אפשר לדווח על באג. כדי לחזור להשתמש בכלי האריזה הישן, צריך להוסיף את הקוד הבא לקובץ gradle.properties:
android.useNewApkCreator=false
שיוך (Attribution) של גרסאות build מקוריות
עכשיו אפשר לקבוע את משך הזמן שנדרש ל-Clang כדי ליצור ולקשר כל קובץ C/C++ בפרויקט. Gradle יכול להפיק קובץ מעקב של Chrome שמכיל חותמות זמן לאירועי המהדר האלה, כדי שתוכלו להבין טוב יותר כמה זמן נדרש לבניית הפרויקט. כדי להפיק את קובץ השיוך של ה-build, מבצעים את הפעולות הבאות:
-
מוסיפים את הדגל
-Pandroid.enableProfileJson=trueכשמריצים build של Gradle. לדוגמה:gradlew assembleDebug -Pandroid.enableProfileJson=true -
פותחים את דפדפן Chrome ומקלידים
chrome://tracingבסרגל החיפוש. -
לוחצים על הכפתור Load ומנווטים אל
<var>project-root</var>/build/android-profileכדי למצוא את הקובץ. שם הקובץ הואprofile-<var>timestamp</var>.json.gz.
נתוני השיוך (Attribution) של ה-build המקורי מופיעים בחלק העליון של חלון התצוגה:

שינויים בהתנהגות
כשמשתמשים בגרסה הזו של הפלאגין, יכול להיות שתבחינו בשינויים הבאים בהתנהגות.
ספריות Native נארזות ללא דחיסה כברירת מחדל
כשמפתחים את האפליקציה, הפלאגין מגדיר עכשיו את extractNativeLibs ל-"false" כברירת מחדל. כלומר, ספריות ה-Native מיושרות לפי דפים ונארזות ללא דחיסה. הפעולה הזו מגדילה את נפח ההעלאה, אבל המשתמשים נהנים מהיתרונות הבאים:
- גודל ההתקנה של האפליקציה קטן יותר כי הפלטפורמה יכולה לגשת לספריות ה-Native ישירות מה-APK המותקן, בלי ליצור עותק של הספריות.
- גודל הורדה קטן יותר, כי הדחיסה של חנות Play בדרך כלל טובה יותר כשכוללים ספריות Native לא דחוסות ב-APK או בקובץ Android App Bundle.
אם אתם רוצים שהפלאגין של Android Gradle יארוז ספריות Native דחוסות, צריך לכלול את הקטע הבא במניפסט של האפליקציה:
<application
android:extractNativeLibs="true"
... >
</application>
הערה: מאפיין המניפסט extractNativeLibs הוחלף באפשרות DSL useLegacyPackaging. מידע נוסף זמין בנתוני הגרסה שימוש ב-DSL כדי לארוז ספריות Native דחוסות.
גרסת ברירת המחדל של NDK
אם מורידים כמה גרסאות של ה-NDK, הפלאגין של Android Gradle בוחר עכשיו גרסת ברירת מחדל לשימוש בהידור של קובצי קוד המקור.
בעבר, הפלאגין בחר את הגרסה האחרונה של ה-NDK שהורדה.
משתמשים במאפיין android.ndkVersion בקובץ build.gradle של המודול כדי לשנות את ברירת המחדל שנבחרה על ידי הפלאגין.
יצירה פשוטה יותר של מחלקת R
הפלאגין של Android Gradle מפשט את ה-classpath של הקימפול על ידי יצירת מחלקת R אחת בלבד לכל מודול ספרייה בפרויקט, ושיתוף מחלקות ה-R האלה עם תלויות אחרות של מודולים. האופטימיזציה הזו אמורה להאיץ את תהליך ה-build, אבל חשוב לזכור את הדברים הבאים:
- מכיוון שהקומפיילר משתף מחלקות R עם יחסי תלות של מודולים במעלה הזרם, חשוב שכל מודול בפרויקט ישתמש בשם חבילה ייחודי.
- ההרשאות של מחלקת R של ספרייה לתלויות אחרות בפרויקט נקבעות לפי ההגדרה שמשמשת להכללת הספרייה כתלות. לדוגמה, אם ספרייה א' כוללת את ספרייה ב' כתלות ב-api, לספרייה א' ולספריות אחרות שתלויות בספרייה א' יש גישה למחלקה R של ספרייה ב'. עם זאת, יכול להיות שלספריות אחרות לא תהיה גישה למחלקה R של ספרייה ב'. אם ספרייה א' משתמשת בהגדרת התלות
implementation. מידע נוסף זמין במאמר הגדרות של יחסי תלות.
הסרת משאבים שחסרים בהגדרות ברירת המחדל
במודולים של ספרייה, אם כוללים משאב בשפה שלא נכללת בקבוצת המשאבים שמוגדרת כברירת מחדל – לדוגמה, אם כוללים את hello_world כמשאב מחרוזת ב-/values-es/strings.xml אבל לא מגדירים את המשאב הזה ב-/values/strings.xml – הפלאגין של Android Gradle לא כולל יותר את המשאב הזה כשמקמפלים את הפרויקט. השינוי הזה בהתנהגות אמור להפחית את מספר החריגות בזמן הריצה של Resource Not Found ולשפר את מהירות ה-build.
D8 עכשיו מכבד את מדיניות השמירה של CLASS להערות
כשמבצעים קומפילציה של האפליקציה, D8 מכבד עכשיו את המקרים שבהם הערות מיישמות מדיניות שמירת CLASS, וההערות האלה כבר לא זמינות בזמן הריצה. ההתנהגות הזו קיימת גם כשמגדירים את ה-SDK לטירגוט של האפליקציה לרמת API 23, שבעבר אפשרה גישה להערות האלה במהלך זמן הריצה כשמקמפלים את האפליקציה באמצעות גרסאות ישנות יותר של הפלאגין של Android Gradle ו-D8.
שינויים אחרים בהתנהגות
-
השדה
aaptOptions.noCompressכבר לא תלוי אותיות רישיות בכל הפלטפורמות (גם ל-APK וגם לחבילות), והוא תומך בנתיבים שכוללים אותיות רישיות. -
קישור הנתונים הוא עכשיו מצטבר כברירת מחדל. מידע נוסף זמין בבעיה מספר 110061530.
-
עכשיו אפשר לשמור במטמון את כל בדיקות היחידה, כולל בדיקות היחידה של Roboelectric. מידע נוסף זמין בבעיה מספר 115873047.
תיקוני באגים
הגרסה הזו של הפלאגין של Android Gradle כוללת את תיקוני הבאגים הבאים:
- עכשיו יש תמיכה בבדיקות יחידה של Robolectric במודולים של ספריות שמשתמשים בכריכת נתונים. מידע נוסף זמין בבעיה מספר 126775542.
- עכשיו אפשר להריץ משימות
connectedAndroidTestבכמה מודולים כשמצב ההרצה במקביל של Gradle מופעל.
בעיות מוכרות
בקטע הזה מתוארות בעיות מוכרות שקיימות בפלאגין של Android Gradle בגרסה 3.6.0.
ביצועים איטיים של משימת Android Lint
בפרויקטים מסוימים, יכול להיות שייקח הרבה יותר זמן להשלים את Android Lint בגלל רגרסיה בתשתית הניתוח שלו, שגורמת לחישוב איטי יותר של סוגים משוערים של פונקציות למבדה במבני קוד מסוימים.
הבעיה דווחה בתור באג ב-IDEA ותתוקן בפלאגין של Android Gradle גרסה 4.0.
חסרה מחלקת מניפסט {:#agp-missing-manifest}
אם האפליקציה מגדירה הרשאות בהתאמה אישית במניפסט שלה, הפלאגין של Android Gradle בדרך כלל יוצר מחלקה Manifest.java שכוללת את ההרשאות בהתאמה אישית בתור קבועים של מחרוזות. הפלאגין אורז את המחלקה הזו עם האפליקציה, כדי שיהיה קל יותר להפנות להרשאות האלה בזמן הריצה.
יצירת מחלקת המניפסט לא פועלת בפלאגין של Android Gradle בגרסה 3.6.0.
אם אתם מפתחים את האפליקציה עם הגרסה הזו של הפלאגין, והיא מפנה למחלקת המניפסט, יכול להיות שתראו חריגה מסוג ClassNotFoundException. כדי לפתור את הבעיה תוכלו לנסות אחד מהפתרונות הבאים:
-
צריך להפנות להרשאות המותאמות אישית לפי השם המלא שלהן. לדוגמה,
"com.example.myapp.permission.DEADLY_ACTIVITY". -
מגדירים קבועים משלכם, כמו בדוגמה הבאה:
public final class CustomPermissions { public static final class permission { public static final String DEADLY_ACTIVITY="com.example.myapp.permission.DEADLY_ACTIVITY"; } }
3.5.0 (אוגוסט 2019)
Android Gradle Plugin 3.5.0, יחד עם Android Studio 3.5, הוא גרסה מרכזית שנוצרה במסגרת Project Marble – פרויקט שמתמקד בשיפור שלושה תחומים עיקריים בכלי הפיתוח ל-Android: תקינות המערכת, ליטוש התכונות ותיקון באגים. אחד מהדגשים העיקריים בעדכון הזה הוא שיפור מהירות ה-build של הפרויקט.
מידע נוסף על העדכונים האלה ועל עדכונים אחרים של Project Marble זמין בפוסט בבלוג של Android Developers או בקטעים הבאים.
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
-
Gradle 5.4.1. מידע נוסף זמין בקטע בנושא עדכון Gradle.
-
SDK Build Tools מגרסה 28.0.3 ואילך.
העדכון הקטן הזה תומך בתאימות עם הגדרות ברירת מחדל ותכונות חדשות של הרשאות גישה לחבילה ב-Android 11.
פרטים נוספים זמינים בנתוני הגרסה של 4.0.1.
3.5.3 (דצמבר 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.5.3 וכולל תיקוני באגים שונים ושיפורי ביצועים.
3.5.2 (נובמבר 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.5.2 וכולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים חשובים, קראו את הפוסט הרלוונטי בבלוג של עדכוני הגרסאות.
3.5.1 (אוקטובר 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.5.1 וכולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים חשובים, קראו את הפוסט הרלוונטי בבלוג של עדכוני הגרסאות.
עיבוד מצטבר של הערות
מעבד האנוטציות (Annotation processor) של קישור נתונים תומך בעיבוד אנוטציות מצטבר אם מגדירים את android.databinding.incremental=true בקובץ gradle.properties. האופטימיזציה הזו משפרת את הביצועים של גרסאות build מצטברות. רשימה מלאה של מעבדי אנוטציות שעברו אופטימיזציה מופיעה בטבלה של מעבדי אנוטציות מצטברים.
בנוסף, KAPT מגרסה 1.3.30 ואילך תומך גם במעבדי אנוטציות מצטברים, שאפשר להפעיל על ידי הכללת kapt.incremental.apt=true בקובץ gradle.properties.
בדיקות יחידה שניתנות לשמירה במטמון
כשמפעילים בדיקות יחידה כדי להשתמש במשאבים, בנכסים ובמניפסטים של Android על ידי הגדרת includeAndroidResources ל-true, הפלאגין של Android Gradle יוצר קובץ תצורה לבדיקה שמכיל נתיבים מוחלטים, וזה פוגע ביכולת להעביר את המטמון. כדי להורות לפלאגין ליצור את הגדרת הבדיקה באמצעות נתיבים יחסיים, שמאפשרים לשמור את המשימה AndroidUnitTest במטמון באופן מלא, צריך לכלול את הקוד הבא בקובץ gradle.properties:
android.testConfig.useRelativePath = true
בעיות מוכרות
-
אם אתם משתמשים בפלאגין Kotlin Gradle בגרסה 1.3.31 או גרסה קודמת, יכול להיות שתראו את האזהרה הבאה בזמן ה-build או הסנכרון של הפרויקט:
WARNING: API 'variant.getPackageLibrary()' is obsolete and has been replaced with 'variant.getPackageLibraryProvider()'.כדי לפתור את הבעיה הזו, צריך לשדרג את הפלאגין לגרסה 1.3.40 ואילך.
3.4.0 (אפריל 2019)
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
-
Gradle בגרסה 5.1.1 ומעלה. מידע נוסף זמין בקטע בנושא עדכון Gradle.
הערה: כשמשתמשים ב-Gradle בגרסה 5.0 ואילך, גודל ברירת המחדל של ערימת הזיכרון של ה-daemon של Gradle יורד מ-1GB ל-512MB. זה עלול לגרום לרגרסיה בביצועי ה-build. כדי לשנות את הגדרת ברירת המחדל הזו, ציינו את גודל ה-heap של ה-daemon של Gradle בקובץ
gradle.propertiesשל הפרויקט. -
SDK Build Tools מגרסה 28.0.3 ואילך.
העדכון הקטן הזה תומך בתאימות עם הגדרות ברירת מחדל ותכונות חדשות של הרשאות גישה לחבילה ב-Android 11.
פרטים נוספים זמינים בנתוני הגרסה של 4.0.1.
3.4.2 (יולי 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.4.2 וכולל תיקוני באגים שונים ושיפורים בביצועים. כדי לראות רשימה של תיקוני באגים חשובים, קראו את הפוסט הרלוונטי בבלוג של עדכוני הגרסאות.
3.4.1 (מאי 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.4.1 וכולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים חשובים, קראו את הפוסט הרלוונטי בבלוג של עדכוני הגרסאות.
תכונות חדשות
-
הגדרות חדשות של תלות בבדיקות Lint: ההתנהגות של
lintChecksהשתנתה, והוספנו הגדרה חדשה של תלות,lintPublish, כדי לתת לכם יותר שליטה על בדיקות ה-Lint שנכללות בחבילה של ספריות Android.-
lintChecks: זוהי הגדרה קיימת שבה צריך להשתמש לבדיקות lint שרוצים להריץ רק כשיוצרים את הפרויקט באופן מקומי. אם השתמשתם בעבר בהגדרת התלותlintChecksכדי לכלול בדיקות lint בקובץ ה-AAR שפורסם, אתם צריכים להעביר את יחסי התלות האלה כדי להשתמש בהגדרה החדשהlintPublishשמתוארת בהמשך. -
lintPublish: משתמשים בהגדרה החדשה הזו בפרויקטים של ספרייה לבדיקות lint שרוצים לכלול ב-AAR שפורסם, כמו שמוצג בהמשך. זה אומר שפרויקטים שמשתמשים בספרייה שלך מחילים גם את בדיקות ה-lint האלה.
בדוגמת הקוד הבאה נעשה שימוש בשתי הגדרות התלות בפרויקט מקומי של ספריית Android.
dependencies { // Executes lint checks from the ':lint' project at build time. lintChecks project(':lint') // Packages lint checks from the ':lintpublish' in the published AAR. lintPublish project(':lintpublish') }
dependencies { // Executes lint checks from the ':lint' project at build time. lintChecks(project(":lint")) // Packages lint checks from the ':lintpublish' in the published AAR. lintPublish(project(":lintpublish")) }
-
באופן כללי, משימות האריזה והחתימה אמורות לשפר את מהירות ה-build הכוללת. אם אתם מבחינים ברגרסיה בביצועים שקשורה למשימות האלה, דווחו על באג.
-
שינויים בהתנהגות
-
אזהרה לגבי הוצאה משימוש של הפלאגין Android Instant Apps Feature: אם אתם עדיין משתמשים בפלאגין
com.android.featureכדי ליצור את האפליקציה ללא התקנה, פלאגין Android Gradle בגרסה 3.4.0 יציג לכם אזהרה לגבי הוצאה משימוש. כדי לוודא שעדיין תוכלו ליצור את האפליקציה ללא התקנה בגרסאות עתידיות של הפלאגין, אתם צריכים להעביר את האפליקציה ללא התקנה לשימוש בפלאגין של התכונה הדינמית, שגם מאפשר לכם לפרסם את חוויית השימוש באפליקציה המותקנת ובאפליקציה ללא התקנה מקובץ Android App Bundle אחד. -
R8 מופעל כברירת מחדל: R8 משלב תהליך הסרה של סוכר תחבירי, כיווץ, ערפול קוד, אופטימיזציה ו-dexing בשלב אחד, וכך משפר באופן משמעותי את ביצועי ה-build. R8 הושק בפלאגין של Android Gradle בגרסה 3.3.0, ועכשיו הוא מופעל כברירת מחדל גם בפרויקטים של אפליקציות וגם בפרויקטים של ספריות Android שמשתמשים בפלאגין בגרסה 3.4.0 ואילך.
התמונה הבאה מציגה סקירה כללית של תהליך ההידור לפני שהוצג R8.
עכשיו, עם R8, תהליך הסרה של סוכר תחבירי, כיווץ, ערפול קוד, אופטימיזציה ו-dexing (D8) מתבצעים כולם בשלב אחד, כמו שמוצג בהמשך.
חשוב לזכור ש-R8 מיועד לעבוד עם כללי ProGuard הקיימים, כך שכנראה לא תצטרכו לבצע פעולות כלשהן כדי ליהנות מהיתרונות של R8. עם זאת, מכיוון שמדובר בטכנולוגיה שונה מ-ProGuard, שמיועדת במיוחד לפרויקטים של Android, יכול להיות שהכיווץ והאופטימיזציה יסירו קוד ש-ProGuard לא הסיר. לכן, במצב הלא סביר הזה, יכול להיות שתצטרכו להוסיף עוד כללים כדי שהקוד הזה יישאר בפלט ה-build.
אם נתקלתם בבעיות בשימוש ב-R8, קראו את השאלות הנפוצות בנושא תאימות ל-R8 כדי לבדוק אם יש פתרון לבעיה. אם הפתרון לא מתועד, דווחו על באג.
כדי להשבית את R8, מוסיפים את אחת מהשורות הבאות לקובץ gradle.properties של הפרויקט:
# Disables R8 for Android Library modules only.
android.enableR8.libraries = false
# Disables R8 for all modules.
android.enableR8 = false
הערה: בסוג build נתון, אם מגדירים את useProguard כ-false בקובץ build.gradle של מודול האפליקציה, הפלאגין של Android Gradle משתמש ב-R8 כדי לצמצם את הקוד של האפליקציה לסוג ה-build הזה, גם אם משביתים את R8 בקובץ gradle.properties של הפרויקט.
-
ndkCompileהוצא משימוש: עכשיו תופיע שגיאת build אם תנסו להשתמש ב-ndkBuildכדי לקמפל את ספריות ה-Native. במקום זאת, צריך להשתמש ב-CMake או ב-ndk-build כדי להוסיף קוד C ו-C++ לפרויקט.
בעיות מוכרות
-
כרגע אנחנו לא אוכפים את השימוש הנכון בשמות חבילות ייחודיים, אבל נהיה מחמירים יותר בגרסאות הבאות של הפלאגין. בגרסה 3.4.0 של הפלאגין של Android Gradle, אפשר להוסיף את השורה הבאה לקובץ
gradle.propertiesכדי לבדוק אם הפרויקט מצהיר על שמות חבילות קבילים.android.uniquePackageNames = trueמידע נוסף על הגדרת שם חבילה באמצעות הפלאגין של Android Gradle זמין במאמר הגדרת מזהה האפליקציה.
3.3.0 (ינואר 2019)
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
-
Gradle בגרסה 4.10.1 ומעלה. מידע נוסף זמין בקטע בנושא עדכון Gradle.
הערה: כשמשתמשים ב-Gradle בגרסה 5.0 ואילך, גודל ברירת המחדל של ערימת הזיכרון של ה-daemon של Gradle יורד מ-1GB ל-512MB. זה עלול לגרום לרגרסיה בביצועי ה-build. כדי לשנות את הגדרת ברירת המחדל הזו, ציינו את גודל ה-heap של ה-daemon של Gradle בקובץ
gradle.propertiesשל הפרויקט. -
SDK Build Tools 28.0.3 ואילך.
העדכון הקטן הזה תומך בתאימות עם הגדרות ברירת מחדל ותכונות חדשות של הרשאות גישה לחבילה ב-Android 11.
פרטים נוספים זמינים בנתוני הגרסה של 4.0.1.
3.3.2 (מרץ 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.3.2 וכולל תיקוני באגים שונים ושיפורי ביצועים. כדי לראות רשימה של תיקוני באגים חשובים, קראו את הפוסט הרלוונטי בבלוג של עדכוני הגרסאות.
3.3.1 (פברואר 2019)
העדכון הקטן הזה תומך ב-Android Studio 3.3.1 וכולל תיקוני באגים שונים ושיפורי ביצועים.
תכונות חדשות
-
סנכרון משופר של classpath: כשפותרים יחסי תלות ב-classpath של זמן הריצה ושל זמן הקימפול, הפלאגין של Android Gradle מנסה לתקן התנגשויות מסוימות בגרסאות של יחסי תלות שמופיעים בכמה classpath.
לדוגמה, אם נתיב המחלקה של זמן הריצה כולל את גרסה 2.0 של ספרייה א' ונתיב המחלקה של הקימפול כולל את גרסה 1.0 של ספרייה א', הפלאגין מעדכן באופן אוטומטי את התלות בנתיב המחלקה של הקימפול לגרסה 2.0 של ספרייה א' כדי למנוע שגיאות.
עם זאת, אם ה-classpath של זמן הריצה כולל את גרסה 1.0 של ספרייה א' וה-classpath של ההידור כולל את גרסה 2.0 של ספרייה א', הפלאגין לא משדרג לאחור את התלות ב-classpath של ההידור לגרסה 1.0 של ספרייה א', ותופיע שגיאה. מידע נוסף זמין במאמר פתרון התנגשויות בין נתיבי classpath.
-
הידור מצטבר משופר של Java כשמשתמשים במעבדי אנוטציות: העדכון הזה מקצר את זמן ה-build על ידי שיפור התמיכה בהידור מצטבר של Java כשמשתמשים במעבדי אנוטציות.
הערה: התכונה הזו תואמת ל-Gradle מגרסה 4.10.1 ואילך, חוץ מ-Gradle מגרסה 5.1 בגלל בעיה 8194 ב-Gradle.
-
בפרויקטים שמשתמשים ב-Kapt (רוב הפרויקטים שכוללים רק Kotlin ופרויקטים היברידיים של Kotlin-Java): הידור מצטבר של Java מופעל, גם כשמשתמשים בקישור נתונים או בפלאגין retro-lambda. עיבוד ההערות על ידי המשימה Kapt עדיין לא מצטבר.
-
בפרויקטים שלא משתמשים ב-Kapt (פרויקטים ב-Java בלבד): אם כל מעבדי האנוטציות שבהם אתם משתמשים תומכים בעיבוד אנוטציות מצטבר, הידור מצטבר של Java מופעל כברירת מחדל. כדי לעקוב אחרי ההטמעה של מעבד אנוטציות (Annotation processor) מצטבר, אפשר לעיין בבעיה 5277 ב-Gradle.
עם זאת, אם אחד או יותר ממעבדי האנוטציות לא תומכים בבנייה מצטברת, הידור Java מצטבר לא מופעל. במקום זאת, אפשר לכלול את הדגל הבא בקובץ
gradle.properties:android.enableSeparateAnnotationProcessing=trueכשמוסיפים את הדגל הזה, הפלאגין של Android Gradle מריץ את מעבדי האנוטציות (Annotation processor) במשימה נפרדת ומאפשר למשימת הקימפול של Java לפעול באופן מצטבר.
-
-
מידע משופר על תוצאות ניפוי הבאגים כשמשתמשים ב-API מיושן: כשהפלאגין מזהה שאתם משתמשים ב-API שכבר לא נתמך, הוא יכול עכשיו לספק מידע מפורט יותר שיעזור לכם לקבוע איפה נעשה שימוש ב-API הזה. כדי לראות את המידע הנוסף, צריך לכלול את הפרטים הבאים בקובץ
gradle.propertiesשל הפרויקט:android.debug.obsoleteApi=trueאפשר גם להפעיל את הדגל על ידי העברת
-Pandroid.debug.obsoleteApi=trueמשורת הפקודה. -
אפשר להריץ בדיקות אינסטרומנטציה במודולים של תכונות משורת הפקודה.
שינויים בהתנהגות
-
הגדרת משימות עצלה: הפלאגין משתמש עכשיו ב-API החדש ליצירת משימות של Gradle כדי להימנע מהפעלה ומהגדרה של משימות שלא נדרשות להשלמת ה-build הנוכחי (או משימות שלא נמצאות בתרשים המשימות לביצוע). לדוגמה, אם יש לכם כמה וריאנטים של build, כמו וריאנטים של build מסוג "גרסת הפצה" ו"גרסת build לניפוי באגים", ואתם יוצרים את גרסת ה-build לניפוי באגים של האפליקציה, הפלאגין לא מאתחל ומגדיר משימות לגרסת ההפצה של האפליקציה.
קריאה ל-methods ישנות מסוימות ב-Variants API, כמו
variant.getJavaCompile(), עדיין עשויה לאלץ הגדרת משימה. כדי לוודא שה-build עבר אופטימיזציה להגדרת משימות עצלה, צריך להפעיל שיטות חדשות שמחזירות אובייקט TaskProvider, כמוvariant.getJavaCompileProvider().אם אתם מריצים משימות build בהתאמה אישית, כדאי לקרוא איך להתאים את המשימות ל-API החדש של Gradle ליצירת משימות.
-
בסוג build נתון, כשמגדירים את
useProguard false, הפלאגין משתמש עכשיו ב-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) ומעלה כוללים עכשיו גרסאות לא דחוסות של ספריות ה-Native כברירת מחדל. האופטימיזציה הזו מונעת את הצורך של המכשיר ליצור עותק של הספרייה, וכך מקטינה את גודל האפליקציה בדיסק. אם אתם מעדיפים להשבית את האופטימיזציה הזו, הוסיפו את הקוד הבא לקובץ
gradle.properties:android.bundle.enableUncompressedNativeLibs = false -
הפלאגין אוכף גרסאות מינימליות של פלאגינים מסוימים של צד שלישי.
-
סנכרון פרויקט עם וריאנט יחיד: סנכרון הפרויקט עם הגדרות ה-build הוא שלב חשוב שמאפשר ל-Android Studio להבין את מבנה הפרויקט. עם זאת, בפרויקטים גדולים התהליך הזה יכול להימשך זמן רב. אם בפרויקט שלכם יש כמה וריאנטים של build, עכשיו אתם יכולים לבצע אופטימיזציה של סנכרון הפרויקטים על ידי הגבלת הסנכרון רק לווריאנט שבחרתם כרגע.
כדי להפעיל את האופטימיזציה הזו, צריך להשתמש ב-Android Studio מגרסה 3.3 ואילך עם הפלאגין של Android Gradle מגרסה 3.3.0 ואילך. אם אתם עומדים בדרישות האלה, סביבת הפיתוח המשולבת תבקש מכם להפעיל את האופטימיזציה הזו כשתסנכרנו את הפרויקט. האופטימיזציה מופעלת כברירת מחדל גם בפרויקטים חדשים.
כדי להפעיל את האופטימיזציה הזו באופן ידני, לוחצים על File > Settings > Experimental > Gradle (Android Studio > Preferences > Experimental > Gradle ב-Mac) ובוחרים את תיבת הסימון Only sync the active variant.
הערה: האופטימיזציה הזו תומכת באופן מלא בפרויקטים שכוללים את השפות Java ו-++C, ויש לה תמיכה מסוימת ב-Kotlin. כשמפעילים את האופטימיזציה לפרויקטים עם תוכן Kotlin, הסנכרון של Gradle חוזר להשתמש בגרסאות מלאות באופן פנימי.
-
הורדה אוטומטית של חבילות SDK חסרות: הפונקציונליות הזו הורחבה כדי לתמוך ב-NDK. מידע נוסף זמין במאמר הורדה אוטומטית של חבילות חסרות באמצעות Gradle.
תיקוני באגים
-
בגרסה 3.3.0 של הפלאגין של Android Gradle תוקנו הבעיות הבאות:
- תהליך ה-build קורא ל-
android.support.v8.renderscript.RenderScriptבמקום לגרסת AndroidX, למרות ש-Jetifier מופעל - התנגשויות בגלל
androidx-rs.jar, כוללannotation.AnyResשנכלל באופן סטטי - כשמשתמשים ב-RenderScript, לא צריך יותר להגדיר ידנית את גרסת כלי ה-build בקובצי
build.gradle
- תהליך ה-build קורא ל-
3.2.0 (ספטמבר 2018)
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
- Gradle 4.6 ואילך. מידע נוסף זמין בקטע בנושא עדכון Gradle.
- SDK Build Tools מגרסה 28.0.3 ואילך.
3.2.1 (אוקטובר 2018)
בעקבות העדכון הזה, כבר לא צריך לציין גרסה של כלי ה-SDK Build Tools. הפלאגין של Android Gradle משתמש עכשיו בגרסה 28.0.3 כברירת מחדל.
תכונות חדשות
-
תמיכה ביצירת קובצי Android App Bundle: קובץ App Bundle הוא פורמט העלאה חדש שכולל את כל הקוד והמשאבים המקומפלים של האפליקציה, אבל דוחה את היצירה והחתימה של ה-APK לחנות Google Play. לא צריך יותר ליצור, לחתום ולנהל כמה חבילות APK, והמשתמשים מקבלים הורדות קטנות יותר שמותאמות למכשיר שלהם. thought מידע נוסף זמין במאמר מידע על קובצי Android App Bundle.
-
תמיכה במהירויות משופרות של גרסאות build מצטברות כשמשתמשים במעבדי אנוטציות: ה-DSL של
AnnotationProcessorOptionsמרחיב עכשיו אתCommandLineArgumentProvider, מה שמאפשר לכם או ליוצר של מעבד האנוטציות להוסיף אנוטציות לארגומנטים של המעבד באמצעות אנוטציות מסוג מאפיין של גרסת build מצטברת. השימוש בהערות האלה משפר את הדיוק והביצועים של גרסאות build נקיות מצטברות וגרסאות build נקיות שנשמרו במטמון. מידע נוסף זמין במאמר העברת ארגומנטים למעבדי אנוטציות. -
כלי העברה ל-AndroidX: כשמשתמשים בפלאגין של Android Gradle בגרסה 3.2.0 עם Android בגרסה 3.2 ואילך, אפשר להעביר את התלויות המקומיות ותלויות Maven של הפרויקט כדי להשתמש בספריות החדשות של AndroidX. כדי לעשות את זה, בוחרים באפשרות Refactor > Migrate to AndroidX בסרגל התפריטים. השימוש בכלי ההעברה הזה גם מגדיר את הדגלים הבאים לערך
trueבקובץgradle.properties:-
android.useAndroidX: כשהערך מוגדר כ-true, הפלאגין של Android משתמש בספריית AndroidX המתאימה במקום בספריית תמיכה. אם לא מציינים את הדגל הזה, הפלאגין מגדיר אותו כ-falseכברירת מחדל. -
android.enableJetifier: כשמגדירים את הערךtrue, הפלאגין של Android מעביר באופן אוטומטי ספריות קיימות של צד שלישי לשימוש ב-AndroidX על ידי שכתוב הקבצים הבינאריים שלהן. אם לא מציינים את הדגל הזה, הפלאגין מגדיר אותו כ-falseכברירת מחדל. אפשר להגדיר את הדגל הזה לערךtrueרק כשגםandroid.useAndroidXמוגדר לערךtrue, אחרת תתקבל שגיאת build.מידע נוסף זמין בסקירה הכללית של AndroidX.
-
-
כלי חדש לכיווץ קוד, R8: R8 הוא כלי חדש לכיווץ קוד ולערפול קוד שמחליף את 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 מקורי כשנפרסה גרסת ניפוי הבאגים של אפליקציה במכשיר עם Android ברמת API 21 ומעלה. עכשיו, לא משנה אם אתם פורסים במכשיר או יוצרים קובץ APK להפצה, הפלאגין של Android Gradle מאפשר multidex מקורי לכל המודולים שמוגדרים ל-
minSdkVersion=21ומעלה. -
הפלאגין אוכף עכשיו גרסה מינימלית של הפלאגין protobuf (0.8.6), הפלאגין Kotlin (1.2.50) והפלאגין Crashlytics (1.25.4).
-
הפלאגין של מודול התכונות,
com.android.feature, אוכף עכשיו שימוש באותיות, בספרות ובקווים תחתונים בלבד כשמציינים שם של מודול. לדוגמה, אם שם המודול של התכונות כולל מקפים, תופיע שגיאת build. ההתנהגות הזו תואמת להתנהגות של הפלאגין של התכונה הדינמית.
תיקוני באגים
- עכשיו אפשר לשמור במטמון את JavaCompile בפרויקטים עם קישור נתונים. (בעיה מספר 69243050)
- מניעת קומפילציה טובה יותר למודולים של ספריות עם קישור נתונים. (בעיה מספר 77539932)
- עכשיו אפשר להפעיל מחדש את configure-on-demand אם השבתתם אותו בגרסאות קודמות בגלל שגיאות לא צפויות ב-build. (בעיה מספר 77910727)
3.1.0 (מרץ 2018)
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
-
Gradle בגרסה 4.4 ואילך.
מידע נוסף זמין בקטע בנושא עדכון Gradle.
-
Build Tools מגרסה 27.0.3 ומעלה.
חשוב לזכור: לא צריך יותר לציין גרסה לכלי ה-build באמצעות המאפיין
android.buildToolsVersion– הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל.
מהדר DEX חדש, D8
כברירת מחדל, Android Studio משתמש עכשיו במהדר DEX חדש שנקרא D8. הידור DEX הוא תהליך של המרת בייטקוד של .class לבייטקוד של .dex לסביבת זמן הריצה ל-Android (או Dalvik, בגרסאות ישנות יותר של Android). בהשוואה לקומפיילר הקודם, שנקרא DX, D8 מבצע הידור מהר יותר ויוצר קובצי DEX קטנים יותר, תוך שמירה על ביצועים זהים או טובים יותר של זמן הריצה של האפליקציה.
השימוש ב-D8 לא אמור לשנות את תהליך העבודה היומיומי של פיתוח האפליקציה. עם זאת, אם נתקלתם בבעיות שקשורות למהדר החדש, אתם יכולים לדווח על באג. כדי להשבית זמנית את D8 ולהשתמש ב-DX, צריך לכלול את הקוד הבא בקובץ gradle.properties של הפרויקט:
android.enableD8=false
בפרויקטים שמשתמשים בתכונות של שפת Java 8, תהליך ההסרה המצטבר של סוכר תחבירי מופעל כברירת מחדל. כדי להשבית אותה, צריך לציין את הפרטים הבאים בקובץ gradle.properties של הפרויקט:
android.enableIncrementalDesugaring=false.
משתמשים בגרסת טרום-השקה (Preview): אם אתם כבר משתמשים בגרסת טרום-השקה של D8, שימו לב שעכשיו היא מקמפלת מול ספריות שנכללות בכלי ה-build של ה-SDK, ולא ב-JDK. לכן, אם אתם ניגשים לממשקי API שקיימים ב-JDK אבל לא בספריות של כלי ה-build של ה-SDK, תופיע שגיאת קומפילציה.
שינויים בהתנהגות
-
כשיוצרים כמה חבילות APK שכל אחת מהן מטרגטת ממשק ABI אחר, לא יוצר יותר חבילות APK לממשקי ה-ABI הבאים כברירת מחדל:
mips,mips64ו-armeabi.אם אתם רוצים ליצור קובצי APK שמטרגטים את ה-ABIs האלה, אתם צריכים להשתמש ב-NDK r16b או בגרסה ישנה יותר ולציין את ה-ABIs בקובץ
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 לא מזהה כראוי יחסי תלות ב-composite builds.
- תיקון בעיה שבה מתקבלת שגיאת סנכרון של פרויקט כשמנסים לטעון את הפלאגין של Android כמה פעמים ב-build אחד. לדוגמה, כשכמה פרויקטי משנה כוללים את הפלאגין של Android ב-classpath של ה-buildscript שלהם.
3.0.0 (אוקטובר 2017)
פלאגין של Android Gradle 3.0.0 כולל מגוון שינויים שנועדו לטפל בבעיות בביצועים של פרויקטים גדולים.
לדוגמה, בפרויקט שלד לדוגמה עם כ-130 מודולים ומספר גדול של יחסי תלות חיצוניים (אבל בלי צורך בקוד או משאבים), אפשר לראות שיפורים בביצועים שדומים לאלה:
| גרסת הפלאגין של Android + גרסת Gradle | פלאגין של Android בגרסה 2.2.0 + Gradle בגרסה 2.14.1 | פלאגין של Android בגרסה 2.3.0 ומעלה + Gradle בגרסה 3.3 | פלאגין של Android בגרסה 3.0.0 ואילך + Gradle בגרסה 4.1 |
|---|---|---|---|
הגדרות אישיות (למשל, הפעלת ./gradlew --help) |
כ-2 דקות | ~9 שניות | ~2.5 שנ' |
| שינוי של שורה אחת ב-Java (שינוי בהטמעה) | ~2 דקות ו-15 שניות | ~29 שניות | ~6.4 שניות |
חלק מהשינויים האלה משבשים גרסאות build קיימות. לכן, כדאי להביא בחשבון את המאמץ הכרוך בהעברת הפרויקט לפני שמשתמשים בפלאגין החדש.
אם לא חוויתם את השיפורים בביצועים שמתוארים למעלה, דווחו על באג וצרפו מעקב של ה-build באמצעות Gradle Profiler.
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
- Gradle 4.1 ואילך. מידע נוסף זמין בקטע בנושא עדכון Gradle.
-
Build Tools 26.0.2 ומעלה. בעקבות העדכון הזה, לא צריך יותר לציין גרסה לכלי ה-build – הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל.
לכן, עכשיו אפשר להסיר את הנכס
android.buildToolsVersion.
3.0.1 (נובמבר 2017)
זהו עדכון קטן לתמיכה ב-Android Studio 3.0.1, והוא כולל תיקוני באגים כלליים ושיפורי ביצועים.
פעולות אופטימיזציה
- מקביליות משופרת לפרויקטים עם כמה מודולים באמצעות תרשים משימות מפורט.
- כשמבצעים שינויים ביחסי תלות, Gradle מבצע גרסאות build מהירות יותר כי הוא לא מקמפל מחדש מודולים שאין להם גישה ל-API של יחסי התלות האלה.
כדאי להגביל את יחסי התלות שחושפים את ממשקי ה-API שלהם למודולים אחרים, על ידי שימוש בהגדרות החדשות של Gradle ליחסי תלות:
implementation,api,compileOnlyו-runtimeOnly. - מהירות גבוהה יותר של בנייה מצטברת, בזכות המרת DEX לכל מחלקה. כל מחלקה עוברת עכשיו הידור לקובצי DEX נפרדים, ורק המחלקות ששונו עוברות המרה מחדש ל-DEX. בנוסף, צפויה עלייה במהירות של פיתוח אפליקציות שבהן הערך של
minSdkVersionהוא 20 או פחות, ומשתמשות ב-multi-dex מדור קודם. - שיפרנו את מהירות ה-build על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שנשמר במטמון. כדי ליהנות מהאופטימיזציה הזו, קודם צריך להפעיל את המטמון של ה-build ב-Gradle.
- עיבוד משאבים מצטבר משופר באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלתם בבעיות במהלך השימוש ב-AAPT2, דווחו על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת
android.enableAapt2=falseבקובץgradle.propertiesוהפעלה מחדש של ה-daemon של Gradle באמצעות הרצת./gradlew --stopמשורת הפקודה.
תכונות חדשות
- ניהול יחסי תלות עם מודעות לווריאנטים. כשיוצרים וריאנט מסוים של מודול, הפלאגין מתאים עכשיו באופן אוטומטי את הווריאנטים של יחסי התלות של מודול הספרייה המקומית לווריאנט של המודול שיוצרים.
- כולל פלאגין חדש של מודול תכונות לתמיכה באפליקציות ללא התקנה ל-Android וב-Android Instant Apps SDK (שאפשר להוריד באמצעות SDK Manager). כדי לקבל מידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, קראו את המאמר מבנה של אפליקציה ללא התקנה עם כמה תכונות.
- תמיכה מובנית בשימוש בתכונות מסוימות של שפת Java 8 ובספריות של Java 8. Jack הוצא משימוש ואין בו יותר צורך, וצריך קודם להשבית את Jack כדי להשתמש בתמיכה המשופרת ב-Java 8 שמובנית ב-toolchain שמוגדר כברירת מחדל. למידע נוסף, קראו את המאמר שימוש בתכונות השפה של Java 8.
-
נוספה תמיכה בהרצת בדיקות באמצעות תזמור בדיקות ל-Android, שמאפשר להריץ כל אחת מהבדיקות של האפליקציה במסגרת הפעלה משלה של Instrumentation. כל בדיקה פועלת במכונה משלה של Instrumentation, ולכן מצבים משותפים בין בדיקות לא מצטברים במעבד או בזיכרון של המכשיר. וגם אם בדיקה אחת קורסת, היא משביתה רק את המכונה שלה ב-Instrumentation, כך שהבדיקות האחרות עדיין פועלות.
- הוספנו את
testOptions.executionכדי לקבוע אם להשתמש בתזמור בדיקות במכשיר. אם רוצים להשתמש בתזמור בדיקות ל-Android, צריך לציין אתANDROID_TEST_ORCHESTRATOR, כמו שמוצג בהמשך. כברירת מחדל, המאפיין הזה מוגדר לערךHOST, שמשבית את התזמור במכשיר וזו השיטה הרגילה להרצת בדיקות.
מגניב
android { testOptions { execution 'ANDROID_TEST_ORCHESTRATOR' } }
Kotlin
android { testOptions { execution = "ANDROID_TEST_ORCHESTRATOR" } }
- הוספנו את
-
הגדרת התלות החדשה של
androidTestUtilמאפשרת להתקין קובץ APK נוסף של כלי עזר לבדיקה לפני שמריצים את בדיקות האינסטרומנטציה, כמו תזמור בדיקות ל-Android:מגניב
dependencies { androidTestUtil 'com.android.support.test:orchestrator:1.0.0' ... }
Kotlin
dependencies { androidTestUtil("com.android.support.test:orchestrator:1.0.0") ... }
-
הוספנו את
testOptions.unitTests.includeAndroidResourcesכדי לתמוך בבדיקות יחידה שדורשות משאבי Android, כמו Roboelectric. כשמגדירים את המאפיין הזה לערךtrue, הפלאגין ממזג את המשאבים, הנכסים והמניפסט לפני הרצת בדיקות היחידה. לאחר מכן, הבדיקות יכולות לבדוק אתcom/android/tools/test_config.propertiesבנתיב המחלקה (classpath) עבור המפתחות הבאים:-
android_merged_assets: הנתיב המוחלט לספריית הנכסים הממוזגת.הערה: במודולים של ספריות, הנכסים הממוזגים לא מכילים את הנכסים של יחסי התלות (ראו בעיה מספר 65550419).
-
android_merged_manifest: הנתיב המוחלט לקובץ המניפסט שעבר מיזוג. -
android_merged_resources: הנתיב המוחלט לספריית המשאבים הממוזגים, שמכילה את כל המשאבים מהמודול וכל יחסי התלות שלו. -
android_custom_package: שם החבילה של מחלקת ה-R הסופית. אם משנים באופן דינמי את מזהה האפליקציה, יכול להיות ששם החבילה הזה לא יהיה זהה למאפייןpackageבמניפסט של האפליקציה.
-
- תמיכה בגופנים כמשאבים (תכונה חדשה שהוצגה ב-Android 8.0 (רמת API 26)).
- תמיכה בקובצי APK ספציפיים לשפה באמצעות Android Instant Apps SDK 1.1 ואילך.
-
עכשיו אפשר לשנות את ספריית הפלט של פרויקט ה-build המקורי החיצוני, כמו שמוצג בהמשך:
מגניב
android { ... externalNativeBuild { // For ndk-build, instead use the ndkBuild block. cmake { ... // Specifies a relative path for outputs from external native // builds. You can specify any path that's not a subdirectory // of your project's temporary build/ directory. buildStagingDirectory "./outputs/cmake" } } }
Kotlin
android { ... externalNativeBuild { // For ndk-build, instead use the ndkBuild block. cmake { ... // Specifies a relative path for outputs from external native // builds. You can specify any path that's not a subdirectory // of your project's temporary build/ directory. buildStagingDirectory = "./outputs/cmake" } } }
- עכשיו אפשר להשתמש ב-CMake בגרסה 3.7 ואילך כשיוצרים פרויקטים מקוריים מ-Android Studio.
-
הגדרת התלות החדשה של
lintChecksמאפשרת לכם ליצור קובץ JAR שמגדיר כללי lint בהתאמה אישית, ולארוז אותו בפרויקטים של AAR ו-APK.כללי ה-lint בהתאמה אישית צריכים להיות שייכים לפרויקט נפרד שמוציא קובץ JAR יחיד וכולל רק יחסי תלות של
compileOnly. אחרי זה, מודולים אחרים של אפליקציות וספריות יכולים להסתמך על פרויקט ה-lint באמצעות ההגדרהlintChecks:מגניב
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")) }
שינויים בהתנהגות
- בגרסה 3.0.0 של הפלאגין של Android הוסרו ממשקי API מסוימים, ואם תשתמשו בהם, ה-build שלכם ייכשל. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג
outputFile()או להשתמש ב-processManifest.manifestOutputFile()כדי לקבל את קובץ המניפסט של כל וריאנט. מידע נוסף זמין במאמר שינויים ב-API. - לא צריך יותר לציין גרסה לכלי ה-build (כלומר, עכשיו אפשר להסיר את המאפיין
android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש באופן אוטומטי בגרסה המינימלית הנדרשת של כלי ה-build עבור גרסת הפלאגין של Android שבה אתם משתמשים. - עכשיו אתם יכולים להפעיל או להשבית את דחיסת ה-PNG בבלוק
buildTypes, כמו שמוצג בהמשך. כברירת מחדל, דחיסת קובצי PNG מופעלת בכל גרסאות ה-build, חוץ מגרסאות build לניפוי באגים, כי היא מאריכה את זמני ה-build של פרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני ה-build של סוגי build אחרים, צריך להשבית את דחיסת ה-PNG או להמיר את התמונות ל-WebP.מגניב
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.
- עכשיו צריך להוסיף מעבדי אנוטציות ל-classpath של המעבד באמצעות הגדרת התלות
annotationProcessor. - השימוש ב-
ndkCompileשהוצא משימוש מוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד Native שרוצים לארוז ב-APK. מידע נוסף זמין במאמר מעבר מ-ndkcompile.
3.0.0 (אוקטובר 2017)
פלאגין של Android Gradle 3.0.0 כולל מגוון שינויים שנועדו לטפל בבעיות בביצועים של פרויקטים גדולים.
לדוגמה, בפרויקט שלד לדוגמה עם כ-130 מודולים ומספר גדול של יחסי תלות חיצוניים (אבל בלי צורך בקוד או משאבים), אפשר לראות שיפורים בביצועים שדומים לאלה:
| גרסת הפלאגין של Android + גרסת Gradle | פלאגין של Android בגרסה 2.2.0 + Gradle בגרסה 2.14.1 | פלאגין של Android בגרסה 2.3.0 ומעלה + Gradle בגרסה 3.3 | פלאגין של Android בגרסה 3.0.0 ואילך + Gradle בגרסה 4.1 |
|---|---|---|---|
הגדרות אישיות (למשל, הפעלת ./gradlew --help) |
כ-2 דקות | ~9 שניות | ~2.5 שנ' |
| שינוי של שורה אחת ב-Java (שינוי בהטמעה) | ~2 דקות ו-15 שניות | ~29 שניות | ~6.4 שניות |
חלק מהשינויים האלה משבשים גרסאות build קיימות. לכן, כדאי להביא בחשבון את המאמץ הכרוך בהעברת הפרויקט לפני שמשתמשים בפלאגין החדש.
אם לא חוויתם את השיפורים בביצועים שמתוארים למעלה, דווחו על באג וצרפו מעקב של ה-build באמצעות Gradle Profiler.
הגרסה הזו של הפלאגין של Android דורשת את הדברים הבאים:
- Gradle 4.1 ואילך. מידע נוסף זמין בקטע בנושא עדכון Gradle.
-
Build Tools 26.0.2 ומעלה. בעקבות העדכון הזה, לא צריך יותר לציין גרסה לכלי ה-build – הפלאגין משתמש בגרסה המינימלית הנדרשת כברירת מחדל.
לכן, עכשיו אפשר להסיר את הנכס
android.buildToolsVersion.
3.0.1 (נובמבר 2017)
זהו עדכון קטן לתמיכה ב-Android Studio 3.0.1, והוא כולל תיקוני באגים כלליים ושיפורי ביצועים.
פעולות אופטימיזציה
- מקביליות משופרת לפרויקטים עם כמה מודולים באמצעות תרשים משימות מפורט.
- כשמבצעים שינויים ביחסי תלות, Gradle מבצע גרסאות build מהירות יותר כי הוא לא מקמפל מחדש מודולים שאין להם גישה ל-API של יחסי התלות האלה.
כדאי להגביל את יחסי התלות שחושפים את ממשקי ה-API שלהם למודולים אחרים, על ידי שימוש בהגדרות החדשות של Gradle ליחסי תלות:
implementation,api,compileOnlyו-runtimeOnly. - מהירות גבוהה יותר של בנייה מצטברת, בזכות המרת DEX לכל מחלקה. כל מחלקה עוברת עכשיו הידור לקובצי DEX נפרדים, ורק המחלקות ששונו עוברות המרה מחדש ל-DEX. בנוסף, צפויה עלייה במהירות של פיתוח אפליקציות שבהן הערך של
minSdkVersionהוא 20 או פחות, ומשתמשות ב-multi-dex מדור קודם. - שיפרנו את מהירות ה-build על ידי אופטימיזציה של משימות מסוימות לשימוש בפלט שנשמר במטמון. כדי ליהנות מהאופטימיזציה הזו, קודם צריך להפעיל את המטמון של ה-build ב-Gradle.
- עיבוד משאבים מצטבר משופר באמצעות AAPT2, שמופעל עכשיו כברירת מחדל. אם נתקלתם בבעיות במהלך השימוש ב-AAPT2, דווחו על באג. אפשר גם להשבית את AAPT2 על ידי הגדרת
android.enableAapt2=falseבקובץgradle.propertiesוהפעלה מחדש של ה-daemon של Gradle באמצעות הרצת./gradlew --stopמשורת הפקודה.
תכונות חדשות
- ניהול יחסי תלות עם מודעות לווריאנטים. כשיוצרים וריאנט מסוים של מודול, הפלאגין מתאים עכשיו באופן אוטומטי את הווריאנטים של יחסי התלות של מודול הספרייה המקומית לווריאנט של המודול שיוצרים.
- כולל פלאגין חדש של מודול תכונות לתמיכה באפליקציות ללא התקנה ל-Android וב-Android Instant Apps SDK (שאפשר להוריד באמצעות SDK Manager). כדי לקבל מידע נוסף על יצירת מודולים של תכונות באמצעות הפלאגין החדש, קראו את המאמר מבנה של אפליקציה ללא התקנה עם כמה תכונות.
- תמיכה מובנית בשימוש בתכונות מסוימות של שפת Java 8 ובספריות של Java 8. Jack הוצא משימוש ואין בו יותר צורך, וצריך קודם להשבית את Jack כדי להשתמש בתמיכה המשופרת ב-Java 8 שמובנית ב-toolchain שמוגדר כברירת מחדל. למידע נוסף, קראו את המאמר שימוש בתכונות השפה של Java 8.
-
נוספה תמיכה בהרצת בדיקות באמצעות תזמור בדיקות ל-Android, שמאפשר להריץ כל אחת מהבדיקות של האפליקציה במסגרת הפעלה משלה של Instrumentation. כל בדיקה פועלת במכונה משלה של Instrumentation, ולכן מצבים משותפים בין בדיקות לא מצטברים במעבד או בזיכרון של המכשיר. וגם אם בדיקה אחת קורסת, היא משביתה רק את המכונה שלה ב-Instrumentation, כך שהבדיקות האחרות עדיין פועלות.
- הוספנו את
testOptions.executionכדי לקבוע אם להשתמש בתזמור בדיקות במכשיר. אם רוצים להשתמש בתזמור בדיקות ל-Android, צריך לציין אתANDROID_TEST_ORCHESTRATOR, כמו שמוצג בהמשך. כברירת מחדל, המאפיין הזה מוגדר לערךHOST, שמשבית את התזמור במכשיר וזו השיטה הרגילה להרצת בדיקות.
מגניב
android { testOptions { execution 'ANDROID_TEST_ORCHESTRATOR' } }
Kotlin
android { testOptions { execution = "ANDROID_TEST_ORCHESTRATOR" } }
- הוספנו את
-
הגדרת התלות החדשה של
androidTestUtilמאפשרת להתקין קובץ APK נוסף של כלי עזר לבדיקה לפני שמריצים את בדיקות האינסטרומנטציה, כמו תזמור בדיקות ל-Android:מגניב
dependencies { androidTestUtil 'com.android.support.test:orchestrator:1.0.0' ... }
Kotlin
dependencies { androidTestUtil("com.android.support.test:orchestrator:1.0.0") ... }
-
הוספנו את
testOptions.unitTests.includeAndroidResourcesכדי לתמוך בבדיקות יחידה שדורשות משאבי Android, כמו Roboelectric. כשמגדירים את המאפיין הזה לערךtrue, הפלאגין ממזג את המשאבים, הנכסים והמניפסט לפני הרצת בדיקות היחידה. לאחר מכן, הבדיקות יכולות לבדוק אתcom/android/tools/test_config.propertiesבנתיב המחלקה (classpath) עבור המפתחות הבאים:-
android_merged_assets: הנתיב המוחלט לספריית הנכסים הממוזגת.הערה: במודולים של ספריות, הנכסים הממוזגים לא מכילים את הנכסים של יחסי התלות (ראו בעיה מספר 65550419).
-
android_merged_manifest: הנתיב המוחלט לקובץ המניפסט שעבר מיזוג. -
android_merged_resources: הנתיב המוחלט לספריית המשאבים הממוזגים, שמכילה את כל המשאבים מהמודול וכל יחסי התלות שלו. -
android_custom_package: שם החבילה של מחלקת ה-R הסופית. אם משנים באופן דינמי את מזהה האפליקציה, יכול להיות ששם החבילה הזה לא יהיה זהה למאפייןpackageבמניפסט של האפליקציה.
-
- תמיכה בגופנים כמשאבים (תכונה חדשה שהוצגה ב-Android 8.0 (רמת API 26)).
- תמיכה בקובצי APK ספציפיים לשפה באמצעות Android Instant Apps SDK 1.1 ואילך.
-
עכשיו אפשר לשנות את ספריית הפלט של פרויקט ה-build המקורי החיצוני, כמו שמוצג בהמשך:
מגניב
android { ... externalNativeBuild { // For ndk-build, instead use the ndkBuild block. cmake { ... // Specifies a relative path for outputs from external native // builds. You can specify any path that's not a subdirectory // of your project's temporary build/ directory. buildStagingDirectory "./outputs/cmake" } } }
Kotlin
android { ... externalNativeBuild { // For ndk-build, instead use the ndkBuild block. cmake { ... // Specifies a relative path for outputs from external native // builds. You can specify any path that's not a subdirectory // of your project's temporary build/ directory. buildStagingDirectory = "./outputs/cmake" } } }
- עכשיו אפשר להשתמש ב-CMake בגרסה 3.7 ואילך כשיוצרים פרויקטים מקוריים מ-Android Studio.
-
הגדרת התלות החדשה של
lintChecksמאפשרת לכם ליצור קובץ JAR שמגדיר כללי lint בהתאמה אישית, ולארוז אותו בפרויקטים של AAR ו-APK.כללי ה-lint בהתאמה אישית צריכים להיות שייכים לפרויקט נפרד שמוציא קובץ JAR יחיד וכולל רק יחסי תלות של
compileOnly. אחרי זה, מודולים אחרים של אפליקציות וספריות יכולים להסתמך על פרויקט ה-lint באמצעות ההגדרהlintChecks:מגניב
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")) }
שינויים בהתנהגות
- בגרסה 3.0.0 של הפלאגין של Android הוסרו ממשקי API מסוימים, ואם תשתמשו בהם, ה-build שלכם ייכשל. לדוגמה, אי אפשר יותר להשתמש ב-Variants API כדי לגשת לאובייקטים מסוג
outputFile()או להשתמש ב-processManifest.manifestOutputFile()כדי לקבל את קובץ המניפסט של כל וריאנט. מידע נוסף זמין במאמר שינויים ב-API. - לא צריך יותר לציין גרסה לכלי ה-build (כלומר, עכשיו אפשר להסיר את המאפיין
android.buildToolsVersion). כברירת מחדל, הפלאגין משתמש באופן אוטומטי בגרסה המינימלית הנדרשת של כלי ה-build עבור גרסת הפלאגין של Android שבה אתם משתמשים. - עכשיו אתם יכולים להפעיל או להשבית את דחיסת ה-PNG בבלוק
buildTypes, כמו שמוצג בהמשך. כברירת מחדל, דחיסת קובצי PNG מופעלת בכל גרסאות ה-build, חוץ מגרסאות build לניפוי באגים, כי היא מאריכה את זמני ה-build של פרויקטים שכוללים הרבה קובצי PNG. לכן, כדי לשפר את זמני ה-build של סוגי build אחרים, צריך להשבית את דחיסת ה-PNG או להמיר את התמונות ל-WebP.מגניב
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.
- עכשיו צריך להוסיף מעבדי אנוטציות ל-classpath של המעבד באמצעות הגדרת התלות
annotationProcessor. - השימוש ב-
ndkCompileשהוצא משימוש מוגבל יותר עכשיו. במקום זאת, צריך לעבור לשימוש ב-CMake או ב-ndk-build כדי לקמפל קוד Native שרוצים לארוז ב-APK. מידע נוסף זמין במאמר מעבר מ-ndkcompile.
2.3.0 (פברואר 2017)
2.3.3 (יוני 2017)
זהו עדכון קטן שמוסיף תאימות ל-Android Studio 2.3.3.
2.3.2 (מאי 2017)
זהו עדכון קטן שמוסיף תאימות ל-Android Studio 2.3.2.
2.3.1 (אפריל 2017)
זהו עדכון קטן לפלאגין של Android בגרסה 2.3.0 שמתקן בעיה שבה מכשירי Android פיזיים מסוימים לא פעלו כראוי עם Instant Run (ראו בעיה מס' 235879).
- תלויות:
-
- Gradle מגרסה 3.3 ואילך.
- Build Tools 25.0.0 ואילך.
- הפרטים החדשים:
-
- שימוש ב-Gradle 3.3, שכולל שיפורים בביצועים ותכונות חדשות. פרטים נוספים זמינים בנתוני הגרסה של Gradle.
- מטמון ה-build: מאחסן פלטים מסוימים שהפלאגין של Android יוצר כשהוא יוצר את ה-build של הפרויקט (כמו קובצי AAR לא ארוזים ויחסי תלות מרוחקים שעברו pre-dexing). ה-builds הנקיים מהירים הרבה יותר כשמשתמשים במטמון, כי מערכת ה-build יכולה פשוט להשתמש שוב בקבצים האלה שנשמרו במטמון במהלך ה-builds הבאים, במקום ליצור אותם מחדש. בפרויקטים שמשתמשים בפלאגין של Android מגרסה 2.3.0 ואילך, המערכת משתמשת במטמון ה-build כברירת מחדל. מידע נוסף זמין במאמר Improve Build Speed with Build Cache.
- כולל משימה של
cleanBuildCacheשמנקה את המטמון של ה-build. - אם אתם משתמשים בגרסה הניסיונית של מטמון ה-build (שכלולה בגרסאות קודמות של הפלאגין), אתם צריכים לעדכן את הפלאגין לגרסה האחרונה.
- כולל משימה של
- השינויים:
-
- תמיכה בשינויים ב-Instant Run שנכללים ב-Android Studio 2.3.
- זמני ההגדרה של פרויקטים גדולים מאוד אמורים להיות מהירים יותר באופן משמעותי.
- תוקנו בעיות בהורדה האוטומטית של ספריית פריסת האילוצים.
- הפלאגין משתמש עכשיו ב-ProGuard בגרסה 5.3.2.
- כוללת הרבה תיקונים של באגים שדווחו. אם נתקלת בבעיות, אפשר להמשיך לשלוח דוחות על באגים.
2.2.0 (ספטמבר 2016)
- תלויות:
-
- Gradle מגרסה 2.14.1 ואילך.
- Build Tools 23.0.2 או גרסה חדשה יותר.
- הפרטים החדשים:
-
- שימוש ב-Gradle 2.14.1, שכולל שיפורים בביצועים ותכונות חדשות, ומתקן פרצת אבטחה שמאפשרת הסלמת הרשאות מקומית כשמשתמשים ב-Gradle daemon. פרטים נוספים זמינים בנתוני הגרסה של Gradle.
- באמצעות ה-DSL של
externalNativeBuild {}, עכשיו Gradle מאפשר לכם לקשר למקורות ה-Native ולקמפל ספריות Native באמצעות CMake או ndk-build. אחרי שיוצרים את ספריות ה-Native, Gradle אורז אותן ב-APK. מידע נוסף על השימוש ב-CMake וב-ndk-build עם Gradle זמין במאמר הוספת קוד C ו-C++ לפרויקט. - כשמריצים build משורת הפקודה, Gradle מנסה להוריד באופן אוטומטי את כל הרכיבים או העדכונים החסרים של ה-SDK שהפרויקט תלוי בהם. מידע נוסף זמין במאמר הורדה אוטומטית של חבילות חסרות באמצעות Gradle.
- תכונה ניסיונית חדשה לשמירה במטמון מאפשרת ל-Gradle להאיץ את זמני ה-build על ידי pre-dexing, אחסון ושימוש חוזר בגרסאות ה-pre-dexed של הספריות. מידע נוסף על השימוש בתכונה הניסיונית הזו זמין במדריך Build Cache.
- שיפור ביצועי ה-build על ידי שימוש בצינור עיבוד נתונים חדש לאריזה כברירת מחדל, שמטפל בדחיסה, בחתימה וב-zipalign במשימה אחת. כדי לחזור להשתמש בכלי האריזה הישנים, אפשר להוסיף את
android.useOldPackaging=trueלקובץgradle.properties. בזמן השימוש בכלי האריזה החדש, המשימהzipalignDebugלא זמינה. עם זאת, אתם יכולים ליצור אחד בעצמכם על ידי קריאה ל-methodcreateZipAlignTask(String taskName, File inputFile, File outputFile). - חתימת APK משתמשת עכשיו ב-APK Signature Scheme
v2 בנוסף לחתימת JAR המסורתית. כל פלטפורמות Android מקבלות את קובצי ה-APK שנוצרו. כל שינוי בקובצי ה-APK האלה אחרי החתימה מבטל את החתימות שלהם בגרסה 2 ומונע את ההתקנה שלהם במכשיר. כדי להשבית את התכונה הזו, מוסיפים את מה שמופיע כאן למטה לקובץ
build.gradleברמת המודול:מגניב
android { ... signingConfigs { config { ... v2SigningEnabled false } } }
Kotlin
android { ... signingConfigs { create("config") { ... v2SigningEnabled = false } } }
- ב-builds של multidex, עכשיו אפשר להשתמש בכללי ProGuard כדי לקבוע אילו מחלקות Gradle צריך לקמפל לקובץ ה-DEX הראשי של האפליקציה. מערכת Android טוענת את קובץ ה-DEX הראשי קודם כל כשהאפליקציה מופעלת, אז אפשר לתת עדיפות למחלקות מסוימות בזמן ההפעלה על ידי קימפול שלהן לקובץ ה-DEX הראשי. אחרי שיוצרים קובץ תצורה של ProGuard במיוחד לקובץ ה-DEX הראשי, מעבירים את הנתיב של קובץ התצורה ל-Gradle באמצעות
buildTypes.multiDexKeepProguard. השימוש ב-DSL הזה שונה מהשימוש ב-buildTypes.proguardFiles, שמספק כללי ProGuard כלליים לאפליקציה ולא מציין מחלקות לקובץ ה-DEX הראשי. - נוספה תמיכה בדגל
android:extractNativeLibs, שיכול להקטין את גודל האפליקציה כשמתקינים אותה במכשיר. כשמגדירים את הדגל הזה לערךfalseברכיב<application>בקובץ המניפסט של האפליקציה, Gradle אורז גרסאות לא דחוסות ומיושרות של ספריות ה-Native עם ה-APK. כךPackageManagerלא מעתיק את ספריות ה-Native מה-APK למערכת הקבצים של המכשיר במהלך ההתקנה, וגם מקטין את העדכונים של האפליקציה. - עכשיו אפשר לציין את
versionNameSuffixואתapplicationIdSuffixלגרסאות המוצר. (בעיה מספר 59614)
- השינויים:
-
-
getDefaultProguardFileמחזירה עכשיו את קובצי ברירת המחדל של ProGuard שפלאגין Android ל-Gradle מספק, ולא משתמשת יותר בקבצים שב-Android SDK. - שיפורים בביצועים ובתכונות של מהדר Jack:
- Jack תומך עכשיו בכיסוי בדיקות של Jacoco כשמגדירים את
testCoverageEnabledל-true. - תמיכה משופרת במעבדי אנוטציות (Annotation processor). מעבדי אנוטציות ב-classpath, כמו יחסי תלות של
compile, מופעלים באופן אוטומטי על ה-build. אתם יכולים גם לציין מעבד אנוטציות ב-build ולהעביר ארגומנטים באמצעות ה-DSLjavaCompileOptions.annotationProcessorOptions {}בקובץbuild.gradleברמת המודול:מגניב
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")) } } } }
אם רוצים להחיל מעבד אנוטציות (Annotation processor) בזמן הקימפול אבל לא לכלול אותו ב-APK, משתמשים בהיקף התלות
annotationProcessor:מגניב
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 }
- כברירת מחדל, אם גודל ה-heap של ה-daemon של Gradle הוא לפחות 1.5GB, Jack פועל עכשיו באותו תהליך כמו Gradle. כדי לשנות את גודל ה-heap של ה-daemon, מוסיפים את מה שמופיע כאן למטה לקובץ
gradle.properties:# This sets the daemon heap size to 1.5GB. org.gradle.jvmargs=-Xmx1536M
כדי להציג רשימה של פרמטרים שאפשר להגדיר, מריצים את הפקודה הבאה משורת הפקודה:
java -jar /build-tools/jack.jar --help-properties
- Jack תומך עכשיו בכיסוי בדיקות של Jacoco כשמגדירים את
-
2.1.0 (אפריל 2016)
2.1.3 (אוגוסט 2016)
העדכון הזה דורש את Gradle בגרסה 2.14.1 ואילך. גרסה 2.14.1 של Gradle כוללת שיפורים בביצועים, תכונות חדשות ותיקון אבטחה חשוב. פרטים נוספים זמינים בנתוני הגרסה של Gradle.
- תלויות:
-
- Gradle מגרסה 2.10 ואילך.
- Build Tools 23.0.2 ואילך.
- הפרטים החדשים:
-
- הוספנו תמיכה בגרסת טרום-השקה למפתחים של N, ב-JDK 8 ובתכונות השפה של Java 8 באמצעות Jack toolchain. מידע נוסף זמין במדריך לגרסת טרום-ההשקה (Preview) של N.
הערה: Instant Run לא פועל כרגע עם Jack ויושבת בזמן השימוש ב-toolchain החדש. צריך להשתמש ב-Jack רק אם מפתחים לגרסת טרום-השקה (Preview) של N ורוצים להשתמש בתכונות הנתמכות של שפת Java 8.
- נוספה תמיכה כברירת מחדל בהידור מצטבר של Java כדי לצמצם את משך הזמן לקימפול במהלך הפיתוח. כדי לעשות את זה, הוא מקמפל מחדש רק את החלקים בקוד המקור שהשתנו או שצריך לקמפל מחדש. כדי להשבית את התכונה הזו, מוסיפים את הקוד הבא לקובץ
build.gradleברמת המודול:מגניב
android { ... compileOptions { incremental false } }
Kotlin
android { ... compileOptions { incremental = false } }
-
הוספנו תמיכה ב-dexing-in-process, שמבצע dexing בתהליך ה-build ולא בתהליכי VM חיצוניים נפרדים. כך לא רק שה-builds המצטברים מהירים יותר, אלא גם ה-builds המלאים מהירים יותר. התכונה מופעלת כברירת מחדל בפרויקטים שבהם הגודל המקסימלי של ה-heap של ה-daemon של Gradle הוא לפחות 2,048MB. כדי לעשות את זה, צריך לכלול את הקוד הבא בקובץ
```none org.gradle.jvmargs = -Xmx2048m ```gradle.propertiesשל הפרויקט:אם הגדרתם ערך ל-
```none org.gradle.jvmargs = -Xmx3072m ```javaMaxHeapSizeבקובץbuild.gradleברמת המודול, אתם צריכים להגדיר אתorg.gradle.jvmargsלערך שלjavaMaxHeapSize+ 1024MB. לדוגמה, אם הגדרתם אתjavaMaxHeapSizeל-"2048m", אתם צריכים להוסיף את השורה הבאה לקובץgradle.propertiesשל הפרויקט:כדי להשבית את dexing-in-process, מוסיפים את הקוד הבא לקובץ
build.gradleברמת המודול:מגניב
android { ... dexOptions { dexInProcess false } }
Kotlin
android { ... dexOptions { dexInProcess = false } }
- הוספנו תמיכה בגרסת טרום-השקה למפתחים של N, ב-JDK 8 ובתכונות השפה של Java 8 באמצעות Jack toolchain. מידע נוסף זמין במדריך לגרסת טרום-ההשקה (Preview) של N.
2.0.0 (אפריל 2016)
- תלויות:
-
- Gradle מגרסה 2.10 ואילך.
- Build Tools 21.1.1 ואילך.
- הפרטים החדשים:
-
- הוספנו אפשרות שמפעילה את Instant Run על ידי תמיכה בהחדרת בייטקוד (bytecode), ודחיפת עדכונים של קוד ומשאבים לאפליקציה שפועלת באמולטור או במכשיר פיזי.
- נוספה תמיכה בבנייה מצטברת, גם כשהאפליקציה לא פועלת. משך הזמן המלא של תהליכי build משתפרים על ידי העברת שינויים מצטברים דרך ממשק הגישור של Android (ADB) למכשיר המחובר.
- הוספנו את
maxProcessCountכדי לקבוע כמה תהליכי dex של worker יכולים להיות מופעלים בו-זמנית. הקוד הבא, בקובץbuild.gradleברמת המודול, מגדיר את המספר המקסימלי של תהליכים מקבילים ל-4:מגניב
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:מגניב
android { ... buildTypes { debug { minifyEnabled true useProguard false } release { minifyEnabled true useProguard true // this is a default setting } } }
Kotlin
android { ... buildTypes { getByName("debug") { minifyEnabled = true useProguard = false } getByName("release") { minifyEnabled = true useProguard = true // this is a default setting } } }
</li> <li>Added logging support and improved performance for the resource shrinker. The resource shrinker now logs all of its operations into a <code>resources.txt</code> file located in the same folder as the Proguard log files. </li> </ul>
- ההתנהגות שהשתנתה:
-
- כשהערך של
minSdkVersionהוא 18 ומעלה, החתימה על קובצי APK משתמשת ב-SHA256.
<li>DSA and ECDSA keys can now sign APK packages. <p class="note"> <strong>Note:</strong> The <a href= "/training/articles/keystore.html">Android keystore</a> provider no longer supports <a href= "/about/versions/marshmallow/android-6.0-changes.html#behavior-keystore"> DSA keys on Android 6.0</a> (API level 23) and higher. </p> </li> </ul> - כשהערך של
- בעיות שתוקנו:
-
- נפתרה בעיה שגרמה לתלות כפולה ב-AAR בשתי תצורות ה-build, גם בבדיקה וגם ב-build הראשי.
פלאגין Android ל-Gradle, גרסה 1.5.0 (נובמבר 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- שילבנו את הפלאגין Data Binding בפלאגין Android ל-Gradle. כדי להפעיל אותו, מוסיפים את הקוד הבא לכל קובץ
build.gradleשל פרויקט שמשתמש בפלאגין: - הוספנו Transform API חדש שמאפשר לפלאגינים של צד שלישי לשנות קובצי
.classשעברו הידור לפני שהם מומרים לקובצי.dex. Transform API מפשט את ההזרקה של מניפולציות על מחלקות בהתאמה אישית, ומציע גמישות רבה יותר לגבי מה שאפשר לשנות. כדי להוסיף טרנספורמציה ל-build, יוצרים מחלקה חדשה שמטמיעה את אחד מהממשקים שלTransformורושמים אותה באמצעותandroid.registerTransform(theTransform)אוandroid.registerTransform(theTransform, dependencies). אין צורך לחבר בין המשימות. חשוב לדעת את הפרטים הבאים על Transform API: - אפשר להחיל טרנספורמציה על אחד או יותר מהבאים: הפרויקט הנוכחי, פרויקטי משנה וספריות חיצוניות.
- צריך לרשום את הטרנספורמציה באופן גלובלי, כדי שהיא תחול על כל הווריאציות.
- עיבוד קוד פנימי, באמצעות Java Code Coverage Library (JaCoCo), ProGuard ו-MultiDex, משתמש עכשיו ב-Transform API. עם זאת, ערכת המהדר של Java ל-Android (Jack) לא משתמשת ב-API הזה, אלא רק נתיב הקוד
javac/dx. - Gradle מבצע את הטרנספורמציות בסדר הזה: JaCoCo, פלאגינים של צד שלישי, ProGuard. סדר ההפעלה של פלאגינים של צד שלישי תואם לסדר שבו הטרנספורמציות נוספות על ידי הפלאגינים של הצד השלישי. מפתחים של פלאגינים של צד שלישי לא יכולים לשלוט בסדר ההפעלה של הטרנספורמציות באמצעות API.
- הוצאה משימוש של ה-getter
dexמהמחלקהApplicationVariant. אי אפשר יותר לגשת למשימהDexדרך ה-API של הווריאנט, כי עכשיו היא מתבצעת באמצעות טרנספורמציה. כרגע אין תחליף לשליטה בתהליך ה-dex. - תוקנה התמיכה המצטברת בנכסים.
- שיפור התמיכה ב-MultiDex על ידי הפיכתה לזמינה לפרויקטים של בדיקות, ועכשיו לבדיקות יש באופן אוטומטי את התלות
com.android.support:multidex-instrumentation. - הוספנו את היכולת להכשיל Gradle build כמו שצריך ולדווח על סיבת השגיאה הבסיסית כש-Gradle build מפעיל משימות אסינכרוניות ויש כשל בתהליך ה-worker.
- הוספנו תמיכה בהגדרה של Application Binary Interface (ABI) ספציפי בגרסאות שמכילות כמה ממשקי ABI.
- הוספנו תמיכה ברשימה מופרדת בפסיקים של מספרים סידוריים של מכשירים למשתנה הסביבה
ANDROID_SERIALכשמתקינים או מריצים בדיקות. - תוקן כשל בהתקנה במכשירים עם Android מגרסה 5.0 (רמת API 20) ומעלה, כאשר שם ה-APK מכיל רווח.
- תוקנו כמה בעיות שקשורות לפלט השגיאה של Android Asset Packaging Tool (AAPT).
- נוספה תמיכה ב-JaCoCo incremental instrumentation כדי לאפשר בנייה מצטברת מהירה יותר. פלאגין 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 כך שיתרחש לפני משימות הערפול במקום במהלך האריזה של ה-APK. השינוי הזה מאפשר למשימות הערפול להתאים את משאבי ה-Java אחרי ערפול החבילות.
- תוקנה בעיה בשימוש בקוד Java Native Interface (JNI) בפלאגין הניסיוני של הספרייה.
- הוספנו את האפשרות להגדיר את גרסת הפלטפורמה בנפרד מהמאפיין
android:compileSdkVersionבפלאגין של הספרייה הניסיונית.
android { dataBinding { enabled = true } }
android { dataBinding { enabled = true } }
- שילבנו את הפלאגין Data Binding בפלאגין Android ל-Gradle. כדי להפעיל אותו, מוסיפים את הקוד הבא לכל קובץ
פלאגין Android ל-Gradle, גרסה 1.3.1 (אוגוסט 2015)
יחסי תלות:- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- תוקנה המשימה ZipAlign כדי לצרוך כראוי את הפלט של המשימה הקודמת כשמשתמשים בשם קובץ מותאם אישית.
- תוקנה בעיה שקשורה לאריזת Renderscript עם NDK.
- המשכנו לתמוך במשימת ה-build של
createDebugCoverageReport. - תוקנה התמיכה בשימוש מותאם אישית במאפיין
archiveBaseNameבקובץ ה-build שלbuild.gradle. - תוקנה האזהרה של
Invalid ResourceTypelint שנגרמה על ידי חיפוש הערות של שיטת פרמטרים בזמן הפעלת lint מחוץ ל-Android Studio.
פלאגין Android ל-Gradle, גרסה 1.3.0 (יולי 2015)
תלויות:- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
-
נוספה תמיכה במאפיין
com.android.build.threadPoolSizeכדי לשלוט בגודל של מאגר השרשורים של המשימהAndroidמהקובץgradle.propertiesאו משורת הפקודה. בדוגמה הבאה, המאפיין הזה מוגדר ל-4.-Pcom.android.build.threadPoolSize=4 - מגדירים את התנהגות ברירת המחדל של ה-build כך שקובצי
LICENSEו-LICENSE.txtלא ייכללו בקובצי APK. כדי לכלול את הקבצים האלה ב-APK, צריך להסיר אותם מהמאפייןpackagingOptions.excludesבקובץbuild.gradle. לדוגמה:android { packagingOptions.excludes = [] }
android { packagingOptions.excludes.clear() }
- הוספנו את המשימה
sourceSetsכדי לבדוק את קבוצת כל קבוצות המקורות הזמינות. - תמיכה משופרת בבדיקות יחידה לזיהוי תיקיות מקור של וריאנט build ושל כמה גרסאות מוצר. לדוגמה, כדי לבדוק אפליקציה עם כמה גרסאות
flavor1ו-flavorAעם סוג ה-buildDebug, קבוצות המקורות לבדיקה הן:- בדיקה
- testFlavor1
- testFlavorA
- testFlavor1FlavorA
- testFlavor1FlavorADebug
בדיקות Android כבר זיהו תיקיות מקור עם כמה גרסאות.
- תמיכה משופרת בבדיקות יחידה:
- מריצים את
javacבמקורות הראשיים ובמקורות הבדיקה, גם אם המאפייןuseJackמוגדר כ-trueבקובץ ה-build. - לזהות בצורה נכונה את יחסי התלות של כל סוג build.
- מריצים את
- נוספה תמיכה בהגדרת ארגומנטים של כלי להרצת בדיקות אינסטרומנטציה משורת הפקודה.
לדוגמה:
./gradlew connectedCheck \ -Pandroid.testInstrumentationRunnerArguments.size=medium \ -Pandroid.testInstrumentationRunnerArguments.class=TestA,TestB הוספנו תמיכה בפרמטרים נוספים של Android Asset Packaging Tool (AAPT) בקובץ
build.gradle. לדוגמה:android { aaptOptions { additionalParameters "--custom_option", "value" } }
android { aaptOptions { additionalParameters += listOf("--custom_option", "value") } }
- נוספה תמיכה במודול APK לבדיקה כמודול בדיקה נפרד, באמצעות המאפיינים
targetProjectPathו-targetVariantכדי להגדיר את נתיב ה-APK ואת וריאנט היעד.הערה: מודול APK לבדיקה לא תומך בגרסאות מוצר ויכול לטרגט רק וריאנט אחד. בנוסף, עדיין אין תמיכה ב-Jacoco.
- נוסף אימות של שם המשאב לפני מיזוג משאבים.
- כשיוצרים חבילת AAR (ארכיון Android) למודולים של ספרייה, לא צריך לספק פלייסהולדר אוטומטי של
@{applicationId}בהגדרות של מיזוג המניפסט. במקום זאת, צריך להשתמש בפלייסהולדר אחר, כמו@{libApplicationId}, ולספק לו ערך אם רוצים לכלול מזהי אפליקציות בספריית הארכיון.
פלאגין Android ל-Gradle, גרסה 1.2.0 (אפריל 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- תמיכה משופרת בהרצת בדיקות יחידה באמצעות Gradle.
- נוספה תמיכה כדי לכלול משאבים בסגנון Java ב-classpath כשמריצים בדיקות יחידה ישירות מ-Gradle.
- נוספה תמיכה בתלות בבדיקות יחידה בשביל ארטיפקטים מסוג Android Archive (AAR).
- נוספה תמיכה במאפיין
unitTestVariantsכדי שאפשר יהיה לשנות וריאנטים של בדיקות יחידה באמצעות הקובץbuild.gradle. - הוספנו את בלוק הקוד
unitTest.allמתחת ל-testOptions, כך שעכשיו אפשר להגדיר משימות בהתאמה אישית לבדיקת יחידות. בדוגמת הקוד הבאה אפשר לראות איך מוסיפים הגדרות של בדיקות יחידה באמצעות האפשרות החדשה הזו:android { testOptions { unitTest.all { jvmArgs '-XX:MaxPermSize=256m' // Or any other gradle option. } } }
android { testOptions { unitTest.all { jvmArgs += listOf("-XX:MaxPermSize=256m") // Or any other gradle option. } } }
- תוקן אופן הטיפול בטיפוסים בני מנייה (enum) ובשדות של מופעים ציבוריים במארז של קובץ
mockable-android.jar. - תוקנו תלויות של משימות בפרויקט של ספרייה, כך שמחלקות בדיקה עוברות קומפילציה מחדש אחרי שינויים.
- נוסף המאפיין
testProguardFileכדי להחיל קובצי ProGuard כשמבצעים הקטנה של קובץ APK לבדיקה. - הוספנו את המאפיין
timeOutלבלוק הקודadbOptionsכדי להגדיר את זמן ההקלטה המקסימלי של המסך בממשק הגישור של Android (ADB). - הוספנו תמיכה במשאבים ברזולוציה של 280dpi.
- שיפרנו את הביצועים במהלך הערכת הפרויקט.
- תמיכה משופרת בהרצת בדיקות יחידה באמצעות Gradle.
פלאגין Android ל-Gradle, גרסה 1.1.3 (מרץ 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- תוקנה בעיה שגרמה לכפילות של יחסי תלות באפליקציית בדיקה, מה שהוביל לכשל ב-ProGuard.
- תוקן יישום של Comparator שלא עמד בדרישות של חוזה ה-Comparator של JDK ויצר שגיאה ב-JDK 7.
פלאגין Android ל-Gradle, גרסה 1.1.2 (פברואר 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- נתיב מנורמל כשיוצרים JAR שניתן ללעג (mockable) לבדיקת יחידות.
- תוקנה ההגדרה
archivesBaseNameבקובץbuild.gradle. - תוקן הכשל של פלייסהולדר לא פתור במיזוג המניפסט כשיוצרים אפליקציית בדיקה של ספרייה.
פלאגין Android ל-Gradle, גרסה 1.1.1 (פברואר 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- שינוי וריאנטים של build כך שרק וריאנטים שמכילים טריגר של אפליקציית Wear יפעילו משימות build ספציפיות ל-Wear.
- שינינו את אופן הטיפול בבעיות שקשורות לתלות, כך שעכשיו הכשל מתרחש בזמן תהליך ה-build ולא בזמן ניפוי הבאגים. ההתנהגות הזו מאפשרת לכם להריץ משימות אבחון (כמו "תלויות") כדי לפתור את הבעיה.
- ה-method
android.getBootClasspath()תוקן, ועכשיו הוא מחזיר ערך.
פלאגין Android ל-Gradle, גרסה 1.1.0 (פברואר 2015)
- תלויות:
-
- Gradle מגרסה 2.2.1 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
- הערות כלליות:
-
- נוספה תמיכה חדשה בבדיקות יחידה
- בדיקות יחידה שמופעלות ב-JVM המקומי מול גרסה מיוחדת של הקובץ
android.jarשתואמת למסגרות פופולריות של Mocking, למשל 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).
- הוספנו את האפשרות
android.testOptions.unitTests.returnDefaultValuesכדי לשלוט בהתנהגות של android.jar שניתן לדמות. -
Testהוחלף ב-AndroidTestבשמות של משימות הבדיקה. לדוגמה, המשימהassembleDebugTestהיא עכשיו המשימהassembleDebugAndroidTest. למשימות של בדיקות יחידה עדיין יש אתUnitTestבשם המשימה, לדוגמהassembleDebugUnitTest. - שינינו את קובצי התצורה של ProGuard כך שלא יחולו יותר על קובץ ה-APK לבדיקה. אם ההקטנה מופעלת, ProGuard מעבד את קובץ ה-APK לבדיקה ומחיל רק את קובץ המיפוי שנוצר כשמבצעים הקטנה של קובץ ה-APK הראשי.
- ניהול מעודכן של יחסי תלות
- תוקנו בעיות בשימוש בהיקפי ההרשאות
providedו-package.הערה: היקפי ההרשאות האלה לא תואמים לחבילות AAR (Android ARchive), ויגרמו לכך שה-build עם חבילות AAR ייכשל.
- שינינו את הרזולוציה של יחסי התלות כדי להשוות בין יחסי התלות של האפליקציה שנבדקת לבין אלה של אפליקציית הבדיקה. אם נמצא פריט מידע שנוצר בתהליך הפיתוח (artifact) עם אותה גרסה בשתי האפליקציות, הוא לא נכלל באפליקציית הבדיקה ונארז רק עם האפליקציה שנבדקת. אם נמצא פריט מידע עם גרסה שונה בשתי האפליקציות, ה-build ייכשל.
- תוקנו בעיות בשימוש בהיקפי ההרשאות
- הוספנו תמיכה במגדיר המשאבים
anyDpiבמיזוג המשאבים. - מהירויות משופרות של הערכה וסנכרון של סביבת הפיתוח המשולבת (IDE) בפרויקטים עם מספר גדול של מודולים של Android.
פלאגין Android ל-Gradle, גרסה 1.0.1 (ינואר 2015)
- תלויות:
-
-
Gradle מגרסה 2.2.1 עד 2.3.x.
הערה: הגרסה הזו של פלאגין Android ל-Gradle לא תואמת ל-Gradle מגרסה 2.4 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
-
- הערות כלליות:
-
- תוקנה בעיה שגרמה לתקלה ב-Gradle build בזמן גישה למודול
extractReleaseAnnotations. (בעיה מספר 81638). - תוקנה בעיה שקשורה להעברת ההגדרה
Disableאל--no-optimizeבבייטקוד ( bytecode) Dalvik Executable (dex). (בעיה מספר 82662). - תוקנו בעיות במיזוג המניפסט כשמייבאים ספריות עם
targetSdkVersionקטן מ-16. - תוקנה בעיה בסדר הצפיפות כשמשתמשים ב-Android Studio עם JDK 8.
- תוקנה בעיה שגרמה לתקלה ב-Gradle build בזמן גישה למודול
פלאגין Android ל-Gradle, גרסה 1.0.0 (דצמבר 2014)
- תלויות:
-
-
Gradle מגרסה 2.2.1 עד 2.3.x.
הערה: הגרסה הזו של הפלאגין של Android ל-Gradle לא תואמת ל-Gradle מגרסה 2.4 ואילך.
- כלי פיתוח בגרסה 21.1.1 ואילך.
-
- הערות כלליות:
-
- גרסה ראשונית של הפלאגין.