העברה ל-Android Studio

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

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

מידע בסיסי על Android Studio

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

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

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

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

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

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

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

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

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

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

תלויות

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

העברה מ-IntelliJ

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

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

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

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

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

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

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

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

כדי להעביר את הפרויקט ל-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. מבצעים את השינויים הנדרשים בכרטיסייה מאפיינים של הפרויקט (לדוגמה, שינוי של minSdk או targetSdk).
9. לוחצים על Dependencies (תלויות) ומוסיפים את כל הספריות שהפרויקט תלוי בהן כתלויות של Gradle. כדי להוסיף תלות חדשה, לוחצים על הוספה , בוחרים את סוג התלות שרוצים להוסיף ופועלים לפי ההנחיות.
10. לוחצים על אישור כדי לשמור את השינויים.
11. לוחצים על Build > Make Project כדי לבדוק את ה-build של הפרויקט, ואם צריך, פותרים את השגיאות שמופיעות.

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

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

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

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

   

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

   מגניב

     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 מפורט מידע נוסף על הגדרה והתאמה אישית של קובץ build של Gradle.

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

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

   מגניב

   ...
   dependencies {
       implementation fileTree(dir: 'libs', include: ['*.jar'])
   
       // AndroidX libraries
       implementation 'androidx.core:core-ktx:1.16.0'
       implementation 'androidx.appcompat:appcompat:1.7.1'
       implementation 'androidx.cardview:cardview:1.0.0'
       implementation 'com.google.android.material:material:1.7.0'
       implementation 'androidx.gridlayout:gridlayout:1.1.0'
       implementation 'androidx.leanback:leanback:'
       implementation 'androidx.mediarouter:mediarouter:1.8.1'
       implementation 'androidx.palette:palette-ktx:1.0.0'
       implementation 'androidx.recyclerview:recyclerview:1.4.0'
       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.16.0")
       implementation("androidx.appcompat:appcompat:1.7.1")
       implementation("androidx.cardview:cardview:1.0.0")
       implementation("com.google.android.material:material:1.7.0")
       implementation("androidx.gridlayout:gridlayout:1.1.0")
       implementation("androidx.leanback:leanback:")
       implementation("androidx.mediarouter:mediarouter:1.8.1")
       implementation("androidx.palette:palette-ktx:1.0.0")
       implementation("androidx.recyclerview:recyclerview:1.4.0")
       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 שיצרתם, ואז לוחצים על אישור כדי לייבא את הפרויקט.
7. לוחצים על Build > Make Project כדי לבדוק את קובץ ה-build על ידי בניית הפרויקט, ומתקנים את השגיאות שמוצאים.

השלבים הבאים

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

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

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

מידע נוסף על עבודה עם בקרת גרסאות זמין במאמר IntelliJ's Version control reference.

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

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

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

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

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

עדכוני תוכנה

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

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

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