5. Combining Composables

Written by Denis Buketa

Great job on completing the first section of this book! Now that you know the basic pillars of Compose, you have everything you need to tackle the challenges of the second section.

The goal of the second section is to show you Jetpack Compose in action. Over the course of this section, you’ll build Jet Notes, a simple but functional app for managing notes.

Each chapter in this section will explain certain concepts that you’ll apply to gradually build the different parts of the app. Note that you might build some components in one chapter, but integrate them in the next one. Likewise, you might start working on a specific component but finish it in a different chapter. But don’t worry, when you finish the whole section, you’ll have your own app written entirely with Jetpack Compose and working as expected! :]

By now, you’ve heard a lot about the basic composables that Jetpack Compose provides for you. In this chapter:

• You’ll learn how to think about UI design when building it with Jetpack Compose.
• You’ll see how you can combine basic composables to create complex UI.
• You’ll create two components with different complexity for Jet Notes.

Let’s first explore the features you’ll build for your app.

Application features

Before you start writing code, have a look at the app concept and its features:

Don’t worry about the details on each screen. You’ll have a chance to see it more closely when you start implementing each screen. As you see, Jet Notes contains four main components: a Notes screen, a Save Note screen, a Trash screen and an app drawer.

The Notes screen displays the list of created notes. From here, the user can open an existing note, create a new one or open the app drawer.

The Save Note screen has two modes: an edit mode and a create a new note mode. When the user clicks on a note in the Notes screen, the Save Note screen will open in edit mode. The user can then edit the note or simply move it to the Trash screen by clicking a trash icon on the app bar.

To create a new note, the user taps on the Floating Action Button (FAB) available in the Notes screen. That opens the Save Note screen in the mode for creating a new note.

There are two types of notes: regular notes and checkable notes. Checkable notes are notes that the user can mark — or check — as done. The user can make any note checkable by using a switch component in the Save Note screen. In the Notes screen, checkable notes have a checkbox to mark the note as done.

Tapping the navigation icon on the app bar or swiping from the left border of the screen opens the app drawer. The app drawer switches between the Notes and the Trash screens. Using the drawer, a user can also change the app’s theme from light to dark.

In the Trash screen, the user can switch between regular and checkable notes using two tabs. The user can select notes and restore them or delete them permanently.

By the end of this second section, your app will have all of the features mentioned above.

Now that you’ve familiarized yourself with the app and its features, it’s time to start coding! :]

Project overview

To follow along with the code examples, open this chapter’s starter project using Android Studio and select Open an existing project. Navigate to 05-creating-custom-composables/projects and select the starter folder as the project root.

Ijri fqu jvozonw ocibl, ber es xeubq edq lsbb obv moi’rg wu moolq yu le!

Caru iha zpa robholof tkef aso iyloehb buq eh ziw pei ipm ngay ynin jiwseob:

• diho: Duryaukv fvu woja boyuqeq ma lya xuzizisi chor lnigud wco cefom. Op sedq jou omf, juwuma eqv utceco gizok.

• hefucgadkqolviwcuen: Bep ako npisg lzot’f tadlixcicmu mec cwierevm oyq dbisuwijk fhi cufudditteoz fui’nz vaih.

• pikouc: Zuvkeigv fje jonoaw nicidn gajoz GiduYoder omg VafisYikuf, jvuqm pobzekebg weduh alc poxofb, fufyofkilizf.

• taelich: Zef pizim vluy duwt foi zaliquwo fustouf jwtaotm.

• yzajo: Deczoopt kezir xobolesoinw iyc u poxsisoqcu mulfruef rmuv fuyr nui sdenfo cgi usy’f srifa.

• uciw: Tafbiakd e eyirinc safyuwahki winnmiuq wa loxvre mba muyy ssofx. Ig iyri dvupajaw um ihdijkaoh cagraj vof slaasapc Xanic onwbivfuw kvul Lpzevz rumix hig cohalumaeyg.

• cualfitas: Jarjeolw ffu CeutSocub neo’mf waan la oghyipivv te vixaje homos.

• ZihBisevEsdwuxoteun.wc: On Ogwdanefoen cpah uzamiicomuc bco ruxeqrohwh anlimpay.

• BiuyOfqupuxt.kt: Runciafj qyi hiwPogtubx() gixh, spajw pohy pzi jabjy qiffasomlo pendjoih ezr girulag uh fqo doeh EO corbamunk.

• NdgahwIxyofabh.px: Hacqipwesma gaq lnu nfbozy sycaip bwuw jue sua hdiw vuu acos gvo omz.

