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

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

3.6 (פברואר 2020)

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

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

כלי עיצוב

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

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

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

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

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

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

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

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

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

מנהל המשאבים

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

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

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

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

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

הצגת הקישור

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

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

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

  android {
      buildFeatures.viewBinding = true
  }
  

  android {
      buildFeatures.viewBinding = true
  }
  

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

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

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

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

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

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

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

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

הסרת האובסוסקציה של בייטקוד של שיטות וסיווגים ב-APK Analyzer

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

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

כלים מקורי

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

התמיכה של Kotlin

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

אמולטורים

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

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

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

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

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

כדי להגדיר את המיקום של המהדמנים למיקום שבחרתם במפה, לוחצים על הלחצן Set location (הגדרת מיקום) בפינה השמאלית התחתונה של החלון Extended controls (אמצעי בקרה מורחבים).

.

מסלולים

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

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

.

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

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

.

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

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

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

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

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

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

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

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

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

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

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

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

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

IntelliJ IDEA 2019.2

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

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

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

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

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

3.5 (אוגוסט 2019)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

עורך פריסות

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

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

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

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

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

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

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

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

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

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

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

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

קישור נתונים

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

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

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

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

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

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

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

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

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

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

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

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

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

תמיכה ב-ChromeOS

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

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

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

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

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

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

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

IntelliJ IDEA 2019.1

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

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

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

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

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

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

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

3.4 (אפריל 2019)

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

IntelliJ IDEA 2018.3.4

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

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

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

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

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

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

משתנים

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

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

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

מודולים

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

יחסי תלות

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

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

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

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

וריאנטים של build

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

הצעות

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

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

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

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

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

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

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

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

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

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

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

עכשיו, עם R8, הסרת סוכרים, כיווץ, ערפול קוד (obfuscation), אופטימיזציה והסרה של שדות (D8) את כל השלבים לביצוע בשלב אחד, כפי שמתואר בהמשך.

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

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

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

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

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

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

שיפורים בעורך הפריסה {:#layout-editor}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

תמיכה ב-Clang-Tidy

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

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

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

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

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

• תמיכה בחריגים (-fexceptions)
• תמיכה במידע סוג זמן ריצה (-ftti)

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

CMake גרסה 3.10.2

CMake גרסה 3.10.2 כלולה עכשיו ב-SDK Manager. חשוב לזכור ש-Gradle עדיין משתמש בגרסה 3.6.0 כברירת מחדל.

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

    android {
        ...
        externalNativeBuild {
            cmake {
                ...
                version "3.10.2"
            }
        }
    }
    
  

למידע נוסף על הגדרת CMake ב-build.gradle, ראו הגדרת Gradle באופן ידני.

תחביר חדש של '+' לציון גרסאות CMake מינימום

כשמציינים גרסה של CMake בקובץ build.gradle של המודול הראשי, אפשר עכשיו להוסיף סימן '+' כדי להתאים את ההתנהגות לפקודה cmake_minimum_required() של CMake.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3.2 (ספטמבר 2018)

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

מה חדש ב-Assistant

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

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

Jetpack ל-Android

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

עורך הניווט

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

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

למידע נוסף, אפשר לעיין במסמכי התיעוד של Navigation Editor.

מיגרציה ל-AndroidX

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

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

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

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

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

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

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

קובץ Android App Bundle

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

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

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

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

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

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

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

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

פרוסות

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

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

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

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

Kotlin 1.2.61

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

IntelliJ IDEA 2018.1.6

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

פרופילרים של Android

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

סשנים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת Lint

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

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

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

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות Lint ל-Slices

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

יעד חדש ב-Gradle

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

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

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

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

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

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

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

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

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

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

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

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

הסרת סוכר D8

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

כיווץ קוד חדש

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

      android.enableR8 = true
    

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

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

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

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

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

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

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

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

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

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

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

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

מודעה מותאמת מסוג multidex מופעלת כברירת מחדל

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

AAPT2 הועבר למאגר Maven של Google

החל מ-Android Studio 3.2, המקור של AAPT2‏ (Android 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.

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

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

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

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

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

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

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

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

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

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

פרטים נוספים זמינים במאמר Snapshots.

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

3.1 (מרץ 2018)

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

תכנות/IDE

IntelliJ 2017.3.3

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

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

שיפורים בעריכת SQL בעזרת חדר

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

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

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

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

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

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

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

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

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

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

מהדר וגרידל

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

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

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

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

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

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

        android.enableD8=true
      

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

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

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

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

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

        android.enableIncrementalDesugaring=false
      

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

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

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

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

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

C++ ו-LLDB

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

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

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

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

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

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

Kotlin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

עורך פריסות

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

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

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

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

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

שיפרנו את העקביות של ההתנהגות של האפשרות Use same selection for future launches בתיבת הדו-שיח Select deployment target. אם השתמשת בחירה מופעלת, ואז בחר פריסה תיבת הדו-שיח target תיפתח רק בפעם הראשונה שמשתמשים הפקודה Run עד שהמכשיר שנבחר יוסר מחובר.

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

מכשיר הדמיה

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

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

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

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

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

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

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

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

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

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

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

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

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

3.0 (אוקטובר 2017)

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

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

פלאגין Android ל-Gradle 3.0.0

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

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

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

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

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

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

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

התמיכה של Kotlin

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

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

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

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

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

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

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

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

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

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

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

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

כלי לניתוח ביצועי ה-CPU

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מודולים של Android Things

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

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

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

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

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

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

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

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

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

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

Firebase App Indexing Assistant

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הכלי לניתוח APK

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

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

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

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

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

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

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

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

android.enableD8=true
    

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

מאגר Maven של Google

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

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

      allprojects {
          repositories {
              google()
          }
      }
    
    

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

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

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

2.3 (מרץ 2017)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2.2 (ספטמבר 2016)

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

<p>
  Highlighted build changes:
</p>

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

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

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

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

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

חדש

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

שינויים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2.1 (אפריל 2016)

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

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

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

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

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

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

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

2.0 (אפריל 2016)

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

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

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

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

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

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