גרסאות Java בגרסאות build של Android

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

מילון מונחים

Java Development Kit (JDK)

ערכת הכלים לפיתוח Java‏ (JDK) כוללת:

• כלים כמו קומפיילר, פרופילר ויוצר ארכיון. הנתונים האלה משמשים מאחורי הקלעים במהלך הבנייה כדי ליצור את האפליקציה.
• ספריות שמכילות ממשקי API שאפשר להפעיל מקוד המקור של Kotlin או Java. חשוב לזכור שלא כל הפונקציות זמינות ב-Android.
• ‫Java Virtual Machine (JVM), מפענח שמבצע אפליקציות Java. משתמשים ב-JVM כדי להפעיל את סביבת הפיתוח המשולבת (IDE) של Android Studio ואת כלי ה-build של Gradle. ‫JVM לא נמצא בשימוש במכשירי Android או באמולטורים.

‫JetBrains Runtime (JBR)

‫JetBrains Runtime (JBR) הוא JDK משופר, שמופץ עם Android Studio. הוא כולל כמה אופטימיזציות לשימוש ב-Studio ובמוצרים קשורים של JetBrains אבל אפשר להשתמש בו גם להפעלת אפליקציות אחרות של Java.

איך בוחרים JDK להרצת Android Studio?

מומלץ להשתמש ב-JBR כדי להריץ את Android Studio. הוא מופעל עם Android Studio ומשמש לבדיקה שלו, והוא כולל שיפורים לשימוש אופטימלי ב-Android Studio. כדי לוודא זאת, אל תגדירו את משתנה הסביבה STUDIO_JDK.

סקריפטים להפעלה של Android Studio מחפשים מכונה וירטואלית של Java (JVM) בסדר הבא:

1. משתנה הסביבה STUDIO_JDK
2. הספרייה studio.jdk (בהפצה של Android Studio)
3. הספרייה jbr (JetBrains Runtime), בהפצה של Android Studio. מומלץ.
4. משתנה הסביבה JDK_HOME
5. משתנה הסביבה JAVA_HOME
6. קובץ ההפעלה java במשתנה הסביבה PATH

איך בוחרים את ה-JDK שדרכו יופעלו ה-builds של Gradle?

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

כדי לקבל את התוצאות הכי עקביות, צריך לוודא שמשתנה הסביבה JAVA_HOME וההגדרה של Gradle JDK ב-Android Studio מוגדרים לאותו JDK.

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

אם מתחילים לבנות עם גרסאות שונות של JDK או Gradle, נוצרים עוד תהליכי daemon שצורכים יותר CPU וזיכרון.

הגדרת Gradle JDK ב-Android Studio

כדי לשנות את הגדרת ה-JDK של Gradle בפרויקט הקיים, פותחים את ההגדרות של Gradle דרך File (קובץ) (או Android Studio ב-macOS) > Settings > Build, Execution, Deployment > Build Tools > Gradle (הגדרות > בנייה, הפעלה, פריסה > כלי בנייה > Gradle). בתפריט הנפתח Gradle JDK אפשר לבחור מבין האפשרויות הבאות:

• פקודות מאקרו כמו JAVA_HOME ו-GRADLE_LOCAL_JAVA_HOME
• רשומות בטבלת JDK בפורמט vendor-version כמו jbr-17, שמאוחסנות בקבצי ההגדרות של Android
• הורדת JDK
• הוספת JDK ספציפי
• ‫JDKs שזוהו באופן מקומי מתוך ספריית ההתקנה של JDK שמוגדרת כברירת מחדל במערכת ההפעלה

האפשרות שנבחרה מאוחסנת באפשרות gradleJvm בקובץ .idea/gradle.xml של הפרויקט, והנתיב שלה ל-JDK משמש להרצת Gradle כשמפעילים אותו דרך Android Studio.

הפקודות המאקרו מאפשרות בחירה דינמית של נתיב JDK של הפרויקט:

• ‫JAVA_HOME: משתמש במשתנה הסביבה עם אותו שם
• ‫GRADLE_LOCAL_JAVA_HOME: משתמש במאפיין java.home בקובץ .gradle/config.properties, שערך ברירת המחדל שלו הוא JetBrains Runtime.

ה-JDK שנבחר משמש להרצת ה-Gradle build ולפתרון הפניות ל-JDK API כשעורכים את סקריפטים של ה-build ואת קוד המקור. שימו לב: הפרמטר compileSdk שצוין יגביל עוד יותר את הסמלים של Java שיהיו זמינים כשעורכים ויוצרים את קוד המקור.

חשוב לבחור גרסת JDK שגבוהה או שווה לגרסאות ה-JDK שמשמשות פלאגינים שבהם אתם משתמשים ב-Gradle build. כדי לדעת מהי גרסת ה-JDK המינימלית הנדרשת עבור פלאגין של Android Gradle ‏ (AGP), אפשר לעיין בטבלת התאימות בהערות על הגרסה.