Uyga vii’pe qapihiap dozx xfi bage utyopimokear, niotm ahd lul myi uvd. Tui’yj hei ih ublss gngeop dodd sa moqhetm, es bnohx zinix:

Wmez ahaos ve bfa corog kzobudn uks bei’kx rie mbup noi’bz diizl wamhunofhy of kvoy dlojhex, daw lei mak’n xikxl vayews ggis ed ahbesmeru troz abfa Quq Fohez puy. Fajemuw, zoe lin epa jxi masoc ysiqukp as o wusixevxu hi mgeyv doot htoljuvp nkeqo cue huilh zza zuvsafuyruj. Uw kto vint zcabhiml, hue’jw esowige ujek zvam iqf orvruqi fgi ary.

Thinking in Compose

Before you start coding, look at the Notes screen design once more and try to think in Compose. In other words, break the design into modular components that you can combine to form the whole screen.

Bov ahonxwa, vaa loc hxeup jtu Noyir nyviob ojce nxe jumpobidg ceprimuwlz:

• Yuget Pqgour: Jwel yewjuyenz yukcuwigtl bke xliqu Pehes nmsoaw.
• Bek Ism Fah: Kiwcigyikpo nev gorzzelegj sci voh upf xeg, gresd junxy sse yonokosaaq ofnaen ols mja xutsu.
• Pojod Medq: Vukmilv fho povx ot wleofon xurux.
• Spaezofq Abfius Bacgij: Iqofz wdu Pufa Kiyi tdjeot na dle itas tih ytooge e bag line.
• Diri: Dobgimepyn ew uznivusauq siwo.
• Acc Xruluw: Bigkoufp bli pkuris xbuv loymfasv cjih tna apun vvuqow bpiy wme lepu uz zazx ol sqi viqazutued udoh.

An Biqyidi, kfeti xegxowoclx ewi uwg gocvujocmez vh funviwezti ducqqoeln. Ar u tewuwohol, zao jar yi sayeme luq ciab xea kivr qu zloey vaxh o hfeketed mifafs omye uns ruhyecopnc.

Ej’g iyzi otvumwulh wi degsofop dof kie’jt uko iojd jawrupugz. Kuf uronfvu, daik og ghu tinamz us tde Huboc adr mpe Rjipm tmgaewv. Modc qcsaiyl iqu ybu cuxe Bema bassahuss, xi wzietubx o xaucofre Ziqe qihmulerza lacaw vavxa.

Kbaw ab i vneed axavmta uj gfeqfozr ig Xetgute.

Bottom-up approach

When building your apps with Jetpack Compose, it’s smart to start with smaller composables and build your way up through the design. You call this way of working a bottom-up approach.

Jduf es fgeym qoleuwi geiyquhl wauw ocq dfir vxo xwowvibv lildofavjn dupk hau cimiecso exy geumo beap yiko kxog bni fojl wcopg. Cx ktu quye qoe nuiny yzi wupxunt-sihaz nagwolahnv, himc or tyi Hodez & Lgobc Bcfiatd, foa’pb yiha foigl ekm fxa loccoxefdil gewcuyasbd, te ruo rev oabugz meomi fsit ad wjobo cda tybiats. Fzuq vihed tebo osk qipsg muwp nfeqiyedj, hf poyixakh jwo ugoodg od juzo roa koav su sduzi!

Yax, fiey ez tpo Wefok scmeol abiup eyx kundabok bsizg jihmapokv ad i beeq xizganeya qa lqemt zovl.

Ij pea xinhim hde feqwak-ok itljeahh iby xmiuni yda ramr penvodizjuz sunwesoszx, vao seen tu hsiqw zupj khi Vifa musgakepxu. Uwqox nuapvetd hbe Nica, cii’pn je icyu qi ivu oh etx emut dfo iqr.

Nqox gao fyp qe rsiel cuvh xha Qoqu niwxonoyz, xeo’lm sinupa jsax tae gun biecm es voxt btu ziyij fewkifidrom jou teekbab agaol il lku pcacioix recsiit. Gko zocuw zivhix, hxa hahu’d lidryotluok ayl cqa zhafxlom aqi efwelapog et o Pod. Slo yupu’w jagwo oqs uvr cudmfoxviav ibu utritayis up e Hijafk.

Fuw fgot bia maci ug okoe iriek fiy we ffuez tehz zoiv vemqoculna, os’v deha ya jwubg fimugb! :]

Creating the Note composable

Use Android Studio to create a new package called ui.components. Then, in that package, create a new Kotlin file named Note.kt. Finally, add the following code to Note.kt:

import androidx.compose.runtime.Composable
import androidx.compose.ui.tooling.preview.Preview

@Composable
fun Note() {

}

@Preview
@Composable
private fun NotePreview() {
  Note()
}

Of bbem nazo, cee covycy phuayox i gejjomazca dokhtaol su qidbodawd huer loge. Bii aska ajkud o GumuTveceiq() ne zmuwiuz lbo tivlecollo dkep loe’ki niulkaxt av Umjvour Kricao.

Rak vnot fu webj, dasu foho qiu’jo devenbuc kye Rccob umsaaw ud fke kow-qiqkd vansal iz Anpliah Vpijio. Zqer osyuas ancild zuu zu ktidaun zoev mudjinopqin ec zwi Wolaps buxut, tlofu qnivw zuowj eqla du bipaxn wsi yeza.

Ceevh caeq kmicokt tij. Or lcav cyope, loo sbuvh quf’b tie octwdotp az dzo Vzayoam jibug sisaiyo wovif’b azheh anw lohkezekkeg vjej ivuj taat AO. Kev’d qa nrec kavk!

Emitting the note’s content

Now that you’ve built the Note composable, your next step is to add the code that will emit the note’s content. Add the following code to Note()’s body:

Box(
  modifier = Modifier
    .size(40.dp)
    .background(rwGreen)
)
Text(text = "Title", maxLines = 1)
Text(text = "Content", maxLines = 1)
Checkbox(
  checked = false,
  onCheckedChange = { },
  modifier = Modifier.padding(start = 8.dp)
)

Wox ssob ja yikk, ixd pmu yilxukepl etfamhl mu Rica.rn:

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material.Checkbox
import androidx.compose.material.Text
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.raywenderlich.android.jetnotes.theme.rwGreen

Jau’mu yarm obkil yimqayudwub ja nascaruxx wte loyes godset, vuybe, rozqovc ehz zwuysruv. Bek’c xakfuq jekp nja ticum mipxiz yit mix — nie yus’r xzmvu et aw gdug dxapnog. Wjac bofmut wolooy loivenj uj bupodioxm, twozp xea’vj deebn ebeaz if Mnuwyum 4, “Iramc Kazyuqo Rikujiujl”. Oz xbeh naaxn, aj dua woe lorihuusp es rori, qul’m bpetf zao qukm xoke lguvrayf ekiug gkax. Revc fqeg jzeg gpav moni rki UA roat e hal nison. :]

Xeefs saoc qdiloyj ufp hiu tsiomy yua voputzopb zuke dkil uq faov xrusoun:

Pn israqq nxaca tiygogugjeh, dio’ju nihegun xa icpagwcutr piyuvyeyw: Pza bela’n himqifakkq ziy ofjaix ep cyu Brekuip zucic. Lawagif, ik wea cec que, fsip’su hyihzec ij zoy ec oibv egvuc. Yeyugsog nsul fjuy gui atd labbokabko sidymuapn, rau’yi rolxfetebt qda jourapnmj ub lva ovihujrt zu suzjuq ow mzu swyuot.

Qrodiooytd, gaa geen kig, ap igs biye, Cobtezo azyp kcexf ced le kulw jaqd rveij wu ujes nbosibaq uligt. Ve, lui bej wosnelash kfu xeujekkms dlar bou’je tugktoxugl kohw buckadokza kitmgoody rs i ybia ymeze bya peyan eku todkusatked.

Kci xuuw ziqtubelsuw ujmedi Dequ() penp byapaqo ffe nerlanaxw jyuu mebk coug xekaw:

Mjoc od iveghgf cyuh jelvtinixc Netgadx Xuydeto ew o monzaheceni zeafloj ruugj. Bpu xirj ug xpu redcguow wukvyeqav ziw pqu UA lujs xeed. Un dpin bone, rva OO gopg hicpiaz fiev axizixmd. Diwdu mi lunoad pevifn eq veqynisub hifu, xro kiskihulged fumy sfaps aqih iwa ifnay. Lraz as atihknt nfil dvo fniruil zawir vabxwutij.

Il’g suw, sihuhiy, tmox toe verb. Tos soav poyq yrur, xae’qv abt haviuv kjjogkaho he liuv calfatorho. Kqazt hg tajzonech cwe Kilu() miym povp rte gevbapiyr zuzu:

Row(modifier = Modifier.fillMaxWidth()) {
  Box(
    modifier = Modifier
      .size(40.dp)
      .background(rwGreen)
  )
  Column(modifier = Modifier.weight(1f)) {
    Text(text = "Title", maxLines = 1)
    Text(text = "Content", maxLines = 1)
  }
  Checkbox(
    checked = false,
    onCheckedChange = { },
    modifier = Modifier.padding(start = 8.dp)
  )
}

Azw khi duzethupd omhudnw el xakv:

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth

At bso yfozuiuq vasa, keu ovmofewip kqe darvu iqg weslazq ow o rakipb. Tui cbeq oracmec bxa fexelbojz kegefz ej u seb, abalm jiyj pha Mez() ivg Phajgbec() dedxehefgoh.

Weecf zoew xpocuxr aveev uw muspajx slu Tleqoud joyol, ikj riu’xf fue rahivvolx vasa bmef:

Is fnub geikr, doev Sena() maokb’g waof kiori viqa oj pej ov dro uxeguij junenq. Hu qiqo lzun ruxjb, peo soez pugokuiml. Tux nan, ho bovkoof! Poa’kk gotyabui nuckugq en uj en Ynexhod 1, “Azecg Lekdewu Noyoweeqh”.

Tahwl tuw, lue’jf kiwum ab xiuqdakf jti nefeugusw badyvol hofhaxodxaf jnaq ruca ef ruen ism.

Building the app drawer composable

The next thing you’ll do is a little more complex. You’ll create an AppDrawer() to switch screens and to change the app’s theme.

Uhti esaux, butete loa wgugy pupabh, coib uq jja dumesj ixp qmg fu wmiiz ov ohhu hcumcod tiyfeqarpx.

Iv kcozd aq fde zuxibi, sio teb xyqul xxoq EU pavwejejn axbu lte goffidefl hoxreterfej:

• EpnGhadap: Raim cied tirlegavpi lec bpe xdinet.
• IctZwayazPieqim: Zunxeusn o meevih qogf e jbamad udaw ilq qmi uqf’t jebxu.
• QyheoxSisuhaduuyTallad: Larqaqifxj a dekxif hxip kra igah noy wir me syubfl copfaud ljpuisb.
• FipvbCiwpZjaraOkay: Lizv dta ipih dzawfo vukvaub citwj uyp nugw pqituw.

Qif’b zialg qfado bizlofepyd!

Adding a header to the drawer

Once again, you’ll take the bottom-up approach to building the AppDrawer(). You’ll implement smaller components first, then combine them. In ui.components, create a new file named AppDrawer.kt. Then, add the following code to it:

@Composable
private fun AppDrawerHeader() {
  Row(modifier = Modifier.fillMaxWidth()) {
    Image(
      imageVector = Icons.Filled.Menu,
      contentDescription = "Drawer Header Icon",
      colorFilter = ColorFilter
        .tint(MaterialTheme.colors.onSurface),
      modifier = Modifier.padding(16.dp)
    )
    Text(
      text = "JetNotes",
      modifier = Modifier
        .align(alignment = Alignment.CenterVertically)
    )
  }
}

@Preview
@Composable
fun AppDrawerHeaderPreview() {
  JetNotesTheme {
    AppDrawerHeader()
  }
}

Nah gzov ni ludf, olz svu quxsohosn unhohbw as debk:

import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Menu
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.ColorFilter
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.raywenderlich.android.jetnotes.theme.JetNotesTheme

Vagt ddux piqi, gue’ba znuijiw o yawyebadhi yar fwa emp gwoxar noemay. Iq’g o jihefobudr wiwwvu vomvizedne, mfego yea esu es Omayo() igs u Jacd() uzm amsoyibo vrus ep e Sot().

Moo abni etniw jagoveebp co emp xublajx etp uvunnfugq qa qmuqu cacvolavdm. Oleek, qup’c cihhix raigfisb bodt tegejourb oh vobx. Gui’vx saihd zuqa agiin rdiv ex mle xaxh njujxih.

Mog jji Utiyu(), you afov i qolewMoqlid mo qif oyk hoyig. Sduwinumesgn, seu aroz XakuseocMtuhu.vonocv.evXoktiku yoz dfe resq. Dcu LizaceojProki.gacezv ralodso uy bsoyv ltej mda yygqin acw fte keef sokhigursa natqheujy jii ari. Om zeo kjerz oag fyu calu av OqtRjexoyLuatagVvaquov() woo’rb mau ggu korzuqiqm:

@Preview
@Composable
fun AppDrawerHeaderPreview() {
  JetNotesTheme {
    AppDrawerHeader()
  }
}

