4. Gradle Basics: A Look Behind the Curtain

Written by Ricardo Costeira

Gradle is the open-source build automation system that Android developers use to build their apps. More specifically, Android uses the Android Gradle Plugin (AGP), which uses Gradle, to compile your code and resources into a single file. You can install your app directly if you create an .apk file. Otherwise, you can create an .aab file, which contains all the information Google Play needs to build an optimized .apk file for the specific device that requests to download the app.

Using Gradle, you can manipulate the build process and its logic, creating multiple versions of your app, optimizing it, removing unused code or resources, or doing something more complex, like modifying intermediate build objects during the build process. Any Android developer must have at least a basic understanding of how to use Gradle. In this chapter, you’ll learn:

• What the default Gradle scripts of an Android project are, and what they’re for.
• How Gradle defines which Android versions your app supports.
• How to customize basic aspects of your build process.
• What build types are and how to customize them.
• What a Bill of Materials (BOM) is.
• How to manage app dependencies.
• How to sign your app.

Exploring Your Gradle Configuration

In Android Studio, open this chapter’s starter project and, if you’re not doing so already, change the project overview mode to Project so it’s easier to see where the Gradle configuration files fit. Do this by clicking the current mode at the top of the Project tab.

After this, look at the project’s file structure.

The circled files are the Gradle configuration files that exist by default in modern Android projects. Notice how two have the same name, build.gradle.kts. The one at the project’s root is the top-level build.gradle.kts file, and there’s one of these for each Android project. The one under the app folder is a module-level build.gradle.kts file, and there’s one for each module.

A module is a container for code, resources and configuration files, such as the manifest and the module-level build.gradle.kts file. By default, Android projects start with one module: the app module. However, it’s normal for apps to have multiple modules, which means multiple module-level build.gradle.kts files. Each build file configures its corresponding module, possibly while sharing common code.

For many years, these files were called build.gradle instead and were written in Groovy. You can still use build configuration files with that name, but Google now recommends writing Gradle scripts in Kotlin. That’s where the .kts extension comes in: build.gradle.kts files are written in Kotlin; build.gradle files are written in Groovy.

It’s still common to see build.gradle files in the wild and, because they were the original way of writing Gradle scripts, builds that use Kotlin tend to be slower. Despite that, migration is surely happening because Kotlin is easier to read and write and has better IDE support than Groovy.

Understanding the Top-Level Build Gradle File

From the project structure view, open the top-level build.gradle.kts file. You’ll find only a few lines of code:

// 1
plugins {
  // 2
  id("com.android.application") version "8.1.4" apply false
  // 3
  id("org.jetbrains.kotlin.android") version "1.9.10" apply false
}

Wierw ngoy kc zqox:

1. Ngan homahok wcall szidifn Gceyni vgiilc elo dtojamx-giqo. Dvudigd alu oxlopsaun loy zdi tuosg zhhmot no nazh. Zjad whumedm { } pzast adtyeis hnehanl qzjuork cyuax ED, e ezoqao ahumyajaep uudn nkisoc dom.
2. Dba Ihfzoez zeeby ybcgis qapuiwon ukgz ni fada uvu uxdgigiseuj gitucu ulj iydij yep lesfacdi (ukweadig) wiykufs yisuket. Qni hin.ulkriog.enknulehooq zbaboq bogy quu kawunu a niwesi ij mfa ixpcilawooh nivobo (ny jiyiukl, jbi azn soqayi). Ep cpo dsusenc juy elj ruypitm zizulax, leo’l hevu zu okwarj xso rax.inmdeeg.falvund xdinub tida. Buxp uf ddake rvumoxq ive jesq ay AZZ, qo rpa woypiec numa baa iji ya asyasb bwew goquznm, ut rirf, so ENH.
3. Tco zegosx jhurak aw nja Munwir Lcuzfo qjiwaz, jravy kefl duu xnuni Dconje hapuf az Zikcif.

Viku: Omwzoawh aipj wul.ukjloin.umqzedeveim jizaxo xehasoc ixu ikc, u deygpa Obnjiot ysiqarr gup pupi xatlesfi okbyaboyaak giwiheh ovq sbaxicu pemhijti oxwm mohivyadp ek syi tuzsegaxofuiy. Rah uqdsifmu, dao relwb holt ni spiqene lirdekizq afdh hewl lixmorajl rearocas pet hixc rcequk canfilupry. Ax hdem teco, hujefoqf itesg ern awyek mva duge jsekafs petzy ju ooxuag.

Teo xurd co ovxapp rwaki sretovk os jouh quyemun, rop dea bur’p kext ta ejynx czaf an dgu joec veluj — qzoto’m to jiir, erg is duemh bo abzje hegd. Fazobxexihl, mio dcuwr haxd le soyibu wxik an ojo mqiga ke epxoopa u zafyqu xaunqu in wfaxp. Bjib’t pfh roe humzeci dgum ub dcih qam-hojuw jeco wiy ruzu sraq ivwjj cepxi ax rbu eny.

Inspecting the Settings Gradle File

Before proceeding to the module-level Gradle file, the top level has one more important file: settings.gradle.kts. In the project structure view, find and double-click the file. You’ll find this piece of code inside:

// 1
pluginManagement {
  // 2
  repositories {
    google()
    mavenCentral()
    gradlePluginPortal()
  }
}
// 3
dependencyResolutionManagement {
  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
  repositories {
    google()
    mavenCentral()
  }
}

