דף זה תורגם על ידי Cloud Translation API.

העברה ל-Android Studio

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

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

העקרונות הבסיסיים של Android Studio

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

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

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

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

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

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

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

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

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

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

פותחים את Android Studio ולוחצים על קובץ > חדש > פרויקט חדש.
נותנים שם לפרויקט האפליקציה ומציינים את המיקום שלו. ואז לוחצים על Next.
בוחרים את גורמי הצורה שבהם האפליקציה תפעל ולוחצים על הבא.
לוחצים על הוספת ללא פעילות ואז על סיום.
בחלון של הכלי פרויקט, לוחצים על החץ כדי לפתוח את התצוגה. בתפריט הנפתח ובוחרים באפשרות Project (פרויקט) כדי לראות ולחקור של פרויקט Android Studio החדש. למידע נוסף על שינויים על המבנה של פרויקטים ב-Android Studio, כדאי לעיין במאמר קובצי פרויקט.
עוברים למיקום שבחרתם לפרויקט החדש ומעבירים את הקוד, בדיקות היחידה, בדיקות המדידה והמשאבים מהספריות של הפרויקט הישן למיקומים המתאימים במבנה הפרויקט החדש.
ב-Android Studio, לוחצים על קובץ > Project Buildure כדי לפתוח את תיבת הדו-שיח Project Buildure (מבנה הפרויקט). מוודאים שהמודול של האפליקציה נבחר ב בחלונית שמימין.
מבצעים את השינויים הנדרשים בכרטיסייה מאפיינים של פרויקט (לדוגמה, שינוי minSdk או targetSdk).
לוחצים על יחסי תלות ומוסיפים ספריות שהפרויקט תלוי בהן שתלויות ב-Gradle. כדי להוסיף תלות חדשה, לוחצים על Add (הוספה). , לאחר מכן בוחרים את סוג התלות שרוצים להוסיף ופועלים לפי ההנחיות.
לוחצים על אישור כדי לשמור את השינויים.
לוחצים על Build > (פיתוח >) יוצרים פרויקט כדי לבדוק את בניית הפרויקט. במקרה הצורך, יפתרו שגיאות שלא טופלו.

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

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

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

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

ב-settings.gradle, בשביל גרובי, או 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")
  
```
אזהרה: ב-31 במרץ 2021 המאגר של JCenter הוגדר לקריאה בלבד. מידע נוסף זמין במאמר הבא: עדכון השירות של JCenter.

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

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

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

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

מגניב

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

    // AndroidX libraries
    implementation 'androidx.core:core-ktx:1.13.1'
    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.8.2'

    // 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.13.1")
    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.8.2")

    // 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.

שומרים את הקובץ build.gradle ואז סוגרים את הפרויקט ב- IntelliJ. עוברים לספריית הפרויקט ומוחקים את הספרייה .idea ואת כל קובצי ה-IML בפרויקט.
מפעילים את Android Studio ולוחצים על קובץ > חדש > ייבא פרויקט.
מאתרים את ספריית הפרויקט ולוחצים על build.gradle או קובץ אחד (build.gradle.kts) שיצרת, ואז לוחצים על OK כדי לייבא פרויקט.
לוחצים על Build > (פיתוח >) יוצרים פרויקט כדי לבדוק את קובץ ה-build באמצעות בבניית הפרויקט שלכם, ותטפלו בשגיאות שמצאתם.

השלבים הבאים

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

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

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

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

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

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

בתפריט Android Studio VCS, לוחצים על Enable Version Control (הפעלת ניהול גרסאות)". שילוב.
בוחרים מערכת לניהול גרסאות שתשויך ל-Root של הפרויקט ולאחר מכן לוחצים על אישור. בתפריט 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 הוא 1280MB. אם אתם אם עובדים על פרויקט גדול או שיש למערכת הרבה RAM, אפשר לשפר את הביצועים באמצעות הגדלת ערך הערימה המקסימלי size.

עדכוני תוכנה

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

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

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