Mastering Gradle for Android: משימות Gradle וקוטלין

תוֹכֶן

בחינת Gradle לבנות קבצים
1. הגדרות
2. build.gradle (רמת פרויקט)
3. build.gradle (רמת מודול)
הצהרת תלות הפרוייקט שלך: ספריות מקומיות
הוספת תלות לבנות: מאגרים מרוחקים
מתחבר למאגר מרוחק
הצהרת תלות מרחוק
יצירת APKs מרובים: כיצד ליצור גרסאות בנייה
יצירת משימת Gradle בהתאמה אישית
בנה את הפרויקט שלך עם עטיפת הגריידל
אילו משימות אחרות ב- Gradle זמינות?
הוצאת יותר מ- Gradle: הוספת תוספים
ה- Gradle Kotlin DSL
מסיימים

במקום Java, XML או Kotlin, קבצי Gradle build אלו משתמשים בשפה ספציפית לתחום מבוסס Groovy (DSL). אם אינך מכיר את גרובי, אנו נבחן שורה אחר שורה על כל אחד מהקבצים האלה לבנות Gradle, אז בסוף מאמר זה יהיה לך נוח לקרוא ולכתוב קוד גרובי פשוט.

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

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

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

בחינת Gradle לבנות קבצים

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

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

1. הגדרות

שם הקובץ settings.gradle תגדיר את כל המודולים של היישום שלך לפי שם, באמצעות מילת המפתח "כלול". לדוגמה, אם היה לך פרויקט המורכב מ"אפליקציה "ו-" secondModule ", קובץ ה- settings.gradle שלך היה נראה כך:

כוללים: app,: secondmodule rootProject.name = MyProject

תלוי בגודל הפרויקט שלך, קובץ זה עשוי להיות ארוך משמעותית.

במהלך תהליך הבנייה, Gradle תבחן את התוכן של קובץ ההגדרות של הפרויקט שלך, ותזהה את כל המודולים הדרושים לו לכלול בתהליך הבנייה.

2. build.gradle (רמת פרויקט)

קובץ build.gradle ברמת הפרויקט ממוקם בספריית השורש של הפרוייקט והוא מכיל הגדרות שיוחלו עליו את כל המודולים שלך (המכונים גם "פרויקטים" על ידי Gradle).

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

קובץ build.gradle טיפוסי ברמת הפרוייקט ייראה כך:

buildscript {מאגרים {google () jcenter ()} תלות {classpath com.android.tools.build:gradle:3.5.0-alpha06 // הערה: אל תניח כאן את תלות היישום שלך; הם שייכים // במודול הבודד קבצי build.gradle}} כל הפרויקטים {מאגרים {google () jcenter ()}} משימה נקייה (סוג: מחק) {מחק rootProject.buildDir}

קובץ build.gradle ברמת הפרויקט מחולק לבלוקים הבאים:

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

3. build.gradle (רמת מודול)

זהו קובץ build.gradle ברמת המודול, המצוי בכל מודול לאורך כל הפרוייקט. אם פרויקט ה- Android שלך מורכב ממספר מודולים, הוא יכלול גם קבצי build.gradle מרובים ברמת המודול.

כל קובץ build.gradle ברמת המודול מכיל את שם החבילה של הפרויקט, שם הגרסה וקוד הגירסה, בתוספת המינימום והיעד SDK עבור מודול מסוים זה.

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

קובץ build.gradle בסיסי ברמת המודול בדרך כלל ייראה כך:

להחיל תוסף: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion 23 targetSdkVersion 28 versionCode 1 גרסהName "1.0" testInstrumentationRunner "androidx.test.runner.Roogle proxy getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} תלות {File fileTree (dir: libs, כוללים:) יישום androidx.appcompat: appcompat: 1.0.2 יישום androidx.constraintlayout: constraintlayout: 1.1. 3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

בואו נסתכל מקרוב על כל אחד מהקטעים הבאים:

החל תוסף. זוהי רשימה של התוספים הנדרשים לבניית מודול זה. התוסף com.android.application נחוץ כדי להתקין את תהליך הבנייה הספציפי לאנדרואיד, כך שזה מתווסף אוטומטית.
אנדרואיד. כאן אתה צריך למקם את כל האפשרויות הספציפיות לפלטפורמה של המודול.
compileSdkVersion. זוהי רמת ה- API איתה נערך מודול זה. אינך יכול להשתמש בתכונות מממשק API הגבוה מערך זה.
גרסאות. זה מצביע על גרסת המהדר. ב- Gradle 3.0.0 ומעלה, buildToolsVersion הוא אופציונלי; אם לא תציין ערך buildToolsVersion, Android Studio כברירת מחדל יהיה הגרסה העדכנית ביותר של כלי בנייה.
defaultConfig. זה מכיל אפשרויות שיוחלו על כל גרסאות ה- build של האפליקציה שלך, כגון build-debug וה- Release.
יישום זהו המזהה הייחודי של היישום שלך.
minSdkVersion. פרמטר זה מגדיר את רמת ה- API הנמוכה ביותר שתומך במודול זה.
targetSdkVersion. זוהי רמת ה- API המרבית שאליה נבדק היישום שלך. באופן אידיאלי, עליך לבדוק את היישום שלך באמצעות ה- API האחרון, שפירושו שערך targetSdkVersion תמיד יהיה שווה לערך compileSdkVersion.
versionCode. זהו ערך מספרי עבור גרסת היישום שלך.
גרסת שם. זהו מחרוזת ידידותית למשתמש, המייצגת את גרסת היישום שלך.
buildtypes. כברירת מחדל, אנדרואיד תומכת בשני סוגים של מבנים: ניפוי באגים ושחרור. אתה יכול להשתמש בבלוקים "ניפוי באגים" ו"שחרור "כדי לציין את ההגדרות הספציפיות ליישום.
תלות. כאן תגדיר ספריות שהמודול הזה תלוי בהן.

הצהרת תלות הפרוייקט שלך: ספריות מקומיות

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

כדי להכריז על תלות בקובץ JAR מקומי, עליכם להוסיף את ה- JAR לספריית ה- “libs” של הפרויקט.

לאחר מכן תוכל לשנות את קובץ build.gradle ברמת המודול כדי להצהיר על תלות בקובץ זה. לדוגמה, כאן אנו מצהירים על תלות ב- JAR "mylibrary".

קבצי יישום (libs / mylibrary.jar)

לחלופין, אם תיקיית ה- "libs" שלך מכילה מספר JAR, ייתכן שיהיה קל יותר לקבוע שהפרויקט שלך תלוי בכל הקבצים שנמצאים בתיקיה "libs", למשל:

קובץ היישום TriT (בימוי: libs, כולל:)

הוספת תלות לבנות: מאגרים מרוחקים

אם ספרייה ממוקמת במאגר מרוחק, תצטרך לבצע את הצעדים הבאים:

הגדר את המאגר בו נמצא תלות זו.
הצהירו על התלות האישית.

מתחבר למאגר מרוחק

השלב הראשון הוא להגיד ל- Gradle באיזה מאגר (או מאגרים) הוא צריך לבדוק, כדי לאחזר את כל התלות של הפרויקט. לדוגמה:

מאגרים {google () jcenter ()}}

כאן, קו "jcenter ()" מבטיח שגראדל תבדוק את מאגר JCenter, שהוא מאגר ציבורי בחינם המתארח ב- bintray.

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

מאגרים {mavenCentral () maven {// קבע את התצורה של כתובת אתר היעד // url "http://repo.mycompany.com/myprivaterepo"} maven {אישורים {שם משתמש סיסמת שם המשתמש שלי סיסמה} url "http://repo.mycompany.com / myprivaterepo "}

אם קיימת תלות בתוך מאגרים מרובים, Gradle תבחר בגרסה "הטובה ביותר" של תלות זו, על סמך גורמים כמו הגיל של כל מאגר והגרסה הסטטית.

הצהרת תלות מרחוק

השלב הבא הוא הכרזת התלות בקובץ build.gradle ברמת המודול שלך. אתה מוסיף מידע זה לחסימה של "תלות", באמצעות אחת מהפעולות הבאות:

יישום. זו תלות רגילה שאתה זקוק לה בכל פעם שאתה בונה את הפרויקט שלך. תלות "יישום" תהיה קיימת לרוחב את כל בונה שלך.
יישום מבחן. זוהי תלות הנדרשת כדי להרכיב את מקור הבדיקה של היישום שלך ולהריץ בדיקות מבוססות JVM. כשאתה מסמן תלות כ"הטמעה של מבחן "Gradle תדע שהיא לא צריכה להריץ משימות לתלות זו במהלך בנייה רגילה, מה שיכול לעזור להפחית את זמן הבנייה.
יישום Androidtimplementation. זוהי תלות הנדרשת בעת הפעלת בדיקות במכשיר, למשל מסגרת אספרסו היא "יישום Androidtest" נפוץ.

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

תלות {יישום fileTree (dir: libs, כולל:) יישום androidx.appcompat: appcompat: 1.0.2 יישום androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTest Implementation androidx.test.espresso: ליבת אספרסו: 3.1.1}

יצירת APKs מרובים: כיצד ליצור גרסאות בנייה

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

זוהי משימת בניה ש- Gradle יכולה לעזור לך בה, אז בואו נראה כיצד ניתן לשנות את תהליך הבנייה ליצירת מספר APKs מפרויקט בודד:

פתח את קובץ ה- strings.xml ומחק את מחרוזת שם היישום המקורית שלך.
בשלב הבא, הגדר את השמות של כל טעם מוצר שברצונך ליצור; במקרה זה אני משתמש ב:

האפליקציה החינמית שלי האפליקציה בתשלום שלי

פתח את קובץ AndroidManifest.xml והחלף את אנדרואיד: label = ”@ string / app_name” באמצעות:

android: label = "$ {appName}"

פתח את קובץ build.gradle ברמת המודול שלך והוסף את הדברים הבאים לחסימה של אנדרואיד:

טעםDimensions "מצב" productFlavors {free {dimension "מצב" applicationIdSuffix ".free" manifestPlaceholders =} בתשלום {dimension "מצב" applicationIdSuffix ".paid" manifestPlaceholders =}}}

בואו נשבר את מה שקורה כאן:

ממדי טעם. התוסף לאנדרואיד יוצר גרסאות בנייה על ידי שילוב טעמים מממדים שונים. כאן אנו יוצרים מימד טעם המורכב מגרסאות "בחינם" ו"בתשלום "של האפליקציה שלנו. בהתבסס על הקוד שלמעלה, Gradle תייצר ארבע גרסאות בניה: תשלוםDebug, paysRelease, freeDebug ו- freeRelease.
מוצר טעמים. זה מציין רשימת טעמים וההגדרות שלהם, שבקוד לעיל הם "בתשלום" ו"חינם ".
חינם / בתשלום. אלה שמות שני טעמי המוצרים שלנו.
ממד. עלינו לציין ערך פרמטר "ממד"; במקרה זה אני משתמש ב"מצב ".
יישוםIdSuffix. מכיוון שאנו רוצים ליצור גרסאות מרובות של האפליקציה שלנו, עלינו לתת לכל APK מזהה אפליקציה ייחודי.
מחזיקי המניפסט. לכל פרויקט יש קובץ מניפסט אחד המכיל מידע חשוב על תצורת הפרויקט שלך. בעת יצירת גרסאות בנייה מרובות, לרוב תרצה לשנות חלק מהמאפיינים של Manifest בזמן הבנייה. אתה יכול להשתמש בקבצי build Gradle כדי לציין ערכי מניפסט ייחודיים עבור כל גרסת בנייה, שתוכנס למניפסט שלך בזמן הבנייה. בקוד שלעיל אנו משנים את ערך "appName", תלוי אם Gradle בונה את הגרסה החינמית או בתשלום של האפליקציה שלנו.

יצירת משימת Gradle בהתאמה אישית

לפעמים יתכן שתצטרך להתאים אישית את תהליך הבנייה באמצעות Gradle משימות.

משימה היא אוסף פעולות ששמו Gradle יבצע כאשר הוא מבצע מבנה, למשל יצירת ג'וואדוק. Gradle תומך בשפע משימות כברירת מחדל, אך באפשרותך גם ליצור משימות בהתאמה אישית, שיכולות להועיל אם יש לך קבוצה ספציפית מאוד של הוראות בנייה.

בחלק זה ניצור משימה מותאמת אישית ל- Gradle שתחליף את כל גרסאות הבנייה של הפרויקט שלנו (תשלום דבוג, בתשלום, חופשי דבוג וחופשי להפיץ), ניצור חותמת תאריך ושעה ואז הוסף מידע זה לכל APK שנוצר.

פתח את קובץ build.gradle ברמת המודול שלך והוסף את הדברים הבאים:

משימה addDateAndTime () {// ביטול דרך כל גרסאות בניית הפלט // android.applicationVariants.all {variant -> // איתור דרך כל קבצי ה- APK // variant.outputs.all {output -> // צור מופע של התאריך והשעה הנוכחיים, בפורמט שצוין // def dateAndTime = תאריך חדש (). פורמט ("yyyy-MM-dd: HH-mm") // הוסף מידע זה לשם הקובץ של APK // def fileName = variant. name + "_" + dateAndTime + ".apk" output.outputFileName = fileName}}}

בשלב הבא עלינו לספר לגראדל מתי עליו לבצע משימה זו. במהלך בנייה, Gradle מזהה את כל מה שהיא צריכה להוריד ואת כל המשימות שיש לה לבצע, ומסדרת אותם בתרשים Acyclic Directed (DAG). לאחר מכן, Gradle יבצע את כל המשימות הללו, לפי הסדר שהוגדר ב- DAG שלה.

עבור האפליקציה שלי, אני הולך להשתמש בשיטת "WhenReady", שמבטיחה שהמשימה שלנו תיקרא ברגע ש- DAG יאוכלסה, ו- Gradle מוכנה להתחיל לבצע את המשימות שלה.

הוסף את הדברים הבאים לקובץ build.gradle ברמת המודול שלך:

// בצע משימה זו // gradle.taskGraph.whenReady {addDateAndTime}

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

בנה את הפרויקט שלך עם עטיפת הגריידל

אתה מוציא פקודות Gradle באמצעות עטיפת Gradle ("gradlew"). סקריפט זה הוא הדרך המועדפת להתחיל בבניית Gradle, מכיוון שהוא הופך את ביצוע המבנה לבלתי תלוי מהגרסה שלך ל- Gradle. הפרדה זו יכולה להיות שימושית אם אתה משתף פעולה עם אחרים שאולי לא בהכרח מותקנת אותה גרסה של Gradle.

כשאתה מפיץ את פקודות העטיפה שלך ל- Gradle, תשתמש ב- "gradlew" עבור מערכות הפעלה דמויות Unix, כולל macOS, ו- "gradlew.bat" עבור Windows. יש לי Mac, אז אני אשתמש בפקודות "gradlew".

אתה יכול להוציא פקודות Gradle מתוך Android Studio:

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

./ בניית גדר

סטודיו אנדרואיד צריך להיראות כך:

לחץ על מקש "Enter" במקלדת. Gradle יבנה כעת את הפרויקט שלך.

Gradle מאחסן את כל ה- APKs שנוצרו בספריית האפליקציות / בנייה / תפוקות / apk של הפרויקט, אז נווט אל הספרייה הזו. תיקיית ה- APK צריכה להכיל מספר תיקיות ותיקיות משנה; וודא ש- Gradle יצרה APK עבור כל אחד מגרסאות ה- build שלך, ושמידת התאריך והשעה הנכונים נוספו לכל קובץ.

אילו משימות אחרות ב- Gradle זמינות?

בנוסף לכל משימות מותאמות אישית שתוכלו ליצור, Gradle תומכת ברשימה של משימות שהוגדרו מראש מחוץ לתיבה. אם אתה סקרן לראות בדיוק אילו משימות זמינות, אז:

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

./gradlew -q משימות

לחץ על מקש "Enter" במקלדת.

משימת "משימות" זו תפעל כעת, ואחרי מספר רגעים הטרמינל יציג רשימה של כל המשימות הזמינות לפרויקט זה, להשלים עם תיאור קצר של כל משימה.

הוצאת יותר מ- Gradle: הוספת תוספים

ספינות גרדל עם מספר תוספים שהותקנו מראש, אך אתה יכול להרחיב עוד יותר את Gradle על ידי הוספת תוספים חדשים. תוספים אלה הופכים משימות חדשות לזמינות לפרויקטים שלך באנדרואיד, למשל התוסף Java כולל משימות המאפשרות לקמפל קוד מקור של Java, להריץ בדיקות יחידות וליצור קובץ JAR, כגון "compileJava", "compileText", "jar," "ג'וואדוק," ו"נקי. "

כדי להחיל תוסף, הוסף את הצהרת "החל תוסף" לקובץ build.gradle ברמת המודול שלך, ואחריו שם התוסף. לדוגמה, כאן אנו מיישמים את התוסף Java:

החל תוסף:

אם אתה סקרן לראות אילו תוספים זמינים, בדוק את חיפוש התוספים של Gradle, שמספק רישום מקיף של תוספי Gradle.

ה- Gradle Kotlin DSL

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

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

אם אתה רוצה להתחיל לכתוב את היגיון ה- build שלך בקוטלין, תצטרך להתקין את ה- Gradle Kotlin DSL ולעקוב אחר ההוראות במדריך ההעברה.

מסיימים

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

האם הרחבת את Gradle לאוטומציה של חלקים אחרים בתהליך בניית אנדרואיד? ספר לנו בתגובות למטה!