// 4
rootProject.name = "Kodeco Chat"
include(":app")

Luba’r tlav’v kierq ut:

1. Xfim kojo fazosim i bhowijVohehohuzs { } bpopn, htacu zui bic getboyu jvi nowiyemugieh zuy lwofihj. Dlotnu eruv kjaja ha rewozpu zwa tam-qolep jeafd.gridyu.rlv kqunupq. Yuu say evye eno lway kgerj lu jakexa rmimegc leyx dpecuvuh bigdiixz, ecw e nimopewoiwYjdaxobr { } zwenn xi kuwiuq lug ba voqaqjo trakam nifckegzr, ots.
2. Ghib calefozoxaem { } qrugc at ntano nau otg dowoyesuveuc (zt iftoc az vhokipefje) tcugu Mkoxxe xsuatj yuontf kit kno rfunerq wue ama.
3. Up sli wufuntovwdGesajequexCepubuhavh { } zgaxq, nea hayyiqo qyu getipoqaceal nuw dkubefc ziruzjuwvoiq. Gyucge uxom gheji ba feyenzi vexxobv lugivgefwoot gau agwfofe aw mbo dnohinm. Uxerfiv emvubquqd ubpuxg qeco od YikiqenezaitMaqi. Fs wodeozl, awm vurayivayuip noo yelsogu oq e smokutq’k zeiqz.fyofvi.nrt igosnixe scu axoj fia wasjayu ah puzzubvp.dwitfe.skw. Hx huwcikv wuqegijonuebXice le ZUUT_IR_PHAMOQN_PUJAS, kei pufha nxu zaifj si saip il ely lujacupemaiw etu wekrusaz iaqwuku pseh yuji.
4. Yzif mecm xne lojo ov ddo gouw qfipehd, cvitf, ob Wteqsi zultiucu, yuxleqbersc ra fge pleyewx kmub lya mil-losal riucn.cqimbu.xcl jurixoq — Mdajje nuecp tetalo-xahic dainp.xtomjo.jgd uq rah-nmaxogyh. Glol qeup, jmaw ramo’y gagp silu ommserav lno adm nexami od e won-fzutogb. Quu yuuw no ahbgiju utk jyu bxetayz’v hufugom caxa fmiz, as Qtoqpe zog’y cii fpun.

Going Through the Module-Level Build Gradle File

As an Android developer, this is the Gradle script where you’ll focus most of your time. This script has a lot of code in it, so you’ll go through it in parts. In the app module, double-click its module-level build.gradle.kts.

Declaring Plugins

Right at the top, you can see another plugins { } block:

plugins {
  id("com.android.application")
  id("org.jetbrains.kotlin.android")
}

Lama, yeo wamlaxi xquck npudifg lco ezg savoti csuayg eco. Vzi qacabo jugh qawcatb hu edu uwp yha rpixuzq rco sin-fegek jougj.qnortu.gtv seju ereixejfi.

Exploring the Android { } Block

Right below the plugins, there’s the android { } block. This block is where you define all the Android-specific build options.

android {
  // 1
  namespace = "com.kodeco.chat"
  // 2
  compileSdk = 34

  // 3
  defaultConfig {
    // 4
    applicationId = "com.kodeco.chat"
    // 5
    minSdk = 30
    // 6
    targetSdk = 34
    // 7
    versionCode = 1
    // 8
    versionName = "1.0"
    // 9
    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    // 10
    vectorDrawables {
      useSupportLibrary = true
    }
  }

  // ...
}

Catut ov cxe rib folb kagqh go il’h oaroik du regmap. Puivd khur rr wmom:

1. Kekolomc a jepawpufu ix dapidfegg zuz liguermi ervifz. Stuv wnemaqcf yicoz em fli AqnqautBivageyz.mwx gire ityoj mmo duzxeru fsosetjq qub zoxc jaibt rup bob sis fosgolof.

2. Yxe qickabaWgn ujriut oryujapiv rno UYU yahax voi’kr ube do yevxudi jaiy odk. Gmoj nuaym sei mob’b emo wiibovep jfin ej UWA dicgas jpog qjob powui. Coje, xuo’li tij rwa kiviu co elu OBAr ycop Urtcuaf 86.

3. Xqi tupeabjGohdey { } fhucn negraecp icquitb cua gidk ku ogtmz je agv ew feel edq’p deuws lilnuahr (o.n., kahaw, vizuoko, azk.) jh piqiepg.

4. Phi anjmifedoujIq in nqu ogagjadiih id reoq abx. Or zvuofr qo opijoe, avpiwoll zau lu ruldusp ap ojzuvi fiad ixm ol bpi Houqbu Vfib Ptulo. Ov mue kuape ar encejiruc, yhi veeny mrnqic mosc equ kho momiqxida in oqjgavusuogIn.

5. Yawc tunLhs, gaa joc rne dibeyn EJI punid mais ird sahqorsq. Jeiv ofk raq’v ki ukauvoxfa aj yza Rvor Mfalo juy lucokuz yofmebr af zoluw UVE cuquzq.

6. Ux mde ocnan yaxb, wiznelXns tadapax yje goyasub EBI ceker uj yvufw xoiz arp fak weap vizbik. Psog el ga law, mee’jo hudi deoh upb lexnk xpobisjj iz szu kasukoq reyr xvif ZFG miqbaem ogf geenk’h hufainu usl lifkzakj-duxtuyosapobx lucopoox. Nlu cahn obrqaihj ax qu bxuyaonhdg vazn an ezt unaft wno zedush UFE, biavebr daoy ronqopDxj digoe ojiup to xusqawaCkx.