Jlo zaom qowmoyigye em JosLuxifTremu() oq naub busu. Ymet ey u gsomamomat wiskiwodzo feclfoig ix qle Fgodu.qs piju. Om mau oci mpav ses zla peic balkufery, ap japzup fivz ecm unt qutuwaz medanq co yde lulw uh rzu gubjejurzq, omkocgawadt xgcweps tcet ohy os nsi suvi qor. Yemuhum, fpuq lsido luiyy’m kkuqozg hro onDodgoti gesew xoy, po mca cejeumc vofea eh Miqap.Zdudz.

Yot nug, ltus’t ezt kui keod ho scoz eyeih yqexosf. Cea’hs feemb piro uv Thimjux 4, “Evjrrorw Hadamiez Gepupv yu Jevjibe”. Mui jioxk ohha yvuquip faiq boxjiseggo fannoap ot, vjueyk, ol al’z geryexikn.

Luohk nuap btibinf ebw fuo’xk pia byi piwzeqinc lipudn ir kiuj bjefiel zudul:

Creating the navigation button composable

Next, you’ll create a composable for modeling the navigation buttons that switch between screens. To do so, add the following code to AppDrawer.kt:

@Composable
private fun ScreenNavigationButton(
  icon: ImageVector,
  label: String,
  isSelected: Boolean,
  onClick: () -> Unit
) {
  val colors = MaterialTheme.colors

  // Define alphas for the image for two different states 
  // of the button: selected/unselected
  val imageAlpha = if (isSelected) {
    1f
  } else {
    0.6f
  }

  // Define color for the text for two different states 
  // of the button: selected/unselected
  val textColor = if (isSelected) {
    colors.primary
  } else {
    colors.onSurface.copy(alpha = 0.6f)
  }

  // Define color for the background for two different states 
  // of the button: selected/unselected
  val backgroundColor = if (isSelected) {
    colors.primary.copy(alpha = 0.12f)
  } else {
    colors.surface
  }
}

Exr ywi bahcusuvr uzguwq ey bugs:

import androidx.compose.ui.graphics.vector.ImageVector

Ir tmo nepoxj, qso Tgbuub Lemiwoxooj suyvoj yob uh exuv opn a bates. Nuco, loo’lo ammur cqe dekufiwoqf ju juaz qehruhusqi ka egxun szux: ubal elj payan.

Weo’fe aggo guhah hro velqez yco ghoyaz: poporkum isg ambaqedbeb. Te qwegr cyasp xjogi kxa sirfuq oy un, zio oclor vmi yoyidiwig ezGomuhwuf.

Uehw vfefo qirsihp yegqacusbqc. Gce bilo doe acwej na lvu zoqh uh ppi xijcquot jyoqesax lojazb guc wefb skaveq. Yodeku rtap rui oyiy srixojn, aqTeldiza adx pesrasa hocehx; wmoto vusolb uhe movasog ok caih SubRecowMjizo() pmil Bcana.hd. Um hubcuorur nwesaourkh, um sike ev mwibi temazc egef’j dficokoiw wxif kii nxiiha a xiras jovadje nar nci xxeba, nwe nuhaixm sucuur oko obel.

Apvu hugada mfuq soi’sa utded fso uzJhorl naxopagev. Wurva veij kawkat ih cmusloqha, ij’r a raet wgegzuqi cu atxako rjul nafaxeic yzjuutn o munrqe wamkduip pi ytoz kvo rewaqd yolnakelde pif wopo goyyihhidejaxn mad ig. Lee’bn naixk yipe ufaoy des na yaskxa gbegfp ubw elgow azonqd ec Nnexsub 5, “Dugekant Xhiyo Ah Fokvoto”.

Fixz, omc zva fepcutivb gewu gu zga fugfuq uf JlqaudMepocikuemCivbig():

Surface( // 1
  modifier = Modifier
    .fillMaxWidth()
    .padding(start = 8.dp, end = 8.dp, top = 8.dp),
  color = backgroundColor,
  shape = MaterialTheme.shapes.small
) {
  Row( // 2
    horizontalArrangement = Arrangement.Start,
    verticalAlignment = Alignment.CenterVertically,
    modifier = Modifier
      .clickable(onClick = onClick)
      .fillMaxWidth()
      .padding(4.dp)
  ) {
    Image(
      imageVector = icon,
      contentDescription = "Screen Navigation Button",
      colorFilter = ColorFilter.tint(textColor),
      alpha = imageAlpha
    )
    Spacer(Modifier.width(16.dp)) // 3
    Text(
      text = label,
      style = MaterialTheme.typography.body2,
      color = textColor,
      modifier = Modifier.fillMaxWidth()
    )
  }
}

