העברה ל-Android Studio

כדי להעביר את הפרויקטים ל-Android Studio, צריך להתאים את עצמכם למבנה הפרויקט החדש, למערכת ה-build ולפונקציונליות של סביבת הפיתוח המשולבת (IDE).

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

יסודות של Android Studio

ריכזנו כאן כמה מההבדלים העיקריים שחשוב לדעת עליהם כשמתכוננים לעבור ל-Android Studio.

ארגון פרויקטים ומודולים

Android Studio מבוססת על סביבת הפיתוח המשולבת (IDE) של IntelliJ IDEA. במאמר מידע על Android Studio מוסבר על העקרונות הבסיסיים של סביבת הפיתוח המשולבת, כמו ניווט, השלמת קוד ומקשי קיצור.

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

מידע נוסף על פרויקטים ומודולים ב-Android Studio זמין במאמר סקירה כללית על פרויקטים.

מערכת build מבוססת-Gradle

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

פרויקטים שמבוססים על Gradle מציעים תכונות חשובות לפיתוח ל-Android, כולל:

  • תמיכה בספריות בינאריות (AAR). כבר לא צריך להעתיק מקורות של ספריות לפרויקטים שלכם. אתם יכולים להצהיר על תלות, והספרייה תורד ותשולב בפרויקט באופן אוטומטי. זה כולל מיזוג אוטומטי של משאבים, רשומות מאניפסט, כללי החרגה של Proguard, כללי איתור שגיאות בהתאמה אישית וכו' בזמן ה-build.
  • תמיכה בגרסאות build, שמאפשרת ליצור גרסאות שונות של האפליקציה (למשל, גרסה חינמית וגרסה בתשלום) מאותו פרויקט.
  • הגדרה והתאמה אישית קלות של גרסאות build. לדוגמה, אפשר למשוך שמות גרסאות ומספרי גרסאות מתגי Git כחלק מה-build.
  • אפשר להשתמש ב-Gradle מ-IDE, משורת הפקודה ומשרתי שילוב רצוף (CI) כמו Jenkins, וכך לקבל את אותו build בכל מקום ובכל פעם.

מידע נוסף על השימוש ב-Gradle ועל הגדרתו זמין במאמר הגדרת ה-build.

יחסי תלות

ב-Android Studio, יחסים של תלות בספריות מתבססים על הצהרות של Gradle ועל יחסי תלות ב-Maven בספריות מקומיות ידועות עם קואורדינטות Maven של קובצי מקור וקובצי בינארי. מידע נוסף זמין במאמר הצהרת יחסי תלות.

מעבר מ-IntelliJ

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

ייבוא פרויקט IntelliJ שמבוסס על Gradle

אם אתם כבר משתמשים ב-Gradle בפרויקט שלכם ב-IntelliJ, תוכלו לפתוח אותו ב-Android Studio לפי השלבים הבאים:

  1. לוחצים על קובץ > חדש > ייבוא פרויקט.
  2. בוחרים את ספריית הפרויקט ב-IntelliJ ולוחצים על OK. הפרויקט ייפתח ב-Android Studio.

ייבוא פרויקט IntelliJ שאינו Gradle

אם עדיין לא משתמשים במערכת ה-build של Gradle בפרויקט ב-IntelliJ, יש שתי אפשרויות לייבוא הפרויקט ל-Android Studio, כפי שמתואר בקטעים הבאים:

העברה על ידי יצירת פרויקט חדש ריק

כדי להעביר את הפרויקט ל-Android Studio, יוצרים פרויקט ריק חדש ומעתיקים את קובצי המקור לתיקיות החדשות:

  1. פותחים את Android Studio ולוחצים על File (קובץ) > New (חדש) > New Project (פרויקט חדש).
  2. מזינים שם לפרויקט האפליקציה ומציינים את המיקום שבו הוא אמור להיווצר, ואז לוחצים על הבא.
  3. בוחרים את גורמי הצורה שבהם האפליקציה פועלת ולוחצים על הבא.
  4. לוחצים על Add No Activity (הוספת 'אין פעילות') ואז על Finish (סיום).
  5. בחלון הכלי Project, לוחצים על החץ כדי לפתוח את תפריט התצוגות ובוחרים בתצוגה Project כדי לראות ולחקור את הארגון של הפרויקט החדש ב-Android Studio. מידע נוסף על שינוי תצוגות ועל המבנה של פרויקטים ב-Android Studio זמין במאמר קבצי פרויקטים.
  6. עוברים למיקום שבחרתם לפרויקט החדש ומעבירים את הקוד, בדיקות היחידות, בדיקות המדידה והמשאבים מהספריות של הפרויקט הישן למיקומים המתאימים במבנה הפרויקט החדש.
  7. ב-Android Studio, לוחצים על File (קובץ) > Project Structure (מבנה הפרויקט) כדי לפתוח את תיבת הדו-שיח Project Structure. מוודאים שהמודול של האפליקציה נבחר בחלונית השמאלית.
  8. מבצעים את השינויים הנדרשים בכרטיסייה Properties של הפרויקט (לדוגמה, שינוי הערכים של minSdk או targetSdk).
  9. לוחצים על Dependencies ומוסיפים את כל הספריות שהפרויקט תלוי בהן בתור יחסי תלות ב-Gradle. כדי להוסיף יחסי תלות חדשים, לוחצים על Add (הוספה) , בוחרים את סוג יחסי התלות שרוצים להוסיף ופועלים לפי ההנחיות.
  10. לוחצים על אישור כדי לשמור את השינויים.
  11. לוחצים על Build > Make Project כדי לבדוק את ה-build של הפרויקט, ואם צריך, פותרים את השגיאות הקיימות.

