הוספת Kotlin לאפליקציה קיימת

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

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

לקבלת דוגמאות, אפשר לעיין דוגמאות קוד של Kotlin

הוספת Kotlin לפרויקט קיים

כדי להוסיף את Kotlin לפרויקט:

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

   

   איור 1. בחר מהתבניות הזמינות, כגון מקטע או פעילות.

2. באשף שמופיע, בוחרים באפשרות Kotlin עבור שפת המקור. איור 2 מציג את תיבת הדו-שיח פעילות חדשה ב-Android כשרוצים. יוצרים פעילות חדשה.

   

   איור 2. תיבת דו-שיח פעילות חדשה ב-Android שבה אפשר בוחרים בKotlin כשפת המקור.

3. ממשיכים לבצע את הפעולות באשף.

לחלופין אפשר ללחוץ על File > חדש > קובץ/כיתה של Kotlin כדי ליצור קובץ Kotlin בסיסי. אם האפשרות הזו לא מופיעה, פותחים את החלון Project ו בוחרים את ספריית Java. החלון New Kotlin File/Class מאפשר לכם מגדירים את שם הקובץ ומספקים כמה אפשרויות לגבי סוג הקובץ: קובץ, Class, Interface, Enum Class או Object. הבחירה שלך קובע את הפיגוע הבסיסי שנוצר עבורך בקובץ Kotlin החדש. אם בוחרים באפשרות Class, Android Studio יוצר קובץ מקור חדש של Kotlin עם והגדרה תואמת של מחלקה. אם בוחרים באפשרות Interface, מוצהר בקובץ, וכן הלאה.

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

איור 3. ב-Android Studio מוצגת אזהרה בתיבת דו-שיח ב-Kotlin שאינו מוגדר בפרויקט שלכם.

בחירה באפשרות להגדרת Kotlin עם כל המודולים שמכילים Kotlin כשמוצגת בקשה לעשות זאת, כפי שמוצג באיור 4:

איור 4. בחירה להגדיר את Kotlin לכל המודולים שמכילים קוד Kotlin.

אחרי שלוחצים על OK (אישור), מערכת Android Studio מוסיפה את Kotlin לנתיב הכיתה של הפרויקט. מחילה את הפלאגין ל-Android של Kotlin על כל מודול שמכיל קובצי Kotlin. הקבצים מסוג build.gradle צריכים להיות דומים לדוגמאות הבאות:

מגניב

// Project build.gradle file.
buildscript {
    ext.kotlin_version = '1.4.10'
    ...
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

Kotlin

// Project build.gradle.kts file.
buildscript {
    extra["kotlin_version"] = "1.4.10"
    ...
    dependencies {
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
    }
}

מגניב

// Inside each module using kotlin
plugins {
    ...
    id 'kotlin-android'
}

...

dependencies {
    implementation 'androidx.core:core-ktx:1.3.2'
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}

Kotlin

// Inside each module using kotlin
plugins {
    ...
    kotlin("android")
}

...

val kotlin_version: String by rootProject.extra

dependencies {
    implementation("androidx.core:core-ktx:1.3.2")
    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
}

ארגון המקור

כברירת מחדל, קובצי Kotlin חדשים נשמרים ב-src/main/java/, ולכן זה קל! כדי לראות קובצי Kotlin ו-Java במיקום אחד. אם אתם מעדיפים להפריד קובצי Kotlin מקובצי Java, אפשר לשים קובצי Kotlin יש גם אפשרות src/main/kotlin/. אם עושים את זה, צריך לכלול גם את המאפיין הזה בספרייה sourceSets כפי שמוצג בהמשך:

מגניב

android {
    sourceSets {
        main.java.srcDirs += 'src/main/kotlin'
    }
}

Kotlin

android {
    sourceSets {
        getByName("main") {
            java.srcDir("src/main/kotlin")
        }
    }
}

המרת קוד Java קיים לקוד Kotlin

כדי להמיר קוד Java ל-Kotlin, פותחים את קובץ ה-Java ב-Android Studio ובוחרים קוד > המרת קובץ Java לקובץ Kotlin. לחלופין, אפשר ליצור שם חדש ב-Kotlin של קובץ (File > New > Kotlin File/Class), ולאחר מכן מדביקים את קוד ה-Java בתוך . לאחר מכן תוצג ב-Android Studio הנחיה והצעות להמרת הקוד ל-Kotlin, כפי שמוצג באיור 5. לוחצים על כן כדי להמיר. אפשר מסמנים את האפשרות אין להציג את תיבת הדו-שיח הזו בפעם הבאה, כדי לגרום להמרות עתידיות באופן אוטומטי.

איור 5. ב-Android Studio אפשר להמיר קוד Java ל-Kotlin.

המרת קוד ויכולת null

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

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

public class JavaFragment extends Fragment {

    // Null until onCreateView.
    private Button button;

    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_content, container,false);

        // Get a reference to the button in the view, only after the root view is inflated.
        button = root.findViewById(R.id.button);

        return root;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        // Not null at this point of time when onViewCreated runs
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ...
            }
        });
    }
}

למרות שמשתנה הלחצן הוא אפסי, למטרות מעשיות הוא בדוגמה הזו אף פעם לא צריך להיות null. אבל מכיוון שהערך שלו לא בנקודת הבנייה, קוד Kotlin שנוצר מתייחס ל-Button בשדה מסוג null ומשתמש באופרטור טענת נכוֹנוּת (assertion) שאינו אפס כדי לפתוח את האריזה של הלחצן כשמוסיפים אוזן קליקים, כפי שמוצג בהמשך:

class JavaFragment : Fragment() {

    // Null until onCreateView.
    private var button: Button? = null

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
            savedInstanceState: Bundle?): View? {
        ...
        // Get a reference to the button in the view, only after the root view is inflated.
        button = root.findViewById(R.id.button)
        ...
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // Not null at the point of time when onViewCreated fires 
        // but force unwrapped nonetheless
        button!!.setOnClickListener { }
    }
}

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

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

במקרים אחרים, שבהם null הוא הקצאת משתנה חוקית על סמך של האפליקציה, באמצעות אופרטור 'שיחה בטוחה' (?.) עם תו סגירה מפעיל (?:) עשוי להיות דרך מתאימה יותר לפתוח את האריזה של אובייקט שהוא ערך null או ערך ברירת מחדל הגיוני שהוא לא null. סטודיו ל-Android אין מספיק מידע כדי לבצע קביעה זו במהלך תהליך המרה. אומנם הגדרת ברירת המחדל היא טענת נכוֹנוּת (assertion) שאינה אפסית, אבל כדאי או לשנות את הקוד שהומר לפי הצורך.

מידע נוסף

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

למידע נוסף על השימוש ב-Kotlin בתרחישים ארגוניים: שימוש ב-Kotlin לצוותים גדולים.

למידע על רכיבי wrapper אידיומטיים של Kotlin לממשקי API קיימים של Android, אפשר להיכנס לכתובת Android KTX.