יחסי תלות בין כלים וספריות

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

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

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

הפורמט של ניהול גרסאות סמנטי הוא major.minor.patch. לדוגמה, בגרסה מספר 4.8.3, ‏4 הוא גרסת ה-major, ‏8 הוא גרסת ה-minor ו-3 הוא מספר ה-patch. כשהחלק major משתנה, יכול להיות שיהיו בספרייה שינויי תוכנה שעלולים לגרום לכשל ב-API או בהתנהגות. זה יכול להשפיע על ההתנהגות של ה-build או של האפליקציה.

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

קשרים בגיליון שיצרתם

גרסאות build של Android מכילות קשרים בין:

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

קוד מקור

קוד המקור הוא קוד Kotlin או Java שאתם כותבים באפליקציה או בספרייה. (לפרטים על השימוש ב-C++‎, ראו Android NDK).

קוד המקור תלוי בספריות (כולל ספריות זמן ריצה של Kotlin ו-Java) וב-Android SDK, ודורש את המהדר התואם של Kotlin או Java.

חלק מקוד המקור כולל הערות שדורשות עיבוד נוסף. לדוגמה, אם אתם כותבים קוד של Jetpack Compose, אתם מוסיפים הערות כמו @Composable שצריך לעבד באמצעות הפלאגין של Compose Kotlin compiler. יכול להיות שאנוטציות אחרות יעובדו על ידי Kotlin Symbol Processor‏ (KSP) או כלים נפרדים לעיבוד אנוטציות.

תלות של הפרויקט בספריות

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

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

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

כדי להשתמש בספריות מסוימות, יכול להיות שתצטרכו להשתמש בפלאגין ספציפי של Gradle. הפלאגינים האלה מתקינים לעיתים קרובות מעבדי Kotlin Symbol Processor או מעבדי אנוטציות אחרים שיוצרים קוד או משנים את הקומפילציה של המקור כדי לתמוך בשימוש בתכונות של הספרייה. לדוגמה, Jetpack Room כולל הערות ו-KSP שהופך אותן לקוד שנוצר כדי לאחזר ולשנות נתונים במסד נתונים. כדי ש-Jetpack Compose יוכל לשנות פונקציות עם אנוטציות ולנהל את האופן שבו הפונקציה מופעלת מחדש ואת המועד שבו היא מופעלת, צריך את הפלאגין של המקמפל של Compose.

כלים

Gradle

‫Gradle הוא כלי ה-build שקורא את קובצי ה-build ויוצר את האפליקציה או הספרייה. הוא גם חושף API לפלאגינים כדי להרחיב את היכולות שלו. ‫Gradle מריץ כמה תהליכים במכונה וירטואלית אחת או יותר של Java, והפלאגינים שלו ל-Java קוראים לכלי Java בתוך ה-JDK.

יישומי פלאגין של Gradle

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

מהדרים

הקומפיילר של Kotlin או Java ממיר את קוד המקור לבייטקוד שניתן להפעלה. הקומפיילר של Kotlin חושף API של פלאגין שמאפשר להריץ ניתוח חיצוני ויצירת קוד ישירות בתוך הקומפיילר, ולגשת למבנה הקוד המנותח.

פלאגינים של קומפיילר

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

Android SDK

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

כל גרסה של Android SDK מספקת ממשקי Java API ספציפיים שקוד המקור שלכם יכול לגשת אליהם, ותמיכה בהסרה של סוכר תחבירי כדי להשתמש בממשקי ה-API האלה בגרסאות קודמות של Android.

JDK

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

היקפי הרשאות ב-Gradle

‫Gradle מקבץ תלויות של הפרויקט בספרייה להיקפים שונים (שנקראים הגדרות ב-Gradle API), וכך מאפשר לכם לציין קבוצות שונות של תלויות של הפרויקט בספרייה לשימוש בחלקים שונים של ה-build. לדוגמה, סביר להניח שלא תרצו לכלול ספריות בדיקה כמו JUnit באפליקציה או בספרייה שאתם מפרסמים, אבל כן תרצו אותן כשאתם בונים ומריצים את בדיקות היחידה שלכם. אפשר גם להשתמש בהיקפים כדי להוסיף מעבדי סמלים או מעבדי אנוטציות (Annotation processor) לניתוח הקוד.

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

מוסיפים תלות של הפרויקט בספריות בבלוק dependencies של קובצי ה-build, כמחרוזות group:artifact:version:

Kotlin

// In a module-level build script
// explicit dependency strings ("group:artifact:version")
dependencies {
    implementation("com.example:library1:1.2.3")
    api("com.example:library2:1.1.1")
}

מגניב

// In a module-level build script
// explicit dependency strings ("group:artifact:version")
dependencies {
    implementation 'com.example:library1:1.2.3'
    api 'com.example:library2:1.1.1'
}

או בקטלוג גרסאות:

# Version catalog - gradle/libs.versions.toml
[versions]
exampleLib = "1.2.3"
examplePlugin = "2.3.4"

[libraries]
example-library = { group = "com.example", name = "library", version.ref = "exampleLib" }

[plugins]
example-plugin = { id = "com.example.plugin", version.ref = "examplePlugin" }

ולציין את המשתנים שנוצרו בקובצי ה-build:

Kotlin

// In a module-level build script
// Using a version catalog
plugins {
    alias(libs.plugins.example.plugin)
}

dependencies {
    implementation(libs.example.library)
}

מגניב

// In a module-level build script
// Using a version catalog
plugins {
    alias(libs.plugins.example.plugin)
}

dependencies {
    implementation libs.example.library
}