Mastering Gradle para sa Android: Mga gawain sa Gradle at Kotlin

Nilalaman

Paggalugad ng Gradle magtayo ng mga file
1. setting.gradle
2. build.gradle (antas ng proyekto)
3. build.gradle (module level)
Ang pagpapahayag ng mga dependencies ng iyong proyekto: Lokal na mga aklatan
Pagdaragdag ng isang dependency ng pagbuo: Mga repote ng Remote
Pagkonekta sa isang malayong imbakan
Pagpapahayag ng isang malayong pagpapakandili
Bumubuo ng maraming mga APK: Paano lumikha ng mga variant ng build
Lumilikha ng isang pasadyang gawain ng Gradle
Pagbuo ng iyong proyekto sa Gradle wrapper
Ano ang iba pang mga gawain sa Gradle na magagamit?
Pagkuha ng higit pa sa Gradle: Pagdaragdag ng mga plugin
Ang Gradle Kotlin DSL
Pagputol

Sa halip na Java, XML o Kotlin, ang mga Gradle na ito ay nagtatayo ng mga file ay gumagamit ng wika na nakabase sa domain na batay sa Groovy (DSL). Kung hindi ka pamilyar sa Groovy, magkakaroon kami ng isang line-by-line na pagtingin sa bawat isa sa mga file na ito ng Gradle, kaya sa pagtatapos ng artikulong ito ay magiging komportable ka sa pagbasa at pagsulat ng simpleng code ng Groovy.

Nilalayon ni Gradle na gawing mas madali ang iyong buhay, sa pamamagitan ng pagbibigay ng isang hanay ng mga default na setting na madalas mong magamit gamit ang minimum na manu-manong pagsasaayos - kapag handa ka na upang mabuo ang iyong proyekto, pindutin lamang ang pindutan ng "Run" ng Android Studio at sisimulan ng Gradle ang proseso ng pagbuo para sa iyo.

Sa kabila ng diskarte ng "Convention over configuration" ni Gradle, kung ang mga default na setting nito ay hindi nakakatugon sa iyong mga pangangailangan, maaari mong ipasadya, i-configure at palawakin ang proseso ng pagbuo, at kahit na i-tweak ang mga setting ng Gradle upang maisagawa ang mga tiyak na gawain.

Dahil ang mga script ng Gradle ay nakapaloob sa kanilang sariling mga file, maaari mong baguhin ang proseso ng pagbuo ng iyong aplikasyon sa anumang oras, nang hindi kinakailangang hawakan ang code ng source ng iyong aplikasyon. Sa tutorial na ito, babaguhin namin ang proseso ng pagbuo gamit ang mga lasa, bumuo ng mga variant at isang pasadyang gawain ng Gradle - lahat nang wala kailanman hawakan ang aming application code.

Paggalugad ng Gradle magtayo ng mga file

Sa bawat oras na lumikha ka ng isang proyekto, ang Android Studio ay bubuo ng parehong koleksyon ng mga file ng build ng Gradle. Kahit na mag-import ka ng isang umiiral na proyekto sa Android Studio, magiging pa rin lumikha ng eksaktong eksaktong mga file ng Gradle, at idagdag ang mga ito sa iyong proyekto.

Upang simulan upang makakuha ng isang mas mahusay na pag-unawa sa Gradle at Groovy syntax, tingnan natin ang isang line-by-line na pagtingin sa bawat file ng Gradle ng Android.

1. setting.gradle

Ang file na setting.gradle ay kung saan mo tukuyin ang lahat ng mga module ng pangalan ng iyong aplikasyon, gamit ang keyword na "isama". Halimbawa, kung mayroon kang isang proyekto na binubuo ng isang "app" at isang "secondModule," kung gayon ang hitsura ng iyong setting.gradle file ay katulad nito:

isama ang: app,: pangalawang gamut rootProject.name = MyProject

