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

‫3.6 (פברואר 2020)

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

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

כלי עיצוב

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

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

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

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

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

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

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

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

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

מנהל המשאבים

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

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

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

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

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

הצגת הקישור

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

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

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

  android {
      buildFeatures.viewBinding = true
  }
  

  android {
      buildFeatures.viewBinding = true
  }
  

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

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

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

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

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

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

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

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

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

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

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

כלים מקוריים

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

תמיכה ב-Kotlin

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

אמולטורים

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

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

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

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

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

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

.

מסלולים

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

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

.

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

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

‫IntelliJ IDEA 2019.2

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

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

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

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

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

‫3.5 (אוגוסט 2019)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

קישור נתונים

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

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

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

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

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

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

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

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

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

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

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

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

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

ChromeOS Support

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

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

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

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

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

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

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

IntelliJ IDEA 2019.1

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

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

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

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

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

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

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

‫3.4 (אפריל 2019)

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

‫IntelliJ IDEA 2018.3.4

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

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

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

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

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

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

משתנים

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

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

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

מודולים

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

פניות קשורות

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

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

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

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

וריאנטים של Build

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

הצעות

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫3.3 (ינואר 2019)

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

‫IntelliJ IDEA 2018.2.2

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

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

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

כלי הניווט

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת נתוני רינדור פריימים

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

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

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

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

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

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

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

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

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

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

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

תמיכה ב-Clang-Tidy

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

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

כדי להגדיר את 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>
    
  

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

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

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

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

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

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

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

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

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

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

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

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

‫3.2 (ספטמבר 2018)

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

מה חדש ב-Assistant

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

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

Android Jetpack

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

כלי הניווט

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

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

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

העברה ל-AndroidX

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

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

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

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

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

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

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

קובץ Android App Bundle

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

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

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

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

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

נתונים לדוגמה ב-Layout Editor

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

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

פרוסות

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

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

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

פעילויות באתר

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

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

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

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

במהלך השימוש בהגדרת המעקב הזו, אפשר לסמן באופן חזותי שגרות קוד חשובות בציר הזמן של כלי לניתוח ביצועים (profiler) על ידי הוספת קוד למעקב לקוד C/C++ באמצעות native tracing API או לקוד Java באמצעות המחלקה Trace.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת Lint

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

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

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

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

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

יעד חדש של Gradle

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

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

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

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

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

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

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

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

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

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

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

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

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

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

כיווץ קוד חדש

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

      android.enableR8 = true
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ADB Connection Assistant

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

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

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

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

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

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

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

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

‫3.1 (מרץ 2018)

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

תכנות/IDE

‫IntelliJ 2017.3.3

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

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

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

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

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

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

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

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

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

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

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

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

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

קומפיילר ו-Gradle

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

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

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

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

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

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

        android.enableD8=true
      

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

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

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

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

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

        android.enableIncrementalDesugaring=false
      

חלון פלט פשוט

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

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

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

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

‫C++‎ ו-LLDB

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

דגימת תהליכי C++‎ מקומיים באמצעות CPU Profiler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מכשיר הדמיה

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

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

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

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

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

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

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

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

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

Android Plugin for Gradle 3.0.0

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

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

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

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

• תמיכה ב-Android 8.0.
• תמיכה ביצירת קובצי APK נפרדים על סמך משאבי שפה.
• תמיכה בספריות Java 8 ובתכונות של שפת Java 8 (ללא מהדר Jack).
• תמיכה ב-Android Test Support Library 1.0 (Android Test Utility ו-Android Test Orchestrator).
• שיפור מהירויות ה-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 באמצעות האשף New Project.

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

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

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

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

Android Profiler

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

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

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

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

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

CPU Profiler

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

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

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

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

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

Network Profiler

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

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

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

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

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

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

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

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

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

מידע נוסף זמין במאמר בנושא מדריך ל-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 באשפי New Project (פרויקט חדש) ו-New Module (מודול חדש) שיעזרו לכם להתחיל לפתח למכשירי IoT מבוססי Android.

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

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

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

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

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

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

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

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

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

Firebase App Indexing Assistant

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

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

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

Android App Links Assistant

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הכלי לניתוח APK

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

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

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

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

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

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

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

      allprojects {
          repositories {
              google()
          }
      }
    
    

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

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

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

‫2.3 (מרץ 2017)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫2.2 (ספטמבר 2016)

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

<p>
  Highlighted build changes:
</p>

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

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

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

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

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

חדש

• 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> &gt; <strong>Signal Strength</strong> controls.
    </li>
    <li>Added an <strong>LTE</strong> option to the <strong>Cellular</strong>
    &gt; <strong>Network type</strong> control.
    </li>
    <li>Added simulated vertical swipes for scrolling through vertical menus
    with a mouse wheel.
    </li>
  </ul>
</li>

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

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

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

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

שינויים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫2.1 (אפריל 2016)

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

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

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

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

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

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

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

‫2.0 (אפריל 2016)

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

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

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

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

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

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