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

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

3.2.1 (אוקטובר 2018)

העדכון הזה ל-Android Studio 3.2 כולל את השינויים והתיקונים הבאים:

• גרסת Kotlin בחבילה היא עכשיו 1.2.71.
• גרסת ברירת המחדל של כלי ה-build היא עכשיו 28.0.3.
• בספריית הניווט, השם של סוגי הארגומנטים השתנה מ-type ל-argType.
• הבאגים הבאים תוקנו:
• כשמשתמשים בספריית Data Binding, שמות המשתנים עם קווים תחתונים גורמים לשגיאות הידור.
• CMake גרם ל-IntelliSense ותכונות CLion אחרות להיכשל.
• הוספת SliceProvider גרמה לשגיאות הידור בפרויקטים שלא השתמשו בספריות androidx.*.
• חלק מבדיקות היחידה של Kotlin לא הופעלו.
• בעיה בקישור הנתונים גרמה ל-PsiInvalidElementAccessException.
• לפעמים רכיבי <merge> גרמו לקריסה של עורך הפריסה.

בעיות מוכרות 3.2.0

הערה: הבעיות האלה נפתרו ב-Android Studio 3.2.1

• מומלץ מאוד לא להשתמש ב-Kotlin בגרסה 1.2.70.

  בגרסה 1.2.61 של Kotlin תוקן באג שעלול לגרום ל-Android Studio להיתקע, אבל גרסה 1.2.70 של Kotlin לא כוללת את התיקון הזה.

  עם זאת, גרסאות Kotlin 1.2.71 ואילך כוללות את התיקון הזה.

• בדרך כלל לא צריך לציין את הגרסה של כלי ה-build, אבל כשמשתמשים בפלאגין של Android Gradle בגרסה 3.2.0 כאשר renderscriptSupportModeEnabled מוגדר ל-true, צריך לכלול את הקוד הבא בקובץ build.gradle של כל מודול:

  android.buildToolsVersion "28.0.3"

מה חדש ב-Assistant

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

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

Android Jetpack

Android Jetpack עוזר לכם לפתח אפליקציות ל-Android מהר יותר ובקלות רבה יותר, בעזרת רכיבים, כלים והנחיות שמבטלים משימות חוזרות ומאפשרים לכם ליצור אפליקציות איכותיות שניתנות לבדיקה. כדי לתמוך ב-Jetpack, Android Studio כולל את העדכונים הבאים: מידע נוסף זמין במסמכי העזרה של 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 > Migrate to AndroidX. אם יש לכם יחסי תלות ב-Maven שלא הועברו למרחב השמות של AndroidX, מערכת ה-build של Android Studio תמיר אוטומטית גם את יחסי התלות האלה בפרויקט.

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

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

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

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

קובץ Android App Bundle

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

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

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

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

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

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

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

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

פרוסות

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

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

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

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

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

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

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

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

כדי לייבא את הקובץ .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. בתפריט הנפתח, בוחרים את הגדרת ההקלטה במעבד (CPU).
4. כדי לפרוס את האפליקציה במכשיר עם Android 8.0 (רמת API 26) ואילך, בוחרים באפשרות הפעלה > פרופיל.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

הבדיקה של איתור השגיאות בקוד

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

יעד Gradle חדש

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

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

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

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

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

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

ב-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. כדי להתחיל להשתמש בגרסה המקדימה של 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.

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

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

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

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

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

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

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

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

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

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

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

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