Mastering Gradle for Android: Gradle feladatok és Kotlin

Tartalom

A Gradle build fájlok feltárása
1. settings.gradle
2. build.gradle (projekt szint)
3. build.gradle (modulszint)
A projekt függőségeinek deklarálása: Helyi könyvtárak
Összeállítási függőség hozzáadása: Távoli tárolók
Csatlakozás távoli lerakathoz
Távoli függőség deklarálása
Több APK előállítása: Hogy készítsünk összeállítási változatokat
Egyéni Gradle-feladat létrehozása
Építsd meg a projektdet a Gradle burkolóval
Milyen más Gradle-feladatok érhetők el?
Minél többet hozhat ki a Gradle-ról: plug-inek hozzáadása
A Gradle Kotlin DSL
Csomagolás

Java, XML vagy Kotlin helyett ezek a Gradle összeállítási fájlok a Groovy-alapú tartomány-specifikus nyelvet (DSL) használják. Ha nem ismeri a Groovy-t, akkor soronként áttekintjük ezeket a Gradle-összeállítási fájlokat, tehát a cikk végére elégedett lesz az egyszerű Groovy-kód olvasásával és írásával.

A Gradle célja, hogy megkönnyítse az életét, olyan alapértelmezett beállításokkal, amelyeket gyakran használhat a minimális kézi konfigurálással - amikor készen áll a projekt felépítésére, egyszerűen nyomja meg az Android Studio „Futtatás” gombot, és a Gradle elkezdi az összeállítási folyamatot. neked.

A Gradle „konfigurációs konvenció” megközelítése ellenére, ha az alapértelmezett beállítások nem felelnek meg teljes mértékben az Ön igényeinek, testreszabhatja, konfigurálhatja és kibővítheti a készítési folyamatot, és még a Gradle beállításait is hozzáigazíthatja a nagyon specifikus feladatok elvégzéséhez.

Mivel a Gradle szkriptek a saját fájlokban vannak, bármikor módosíthatja az alkalmazás készítési folyamatát anélkül, hogy meg kellene érintenie az alkalmazás forráskódját. Ebben az oktatóanyagban az összeállítás folyamatát ízek, összeállítási variánsok és egyéni Gradle feladat felhasználásával módosítjuk - mindezt valaha megérinti az alkalmazáskódot.

A Gradle build fájlok feltárása

Minden alkalommal, amikor projekt készül, az Android Studio ugyanazt a Gradle összeállítási fájlok gyűjteményét generálja. Még ha egy meglévő projektet is importál az Android Studioba, az meg fog történni még mindig hozza létre ugyanazokat a Gradle fájlokat, és vegye fel őket a projektbe.

Annak érdekében, hogy jobban megértsük a Gradle-t és a Groovy-szintaxist, soronként tekintsük át az Android összes Gradle-összeállítási fájlját.

1. settings.gradle

A settings.gradle fájl az, ahol az alkalmazás összes modulját név szerint határozhatja meg az „tartalmazza” kulcsszó használatával. Például, ha volt egy olyan projekt, amely egy „alkalmazásból” és „második modulból” áll, akkor a settings.gradle fájl a következőképpen néz ki:

tartalmazzák: app,: secondmodule rootProject.name = MyProject

A projekt méretétől függően ez a fájl sokkal hosszabb lehet.

Az összeállítási folyamat során a Gradle megvizsgálja a project.scape.php fájljának tartalmát, és azonosítja az összes modult, amelyet be kell építenie az összeállítási folyamatba.

2. build.gradle (projekt szint)

A projekt szintű build.gradle fájl a projekt gyökérkönyvtárában található, és tartalmazza az alkalmazandó beállításokat minden moduljai (amelyeket Gradle „projekteknek” is nevez).

Ezt a fájlt kell használnia az olyan pluginek, adattárak, függőségek és konfigurációs beállítások meghatározására, amelyek az Android projekt minden moduljára vonatkoznak. Vegye figyelembe, hogy ha meghatároz egy Gradle-feladatot a projekt szintű build.gradle fájlban, akkor továbbra is felülbírálhatja vagy kibővítheti ezeket a feladatokat az egyes modulok számára a megfelelő szerkesztéssel modul-szintű build.gradle fájl.

Egy tipikus projekt szintű build.gradle fájl a következőképpen néz ki:

építési cikk {tárolók {google () jcenter ()} függőségek {classpath com.android.tools.build:gradle:3.5.0-alpha06 // MEGJEGYZÉS: Ne tegye ide az alkalmazásfüggőségeket; tartoznak // az egyedi modulban build.gradle fájlok}} összes projekt {tárolóhelyek {google () jcenter ()}} tiszta feladat (típus: törlés) {törölje rootProject.buildDir}

Ez a projekt szintű build.gradle fájl a következő blokkokra oszlik:

Buildscript. Ez tartalmazza az összeállítás végrehajtásához szükséges beállításokat.
Tárolókban. A Gradle felelős a projekt függőségeinek felkutatásáért és elérhetővé tételéért az építkezésben. Ugyanakkor nem minden függőség származik ugyanabból a lerakatból, ezért meg kell határoznia az összes olyan tárházat, amelyben a Gradle-nek meg kell keresnie a projekt függőségeinek lekérdezéséhez.
Függőségeket. Ez a szakasz tartalmazza a plugin-függőségeket, amelyeket letölt és tárol a helyi gyorsítótárban. Neked kellene nem határozza meg a modulfüggőségeket ebben a blokkban.
Allprojects. Itt határozhatja meg a rendelkezésre álló tárolókat minden a projekt moduljai közül.

3. build.gradle (modulszint)

Ez a modulszintű build.gradle fájl, amely a projekt minden moduljában megtalálható. Ha az Android-projekt több modulból áll, akkor több modulszintű build.gradle fájlt is tartalmaz.

Minden modulszintű build.gradle fájl tartalmazza a projekt csomagnevét, verzióját és verziószámát, valamint az adott modul minimális és cél SDK-ját.

A modulszintű build.gradle fájlnak is lehet saját egyedi készítési utasításai és függőségei. Például, ha egy alkalmazást Wear OS összetevővel hoz létre, akkor az Android Studio projekt különálló okostelefon- / táblagép-modulból és Wear-modulból áll - mivel teljesen más eszközöket céloznak meg, ezek a modulok drasztikusan eltérőek függőségek!

Az alapmodul szintű build.gradle fájl általában így néz ki:

alkalmazni bővítmény: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion paraméterének 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"} buildTypes {kiadás {minifyEnabled hamis proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} függőségek {végrehajtási fájlTree (dir: libs, include:) implementáció androidx.appcompat: appcompat: 1.0.2 implementáció 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}

Nézzük meg közelebbről a következő szakaszokat:

alkalmazza a bővítményt. Ez a modul létrehozásához szükséges pluginek listája. A com.android.application beépülő modul szükséges az Android-specifikus összeállítási folyamat beállításához, tehát ez automatikusan hozzáadódik.
android. Itt kell elhelyeznie a modul összes platformspecifikus beállítását.
compileSdkVersion. Ez az az API szint, amellyel a modul összeáll. Az ezen értéknél magasabb API-t nem használhatja.
buildToolsVersion. Ez jelzi a fordító verzióját. A Gradle 3.0.0 vagy újabb verziójában az buildToolsVersion opcionális; ha nem adja meg a buildToolsVersion értéket, akkor az Android Studio alapértelmezés szerint a Build Tools legújabb verziója lesz.
defaultConfig. Ez olyan opciókat tartalmaz, amelyeket az alkalmazás összes összeállítási verziójára alkalmazni kell, például a hibakeresési és kiadási összetevőkre.
applicationId. Ez az alkalmazás egyedi azonosítója.
minSdkVersion paraméterének. Ez a paraméter határozza meg a legalacsonyabb API szintet, amelyet ez a modul támogat.
targetSdkVersion. Ez az a maximális API szint, amellyel az alkalmazásod tesztelték. Ideális esetben az alkalmazást a legújabb API-val kell tesztelnie, ami azt jelenti, hogy a targetSdkVersion érték mindig megegyezik a compileSdkVersion értékkel.
versionCode. Ez az alkalmazás verziójának numerikus értéke.
versionName. Ez egy felhasználóbarát karakterlánc, amely képviseli az alkalmazás verzióját.
buildTypes. Alapértelmezés szerint az Android két építéstípust támogat: a hibakeresést és a kiadást. A „hibakeresés” és a „kiadás” blokkok segítségével megadhatja az alkalmazás típus-specifikus beállításait.
függőségeket. Itt határozhatja meg azokat a könyvtárakat, amelyektől ez a modul függ.

A projekt függőségeinek deklarálása: Helyi könyvtárak

További funkcionalitást tehet elérhetővé az Android-projektek számára egy vagy több projektfüggőség hozzáadásával. Ezek a függőségek lehetnek helyi, vagy távoli lerakatban tárolhatók.

A helyi JAR-fájltól való függőség megállapításához a JAR-t hozzá kell adnia a projekt „libs” könyvtárához.

Ezután módosíthatja a modul szintű build.gradle fájlt, hogy deklarálja a függőséget ettől a fájltól. Például itt kijelentsük, hogy függőségük van a „saját könyvtár” JAR-tól.

végrehajtási fájlok (libs / mylibrary.jar)

Alternatív megoldásként, ha a „libs” mappa több JAR-t tartalmazott, akkor könnyebb egyszerűen kijelenteni, hogy a projekt a „libs” mappában található összes fájltól függ, például:

végrehajtási fileTree (dir: libs, tartalmaz:)

Összeállítási függőség hozzáadása: Távoli tárolók

Ha egy könyvtár távoli lerakatban található, akkor a következő lépéseket kell végrehajtania:

Adja meg a lerakatot, ahol ez a függőség található.
Nyilatkozzon az egyéni függőségről.

Csatlakozás távoli lerakathoz

Az első lépés, hogy elmondja a Gradle-nak, hogy melyik lerakatot (vagy lerakatokat) kell ellenőriznie a projekt összes függőségének beolvasása érdekében. Például:

tárolók {google () jcenter ()}}

A „jcenter ()” sor biztosítja, hogy a Gradle ellenőrizze a JCenter tárházat, amely egy ingyenes, nyilvános tároló, amely a bintray-ben található.

Alternatív megoldásként, ha Ön vagy szervezete személyes lerakatot üzemeltet, akkor hozzá kell adnia ennek a lerakatnak az URL-jét a függőségi nyilatkozathoz. Ha a lerakat jelszóval védett, akkor a bejelentkezési adatait is meg kell adnia, például:

tárolók {mavenCentral () maven {// a cél URL konfigurálása // url "http://repo.mycompany.com/myprivaterepo"} maven {hitelesítő adatok {felhasználónév myUsername jelszó myPassword} url "http://repo.mycompany.com / myprivaterepo "}

Ha függőség létezik több tárolóhelyen, akkor a Gradle kiválasztja ennek a függőségnek a „legjobb” verzióját, olyan tényezők alapján, mint például az egyes tárolók kora és a statikus változat.

Távoli függőség deklarálása

A következő lépés a modulszintű build.gradle fájl függőségének deklarálása. Ezeket az információkat hozzáadja a „függőségek” blokkhoz, a következők bármelyikének felhasználásával:

Végrehajtás. Ez egy normális függőség, amelyre a projekt felépítésekor szükség van. A „végrehajtás” függőség mindenütt jelen lesz minden az épít.
Testimplementation. Ez egy olyan függőség, amelyre szükség van az alkalmazás tesztforrásának összeállításához és a JVM-alapú tesztek futtatásához. Amikor a függőséget „Tesztelés” -ként jelöli, a Gradle tudni fogja, hogy normál összeállítás során nem kell feladatokat elvégeznie ehhez a függőséghez, ami csökkentheti az összeállítási időt.
Androidtestimplementation. Ez egy olyan függőség, amelyet teszteken futtatni kell egy eszközön, például az Espresso-keret egy általános „Android-teszt-végrehajtás”.

A távoli függőséget a fenti kulcsszavak egyikének felhasználásával definiáljuk, majd a függőség csoport-, név- és verzióattribútumait követjük, például:

függőségek {végrehajtási fájlTree (könyv: libs, tartalmaz:) implementáció androidx.appcompat: appcompat: 1.0.2 implementáció androidx.constraintlayout: kényszerlejátszás: 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}

Több APK előállítása: Hogy készítsünk összeállítási változatokat

Előfordulhat, hogy az alkalmazás több verzióját kell létrehoznia. Előfordulhat például, hogy kiad egy ingyenes verziót és egy fizetett verziót, amely tartalmaz néhány további funkciót.

Ez egy összeépítési feladat, amelyben a Gradle segíthet, tehát nézzük meg, hogyan módosíthatta az összeállítási folyamatot, hogy egy projektből több APK-t hozzon létre:

Nyissa meg a strings.xml fájlt, és törölje az alkalmazás eredeti nevét.
Ezután határozza meg a létrehozni kívánt termékaromák nevét; ebben az esetben a következőket használom:

Ingyenes alkalmazásom A fizetett alkalmazásom

Nyissa meg az AndroidManifest.xml fájlt és cserélje ki az androidot: label = ”@ string / app_name” a következőre:

android: label = "$ {appName}"

Nyissa meg a modulszintű build.gradle fájlt, és adja hozzá a következőket az „android” blokkhoz:

flavorDimensions "mode" productFlavors {free {dimenzió "mode" applicationIdSuffix ".free" manifestPlaceholders =} fizetett {dimenzió "mode" applicationIdSuffix ".paid" manifestPlaceholders =}}}

Lebontjuk, mi történik itt:

flavorDimensions. Az Android bővítmény különféle dimenziókból álló ízek kombinálásával hoz létre építési változatokat. Itt olyan íz-dimenziót hozunk létre, amely alkalmazásunk „ingyenes” és „fizetett” verzióiból áll. A fenti kód alapján a Gradle négy összeállítási variánst generál: paidDebug, paidRelease, freeDebug és freeRelease.
productFlavors. Ez meghatározza az ízesítések listáját és azok beállításait, amelyek a fenti kódban „fizettek” és „ingyenesek”.
Ingyenes / fizetett. Ez a két termékízünk neve.
Dimenzió. Meg kell határoznunk egy „dimenzió” paraméter értékét; ebben az esetben a „módot” használom.
applicationIdSuffix. Mivel alkalmazásunk több változatát szeretnénk létrehozni, minden APK-nak egyedi alkalmazási azonosítót kell adnunk.
manifestPlaceholders. Minden projektnek egyetlen manifeszt fájlja van, amely fontos információkat tartalmaz a projekt konfigurációjáról. Több összeállítási variáns létrehozásakor általában a Manifest tulajdonságait módosítania kell az építkezés során. A Gradle összeállítási fájlokkal meghatározhat egyedi manifesztbejegyzéseket minden egyes összeállítási változathoz, amelyeket azután beilleszt a manifesztbe az összeállítás idején. A fenti kódban módosítjuk az „appName” értéket attól függően, hogy a Gradle építi alkalmazásunk ingyenes vagy fizetett verzióját.

Egyéni Gradle-feladat létrehozása

Előfordulhat, hogy a Gradle használatával testreszabnia kell a készítési folyamatot feladatok.

A feladat egy megnevezett olyan műveletek gyűjteménye, amelyeket a Gradle végrehajt, amikor végrehajt egy építést, például létrehoz egy Javadoc-ot. A Gradle alapértelmezés szerint sok feladatot támogat, de létrehozhat egyéni feladatokat is, amelyek hasznosak lehetnek, ha szem előtt tartja egy nagyon konkrét készítési utasítást.

Ebben a szakaszban egy olyan egyéni Gradle-feladatot hozunk létre, amely a projekt összes építési változatán (payDebug, paidRelease, freeDebug és freeRelease) ismétlődik, létrehoz egy dátumot és időbélyegzőt, majd ezt az információt csatolja az egyes generált APK-khoz.

Nyissa meg a modulszintű build.gradle fájlt, és adja hozzá a következőket:

addDateAndTime () {// az összes kimeneti összeállítási variánst megismételni // android.applicationVariants.all {variáns -> // Iratkozzon fel az összes APK fájlon // variant.outputs.all {output -> // hozzon létre egy példányt az aktuális dátum és idő, a megadott formátumban // def dateAndTime = new Date (). formátum ("éééé-hh-hh: óó-hh") // Adja hozzá ezt az információt az APK fájlnevéhez // def fájlnév = változat. név + "_" + dateAndTime + ".apk" output.outputFileName = fájlnév}}}

Ezután el kell mondanunk Gradle-nak mikor végre kell hajtania ezt a feladatot. A felépítés során a Gradle azonosítja a letöltéshez szükséges összes feladatot és a végrehajtandó feladatokat, és elrendezi azokat egy irányított aciklikus gráfban (DAG). A Gradle ezeket a feladatokat a DAG-ban meghatározott sorrend szerint hajtja végre.

Alkalmazásomban a „whenReady” módszert fogom használni, amely biztosítja, hogy feladatunkat a DAG kitöltése után hívják fel, és a Gradle készen áll a feladatainak végrehajtására.

Adja hozzá a következőket a modulszintű build.gradle fájlhoz:

// Végezzük el ezt a feladatot // gradle.taskGraph.whenReady {addDateAndTime}

Tegyük fel az egyedi feladatunkat és a build variancia kódunkat a teszthez úgy, hogy ezt a projektet Gradle paranccsal építjük fel.

Építsd meg a projektdet a Gradle burkolóval

A Gradle parancsokat a Gradle wrapper segítségével adhatja ki. Ez a parancsfájl az előnyben részesített módszer a Gradle összeállításának elindításához, mivel a build végrehajtását függetleníti a Gradle verziójától. Ez a szétválasztás akkor hasznos lehet, ha másokkal együttműködik, akiknek nem feltétlenül telepítve van a Gradle ugyanaz a verziója.

A Gradle burkolóparancsok kiadásakor a „gradlew” -et Unix-szerű operációs rendszerekhez, beleértve a macOS-t, és a „gradlew.bat” -t használja a Windowshoz. Van egy Mac, tehát a „graww” parancsokat fogom használni.

A Gradle parancsokat az Android Studio belsejéből adhatja ki:

Az Android Studio eszköztáron válassza a „Nézet> Eszközök Windows> Terminál” lehetőséget. Ez megnyitja a Terminál panelt az IDE ablak alján.
Írja be a következő parancsot a terminálba:

./gradlew build

Az Android Stúdiónak így kell kinéznie:

Nyomja meg a billentyűzet „Enter” billentyűjét. A Gradle elkészíti a projektjét.

A Gradle az összes generált APK-t tárolja a projekt app / build / output / apk könyvtárában, tehát keresse meg ezt a könyvtárat. Az “APK” mappának több mappát és almappát kell tartalmaznia; győződjön meg arról, hogy a Gradle létrehozott egy APK-t az összes építkezési változathoz, és hogy a helyes dátum- és időinformáció lett hozzáadva minden fájlhoz.

Milyen más Gradle-feladatok érhetők el?

Az esetlegesen létrehozott egyedi feladatokon kívül a Gradle támogatja az előre definiált feladatok listáját is. Ha kíváncsi, hogy pontosan tudja, milyen feladatok állnak rendelkezésre, akkor:

Nyissa meg az Android Studio terminálablakát, ha még nem nyílt meg (az Android Studio eszköztárán válassza a „Nézet> Eszközök Windows> Terminál” menüpontot).
Írja be a következőt a terminálba:

./gradlew -q feladatok

Nyomja meg a billentyűzet „Enter” billentyűjét.

Ez a „feladatok” feladat most fut, és néhány perc múlva a terminál megjeleníti a projekthez rendelkezésre álló összes feladat listáját, kiegészítve az egyes feladatok rövid ismertetésével.

Minél többet hozhat ki a Gradle-ról: plug-inek hozzáadása

A Gradle számos előre telepített bővítménnyel érkezik, de a Gradle-t további bővítményekkel bővítheti. Ezek a beépülő modulok új feladatokat tehetnek elérhetővé az Android-projektek számára, például a Java beépülő modul olyan feladatokat tartalmaz, amelyek lehetővé teszik a Java forráskód lefordítását, az egységteszt futtatását és a JAR fájl létrehozását, például „compileJava”, „compileText”, „jar”. „Javadoc” és „tiszta”.

Beépülő modul alkalmazásához adja hozzá az „plugin bejelentése” nyilatkozatot a modulszintű build.gradle fájljához, majd a beépülő modul nevét. Például itt a Java plugint alkalmazzuk:

plugin alkalmazása: java

Ha kíváncsi, hogy milyen bővítmények érhetők el, akkor nézd meg a Gradle plugin-keresést, amely átfogó nyilvántartást nyújt a Gradle-bővítményekről.

A Gradle Kotlin DSL

Alapértelmezés szerint a Gradle build szkripteit a Groovy DSL használatával fogja írni, de ha Ön a sok fejlesztő egyike, aki elfogadta a Kotlin alkalmazást az Android fejlesztéshez, akkor inkább inkább inkább Kotlin-ben írja az építési szkripteket.

A Groovy-tól eltérően a Kotlin statikusan tipizált programozási nyelv, tehát ha átvált, akkor a build fájlok kompatibilisek lesznek az Android Studio automatikus kiegészítésével és a forráskód navigációs funkcióival. Ráadásul a Groovy-ról Kotlinre való átállás azt jelenti, hogy ugyanazt a programozási nyelvet fogja használni a projekt során, ami egyszerűbbé teheti a fejlesztést - különösen, ha nem ismeri túlzottan a Groovy-t!

Ha Kotlinben el szeretné kezdeni az építési logika írását, akkor be kell állítania a Gradle Kotlin DSL-t, és követnie kell az áttelepítési útmutató utasításait.

Csomagolás

Ebben a cikkben az Android Studio beépített automatizálási és függőségi kezelő eszközét vizsgáltuk meg. Megvizsgáltuk, hogy a Gradle miként automatizálja az építkezési folyamatot, és hogyan módosíthatja az összeállítási folyamatot a projekt Gradle összeállítási fájljainak szerkesztésével, ideértve az egyedi Gradle feladatok létrehozását és a több összeállítási variáns generálását egyetlen projektből.

Bővítette a Gradle alkalmazást az Android készítési folyamat más részeinek automatizálására? Tudassa velünk az alábbi megjegyzésekben!