Depende sa laki ng iyong proyekto, ang file na ito ay maaaring mas matagal.

Sa panahon ng proseso ng pagtatayo, susuriin ng Gradle ang mga nilalaman ng file ng setting ng iyong proyekto at tukuyin ang lahat ng mga module na kailangang isama sa proseso ng pagbuo.

2. build.gradle (antas ng proyekto)

Ang proyekto na antas ng build.gradle file ay matatagpuan sa direktoryo ng root ng iyong proyekto at naglalaman ng mga setting na mailalapat sa lahat ang iyong mga module (tinukoy din bilang "mga proyekto" ni Gradle).

Dapat mong gamitin ang file na ito upang tukuyin ang anumang mga plugin, repository, dependencies, at mga pagpipilian sa pagsasaayos na nalalapat sa bawat module sa buong iyong proyekto sa Android. Tandaan na kung tinukoy mo ang anumang mga gawain sa Gradle sa loob ng file na antas ng build.gradle ng proyekto, posible pa rin na i-override o pahabain ang mga gawaing ito para sa mga indibidwal na module, sa pamamagitan ng pag-edit ng kanilang kaukulang antas ng module build.gradle file.

Ang isang tipikal na file na antas ng build.gradle ay magmukhang katulad nito:

buildscript {repositories {google () jcenter ()} dependencies {classpath com.android.tools.build:gradle pony.5.0-alpha06 // TANDAAN: Huwag ilagay ang iyong mga dependencies sa aplikasyon dito; kabilang sila // sa indibidwal na module build.gradle files}} allprojects {repositories {google () jcenter ()}} gawain na malinis (type: Delete) {tanggalin ang rootProject.buildDir}

Ang file na antas ng build.gradle ng proyekto ay nahahati sa mga sumusunod na bloke:

Bumubuo. Naglalaman ito ng mga setting na kinakailangan upang maisagawa ang build.
Mga Repositori. Ang Gradle ay responsable para sa paghahanap ng mga dependencies ng iyong proyekto at gawing magagamit ito sa iyong build. Gayunpaman, hindi lahat ng dependencies ay nagmula sa iisang repositoryo, kaya kakailanganin mong tukuyin ang lahat ng mga repositori na dapat hanapin ng Gradle, upang makuha ang mga dependencies ng iyong proyekto.
Depende. Ang seksyon na ito ay naglalaman ng iyong mga dependency ng plugin, na na-download at naka-imbak sa iyong lokal na cache. Dapat mo hindi tukuyin ang anumang mga dependencies ng module sa loob ng block na ito.
Lahat ng mga bagay. Narito kung saan mo tukuyin ang mga repositori na dapat makuha lahat ng mga module ng iyong proyekto.

3. build.gradle (module level)

Ito ang module na antas ng build.gradle file, na naroroon sa bawat module sa buong proyekto mo. Kung ang iyong Android proyekto ay binubuo ng maraming mga module, magkakaroon din ito ng maraming file na antas ng build.gradle ng module.

Ang bawat file na antas ng build.gradle na antas ay naglalaman ng pangalan ng package ng iyong proyekto, pangalan ng bersyon at code ng bersyon, kasama ang minimum at target ang SDK para sa partikular na modyul.

Ang isang module-level build.gradle file ay maaari ring magkaroon ng sariling natatanging hanay ng mga tagubilin at mga dependencies. Halimbawa, kung gumagawa ka ng isang application na may sangkap na Wear OS, kung gayon ang iyong proyekto sa Android Studio ay bubuo ng isang hiwalay na smartphone / tablet module at isang Module ng suot - dahil target nila ang ganap na magkakaibang mga aparato, ang mga modyul na ito ay may ibang naiiba dependencies!

Ang isang pangunahing module na antas ng build.gradle file ay karaniwang magmukhang katulad nito:

mag-apply ng plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion 23 targetSdkVersion 28 bersyonCode 1 bersyonName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUn" getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} dependencies {pagpapatupad ng fileTree (dir: libs, kasama ang:) pagpapatupad ng androidx.appcompat: appcompat: 1.0.2 pagpapatupad ng androidx.constraintlayout: paghihigpit: 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}

Tingnan natin ang bawat isa sa mga seksyon na ito:

mag-apply ng plugin. Ito ay isang listahan ng mga plugin na kinakailangan upang bumuo ng modyul na ito. Ang plugin ng com.android.application ay kinakailangan upang i-setup ang proseso ng tukoy na partikular sa Android, kaya awtomatikong idinagdag ito.
android. Narito kung saan dapat mong ilagay ang lahat ng mga pagpipilian na naaangkop sa platform ng module.
pag-compileSdkVersion. Ito ang antas ng API na ang modyul na ito ay naipon. Hindi ka maaaring gumamit ng mga tampok mula sa isang API na mas mataas kaysa sa halagang ito.
magtayoToolsVersion. Ipinapahiwatig nito ang bersyon ng tagatala. Sa Gradle 3.0.0 at mas mataas, opsyonal ang buildToolsVersion; kung hindi mo tukuyin ang isang halaga ng buildToolsVersion pagkatapos ay default ang Android Studio sa pinakahuling bersyon ng Gumagawa ng Mga tool.
defaultConfig. Naglalaman ito ng mga pagpipilian na ilalapat sa lahat ng mga bersyon ng pagbuo ng iyong app, tulad ng iyong debug at paglabas ng build.
applicationId. Ito ang natatanging identifier ng iyong aplikasyon.
minSdkVersion. Tinukoy ng parameter na ito ang pinakamababang antas ng API na sinusuportahan ng module na ito.
targetSdkVersion. Ito ang pinakamataas na antas ng API na sinubukan ng iyong aplikasyon. Sa isip, dapat mong subukan ang iyong aplikasyon gamit ang pinakabagong API, na nangangahulugang ang halaga ng targetSdkVersion ay palaging magiging pantay sa halaga ng compileSdkVersion.
bersyonCode. Ito ay isang numerong halaga para sa iyong bersyon ng aplikasyon.
bersyonName. Ito ay isang string ng user-friendly, na kumakatawan sa iyong bersyon ng aplikasyon.
buildTypes. Bilang default, sinusuportahan ng Android ang dalawang uri ng build: debug at paglabas. Maaari mong gamitin ang mga "debug" at "paglabas" na mga bloke upang tukuyin ang mga setting ng tukoy na uri ng iyong aplikasyon.
dependencies. Narito kung saan mo tukuyin ang anumang mga aklatan na nakasalalay sa modyul na ito.

Ang pagpapahayag ng mga dependencies ng iyong proyekto: Lokal na mga aklatan

Maaari kang makagawa ng karagdagang pag-andar na magagamit sa iyong mga proyekto sa Android, sa pamamagitan ng pagdaragdag ng isa o higit pang mga dependency ng proyekto. Ang mga dependencies ay maaaring maging lokal, o maaari silang maiimbak sa isang malayong imbakan.

Upang maipahayag ang isang dependency sa isang lokal na file ng JAR, kakailanganin mong idagdag ang JAR sa direktoryo na "libs" ng iyong proyekto.

Pagkatapos ay maaari mong baguhin ang module na antas ng build.gradle file upang magpahayag ng isang dependency sa file na ito. Halimbawa, narito kami ay nagdedeklara ng isang dependant sa isang "mylibrary" JAR.

pagpapatupad ng mga file (libs / mylibrary.jar)

Bilang kahalili, kung ang iyong "libs" folder na naglalaman ng maraming JARs, kung gayon mas madali itong sabihin na ang iyong proyekto ay nakasalalay sa lahat ng mga file na matatagpuan sa loob ng "libs" folder, halimbawa:

pagpapatupad ng fileTree (dir: libs, kasama ang:)

Pagdaragdag ng isang dependency ng pagbuo: Mga repote ng Remote

Kung ang isang silid-aklatan ay matatagpuan sa isang liblib na imbakan, kakailanganin mong kumpletuhin ang mga sumusunod na hakbang:

Tukuyin ang imbakan kung saan matatagpuan ang dependency.
Ipahayag ang indibidwal na pag-asa.

Pagkonekta sa isang malayong imbakan

Ang unang hakbang, ay nagsasabi sa Gradle kung aling mga imbakan (o mga repositori) na kinakailangang suriin, upang makuha ang lahat ng mga dependencies ng iyong proyekto. Halimbawa:

mga repositori {google () jcenter ()}}

Dito, tinitiyak ng linya na "jcenter ()" na susuriin ni Gradle ang reporter ng JCenter, na kung saan ay libre, pampublikong imbakan na naka-host sa bintray.

Bilang kahalili, kung ikaw o ang iyong samahan ay nagpapanatili ng isang personal na imbakan, dapat mong idagdag ang URL ng repository na ito sa iyong pagpapahayag ng dependency. Kung ang repository ay protektado ng password, kakailanganin mo ring magbigay ng impormasyon sa iyong pag-login, halimbawa:

repositoryo {mavenCentral () maven {// Configure the target URL // url "http://repo.mycompany.com/myprivaterepo"} maven {credentials {username myUsername password myPassword} url "http://repo.mycompany.com / myprivaterepo "}

Kung ang isang dependency ay naroroon sa loob ng maraming mga repositori, pagkatapos ay pipiliin ni Gradle ang "pinakamahusay" na bersyon ng pagiging maaasahan, batay sa mga kadahilanan tulad ng edad ng bawat repositoryo at static na bersyon.

Pagpapahayag ng isang malayong pagpapakandili

Ang susunod na hakbang ay ang pagdedeklara ng dependant sa iyong file-level build.gradle file. Idagdag mo ang impormasyong ito sa "dependencies" block, gamit ang alinman sa mga sumusunod:

Pagpapatupad. Ito ay isang normal na dependency na kailangan mo tuwing itinatayo mo ang iyong proyekto. Isang "pagpapatupad" dependency ay naroroon sa kabuuan lahat iyong mga build.
Pagsubok. Ito ay isang dependency na kinakailangan upang i-compile ang mapagkukunan ng pagsubok ng iyong aplikasyon at magpatakbo ng mga pagsubok na nakabase sa JVM. Kapag minarkahan mo ang isang dependency bilang "Testimplementation" Gradle ay malalaman na hindi kailangang magpatakbo ng mga gawain para sa dependency sa panahon ng isang normal na build, na makakatulong na mabawasan ang oras ng pagbuo.
Pinakahusay naplikasyon. Ito ay isang dependency na kinakailangan kapag nagpapatakbo ng mga pagsubok sa isang aparato, halimbawa ang balangkas ng Espresso ay isang pangkaraniwang "Androidtestimplementation."

Tinukoy namin ang isang sobrang dependency, gamit ang isa sa mga keyword sa itaas, na sinusundan ng mga katangian ng grupo, pangalan at bersyon ng dependency, halimbawa:

dependencies {pagpapatupad fileTree (dir: libs, may kasamang:) pagpapatupad ng androidx.appcompat: appcompat: 1.0.2 pagpapatupad ng androidx.constraintlayout: konstruksyon: 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}

Bumubuo ng maraming mga APK: Paano lumikha ng mga variant ng build

Minsan, maaaring kailanganin mong lumikha ng maraming mga bersyon ng iyong aplikasyon. Halimbawa, maaari mong ilabas ang isang libreng bersyon at isang bayad na bersyon, na kasama ang ilang mga karagdagang tampok.

Ito ay isang gawaing magtayo na makakatulong sa iyo ng Gradle, kaya tingnan natin kung paano mo mababago ang proseso ng pagbuo upang lumikha ng maraming mga APK mula sa iisang proyekto:

Buksan ang iyong strings.xml file at tanggalin ang iyong orihinal na string ng pangalan ng application.
Susunod, tukuyin ang mga pangalan ng bawat lasa ng produkto na nais mong likhain; sa pagkakataong ito, gumagamit ako:

Ang aking libreng app Ang bayad kong app

Buksan ang iyong AndroidManifest.xml file at palitan ang android: label = "@ string / app_name" gamit ang:

android: label = "$ {appName}"

Buksan ang iyong file-level build.gradle file at idagdag ang sumusunod sa block na "android":

flavorDimensions "mode" productFlavors {free {dimension "mode" applicationIdSuffix ".free" manifestPlaceholders =} bayad na {dimension "mode" applicationIdSuffix ".paid" manifestPlaceholders =}}}

Babaguhin natin kung ano ang nangyayari dito:

lasaDimensions. Lumilikha ang plugin ng Android ng mga variant sa pamamagitan ng pagsasama ng mga lasa mula sa iba't ibang mga sukat. Dito, gagawa kami ng isang sukat ng lasa na binubuo ng mga "libre" at "bayad" na bersyon ng aming app. Batay sa code sa itaas, ang Gradle ay bubuo ng apat na variant ng build: bayadDebug, bayadRelease, freeDebug at freeRelease.
produktoFlavors. Tinukoy nito ang isang listahan ng mga lasa at ang kanilang mga setting, na sa itaas na code ay "bayad" at "libre."
Libre / bayad. Ito ang mga pangalan ng aming dalawang flavors ng produkto.
Ang sukat. Kailangan naming tukuyin ang halaga ng parameter na "sukat"; sa pagkakataong ito, gumagamit ako ng "mode."
applicationIdSuffix. Dahil nais naming lumikha ng maraming mga bersyon ng aming app, kailangan naming bigyan ang bawat APK ng isang natatanging identifier ng app.
manifestPlaceholders. Ang bawat proyekto ay may isang solong Manifest file na naglalaman ng mahalagang impormasyon tungkol sa pagsasaayos ng iyong proyekto. Kapag lumilikha ng maraming mga variant ng build, karaniwang gusto mong baguhin ang ilan sa mga Manifest na katangian na ito sa oras ng pagtayo. Maaari mong gamitin ang Gradle magtayo ng mga file upang tukuyin ang mga natatanging Manifest na mga entry para sa bawat variant ng build, na kung saan ay maipasok sa iyong Manifest sa oras ng pagbuo. Sa code sa itaas, binabago namin ang halaga ng "appName" depende sa kung ang Gradle ay nagtatayo ng libre o bayad na bersyon ng aming app.

Lumilikha ng isang pasadyang gawain ng Gradle

Minsan maaaring kailanganin mong ipasadya ang proseso ng pagbuo, gamit ang Gradle mga gawain.

Ang isang gawain ay isang pinangalanang koleksyon ng mga aksyon na isasagawa ni Gradle habang nagsasagawa ito ng isang build, halimbawa na bumubuo ng isang Javadoc. Sinusuportahan ng Gradle ang maraming mga gawain sa pamamagitan ng default, ngunit maaari ka ring lumikha ng pasadyang mga gawain, na maaaring madaling magamit kung mayroon kang isang napaka tukoy na hanay ng mga tagubilin sa pagbuo sa isip.

Sa seksyong ito, gagawa kami ng isang pasadyang gawain ng Gradle na magpapalala sa lahat ng mga variant ng pagbuo ng aming proyekto (bayadDebug, bayad naRelease, freeDebug at freeRelease), lumikha ng isang petsa at oras stamp, at pagkatapos ay idagdag ang impormasyong ito sa bawat nabuong APK.

Buksan ang iyong file-level build.gradle file at idagdag ang sumusunod:

task addDateAndTime () {// Iterate through all the output build variants // android.applicationVariants.all {variant -> // Iterate through all the APK files // variant.outputs.all {output -> // Lumikha ng isang halimbawa ng ang kasalukuyang petsa at oras, sa format na tinukoy // def dateAndTime = bagong Petsa () na format ("yyyy-MM-dd: HH-mm") // Ipakilala ang impormasyong ito sa filename ng APK // def fileName = variant. pangalan + "_" + dateAndTime + ".apk" output.outputFileName = fileName}}}

Susunod, kailangan nating sabihin sa Gradle kailan dapat itong isagawa ang gawaing ito. Sa panahon ng isang build, kinilala ng Gradle ang lahat ng kailangan nito upang i-download at ang lahat ng mga gawain na dapat gawin, at ayusin ang mga ito sa isang Directed Acyclic Graph (DAG). Pagkatapos ay isasagawa ni Gradle ang lahat ng mga gawaing ito, ayon sa pagkakasunud-sunod na tinukoy sa DAG nito.

Para sa aking app, gagamitin ko ang pamamaraan na "whenReady", na nagsisiguro na tatawagin ang aming gawain sa sandaling mai-populasyon ang DAG, at handa nang Gradle na simulan ang pagsasagawa ng mga gawain.

Idagdag ang sumusunod sa iyong file na antas ng build.gradle ng module:

// Gawin ang gawaing ito // gradle.taskGraph.whenReady {addDateAndTime}

Ilagay natin ang aming pasadyang gawain at aming bumuo ng iba't ibang code sa pagsubok, sa pamamagitan ng pagbuo ng proyektong ito gamit ang isang utos ng Gradle.

Pagbuo ng iyong proyekto sa Gradle wrapper

Nag-isyu ka ng mga utos ng Gradle gamit ang Gradle wrapper ("gradlew"). Ang script na ito ay ang ginustong paraan upang magsimula ng isang Gradle build, dahil ginagawang malaya ang pagpapatupad ng build mula sa iyong bersyon ng Gradle. Ang paghihiwalay na ito ay maaaring maging kapaki-pakinabang kung nakikipagtulungan ka sa iba na maaaring hindi kinakailangang i-install ang parehong bersyon ng Gradle.

Kapag naglalabas ng iyong mga utos ng wrapper ng Gradle, gagamit ka ng "gradlew" para sa mga operating system na katulad ng Unix, kabilang ang macOS, at "gradlew.bat" para sa Windows. Mayroon akong isang Mac, kaya gumagamit ako ng mga "gradlew" na utos.

Maaari kang mag-isyu ng mga utos ng Gradle mula sa loob ng Android Studio:

Sa toolbar ng Android Studio, piliin ang "Tingnan> Mga tool sa Windows> Terminal." Binubuksan nito ang isang panel ng Terminal sa ilalim ng window ng IDE.
Ipasok ang sumusunod na utos sa Terminal:

./gradlew magtayo

Ang Android Studio ay dapat magmukhang ganito:

Pindutin ang "Enter" key sa iyong keyboard. Tatayo na ngayon ang Gradle ng iyong proyekto.

Inilalagay ng gradle ang lahat ng nabuong mga APK sa app / build / output / direktoryo ng iyong proyekto, kaya mag-navigate sa direktoryo na ito. Ang folder na "APK" ay dapat maglaman ng maraming mga folder at subfolder; siguraduhin na ang Gradle ay nakabuo ng isang APK para sa bawat isa sa iyong mga variant ng build, at na ang tamang impormasyon sa petsa at oras ay naidagdag sa bawat file.

Ano ang iba pang mga gawain sa Gradle na magagamit?

Bilang karagdagan sa anumang mga pasadyang gawain na maaari mong likhain, suportado ni Gradle ang isang listahan ng mga paunang natukoy na mga gawain sa labas ng kahon. Kung gusto mong makita kung ano mismo ang mga magagamit na gawain, pagkatapos:

Buksan ang window ng Terminal ng Android Studio, kung hindi pa ito nakabukas (sa pamamagitan ng pagpili ng "Tingnan ang> Mga tool sa Windows> Terminal" mula sa tool ng Android Studio).
I-type ang sumusunod sa Terminal:

./gradlew -q mga gawain

Pindutin ang "Enter" key sa iyong keyboard.

Ang gawain na "mga gawain" ay tatakbo na ngayon, at makalipas ang ilang sandali ay magpapakita ang Terminal ng isang listahan ng lahat ng mga gawain na magagamit para sa proyektong ito, kumpleto sa isang maikling paglalarawan ng bawat gawain.

Pagkuha ng higit pa sa Gradle: Pagdaragdag ng mga plugin

Ang mga barko ng gradle na may isang bilang ng mga plug-in na na-install, ngunit maaari mo pang palawakin ang Gradle sa pamamagitan ng pagdaragdag ng mga bagong plugin. Ang mga plugin na ito ay nagbibigay ng mga bagong gawain na magagamit sa iyong mga proyekto sa Android, halimbawa ang Java plugin ay may kasamang mga gawain na nagpapahintulot sa iyo na mag-ipon ng code ng source ng Java, magpatakbo ng mga pagsubok sa yunit at lumikha ng isang JAR file, tulad ng "compileJava," "compileText," "garapon," "Javadoc," at "malinis."

Upang mag-apply ng isang plugin, idagdag ang deklarasyong "mag-apply ng plugin" sa iyong file na antas ng build.gradle ng module, na sinusundan ng pangalan ng plugin. Halimbawa, dito inilalapat namin ang plugin ng Java:

mag-apply ng plugin: java

Kung gusto mong malaman kung anong magagamit ang mga plugin, pagkatapos suriin ang paghahanap ng Gradle Plugin, na nagbibigay ng isang komprehensibong pagpapatala ng Gradle plugin.

Ang Gradle Kotlin DSL

Bilang default, isusulat mo ang iyong mga script ng Gradle build gamit ang Groovy DSL, ngunit kung isa ka sa maraming mga developer na nagpatibay ng Kotlin para sa pagpapaunlad ng Android, baka mas gusto mong isulat ang iyong mga script ng build sa Kotlin.

Hindi tulad ng Groovy, ang Kotlin ay isang statically typed programming language, kaya kung gagawa ka ng switch, ang iyong mga file ng build ay magkatugma sa autocompletion ng Android Studio at mga tampok ng pag-navigate ng code ng source. Dagdag pa, ang paglipat mula sa Groovy patungong Kotlin ay nangangahulugan na gumagamit ka ng parehong wika ng programa sa kabuuan ng iyong proyekto, na maaaring gawing diretso ang pag-unlad - lalo na kung hindi ka masyadong pamilyar sa Groovy!

Kung nais mong simulan ang pagsusulat ng iyong logic ng build sa Kotlin, kakailanganin mong i-setup ang Gradle Kotlin DSL at sundin ang mga tagubilin sa gabay sa paglilipat.

Pagputol

Sa artikulong ito, ginalugad namin ang pagbuo ng automation at tool sa pamamahala ng dependensya ng Android. Sinuri namin kung paano awtomatiko ni Gradle ang proseso ng pagbuo, at kung paano mo mababago ang proseso ng pagtatayo sa pamamagitan ng pag-edit ng mga file ng pagbuo ng Gradle ng iyong proyekto, kasama ang paglikha ng mga pasadyang gawain ng Gradle, at pagbuo ng maraming mga variant ng pagbuo mula sa isang proyekto.

Pinalawak mo ba ang Gradle upang awtomatiko ang iba pang mga bahagi ng proseso ng pagbuo ng Android? Ipaalam sa amin sa mga komento sa ibaba!