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

‫3.6 (פברואר 2020)

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

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

כלי עיצוב

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

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

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

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

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

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

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

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

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

Resource Manager

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

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

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

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

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

הצגת הקישור

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

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

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

כלים מקוריים

העדכונים הבאים תומכים בפיתוח מקורי (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 בחלונית heap dump של הכלי 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 על ידי בחירה באפשרות File > New > New Module (קובץ > חדש > מודול חדש) מסרגל התפריטים, ובחירה באפשרות Automotive Module (מודול לרכב). אשף Create New Module (יצירת מודול חדש) ידריך אתכם בתהליך יצירת מודול חדש באמצעות אחת מהתבניות של פרויקט Android Automotive.

.

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

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

‫IntelliJ IDEA 2019.2

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

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

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

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

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

‫3.5 (אוגוסט 2019)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

כבילת נתונים

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

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

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

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

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

שיפורים בחלונית Build Variants (בניית וריאציות) לסנכרון של וריאציה יחידה

עכשיו אפשר לציין את גרסת ה-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

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

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

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

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

‫3.4 (אפריל 2019)

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

‫IntelliJ IDEA 2018.3.4

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

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

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

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

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

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

משתנים

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

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

הצעות

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

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

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

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

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

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

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

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

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

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

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

שיפורים ב-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

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

כלי הניווט

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

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

מחיקת ספריות של 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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בעבר, הכלי Network profiler הציג רק טקסט גולמי ממטענים של חיבורים. ב-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>
    
  

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

כדי לפרוס את האפליקציה במכשיר מקומי כחוויה מיידית, עורכים את הגדרות ההפעלה ומסמנים את התיבה לצד 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 אחרי התקנה חדשה או עדכון, אם הוא מזהה שיש מידע חדש להציג. אפשר גם לפתוח את Assistant על ידי בחירה באפשרות Help > What's new in 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 Support Libraries לספריית הרחבות חדשה של Android באמצעות מרחב השמות androidx. מידע נוסף זמין במאמר סקירה כללית על AndroidX.

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

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

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

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

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

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

קובץ Android App Bundle

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

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

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

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

מידע נוסף, כולל הוראות לבנייה ולניתוח של קובץ 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, מופיע במדריך לתחילת השימוש ב-Slices.

‫Kotlin 1.2.61

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

‫IntelliJ IDEA 2018.1.6

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

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

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

סשנים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Energy Profiler

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות Lint ל-Slices

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

יעד חדש של Gradle

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

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

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

כיווץ קוד חדש

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

      android.enableR8 = true
    

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‫AAPT2 עבר למאגר Maven של Google

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

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

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

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

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

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

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

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

עזרה בחיבור ADB

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

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

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

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

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

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

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

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

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

קומפיילר ו-Gradle

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

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

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

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

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

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

        android.enableD8=true
      

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

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

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

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

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

        android.enableIncrementalDesugaring=false
      

חלון פלט פשוט

מסוף Gradle הוחלף בחלון Build, שכולל את הכרטיסיות Sync ו-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 כוללות תכונת חיפוש שמאפשרת לסנן תוצאות מהקלטה של מעקב אחר שיטה, הקצאות זיכרון או dump של heap.

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

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

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

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

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

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

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

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

• Connection View: מספק את אותו מידע כמו בגרסאות קודמות של Android Studio – מוצגת רשימה של קבצים שנשלחו או התקבלו במהלך החלק שנבחר בציר הזמן בכל ה-thread של ה-CPU של האפליקציה. לכל בקשה אפשר לבדוק את הגודל, הסוג, הסטטוס ומשך השידור.
• תצוגת שרשור: מציגה את פעילות הרשת של כל אחד משרשורי ה-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 Plugin for Gradle 3.0.0

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

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

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

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

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

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

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

תמיכה ב-Kotlin

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

כדי לשלב את Kotlin בפרויקט, אפשר להמיר קובץ Java ל-Kotlin (לוחצים על Code > Convert Java File to Kotlin 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, להציג הקצאות של זיכרון ולבדוק את הפרטים של קבצים שמועברים ברשת.

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

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

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

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

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

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

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

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

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

‫Image Asset Studio תומך עכשיו בנכסי תמונות מסוג וקטור ומאפשר ליצור סמלי אפליקציות דינמיים ל-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 של מסנן הכוונות. אלה אותם תגים שהעוזר הדיגיטלי להטמעת קישורים לאפליקציות יכול ליצור בשבילכם.

כדי להצהיר על כתובת 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 עודכן, והשיפורים הבאים נוספו לו:

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

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

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

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

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

      allprojects {
          repositories {
              google()
          }
      }
    
    

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

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

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

חדש

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שינויים

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

פלטפורמת 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 בהגדרות ההרצה או ניפוי הבאגים).

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

‫2.0 (אפריל 2016)

הערה: אם אתם מפתחים לגרסת N Developer Preview, אתם צריכים להשתמש ב-Android Studio 2.1 Preview. ‫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. בנוסף, התכונה מתחשבת במערכי מקור לא פעילים (כמו משאבים שמשמשים בטעמים אחרים של בנייה) ומטפלת כראוי בייבוא של שדות סטטיים.
• בודק אם הפניות מרומזות ל-API נתמכות בכל הפלטפורמות שמטורגטות על ידי minSdkVersion.
• סימון שימוש לא תקין בתגי RecyclerView ו-Parcelable.
• בדיקות של @IntDef, @IntRange ו-@Size כוללות עכשיו גם בדיקות של מערכים וארגומנטים משתנים (varargs) מסוג int.