לדוגמה, פלאגין של Android Gradle בגרסה 8.x דורש JDK 17. אם תנסו להריץ Gradle build שמשתמש בגרסה מוקדמת יותר של JDK, תוצג הודעה כמו:

An exception occurred applying plugin request [id: 'com.android.application']
> Failed to apply plugin 'com.android.internal.application'.
   > Android Gradle plugin requires Java 17 to run. You are currently using Java 11.
      Your current JDK is located in /usr/local/buildtools/java/jdk
      You can try some of the following options:
       - changing the IDE settings.
       - changing the JAVA_HOME environment variable.
       - changing `org.gradle.java.home` in `gradle.properties`.

באילו ממשקי Java API אפשר להשתמש בקוד המקור ב-Java או ב-Kotlin?

אפליקציה ל-Android יכולה להשתמש בחלק מממשקי ה-API שמוגדרים ב-JDK, אבל לא בכולם. ‫Android SDK מגדיר הטמעות של פונקציות רבות בספריית Java כחלק מממשקי ה-API הזמינים שלו. המאפיין compileSdk מציין באיזו גרסת Android SDK להשתמש כשמדרים את קוד המקור ב-Kotlin או ב-Java.

android {
    ...
    compileSdk = 36
}

android {
    ...
    compileSdk 36
}

כל גרסה של Android תומכת בגרסה ספציפית של JDK ובקבוצת משנה של ממשקי Java API שזמינים בה. אם אתם משתמשים ב-Java API שזמין ב-compileSdk שלא זמין ב-minSdk שצוין, יכול להיות שתוכלו להשתמש ב-API בגרסה קודמת של Android באמצעות תהליך שנקרא desugaring. כאן אפשר לראות את ממשקי ה-API הנתמכים של Java 11 ומעלה שזמינים באמצעות desugaring.

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

איזה JDK קומפל את קוד המקור של Java?

ערכת הכלים של Java‏ JDK מכילה את מהדר Java שמשמש להידור של כל קוד המקור של Java. בנוסף, ה-JDK הזה מריץ javadoc ובדיקות יחידות במהלך ה-build.

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

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

• הכלי מאתר JDK תואם במערכת שבה מופעל ה-build.
  • אם לא קיים JDK תואם (ומוגדר כלי לפתרון בעיות בשרשרת הכלים), המערכת תוריד JDK.
• חשיפת ממשקי ה-API של Java בשרשרת הכלים לקריאות מקוד המקור.
• קומפילציה של קוד מקור ב-Java באמצעות גרסת שפת Java.
• ברירות המחדל של sourceCompatibility ו-targetCompatibility.

מומלץ תמיד לציין את ערכת הכלים של Java, ולוודא שערכת ה-JDK שצוינה מותקנת, או להוסיף toolchain resolver לבנייה.

אתם יכולים לציין את ערכת הכלים גם אם קוד המקור שלכם כתוב ב-Java, ב-Kotlin או בשתי השפות. מציינים את שרשרת הכלים ברמה העליונה של קובץ build.gradle(.kts) של המודול.

מציינים את הגרסה של Java toolchain באופן הבא:

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

האפשרות הזו פועלת אם המקור הוא Kotlin,‏ Java או שילוב של שתי השפות.

יכול להיות שגרסת ה-JDK של ערכת הכלים תהיה זהה לגרסת ה-JDK שמשמשת להרצת Gradle, אבל חשוב לזכור שהן משמשות למטרות שונות.

באילו תכונות של קוד מקור בשפת Java אפשר להשתמש בקוד המקור של Java?

המאפיין sourceCompatibility קובע אילו תכונות של שפת Java זמינות במהלך קומפילציה של מקור Java. היא לא משפיעה על מקור Kotlin.

מציינים sourceCompatibility בקובץ build.gradle(.kts) של המודול באופן הבא:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
    }
}

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

באילו תכונות של קובץ בינארי של Java אפשר להשתמש כשמבצעים קומפילציה של קוד מקור ב-Kotlin או ב-Java?

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

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

גרסאות שונות של Android תומכות בגרסאות שונות של Java. כדי ליהנות מתכונות נוספות של Java, אפשר להגדיל את targetCompatibility, אבל יכול להיות שתצטרכו גם להגדיל את גרסת ה-Android SDK המינימלית כדי לוודא שהתכונה זמינה.

הערה: הערך של targetCompatibility חייב להיות גדול מ-sourceCompatibility או שווה לו. בפועל, בדרך כלל צריך להשתמש באותו ערך בשדות sourceCompatibility ו-targetCompatibility. אפשר להגדיר אותם באופן הבא:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

אם אתם משתמשים בגרסה של Kotlin שקטנה מ-2.2, אתם צריכים להגדיר גם את kotlinOptions:

android {
    kotlinOptions {
        jvmTarget = "17"
    }
}

android {
    kotlinOptions {
        jvmTarget = "17"
    }
}

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