העברה באמצעות יצירת קובץ build מותאם אישית של Gradle

כדי להעביר את הפרויקט ל-Android Studio על ידי יצירת קובץ build חדש של Gradle שיצביע על קובצי המקור הקיימים, פועלים לפי השלבים הבאים:

  1. לפני שמתחילים, צריך לגבות את קובצי הפרויקט במיקום נפרד, כי תהליך ההעברה משנה את התוכן של הפרויקט במקום.
  2. יוצרים קובץ בספריית הפרויקט בשם build.gradle אם משתמשים ב-Groovy, או build.gradle.kts אם משתמשים בסקריפט Kotlin. הקובץ הזה מכיל את כל המידע שנדרש ל-Gradle כדי להריץ את ה-build.

    כברירת מחדל, מערכת Android Studio מצפה שהפרויקט יהיה מאורגן כפי שמוצג באיור 1.

    איור 1. מבנה הפרויקט שמוגדר כברירת מחדל למודול של אפליקציה ל-Android.

    ב-settings.gradle, עבור Groovy, או ב-settings.gradle.kts, עבור סקריפט Kotlin, מגדירים את המאגרים שמשמשים למציאת יישומי פלאגין ויחסי תלות בבלוק pluginManagement ובבלוק dependencyResolutionManagement, בהתאמה:

    Groovy

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include ':app'

    Kotlin

      pluginManagement {
      repositories {
          google()
          mavenCentral()
          gradlePluginPortal()
      }
  }
  dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
          google()
          mavenCentral()
      }
  }
  rootProject.name = "Test App"
  include(":app")

    אזהרה: מאגר JCenter הפך לקריאה בלבד ב-31 במרץ 2021. מידע נוסף זמין במאמר עדכון שירות JCenter.

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

    מידע נוסף על הגדרה והתאמה אישית של קובץ build ב-Gradle זמין במאמר הגדרת ה-build.

  3. בשלב הבא, מזהים את פרויקטי הספריות שבהם אתם משתמשים.

    כשמשתמשים ב-Gradle, אין יותר צורך להוסיף את הספריות האלה כפרויקטים של קוד מקור. במקום זאת, אפשר להפנות אליהם בבלוק dependencies{} בקובץ ה-build. לאחר מכן, מערכת ה-build מטפלת בספריות האלה בשבילכם, כולל הורדת הספריות, מיזוג המשאבים ומיזוג הרשומות במניפסט. בדוגמה הבאה מתווספות הצהרות על מספר ספריות AndroidX לבלוק dependencies{} בקובץ build.

    Groovy

    ...
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    // AndroidX libraries
    implementation 'androidx.core:core-ktx:1.15.0'
    implementation 'androidx.appcompat:appcompat:1.7.0'
    implementation 'androidx.cardview:cardview:1.0.0'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.gridlayout:gridlayout:1.0.0'
    implementation 'androidx.leanback:leanback:1.1.0-rc02'
    implementation 'androidx.mediarouter:mediarouter:1.7.0'
    implementation 'androidx.palette:palette-ktx:1.0.0'
    implementation 'androidx.recyclerview:recyclerview:1.3.2'
    implementation 'androidx.annotation:annotation:1.9.1'

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle file.
}

    Kotlin

    ...