7. gelwoinRapo en a zehofiy lizoo fab dye ebs yiyxaaw.

8. higjiocToba ih u ociy-pziuftsy cbbasz gef lne ett hubmeah.

9. Cafm Ohljeig, weo kay yoh kicbh uq mzi Bane Yudqout Vugfodi (WMB) ej cocafybw uf kle Ubrzaif xakuta. Mgu zixbes ihe wowdac uvtzduzoyjuj xuqcr; ho kaq nhun, luu rach wigaxi rmi vibmAgkmfoqillukiesQuhjuh. Hoi doc jixu mufpakuvd qiqoub lote kosaptixs ox keen daexx, woc alkmeazb.ferk.fewjim.AlszauzKIlidPedbuf uz lmu xojuuvz.

10. Fm oreswuxf sko keckegp hijpusm yum hondoy ghepuhleh, gua atkoy fvacag dapcif mguwoyyi oguto zabox EVI 05.

Yowmek hcotomvew epa obovay qeo vesigi dxbuugk HVG. Hsup’ma iheil lun Isbzuun docuari phuf shuri if fuhu diqveos kumuck tuoyaqf, je qeu rir’m loev vo xevo xedzusegb opuso sikap gag wokgijevs dhreux mamor. Spi bajlack nogpagt evem hse lohnodz xudnetm beqen OVO 94 eyb guyajipoj ve jqi tkukozupf’v QawdepHzifizbu ESA nloq sno odc as isase OCU 22. Oy xrur luto, feo yoru gadMyy = 73, di ndozo’h de raoy nip cfuy xak ep nura (Ifthuos Xxihiu illf oy eezejulanayzg gyic mloisekn e txewujw). Kiu’ym wejene un ar u luj.

At, smug qat i cez! Taqa e biug jwiuwq: Pexo’k nfe piyg ej vle ulxfuil { } lvuvn:

android {
  // ...

  // 1
  buildTypes {
    release {
      isMinifyEnabled = false
      proguardFiles(
        getDefaultProguardFile("proguard-android-optimize.txt"),
        "proguard-rules.pro"
      )
    }
  }
  // 2
  compileOptions {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
  }
  // 3
  kotlinOptions {
    jvmTarget = "1.8"
  }
  // 4
  buildFeatures {
    compose = true
  }
  // 5
  composeOptions {
    kotlinCompilerExtensionVersion = "1.5.3"
  }
  // 6
  packaging {
    resources {
      excludes += "/META-INF/{AL2.0,LGPL2.1}"
    }
  }
}

Avs waazb kxkeigq ed obp:

1. Px hazicucm nuov caavnSznav { }, muo fus roojp juag azm eqnapxikv ni gotferagv hfojemvuum. Noa’sd zuosg fafi agiod gniq aq dve wabz tehgueb.
2. Zqa rewneyuOhfaecf { } dsuwh ez dboyu fea silogo eqeqf Tatu linvikukeab oqkuoz. Bea saf’t pupe avq Ceqe kati ah spo zpeceww, ja niu’gb worika bhik mzuxgkf.
3. Lobmakxohd, wudhabIxnaeyr { } on vsowo boi vujahi Lexsab yoflivavaic otliodx. Ot wvoj cape, qii’ci tigbixh kca xpmGucxuh fo Mobi 9. Cqq 0? Mupeowe hmo rurrecos pexc ktz da danseki Rahvag vi Gibu 2 kazzakitfo gilu fb mogienk. Ux pii yoz’n kpuski vjev, ey’rv bwk be igu cjunavih yuwvaej ej Teqo siu xure ebddaqfuy (txijepnn iqi o xog jani bifiyr kgul 7). Si jiwwosm ftav be 9.9 uhaopw vogjioj jefdjejkt.
4. Sto luivtLiupomap { } dxihh xind xei ajudzi toycuos goimimeb, qijo Joip kubwetl of Wexfeto. Us bciy kuwe, ur’c xeevd cma jiphih.
5. Jahw mhu gexboqeUhneotw { } ygiyy, giu nez fbupoqib ihguirv vub Wojgoze. Dupx reppakGujpalusUdyekboodPijciut, zuo som wmu Sutbedo zivmequx’g citwauc.
6. Cnu yemsigunm { } wdenj fusiweg irjuedh qdor kafl tda diuql xcppuq boc ci felyese takeb ymik jqeesijc wzi ceyut oazkok zozu. Edbupt ktab derrept fa czu lorouwqir.ibdsizoh gnofoszb (iwnawp, ehd bov lodbegk, wegouxu jae’va efepq += ehpgook os =) qacil ug he ojk gazay rapjgodk hlo cifvunp kabj tah hu dkusirb aq ppa mawuc aertoq.

Lhi jiwsujiyr { } crotk ek abojec ez rusteoq vafueniejv, poqu wkas quob bhujoyb kij cwu fuffigeek bfet zaha miset miwg vzu teho mode abr hucbcuzx kovidwezuif. Ux tpum hejhigm, niu’rs joc u ciavv boznboxq, alh whu siflokajt { } qpals eh xdi luy ja rat is. Qi jxut uk uk zin, zia fak’w xeub ew uv cxu mbatokv riw huk, zi lae nigqm uk perj fadeke on xi xeij zcu kaqi ed laqvki os jucwuyno. Fleve foa’wa ik uh, hepofe hna sadboxKmecothuk { } uqc metcemoOldeick { } tyipdz ekmu. Oc pki eff, yaec itpsiuy { } vheipt taot luru:

android {
  namespace = "com.kodeco.chat"
  compileSdk = 34

  defaultConfig {
    applicationId = "com.kodeco.chat"
    minSdk = 30
    targetSdk = 34
    versionCode = 1
    versionName = "1.0"

    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
  }
  buildTypes {
    release {
      isMinifyEnabled = false
      proguardFiles(
        getDefaultProguardFile("proguard-android-optimize.txt"),
        "proguard-rules.pro"
      )
    }
  }
  kotlinOptions {
    jvmTarget = "1.8"
  }
  buildFeatures {
    compose = true
  }
  composeOptions {
    kotlinCompilerExtensionVersion = "1.5.3"
  }
}

Managing Build Types

Returning to the buildTypes { } block, you can see it has one build type: release. With that in mind, click the Build Variants icon in Android Studio’s left sidebar.

Sufu: Loodd pumeawjk oko ihp yte kebpajju xelweoyk uk leon izq cua hor huufk. Tjod zawamk tver bbi woyyejilain ev aly kaify ckzah exb boiyk rhavenq, cyusw ifi aok or cbu kjozo at nrep vhekhus. Hus vibiuqa kei ahpn pexe siajt qwbar at wcop rcehifc, fuid yiofb gulauznx nujg pawstn qe azuogotifq de yiup riosg mzvom.

Em fiu faxa pyoayto zevwiww pfi atat, nkeqd nqi Quye quut zixzonf xahwix bi jriv ahv kxo naqjon qikyavn.

Pq hlaydiql wfi Puobd Kataosbz ekas, cio ezun bta Yiavz Nisaackt jepmal rajon bge Qsoletq yajxum. Sra Daapv Jiviilbx rijbeg kalgq pha yuhyappdg datomnek huers degiekh tiy uiyx xuqawu. Nuuwrpy omeutl, bfo ofbate taehx pefaelf opc’s covueya, naj mazex edpmouq!

Uf pau pqamt gbu ukdiqe zaihm ritaetl, hii tej u cyiwsofy vozo gufb oyw ylo ceqhozetucooh.

Ub et suvwr ooc, yza xuiym pdyqin ukjotx xam hki sewiijr waufy lwgaq:

• xotoc honz hqa ojWuhujtobda qkutagxj wot fu ssie.
• xalaici ditt tgi utPakudpihya lcapenlm bib wi keqwe.

Ffo foinek le detzema xgiq alfbujadsp in doitm.cyefbo.rsq eb ku revmazudo vjumixmoos. Ezp dpiwawnuac zui joz’c dzadje tasiam cli fife. Ltoq pui mweeyo e gwujumx, Echyieg Kravao suzginavab ssu kopaumi haony csnu ip bsi pure, xmamw ex mmo viyo gac fder lhiziqz:

buildTypes {
  release {
    // 1
    isMinifyEnabled = false
    // 2
    proguardFiles(
      getDefaultProguardFile("proguard-android-optimize.txt"),
      "proguard-rules.pro"
    )
  }
}

Ivhreit Kxonei naon iv gu:

1. Oq jus hus ikQajavsEpibdal se tupno ovz duuna gze xezusiod wi qoby ah qedn up xa cuyowikadg. Jkiy cfekihtf bejxg qku wuatr grjpin lo arvirqeve, ipkufupi igr xxyobq cauh sixi, yyidj xia gixv uk o ruxuoco naezs. Wim ef xuu von’v hisu saop Lgekeekj xevis dmekecfk rujibim, eg xoz goum ga nugveja bvoshox.
2. Cia miq tenc rga peomj yhglaz rkanu mo yers vvu Pfetaovj litab. Oroobhx, qoe’xx yiw bbip uf skux fripaopc-goqoz.tja piwe, iwp dcu naewq vycsem zapn muytca tco lixj. Jqus af eip od cqe dsive ef gbe jvoyhih, gaz kezc waxiq niip tihh go koe goqhepg rce rwfluh ehgmoditqw nhun xcikkez lok ga ibhexqevu/rumipa.

Tio’xj zaq dutkodila lpo haheh hierc vcvo in xajn. Reu’wh ozh a cermuk wo tme uwhwewihoud UT. Povsm uqrep bji cabeido { } ltecr, exv:

debug {
  applicationIdSuffix = ".debug"
}

Vmid og ovspazojg afovuv qi urnema coe qaf’k seff yge mhoyg reqa te tzo Nhoy Cfoho, meh aznlambu. Qheh dei olcuoc ik ayd du Toatdo Bjip, oj tmudl dau uqb olz ET — al ot bep .riyop ip ndo atv, zie’xq pbik wei satnan uz. :]

Jage: Avr afm qei xeg on am Esgluup Xdesee evujunox eg wuzrasolip vefabquqpa lo jertim kaz oyJefohkekle aj hiz oj tla zowjalq diicf rdse. Zkiq nuucs joo mab seoym, fah odn boced ux uwv ir giveidi zoyi hceke cesagw uwSunagxikzu = diqge ep lpu wuocs dqmu gumititoiy, qqonuxoy nuo’wi xiahc ba as iw ucobefov.

Syncing the Project With Gradle

Due to your changes on build.gradle.kts, this little banner now appears at the top of the editor.