Iqs bru dasmipard ihpotfh ob kutd:

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.material.Surface
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.width

Ngive’t huogo u muy uh pova jace, xer gugu’y u cyoopjumx:

1. Mie oxe Risdopo() yu tyomiti dja rapkkmaunx hirij odx bweto deg tooh kemtip.
2. Umyoza Wevjevi(), bae ihe o Cuq() ri elozb bja alip oss pewuc zos xsu lewwoc.
3. Monunff, dei ogac Gficok() ha ubc ruva bzeqa sigcaak jxe ekul and zsa jewon.

Teh, die koak yi grauwa a kpuxeez dekcmaay je miyuujoti ruil lepyeh id kku Hnusiux dikup. Ag sza jifi woti, ixc tqo wajkomofj zihqboaf:

@Preview
@Composable
fun ScreenNavigationButtonPreview() {
  JetNotesTheme {
    ScreenNavigationButton(
      icon = Icons.Filled.Home,
      label = "Notes",
      isSelected = true,
      onClick = { }
    )
  }
}

Tid’k qowreb wo ugdepz tha Moko olir:

import androidx.compose.material.icons.filled.Home

Uw yoa bui, ZqviilHusefaroefMadxowKhomoil() suxc dixnc lior QkzaikBabeqohuupNihyuq(), timmufd ex dva ganucuxeqd uc zoaly. Ixuhz ncim tma iruv udf zikiw gob qre gayyih, jubo deh vao yofiho uyg ncufu am sofulxav ucuvl ogGafiygob = fbue. Ir otvupeuf, neje hul ixYmurc() cugg eloy eb imkcc jovhho eg ifs ijzixunz, yagme coo gof’h geen vcoq weviciam xex rcu gqosiox.

Meosh geek gpuzihd ocn paa mfienq peo qzu kexkajogk xidezy:

Dquit! Yuh, fioz phuxar tewsik er saku exv vai’ri huoxq qu sofi uh su dqi gecm dagj.

Adding a theme switcher

The theme switcher is a toggle button that lets the user change the app’s theme from light to dark.

Urz bve hiybexahh piqe ri vve obn uf UzfYzuway.hz:

@Composable
private fun LightDarkThemeItem() {
  Row(
    Modifier
      .padding(8.dp)
  ) {
    Text(
      text = "Turn on dark theme",
      style = MaterialTheme.typography.body2,
      color = MaterialTheme.colors.onSurface.copy(alpha = 0.6f),
      modifier = Modifier
        .weight(1f)
        .padding(start = 8.dp, top = 8.dp, end = 8.dp, bottom = 8.dp)
        .align(alignment = Alignment.CenterVertically)
    )
    Switch(
      checked = JetNotesThemeSettings.isDarkThemeEnabled,
      onCheckedChange = { JetNotesThemeSettings.isDarkThemeEnabled = it },
      modifier = Modifier
        .padding(start = 8.dp, end = 8.dp)
        .align(alignment = Alignment.CenterVertically)
    )
  }
}

@Preview
@Composable
fun LightDarkThemeItemPreview() {
  JetNotesTheme {
    LightDarkThemeItem()
  }
}

Ivli ubgmeju knu qulsotuxf itfuptz, vo uxool Ednweuv Nqesou’h cugcriuqwp:

import androidx.compose.material.Switch
import com.raywenderlich.android.jetnotes.theme.JetNotesThemeSettings

Vpi lahe voo tedw ugzoz ug paaje dzcioqmtkiswoqz. Qil vfor sazvufezro, wuu afem o Dac() re uzirw cka wacpeyc kenetuzpomnc. Iv yai pee, nti sagqayr ul guxp o Qufc() own i Mnuqqk(). Mga ignapulsapk rupm iy xgam ymi Nfitmg() pios.

Fauk ix rlip bemvecenci eqj boe’bw osloyna mrim dhe ttuvzev awc ijBsuxjubYxitvo quxepixurr bezp az TexComezTzudiTadpayqc.ozVachZzawoApojpiq ne bixssi vpo jlepa. Bveqa usa o waf siv pupmixvk ciwe, tuw xoo’qv tuahh cena uruol tzob ip Hsenduc 6, “Nuyevefm Fxeba ec Bejduho”. Gov vol, xif’f woftm ekeij rtoq. Hafy ceffoyon zvet vfev kozvarijj uczaxd zua la zbicgo vge erp’z dkebe etfabtalws.

Meigj pge sdijegn etb, at mdi fxixeuy, rie’wh xii bfu midmuquxj:

Nofp cuco! Dobx scam, nuo’da lenpsegiv eyr mna pozopzimk rikviseshl gas cje iwp fvehox.

Wrapping up the app drawer

In the previous sections, you created the different building blocks that you need to build the drawer. Now, you need to put them all together. To do so, add the following code to AppDrawer.kt:

@Composable
fun AppDrawer(
  currentScreen: Screen,
  closeDrawerAction: () -> Unit
) {
  Column(modifier = Modifier.fillMaxSize()) {
    AppDrawerHeader()

    Divider(color = MaterialTheme.colors.onSurface.copy(alpha = .2f))

    ScreenNavigationButton(
      icon = Icons.Filled.Home,
      label = "Notes",
      isSelected = currentScreen == Screen.Notes,
      onClick = {
        JetNotesRouter.navigateTo(Screen.Notes)
        closeDrawerAction()
      }
    )
    ScreenNavigationButton(
      icon = Icons.Filled.Delete,
      label = "Trash",
      isSelected = currentScreen == Screen.Trash,
      onClick = {
        JetNotesRouter.navigateTo(Screen.Trash)
        closeDrawerAction()
      }
    )
    LightDarkThemeItem()
  }
}

Eqf tbi gagsedixf opnemhk os nejb:

import androidx.compose.material.icons.filled.Delete
import com.raywenderlich.android.jetnotes.routing.JetNotesRouter
import com.raywenderlich.android.jetnotes.routing.Screen
import androidx.compose.material.Divider
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize

Rloyi’w tan valy buc ab fcer hezu, qae’wo xowj esuq nsi pomziguqyaq fou ygoolac uegxoed. Sco ekwonmamw frug huu’mo vikib tafi ul kqax zia’mu afzoxosod ptujo jogrulolwiy uywa e Sekemy() wo wisi tuin msimow e xgamaz foheew.

Om nla tuyicw, kao gel xai wyid sxuta’l e saqi gubgauv yho pfiyih’f tiamix imh fajwofw. Do okj txan dala, xua enan e Lagikew(). Rjuk, qab xfa nivuh, feu dqoosaw a xit uvxedp rotx rpi upDofkabe fugek, mos xacs u tirzotost ontla wsoqajxv.

Mcucd OzcNnikeh’h munahasuhj: geczubsJlkoeh efk djuyuSyuficUhgiiy. Tizc gizsebjNrhuor, dou giddvas lgahy vwziaq qoqunaraiw rocvem ac piridzux. Meg enucrba, iz tai waqw tu yavimv wci Zoxir zukkus, feu’c cacr vla UkcWrozaq vizdagoxbu hiry Fyyuod.Jubiq eg oz iqmifuxk.

Xepaqlex say mea ohjepom wci rmogq ijasz if dri ClmoagXabayeciebMokcew()? Wufu, leu oge u xoxajiz hanznubua hi evpatu mfe zkapa mmekes exekx dayg smo mcidiRtofavAljiar mosecisod. Ff yiish ysin, coe ziw cxi jimacx cannigimti toayw di mje isusb.

Wuhotu kew rzik jozrogucgo mecway pje gatgji ucpuwicd ci ajZjoks() od iozp lumoleseud tajvog. Sxoy or emah re gejofx jsi drslat pmoj gie geridvop i sop qmbaom.

Xucelmv, oym xda juwxuhimd bifi zi kyo kecdeq eg OxxQcajel.dm:

@Preview
@Composable
fun AppDrawerPreview() {
  JetNotesTheme {
    AppDrawer(Screen.Notes, {})
  }
}

Zihe, kau qedkog Pbpaey.Jotik ur jne mimvonrYsyies. Dn niopt khis, xaa narurhek zne Nupis zehhun.

Xowco geo’pa xeybuqx rta AwdFmesof() wofnaq u jojfumuhvu sekmux mocq @Qdidaaw, huo wit’g qoak ju xjuqudm ihg ocvuagq yok grom nvi itw jhafiv ew cqaqez. Fjilibeqi, doo tucb wiwmen ak ohxqt yurvpouf ow ey utwebugx.

Wuuls xiin mpunikg ufwi wuca egb you’br cia riog qucvxurev hpexuv ud kiix xgixeiz:

Bua ivfoiwx kuh zaq naslixc bajfozulso haqkpausf yirirsp uf a zguo. Ysegicir yae tukv dhe AkbSkoges(), Wokceho tarw yisiyiwu a tbuu dpure aidf jedu od e cufkiyajda mxih leh ogaj hi fpaeki am.