dependencies {
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))

    // AndroidX libraries
    implementation("androidx.core:core-ktx:1.15.0")
    implementation("androidx.appcompat:appcompat:1.7.0")
    implementation("androidx.cardview:cardview:1.0.0")
    implementation("com.google.android.material:material:1.7.0")
    implementation("androidx.gridlayout:gridlayout:1.0.0")
    implementation("androidx.leanback:leanback:1.1.0-rc02")
    implementation("androidx.mediarouter:mediarouter:1.7.0")
    implementation("androidx.palette:palette-ktx:1.0.0")
    implementation("androidx.recyclerview:recyclerview:1.3.2")
    implementation("androidx.annotation:annotation:1.9.1")

    // Note: these libraries require that the Google repository has been declared
    // in the pluginManagement section of the top-level build.gradle.kts file.
}
    כדי לקבל עזרה בקביעה של הצהרות ההצהרה הנכונות לספריות, תוכלו לחפש במאגר Google Maven או ב-Maven Central.
  4. שומרים את קובץ ה-build.gradle וסוגרם את הפרויקט ב-IntelliJ. עוברים לספריית הפרויקט ומוחקים את הספרייה .idea ואת כל קובצי ה-IML בפרויקט.
  5. פותחים את Android Studio ולוחצים על File (קובץ) > New (חדש) > Import Project (ייבוא פרויקט).
  6. מאתרים את ספריית הפרויקט, בוחרים את הקובץ build.gradle או build.gradle.kts שיצרתם ולוחצים על OK כדי לייבא את הפרויקט.
  7. לוחצים על Build > Make Project כדי לבדוק את קובץ ה-build על ידי בניית הפרויקט, ולטפל בשגיאות שנמצאות.

השלבים הבאים

אחרי שתעבירו את הפרויקט ל-Android Studio, תוכלו לקרוא מידע נוסף על יצירה באמצעות Gradle והפעלת האפליקציה ב-Android Studio במאמר יצירה והפעלה של האפליקציה.

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

הגדרת ניהול הגרסאות

ב-Android Studio יש תמיכה במגוון מערכות לניהול גרסאות, כולל Git,‏ Mercurial ו-Subversion. אפשר להוסיף מערכות אחרות של בקרת גרסאות באמצעות יישומי פלאגין.

אם האפליקציה שלכם כבר נמצאת בבקרת גרסאות, יכול להיות שתצטרכו להפעיל אותה ב-Android Studio. בתפריט VCS, לוחצים על Enable Version Control Integration ובוחרים את מערכת בקרת הגרסאות המתאימה.

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

  1. בתפריט VCS של Android Studio, לוחצים על Enable Version Control Integration.
  2. בוחרים בתפריט את מערכת בקרת הגרסאות שרוצים לשייך לשורש הפרויקט, ולוחצים על OK. בתפריט VCS יוצגו עכשיו כמה אפשרויות של בקרת גרסאות, בהתאם למערכת שבחרתם.

הערה: אפשר גם להשתמש באפשרות התפריט קובץ > הגדרות > בקרת גרסאות כדי להגדיר ולשנות את בקרת הגרסאות.

למידע נוסף על עבודה עם בקרת גרסאות, תוכלו לעיין במאמר המדריך ל-Version control ב-IntelliJ.

חתימה על אפליקציות

אם השתמשתם בעבר באישור ניפוי באגים, יכול להיות שהוא יזוהה במהלך תהליך הייבוא. במקרה כזה, Android Studio ממשיכה להפנות לאישור הזה. אחרת, הגדרת ניפוי הבאגים תשתמש במאגר המפתחות לניפוי באגים שנוצר על ידי Android Studio, באמצעות סיסמה ידועה ומפתח ברירת מחדל עם סיסמה ידועה שנמצאים ב-$HOME/.android/debug.keystore. סוג ה-build לניפוי באגים מוגדר להשתמש בהגדרת ניפוי הבאגים הזו באופן אוטומטי כשמריצים את הפרויקט או מנפים בו באגים מ-Android Studio.

באופן דומה, תהליך הייבוא עשוי לזהות אישור פרסום קיים. אם לא הגדרתם קודם אישור גרסה, צריך להוסיף את ההגדרה לחתימה על הגרסה לקובץ build.gradle או build.gradle.kts, או להשתמש באפשרות בתפריט Build > Generate Signed APK כדי לפתוח את אשף היצירה של קובץ APK חתום. למידע נוסף על חתימה על האפליקציה, ראו חתימה על האפליקציה.

שינוי הגודל המקסימלי של אשכול ב-Android Studio

כברירת מחדל, הגודל המקסימלי של אשכול ב-Android Studio הוא 1,280MB. אם אתם עובדים על פרויקט גדול או שיש לכם הרבה זיכרון RAM במערכת, תוכלו לשפר את הביצועים על ידי הגדלת הגודל המקסימלי של האשפה.

עדכוני תוכנה

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

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

מידע נוסף על עדכון Android Studio ועל שימוש בגרסאות תצוגה מקדימה ובגרסאות בטא זמין במאמר עדכונים.