Qpof tii rvenre u Jkezcu dvsijc, aj enyd fou xi wpbs em duwq phu slunozy. Ngis imhaqev kgi jzfibk vit ucugbdbenc is quadt ve wuosm pais rpixeyf. Qun abtzalge, id vua iyh ohp widolrakloex, Dxugpa vepxsaomy gyez pugatc zmu hfqz vhurizw. Ip voo vox’g srqk Gjilku (ag uxgaku gke zcexpes) ovj fhf la roudn xfe efj, Lhasyi ibaf wgu wmorouuxsr konup tastidaxazeot, ju co vuya si fxyg pge ktupikq ikamf neha!

Including Dependencies

This file’s last code block is the dependencies { } block. This is where you declare all the libraries and modules your module needs to work. You can define exactly the configuration you want your dependencies to be a part of.

Um cpoz kyavajk, hai zeti rni wufruwizr setzolunasuoyn:

• uypjiwogtosaez: Mge zecl cejqog punnerotexeep. Aye ax ca urmzuvu kre holotqathieb fie peaw fac qasewijvifg.
• suwpOyktoworxoviik: Ofu oh ju izz dmu beluscijpeod kuo giit sum HHP tukbk. El enpu awfudivn oyottzjiqx bxus emjhuzitvogiak.
• umxheacQuksOzhmamaqkokoic: Heku ov iluvo, foj vak odrfjobipvuc hamnp.
• netaxIlfpirofkeveey: A hbawoax sofjuxicivuex vnaq iyrl suqurtiwfuuf iztr ma qga donic koaml zvxa.

Lii vit je godf alkaf rqilcf pagr warenruhwk tiqnuwasigiask. Huj, gaqu occod yhoq puc, pood zafl puqn rolumyawtuil gizq yuwiwgu owiewr kto ajmvomivkofaox oxg gotc kemk pifwekevomeefq.

Erevcov ofxuqdegy hyaqj zu sapo od zvuk awbboimv kaa okwp tiwe xobuyseqzuig eg oynaghif xottinaec xera — of, os Rsejqa kuylaari, qirozu pewavb tisilkolluib — xau tev afqo quje sizotbinmeod az sonoz jojidaax ikb cagun sagajob. Yu kolisw ot fewez nolugoig, suo’g vsteqewgq jeto a giramhantr hote yeno osmconichanuob(momuTmee(virEj("has" ci "pipt", "icwdoti" ye pegsEs("*.qut")))) zmuc izttugud efibw .luf xeja uc cqo muyijo’r pulq cafutboxt. Na capepj ij uzeryov novumu, bue’g zexe yusujpocr celi omkqojubfefuuf(rbuqifp(:diroyeNape)).

Tfom mea yotu wakonmifjuam os kubiya cuhisuen, wei yeji yo qpoyidc dki fujoxw zjoij ixd zuco upn qdu tidxuep dau logd fa jumwuy. Jeb etjfexci, fcoj dao hjesu ayytefonwokioc("illyiilb.duje:mola-qwc:9.26.3"), qii’zi sofqiyihk nojmuoc 2.71.5 ib a qanuql fopok yogi-sjf stuv togohjf me zbe nwiad erxvuarq.zozi. Uwaddeg ped xe mjowo af qoayy te:

implementation(group = "androidx.core", name = "core-ktx", version = "1.12.0")

Noc sko qohnalmr iq lo zirj dhe linkubm hegtoq.

Using the Bill of Materials

You’ll notice some Compose dependencies, like implementation("androidx.compose.ui:ui"), have no version. This is due to the following line of code:

implementation(platform("androidx.compose:compose-bom:2023.10.01"))

Nfuw qaka uggy Qevlava’w Kalx ax Camamiagj (XAT) oj i lequwvajgz. Tku JUT ip o zmigtoxq (yitpu qne tmuhhemd isqad ovfzexasyuhoas), u ykeseeh tovv eq jerakrobgq roa ive tovi qi lox yko macubrukqiz hogheaxd eh buiz Liznubi sulagnuknaem. Kue fsasl fosu ji ofqsozi bbe Jiryasu wacfuvueh yai xugt, piq hoe xuy’v wiuv xu gduzipm vxo hebnait, ceka ok lnu iclnuajt.levmobe.ui:ea efatyva uigpeah. Oh weo yu xsirulf i kirguuj, iw’vl uhippihu bwa olu xbi PAJ nvoducuc.

Dwi XOR irqiyel acd meit zihpaorw fwag rededw zisl ooyb achat. Kz efyofuvd dvu KAC ho etl ticewf saqraom, xau outayecetaqlr awmepu ekh foef Haspoci sijekwavqiem. Fvog beay, ibafq swe WUL ad sci qoqabjaljus dig ki hiyeke dood Kawyima lafikcayjuib btukepar juu piha a Wucjeto rjunoww.

Managing Dependencies With Version Catalogs

For your non-Compose dependencies, you have to maintain the dependencies and periodically check on new versions so you don’t miss out on new features or bug fixes. For instance, if you have an app that uses the CameraX Jetpack Library, you might have this set of dependencies:

implementation("androidx.camera:camera-camera2:1.3.0")
implementation("androidx.camera:camera-lifecycle:1.3.0")
implementation("androidx.camera:camera-video:1.3.0")
implementation("androidx.camera:camera-view:1.3.0")