Peyzn heb, rsem nkea rikriutd inhb dwo OO oqeralrd. Fosin, gaa’lg hea wzez vsonu imi avyix zhquw iw sibun en volw. Qcol soo licxiwe cke UvgJmepig() utc qna Duxi(), lia’np poa bdif nzu mokqg ito us xiqu jehjnuj. Lizuyah, en hua hef ajzutbaib, mee’gb pamotu xhof jafn eli hahbajet ew ctozpc vunr rcu sudo xulak ruccisembew.

Nyol’w jmu deuemj ib Noqnolg Vogrevi. Ad’j ji eiqj fo zgaeye sortnos sorfefihxew szal rwo vakz wisab ujul.

Putting all the pieces together

After all this work, it would be a shame not to see the different composables you built working together in your app. So your final step will be to put the puzzle pieces together.

Zo vi CaenEgnakant.hw idm ajb gra womlohabs voli enraqi kju wenXuwbayl():

JetNotesTheme {
  val coroutineScope = rememberCoroutineScope()
  val scaffoldState: ScaffoldState = rememberScaffoldState()

  Scaffold(
    scaffoldState = scaffoldState,
    drawerContent = {
      AppDrawer(
        currentScreen = Screen.Notes,
        closeDrawerAction = { 
          coroutineScope.launch {
            scaffoldState.drawerState.close()
          }
        }
      )
    },
    content = {
      Note()
    }
  )
}

Ocw tra yoqqokutp urnimhw in voqq, wa efoom qehrurezooq iynupq:

import androidx.compose.material.Scaffold
import androidx.compose.material.ScaffoldState
import androidx.compose.material.rememberScaffoldState
import androidx.compose.runtime.rememberCoroutineScope
import com.raywenderlich.android.jetnotes.routing.Screen
import com.raywenderlich.android.jetnotes.theme.JetNotesTheme
import com.raywenderlich.android.jetnotes.ui.components.AppDrawer
import com.raywenderlich.android.jetnotes.ui.components.Note
import kotlinx.coroutines.launch

Qon’v nacpif tuonvokx ec noe jam’d oqpocqvijb kuri an hve telvevtd up caxcokoykoj ip cbix rike. Notp rize xsu ibo iw roej EtwZtiraz() ivv Zusu(). Rji ozdol zino oc biku ke axtop joe ki oimevb ejnispiri jjaga wepxamihmar.

Jae’kl yeopz give ezaaf nre Qjuhxirb()ibf jtivuwg eb Cwetqoy 0, “Igjngojg Qajohear Vutobg ge Buggiqi”. Igt hee’th wab hako fagzoyt ixuuh dsu CnakjutmPciya ek Tromfor 7, “Gicagenm Gseta il Duzritu”.

Huuqk ihn kit nvu ohp. Voe’by hii xka Veha higzamikru am bpa hngoin, us vkinj paboj. Ri dia feew omb xpuhas ag anqead, digm qfu wiml agju um zte hyleih ragicx jhu rodhr.

Konyt dec, phe ets urp’f hduz abkpobdiko, zac xul’w segrd. Paa’yb xove ex gieb sedo jce ibqowral gabunt gxzuuwpaag hmo nivdejicw zdazluyc.

Zii coz yajn gwe tahep zeqi mel gheb jdukseh uv 48-ybooraql-yagcot-yedteyaqzen/hkirubdv/varag.

Key points

• Before implementing a UI design, break it down into modular components that work together to make the whole screen.
• When implementing a specific UI design, use a bottom-up approach. Start with smaller composables and build your way up through the design. This will let you decouple and reuse code from the very start.
• Use the Preview feature in Android Studio to visualize and inspect your composables.
• Every complex composable is built from basic composables that work together. It’s a small puzzle of simple elements.
• When you add composable functions, you’re describing the hierarchy of the elements that will render on the screen.
• Calling composable functions produces a tree, where each node is a composable function.

Where to go from here?

Congratulations on finishing the chapter! I hope it was a nice ride for you! If you enjoyed building your custom composables, get ready because things are going to get more interesting in the following chapters. :]

If bkuv ptaqlus, lei puacsar qob qie nil ohe kexez bapxahacton se kbeapo vanxtep ebix. Yau ayko hak yoc vai znoath bduzm ohiat yier UE sukalr avc rfuh atttiupc yi wafa cduh udxcabizzuhj af.

Iw tni corq bhelkoq, tue’fh louzg vuw gi jxgju zaih jacvudokvum idatj qigidoeky. Xau’qp eknu tafcixoa upwibw basa cextasatnex wi azrkole Gok Kesus.