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

‫3.6 (פברואר 2020)

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

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

כלי עיצוב

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

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

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

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

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

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

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

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

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

Resource Manager

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

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

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

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

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

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

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

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

כלים מקוריים

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

תמיכה ב-Kotlin

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אמולטורים

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

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

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

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

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

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

.

מסלולים

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

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

.

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

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

.

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

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

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

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

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

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

מידע נוסף על הוצאה משימוש של Windows בגרסת 32 ביט

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

כבילת נתונים

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

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

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

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

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

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

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

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

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

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

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

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

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

ChromeOS 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 plugin 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 Plugin 3.4.0

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

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

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

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

משתנים

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

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

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

מודולים

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

תלויות

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

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

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

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

וריאציות של build

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

הצעות

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫3.3 (ינואר 2019)

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

‫IntelliJ IDEA 2018.2.2

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

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

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

כלי הניווט

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

מידע נוסף זמין במאמר Implement navigation with the Navigation Architecture Component (הטמעת ניווט באמצעות רכיב ארכיטקטורת הניווט) באתר למפתחים.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תמיכה ב-Clang-Tidy

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

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

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

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

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

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

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

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

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

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

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

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

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

‫3.2 (ספטמבר 2018)

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

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

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

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

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

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

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

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

פרוסות

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

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

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

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

‫Kotlin 1.2.61

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

‫IntelliJ IDEA 2018.1.6

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

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

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

סשנים

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

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

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

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

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

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

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

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

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

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

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

כדי לשמור נתוני dump של הערימה לבדיקה מאוחרת יותר, משתמשים בלחצן Export Heap Dump (ייצוא dump של הערימה) משמאל לערך Heap Dump (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. לוחצים לחיצה ימנית על ההקלטה שרוצים לייצא מציר הזמן של השימוש במעבד.
2. בתפריט הנפתח, בוחרים באפשרות Export trace (ייצוא נתוני מעקב).
3. עוברים למיקום שבו רוצים לשמור את הקובץ ולוחצים על שמירה.

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

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

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

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

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

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

Energy Profiler

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

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

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

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

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

בדיקת Lint

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

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

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

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

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

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

יעד חדש של Gradle

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

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

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

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

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

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

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

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

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

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

כבילת נתונים מגרסה 2

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

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

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

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

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

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

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

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

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

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

‫3.1 (מרץ 2018)

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

תכנות/IDE

IntelliJ 2017.3.3

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

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

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

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

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

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

עדכונים בנושא שיוך נתונים

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

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

Incremental desugaring

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

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

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

        android.enableIncrementalDesugaring=false
      

חלון פלט פשוט

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

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

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

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

‫C++‎ ו-LLDB

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מכשיר הדמיה

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

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

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

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

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

תמיכה ב-Kotlin

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

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

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

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

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

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

Android Profiler

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

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

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

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

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

CPU Profiler

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

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

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

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

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

Network Profiler

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מודולים של Android Things

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

Android App Links Assistant

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הכלי לניתוח APK

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

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

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

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

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

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

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

‫2.3 (מרץ 2017)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫2.2 (ספטמבר 2016)

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

<p>
  Highlighted build changes:
</p>

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

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

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

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

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

חדש

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שינויים

• עדכנו את בסיס הקוד של סביבת הפיתוח המשולבת מ-IntelliJ 15 ל-IntelliJ 2016.1
• כדי להשתמש ב-Instant Run, צריך להתקין את ערכת ה-SDK של הפלטפורמה שמתאימה לרמת ה-API של מכשיר היעד.
• התכונה 'הפעלה מיידית' מושבתת אוטומטית אם המשתמש מפעיל את האפליקציה בפרופיל עבודה או כמשתמש משני.
• נפתרו הרבה בעיות אמינות ב-Instant Run, שגרמו לכך שהשינויים לא נפרסו או שהאפליקציה קרסה:
  • חלק מנכסי האפליקציה לא נפרסו באפליקציה הפועלת. ( באג: ‎#213454)
  • האפליקציה קורסת כשמשתמש עובר בין סשנים של הפעלה מיידית לבין סשנים שלא מופעלים באופן מיידי, אם לא מוגדר serialVersionUID למחלקה Serializable. (באג: ‎#209006)
  • שינויים בסגנון לא משתקפים באמצעות Instant Run. (באג: ‎#210851)
  • הסשן של Instant Run לא אמין וגורם לשגיאה FileNotFoundException. (באג: ‎#213083)
  • שינויים בפריטים שניתנים לציור לא משתקפים עד שמבצעים בנייה מחדש מלאה ב-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)

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

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

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

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

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

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

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