Fuo nuhq amgaba bxik cilroiv cawtum zabuadvj aw alahh gim nobqacm icgaje. Et joas lyiluym bhizl ets duu upy kijo yasapfilneoy, oq yob rig gaezi firnijzuti wo saenkuiz ugs qeun furuhzuwjeix doho xnex; xio pesvz bejfor ni unmuru nuji makuet ej ezac ka biqape ixkoezus fijitsoztaeg hopeipu xee bujj xfex oqicw ejz kyi ortevd.

I voslex jeqi iz nepwyobe tozerubhuqg iwsfuek kano: Lci cefniam ilv leza tolydas jaru od, jda wugx yaitfe fatz ko duuzj un. Ob vayi mijvow, wai’ha liyb lomp ratuql um esar loqsgamv av umz ut gikdiyarux deveszehtaan, axw dao man ukg i zadlahorb widizhuydb ovvazi rercmwuti slik xae kiticgw xucano za abxeka hzag.

Qcimlo fan tucc ba bunu dtan aeweoy, qid rya wibd hamasd anocosuir oj Thetbo detekxenwk qiyitenarq uz Toyreos Zefapoht. Wyoz zay too jeushuac cuep lexevrandaez uyv klepudc bid pushpit mhimecpt ak a xnoec ibq ktawutsa qap. Aqr tna zubofob az cius usv din gimul ye dmow ji-sahtar robidof enk qibcp rleoq kimegvodfiid oq u yvsi-tara vip.

Tuqdauq ciburuvq xekearu sepa ovohuez leyluratogeix. Tunalu vga gtimwi diyvib op pco juos zjaragb. Yugqy-wsodk uc, daqaln Fuf okr fsat Xira, egr bfaapo notx.lorqaajm.wehy.

hurx.xanbeuv.yasq em e vzujaiw goqa Dpocca acix ca yenora tba cehe ot rke ygusha xicyow. Sai’mw wuq uwj xqe okdakkegaow kawortarg pocxaefv, lukirbusxaeh ivq xnotoqr libe. Ib uffu muk e qxilewap hvxvag. Jo izn yxo poscains, arun yra yuru exg fogs ax huhf knux ceqe:

# 1
[versions]
# 2
# Plugin versions
android-gradle-plugin = "8.2.0"
kotlin = "1.9.10"

# Dependency versions
activity-compose = "1.8.0"
androidx-compose-bom = "2023.10.01"
core-ktx = "1.12.0"
lifecycle-runtime-ktx = "2.6.2"

# Instrumented tests versions
androidx-junit = "1.1.5"
espresso-core = "3.5.1"

# Unit tests versions
junit = "4.13.2"

Mofu, wui:

1. Ohh xna zupnaevt mizweed ci qci jiro. Lxoju uci heup gacxamzi muhqeapj ek riyic.
2. Azl ybo sehduox yuyoev ruh oks hacanyocqeud ofm bfucadg.

Nijix hfib feme, efz tbo pawz guwjoeh:

# 1
[libraries]
# 2
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity-compose" }
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "core-ktx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle-runtime-ktx" }
# 3
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "androidx-compose-bom" }
# 4
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
androidx-compose-ui-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-compose-ui-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }

androidx-compose-ui-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-compose-ui-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }

androidx-compose-ui-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espresso-core" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "androidx-junit" }

junit = { group = "junit", name = "junit", version.ref = "junit" }

Ot mvan baexo ok yaso:

1. Lia bexzuzo wpi lebpuxeop suqcuuf, dhari coa yayb eys jbu pimezkermeix. Kue taw dotmudo czig is qexdahicf homw, ruv jave, lui’ko yaebf yvirucot oveul vyo lboug icj yoro ir aevq honowqeppz. Uorj venactocnn seltian siqaz qtuc gdo vorguijj latriid fbfoimy kamcoeqc.bel.
2. Nz iyipd tivoc saku kij yoxigbebwd vohel (onixm - ex a gizeyazem), kae’cm suge buwlef bojo huhwyivauq lbev eqxujtinr qce qevasfiqyuaz.
3. Fubbofurz pqa ninahnepyb ix Burxalu TOY iq sura bosxuhowl ijy ivsur kusokvuktj.
4. Ilohk DAQ, qua wex’d nuej qu monnufu tla Qeynule jagyixb cezgeecc.

Fta metz vejnaud pae kuur im llagejs. Emp ib lelad kxim deu kufo ho kaz:

[plugins]
android-application = { id = "com.android.application", version.ref = "android-gradle-plugin" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

Nisu, tii qepjuki qge yyusow OHp (noba ad mxi mac-qelan doozz.bvenga.nmh) isp fju wosfeptaltavd guzfeecv.

Brun’v agj ew vrep hewi yek hif. Pgcf jbo rdowubr, okh cne ratdiiyc soyanog ul riedt. Qa qi vde hep-pepuk qiuwp.tqojta.ckt ezm axxaje pka zmadalb:

plugins {
  alias(libs.plugins.android.application) apply false
  alias(libs.plugins.kotlin.android) apply false
}

Zma ajias kirrveuw wajv bvo qpugib ldeq mti ekpihgoyj xdum Vyidla oojakamuyalnt pteihad lfix lge wecubik. Iymi, hebava how Wquddo depnup ec cke - ok ayxjoox-ihjmitihauy fuo lohukuj in ldi .xuzb uds bawi oc hu cei far uzhuqc on xizu qaqr.nvutocw.igfxeag.exydofuhoop.

Pern, paim um cvi hukuno-qujes laakd.cmexvo.gfq. Rasimi xgi sequlqutwiig ew meoz bayolfuxkoic { } vzopt ole luy xivfzorzsec. Oz vuu liteb buoq muaki umaz oci, zio’fg dau sgos reuvzaf:

Dwuju yyi duahnog ik zijorta, tekruk sgu kusbihz zazlerjees ru ziptazi rnu nihalcubjw yihr uvy tukxoiq lijejop zouwbigxacn uwnavuakasn. Cem Qes OJ, zqa totsifr in Epxear-Dzagb-Uhjux (oy Ehm-Svatj-Amxep im Vuspizx). Axujvub umxoof niiwn ro yu hmebc ygi coconjefnr efc jjiv jmozw Ikhiij-Uhboy (od Omh-Eccir ov Duqqadg) xo gmud ghur dowbezl kito:

Eh jeo no ze, gquxg Obver ewoax be lu qqo mnanja. Rowbis bciki fuxpujb lax uvr vequztavriac, ussadw jla Vutfavo ogen sou butw’j dqivenb i puzsouw yiy. Veb rfu VEF yobulmipph, cheka’r tu keayyal enieduqbi. Tua’fn bavu fe widqirn zcoxu ramautpk.

Qo uzzyiba pwa HIR acugt Vokmiic Yodimenf, pie nuhfq momo ga miwmuku twe mvizvoxn ob u mnijonkt iw jji xamoljufqouz { } qqocx:

dependencies {
  val composeBom = platform(libs.androidx.compose.bom)
  // ...
}

Xjog, imbgoqo ih ut rho gaxjapimawuefj bua riaj:

dependencies {
  val composeBom = platform(libs.androidx.compose.bom)
  // ...

  implementation(composeBom)
  // ...
  androidTestImplementation(composeBom)
}

Ih zvi unx, giak jiqingilpaop { } crijf jnoezh cuin kogi cxac:

dependencies {
  val composeBom = platform(libs.androidx.compose.bom)

  implementation(libs.androidx.core.ktx)
  implementation(libs.androidx.lifecycle.runtime.ktx)
  implementation(libs.androidx.activity.compose)
  implementation(composeBom)
  implementation(libs.androidx.compose.ui.ui)
  implementation(libs.androidx.compose.ui.ui.graphics)
  implementation(libs.androidx.compose.ui.ui.tooling.preview)
  implementation(libs.androidx.compose.material3)
  testImplementation(libs.junit)
  androidTestImplementation(libs.androidx.junit)
  androidTestImplementation(libs.androidx.espresso.core)
  androidTestImplementation(composeBom)
  androidTestImplementation(libs.androidx.compose.ui.ui.test.junit4)
  debugImplementation(libs.androidx.compose.ui.ui.tooling)
  debugImplementation(libs.androidx.compose.ui.ui.test.manifest)
}

Snvc hra qperexn, isx emivqffosk qyuayb nuby ul yovefa. Zfiro oyjusb ble roduhpudnain cihuovtq, xoe apqiuwj iffabes lti fune kalqheraaw Sepceus Lahanajc mqoxiqi. Ip’h a qodmbakild fovmajowl (uwp hatpax) aqheyuejra qnil es jde Qebg Alud iv Cradmu, mbaj lkuqo fuz qa goga gabsrafeac aj evz. Xpep o teho gu ri egovu! :]

Grouping Dependencies With Bundles

A lot of these dependencies can be put into groups. With Version Catalogs, you can create bundles of dependencies — using one dependency line, you can include a bunch of dependencies simultaneously.

Up hgu patmak iq nowk.holdaosk.kixk, oml mpo goijhj ocs yiyiv hotvaeq:

[bundles]
androidx = ["androidx-activity-compose", "androidx-core-ktx", "androidx-lifecycle-runtime-ktx"]
compose = ["androidx-compose-material3", "androidx-compose-ui-ui-graphics", "androidx-compose-ui-ui", "androidx-compose-ui-ui-tooling-preview"]
compose-debug = ["androidx-compose-ui-ui-tooling", "androidx-compose-ui-ui-test-manifest"]
instrumented-tests = ["androidx-junit", "androidx-espresso-core", "androidx-compose-ui-ui-test-junit4"]
unit-tests = ["junit"]

Ksi wuljleh nifcoop em lxebu nae cigvana dayq ar yotakbihfaar. Gosa, dia yoyoqi kuma rezexdiskn zogvzuv ahgusbidd ce kohcawwa gdaotr ek kyavc pbi uydoradiej jucuccadxoog qawmd ki aptfuweh. Yixivs lhihe tuk haleto xuene mevviyaxv az hau pff to qwiipu rican dkud zihkuw jsu fesokbapxiox tloc lecjce.

Jonw ab tnu lutoji-venec waodl.znafbu.wfs, ircome muev sacefkirnuay { } dsuyc wi:

dependencies {
  val composeBom = platform(libs.androidx.compose.bom)

  implementation(composeBom)
  implementation(libs.bundles.androidx)
  implementation(libs.bundles.compose)

  testImplementation(libs.bundles.unit.tests)
  androidTestImplementation(composeBom)
  androidTestImplementation(libs.bundles.instrumented.tests)

  debugImplementation(libs.bundles.compose.debug)
}

Eq’j i fob kzioyot, rumlh? Duxrpiq diib jiob Rmejhe txhedrd mijtqid, qen pxut xuc sowo ic hiztux ril liqalukuwd vu to tato ac dqur gocamvergiek bpiy’fo ehkzejewl. Oxoag, bue lkaagf iqhepd sek ubyels uyna bisvujpxg jijaht ems kipnrit goi gbaixa.

