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.
  • תוקנו הבאגים הבאים:
    • כשמשתמשים בספרייה של קישור הנתונים, שמות של משתנים עם קווים תחתונים גרמו לשגיאות הידור.
    • 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, עורך הניווט הוא תכונה ניסיונית. כדי להפעיל את Navigation Editor, לוחצים על File (קובץ) > Settings (הגדרות) (Android Studio > Preferences (העדפות) ב-Mac), בוחרים בקטגוריה Experimental (ניסיוני) בחלונית הימנית, מסמנים את התיבה לצד Enable Navigation Editor (הפעלת Navigation Editor) ומפעילים מחדש את 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 כוללות נתונים על סביבת זמן הריצה ולכן קשה להמחיש את העיצוב והסגנון של הפריסה בשלב התכנון של פיתוח האפליקציה. עכשיו אפשר לראות בקלות תצוגה מקדימה של התצוגה בעורך הפריסה, שמלא בנתונים לדוגמה. כשמוסיפים תצוגה, הלחצן מופיע מתחת לתצוגה בחלון העיצוב. לוחצים על הלחצן הזה כדי להגדיר את מאפייני התצוגה של שלב התכנון. אפשר לבחור מתוך מגוון תבניות של נתוני דוגמה ולציין את מספר הפריטים לדוגמה שיאוכלסו בתצוגה.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

לוחצים על השורה אנרגיה כדי להגדיל את תצוגת Energy Profiler. צריך להעביר את העכבר מעל לסרגל בציר הזמן כדי לראות פירוט של השימוש באנרגיה לפי מעבד (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

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

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

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

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

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

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

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

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