Android Studio 3.2 (ספטמבר 2018)

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

מה חדש ב-Assistant

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

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

Android Jetpack

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

עורך הניווט

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

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

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

העברה ל-AndroidX

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

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

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

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

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

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

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

קובץ Android App Bundle

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

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

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

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

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

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

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

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

פרוסות

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

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

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

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

Kotlin 1.2.61

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

IntelliJ IDEA 2018.1.6

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

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

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

סשנים

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ייצוא של מעקב אחר מעבדים (CPU)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

בדיקת Lint

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

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

בדיקות Lint לשילוב בין Java ל-Kotlin

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

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

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

        android {
            lintOptions {
                check 'Interoperability'
            }
        }
        
      

בדיקות Lint ל-Slices

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

יעד Gradle חדש

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

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

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

אזהרה אם מריצים איתור שגיאות בקוד (lint) בגרסה חדשה

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

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

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

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

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

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

Data Binding V2

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

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

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

מכשיר חדש לכווץ קוד

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

      android.enableR8 = true
    

שינוי ברירת המחדל של ממשקי ABI לחבילות APK מרובות

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

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

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

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

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

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

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

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

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

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

אם כבר כללתם בפרויקט קוד וספריות של C/C++, פותחים את החלון Project בצד ימין של סביבת הפיתוח (IDE) על ידי בחירה באפשרות View > Tool Windows > Project בתפריט הראשי, ובוחרים באפשרות 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.

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

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

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

ADB Connection Assistant

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

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

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

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

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

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

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

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