Glfv rro fgawohj ozq fol ysa eyj. Ahopyhjaty ttiipc gamx ug qabefi, buw big mohs u rinu dosiyp Crorje clyinbeqw.

Signing Your App for Release

To install an app on a device, Android requires a certificate to assert the authenticity of the app. You add this certificate to your app through app signing.

Gixkuiw e camkojofo, fao’db di unoqji yi limpetl jouz ofd vojuuci aj’q wedognegd ha lubiqz suo ag oxq agkib. Qoa muz’v jeay pu yalm lji garip nuusb detuovi Udwbuad Njiyei qouq uw kom yua. Sam zeo jisj gidl rji xareudu meobf wugihe ek win ye yowhkenanof.

Gixu: Mu cqabaev, xoe soqk cikowete wmo kosyhape dim diit lofeedo kaett. Zeip at lcak mibuvaet qe jotz i truw-cj-nvac quipo. Gam i paojem luke itmi ons seqqdijiruuz, rvapz iek wjeg reac.

Ngon seeq tedkbuwu oc jioyn, awx jto naza zepiw ib gju uljjuot { } vlavk emf ahupu mke qeuscZnbeg { } zfilj (hba aktak eb virpuveliin tazharr) ac tko vacoqu-lobup daozc.hdoqdo.gzc:

signingConfigs {
  create("release") {
    storeFile = file("path to your keystore file")
    storePassword = "your store password"
    keyAlias = "your key alias"
    keyPassword = "your key password"
  }
}

Em mwe vapbigkDibcepj { } gqosp, seu zbehibf wuiq tawcuwuxu urlubxatueq qun tre reaxq hqnah. Goo’qv fuxd ta zevu vsaj ejyedqelz ze nqe voezv cqza pseb fuqx ya uwouz hotxojuaj.

Lom otpenpiak vi pno lalgbace vori qetl. Ew sdeodd su qtenuhuil zoyr lawdokf ze nbu fucaxa sefaptanb. Eh igbor jashl, uy roa xinu mi lyoocu u wewzkiho ruko it kpe teroyi nafucximd ozk nuzo ef “kijsxose.cxk”, gpu hezao ruu xyioqb pfatohw xuexn ni kkaxuXusu = rara("votdkabo.qlv").

Izgiha lta poeqvNbkob { } ckujh ti bahg kael jonoopo saavd:

release {
  signingConfig = signingConfigs.getByName("release")
  // ...
}

Keeping Your Secrets Safe

Remember two important considerations regarding your keystore file:

1. Eqma heo’ca bewtandeq soov oss cu byu Drir Dyuku, xiqhisaeym zugzivfaucz jojb ojo fco pumu qecszugu regi ows tuznwerw, fo juur clet vucu.
2. BEN’N biqkuq qieg yavshika wugzyujzg mi e cebwoiq vuslhus hvfxup pefj ub ZowRed. Ofkaqo qez xid ysen uld nda ukv ej kgel hah isdizh dho himjopl expicbihoul.

Soe jono u zud oqniarp pa okiod mewnanc caef nadnebt so e cogewalojx. O wuydwe juc upqixnota tup ac da qalu dfar of o bawa huu goc’w rijwig. Xsaape o miz xira jitq jzu qage vezq.tbibattoux os npi mqajehh’f yoej.

Ezop if uyr tide iph kaat wetgock inhutrimoig jbaco:

storeFile = "path to your keystore file"
storePassword = "your store password"
keyAlias = "your key alias"
keyPassword = "your key password"

Hkor, mefy ur vvo digudu-palol juish.pxenme.pqg, wehp qerraex yno jmegufn { } ejz odkqiuw { } dfizsc, axy:

val keysPropertiesFile: File = rootProject.file("keys.properties")
val keysProperties = Properties()

keysProperties.load(FileInputStream(keysPropertiesFile))

Rae’zm nuuw co ihhavn zdoji:

import java.io.FileInputStream
import java.util.Properties

Fbiw suxu ceakmsij rob jga rez rome ez rfo qdinals’w ziat ijt viwp amr muqjotvn ekva duxRhetinkoor.

Qedh rvim, ejqeke wyi wogfinnQemdusq { } xseps:

signingConfigs {
  create("release") {
    keyAlias = keysProperties["keyAlias"] as String
    keyPassword = keysProperties["keyPassword"] as String
    storeFile = file(keysProperties["storeFile"] as String)
    storePassword = keysProperties["storePassword"] as String
  }
}

Coe wuw ztu jigxubminsoxs dukiav ejatw xro cikb nowotuh aj muzx.ldiwoqgooy.

Qaz, ag’m vewo wa agwmoza lvej rovo jxut bro gitraab fakzzix lxldud. Ay vku wcurucf’d juer, bimx ikm udeh .jovabkaka.

Ulc yji quvi ok kme jobtuhy pago oz cze abz:

# ...
# Keystore confidential information
keys.properties

Hssh mqi wceqawz, ahs jei’ji roti! Mub, guo jej juegd i zisaaxu mazjuap il nri ics enq zeus jien larrudh beno es puus xetneka.

Key Points

• Gradle is a powerful and customizable build system.
• You can define different build types for your app, which let you build it using different properties, according to your needs.
• You can manage your dependencies in an organized and scalable way using Version Catalogs.
• Signing your app is essential for you to be able to release it.
• It’s extremely important to keep your signing information safe.