העברה ל-Android Studio

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

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

יסודות של Android Studio

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

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

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

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

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

מערכת build המבוססת על Gradle

מערכת ה-build של Android Studio מבוססת על Gradle ומשתמשת בקובצי תצורה של build שנכתבו בסקריפט גרובי או 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. נותנים שם לפרויקט האפליקציה, מציינים את המיקום שבו רוצים ליצור אותו ולוחצים על Next.
  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.

    מגניב

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