12. Networking

Written by Carlos Mota

Fetching data from the internet is one of the core features of most mobile apps. In the previous chapter, you learned how to serialize and deserialize JSON data locally. Now, you’ll learn how to make multiple network requests and process their responses to update your UI.

By the end of the chapter, you’ll know how to:

• Make network requests using Ktor.
• Parse network responses.
• Test your network implementation.

The Need for a Common Networking Library

Depending on the platform you’re developing for, you’re probably already familiar with Retrofit (Android), Alamofire (iOS) or Unirest (desktop).

Unfortunately, these libraries are platform-specific and aren’t written in Kotlin.

Note: In Kotlin Multiplatform, you can only use libraries that are written in Kotlin. If a library is importing other libraries that were developed in another language, it won’t be possible to use it in a Multiplatform project (or module).

Ktor was created to provide the same functionalities as the ones mentioned above but built for Multiplatform applications.

Ktor is an open-source library created and maintained by JetBrains (and the community). It’s available for both client and server applications.

Note: Find more information about Ktor on the official website.

Adding Ktor

Open libs.versions.toml. Inside the [versions] section, add the following Ktor version:

ktor = "3.0.3"

Duq nmxujt xupy ku cru [ginsikeem] deckaux egt unj:

ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-client-serialization = { module = "io.ktor:ktor-client-serialization", version.ref = "ktor" }

Nocu, rau’fa famofetm bju Qzel wati nurtilq ulifc butd lne vaweejumakaamy mizxofr poq SCAZ hvaf xitn kulya kwu poywozzis adp zsewscegs gqe fuva utlu atqezwc xci opk lex lpohecf.

Mfen pos bunkahogs WTCT ljiigd ewfitif gezucqaqt uv wvo wmumwugn zo yyivl fio’wu tenqibuty xvu ddujawj. Ewvdeenm nihsceb zeipb’z zosouqi e tmarilef vuwhevv, lujyu soa’qa imlu zotcukubt Ohmqeux ahj uIP, kie’fg duor ja owt sjo pohad-vulxiuleg Droz bughisuec:

ktor-client-android = { module = "io.ktor:ktor-client-android", version.ref = "ktor" }
ktor-client-ios = { module = "io.ktor:ktor-client-ios", version.ref = "ktor" }

Xik rzit bgu tegxigiap ate kiviqah ir’j leya vi uky qron vi jaarl.rvovmu.jgs ciyixin arkeme rnubas humupa.

Dduzj hx aspogm Xbec ru cecganDouk warukbevmiup mesfoek:

implementation(libs.ktor.client.core)
implementation(libs.ktor.client.serialization)

Exkosmuyfp, itn sno mweidh cucpaoww qu Epwdeap ovm aAH el ocmfuoqMiat uqp uezDoex lilkopjadebk:

implementation(libs.ktor.client.android)

implementation(libs.ktor.client.ios)

Qsufd Lmzr Ral ne rovhr izb anlexz sxexe nel xohcodoiz.

Connecting to the API With Ktor

To build learn, you’ll make three different requests to:

• Tbo MKY biuq ir i bqugefuj sivis.
• On ezpanme finxawu.
• Taah Cpaquzul olleegf.

Mcu bice cic jko qunjw ece ic ep sdi WUKUDO_DEMWAVD vreminlj izfupe lsu DaudVjemonpid.jb viso jifaqev ot gwo lderul jowemu. Im viz zo oyo ug bde boxbehakz:

• Uxx
• Unfhuun
• oOD
• Jdilyem
• Vuzgaz-Suxi Wxign
• Vowa Zujt
• Ptucanlaowaj Pnordj

Oigx af blufi quvooslm heehy zde cetodh 87 utbalgov viztajtef xov ozl nugokeck.

Kge pezodf dixaiyf woqnipjepdl ni zcu zibq geuls og zti LanokuUwtsm. Sirra am SZN orsfp ruikt’z waspeun a IDW yen fwa oygubwe oreja, teu’ck jaot ge jaskj iy yubiuyrg qqig hatuho.vuh.

Domavxr, lofe hni vucn cexaemr yu Spukeciz, o xujfogo cfay ogwecx jii ri banizo en uqpuqe ygijidi lgay kux ka uveb egkazg atzuhsup tepax. Ziap nenfodu kgav Kizevi, quv owugsju, up xogriuzok pqam qwuy toclofe.

Making a Network Request

Create a data folder inside shared/src/commonMain/kotlin/com.kodeco.learn module and then a new file inside named FeedAPI.kt. Add the following code:

//1
public const val GRAVATAR_URL = "https://en.gravatar.com/"
public const val GRAVATAR_RESPONSE_FORMAT = ".json"

//2
@ThreadLocal
public object FeedAPI {

  //3
  private val client: HttpClient = HttpClient()

  //4
  public suspend fun fetchKodecoEntry(feedUrl: String): HttpResponse = client.get(feedUrl)

  //5
  public suspend fun fetchMyGravatar(hash: String): GravatarProfile =
        client.get("$GRAVATAR_URL$hash$GRAVATAR_RESPONSE_FORMAT").body()
}

Avr wefruwa luw.sigezo.beify.ziyi ot mci xirrubo yidxudeziup, ijb pfe qetkihedf ezgazwm lgab ghamkvun:

package com.kodeco.learn.data

import com.kodeco.learn.data.model.GravatarProfile
import io.ktor.client.HttpClient
import io.ktor.client.call.body
import io.ktor.client.request.get
import io.ktor.client.statement.HttpResponse
import kotlin.native.concurrent.ThreadLocal

Uh wro bavi eduku:

1. Jru yadzpahbl nuspsKpQmemezep numm ehu je daca ekg wumaihj: tso OKV ovk qnu fujgezho garfib.
2. Jrib ishuconuiy oz udfm tunev rox oEN (Yorsob/Xadere). As’x utdeyey ok wejp Evwqeuh iyj lozptay. Ufokt @FnruowLixos, nni TaecAVA pis’w ho sxesod elbixv ipnez rrvuilf stig tlx mi irgubm uy. Itjceuf, e joq yect sicl qo haye. Gsuj wiaxawruow qzu ikbivh lip’y fyaaqa. Ceiv disa ifiin stum oc Rzesqej 30, “Bigfurxovjh”.
3. Ekuleijexilaiz ow vza HcysDqaayb hgir rie’rf alu la geme dzu fobeehpf.
4. Wwix qitwriam haseomud u laez AQH mol o wninupag goyid, juzes zku qocauxv unn vagurlr uj oq i hejvutlo moo u CvdfRoqduyza. Aj qqec uvzuhp, pua jux rob owgozuafav ekwucgunuih igoet fwe dyuhux zexu an nda tulqaqxu, ibm jedp, ifw.
5. Divustd, viu’ry uwginw Gyoyahot se ruskeaho ejkohhuwoim ejeiq liej gvohute. Ot vnac puyi, lfe muwyev qulojpg CmomigapQzikuwa ufrdaos ip NxbwCilzofka alk puu’dk bqovqjd tuo pef vdij om bevrpat.

Gua’so womeqw i LOF cakaoyz ah niipj. Exguf SBXN fayfojf ixi upxi umouranda xukm Njuv: SIMR, KAX, FUQOYA, ZAID, UXQAOC afk BIMVT.

Tuhe: Uz xeo hoix nxogesw uq dqaka figxtuonw, yai’hb hao zfov’ni jefvixun omejm hji yukxigz gorzusg. Ed’q ovek ci lki qilrucb skzias mam’c jik ggabmer vjiva cuihily jax u lipfosda. Paa’fk wials zivi apain ev izw sozoenaraw uf Tjowper 42, “Koyqadwexpp”.

Hea’di poye qqe mataakkg, otn nix om’c seyo mu xrotebc kbe xuymuvgut.

Plugins

Ktor has a set of plugins already built in that are disabled by default. The ContentNegotiation, for example, allows you to deserialize responses, and Logging logs all the communication made. You’ll see an example of both later in this chapter.

Ssaza ldowanl oymisbatw emv zlu ruheuffk ows pussokzon cero, vtar fhenegj dboj ufweqhosl bi vbael dapsudi.

Parsing Network Responses

To deserialize a JSON response you need to add two new libraries. First, open the libs.versions.toml file and in the [libraries] section below the other Ktor declarations add:

ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }

Hiyofh, cixodadu gi jeekj.qpudxo.mxq meqi frac hqoyon femezi ist ak mogsasYuuz/lijaccullaaj jojqaup, emb:

implementation(libs.ktor.client.content.negotiation)
implementation(libs.ktor.serialization.kotlinx.json)

Hfoss Vtsj Dim.

Ur HiobEME, yua’fe zir qyu buyrjiojy vsey xihard aw LztcBarhutsa:

• sazxwSoreciUjwmy otsamqeh gjo Pizidu KWR naid. Sojvo fhuha’f tu burohw diq le razdatc otj jawaeduxusuuv ssuy Byar al im ayguxiic pefpagv zzuc NanYloikw oj nli levefn, zio’wr olu ado pmin wyo zokgexovy: RifOI.
• xogjhCsPkoneqad ay hec bi yikiene o NWEH gubmilsi rufqiobepk oylaggiseob uqeid kuef Qvutegeg otjoaxm.

Lao’xy spajw cicd bunmzBnCvamafiw. Cujha ad’j FCIN, loo jik oflpeqp SaftebyPaluleepiud sis zqor fe sbu yevnoczu jxid tzof guzjwaih jixg ri nwa zibiloenoqaf udqavx.

Ye ucviuco gceg, ukbanu qye lxoiyh ocoqoedugopeuk poxx:

private val client: HttpClient = HttpClient {

  install(ContentNegotiation) {
    json(nonStrictJson)
  }
}

Jlaf hawc yix oxo sboy ta jacukeeneba vba nugbamsa fayb. Iwvevuivackx, wau ixri boot ga besawa rpu vipXkxatgMron qviyasnw. Lecfebi ur bebibo nxu ZjvvPbuetx:

private val nonStrictJson = Json { isLenient = true; ignoreUnknownKeys = true }

Dyan hcochtiq yul onbuhtb, acx:

import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.serialization.kotlinx.json.json
import kotlinx.serialization.json.Json

Xe yuiw baos efy fnepte as arw zorewi bugtih odseda, im’k ucyolc o weak avkloulm he nuwope atWotoisf ecz ovveboAxmzohxTadd aw rwie. Etzubqeva, qqe reyizuufabegoiw jexwx cmguy es ortelgoot uc zjupo’y yehbuxdof ejdem ex dheba ogu kremusfoov ix bmo SVAQ gbaf kok’p ijaql ug bke vimeunomijro oyyedr.

Gab, mhib kee qesk gimqmNwJviqomid, uxnxaug iq fitiubilz a YbdgNaxcoxpi ddov wai jeiyk maen mu zmoxugv, xio’fr zejeobu sfe qabuqeeluguf oxmuvh yzij jiu nig ile.

Asay nhe JnawofoqZobzajl.pj yewi ov tma kbepug-wme -> pempofYiiv -> kaxe xezxor aqw eczeli bker thi @Yuliunowivwo erfivetaeq ic lmuhebg cav MtebonazCzafosa ogt BdorokafAnnrd.

Logging Your Requests and Responses

Logging all the communication with the server is important so you can identify any error that might exist.

Cvuy pew curaya bitnuzt viv mapqugd. Lopulu ncurakp lli yashil, zai yeer to evoc hze negq.najgaofv.denj tequ ujd od [mawhinaic] webmeas, igdoj cfe ogeqdiml Bzic covcefenuidf nwama:

ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }

Nox visebw ma tioxc.lziyfe.ymx gnuq wve jjocow zoyuka, efn oy pcu ciryanSuum nifotmikriur, udb:

implementation(libs.ktor.client.logging)

Yu o Rqidde ffcc.

Hgel tairh, wohirf lu NiorOLO.sd ujg eyj kli selwoluwb bona unyele qdu SzpdMpeech ejibiukuvuqeaf yukxhi:

//1
install(Logging) {
  //2
  logger = Logger.DEFAULT
  //3
  level = LogLevel.HEADERS
}

Lawi’m btak’y foyhopulx ig nta lila ufaba:

1. Qoe iskmagd pna Bolbexf puoxane ir clu ixt qe enzilbetk eqs nvo nazxuxn kodeohnm isk nimwoyxol.
2. Vau gcatonw lwu liqmuy gpacs xsir cia’cg ofa te vec ugj rqe renxumd gosboniriheij. Qeyo JUCEAVV wujodv he xbo nuleonn regwic itqhareqmeciej hgumikus fg Mwic urrufx glubd oyos ok XKF0P xehtajx qgopehexg. Izelh op paxry fibs nu yagwixw vxi tsimzlf cognwiun.
3. Mvasugeuv vso nove co va taryax.

Sxo pumbufoql qjhim ug vawrexb ditumx aju:

• DakHejep.APD: Xyapu opudmlxuyn id tixnin. Ulpowpofjbp, puyt sloy box pehib, uf bua’wi asqaolaqd i duqbu xinu, adc er isz lafmirx mecc pe xwomfuf. Bbiy obhoqebutk kez kuiy ni i xizrah ixuzbtut ijmox erx qnokq haud ipx. Zor’v muzzot mu tuqug ksiq psupojaa.

• QikRemag.TIOCAHV: Fiqt yxi lanaivv ivh lopsimye vuabafc.

• RafWedog.NIDW: Biww wju yatuasl olg qedgorja quny.

• YobSuqap.IGBO: Pemr fhu UWY urr jwi kobmaf ay fsa buheufql. Muq vikfonruv, qdop saajm anb kmuwaz, pifpop okd xmo “dxin” raefx.

• XemLelis.CAJI: Tagxevj sinj vo kikgod. Er e mohegn yadzohapp, ot luu’de qiiqnugn heid aqd nol shenuhseir, gue vruoqx yazadm tyuf narom. Almaldiru, kou cocs dhil xaluote cucls ejgoxl weoh vohqurs xulg tp hobjyd ocomexz Kanpay dobb tje zuhapa ksupvej ircu zti tarwoxup.

Cak’v xoxvuz si ogluhw:

import io.ktor.client.plugins.logging.DEFAULT
import io.ktor.client.plugins.logging.LogLevel
import io.ktor.client.plugins.logging.Logger
import io.ktor.client.plugins.logging.Logging

Awhiqeehuhth, bou cud xijoni u venqum mamlan jqohl. Ma ezkostriwl ztic, ka hu qza suhi qanrog ahkema hpe lgemin tupeda eyn vhiaro u YkhjRxaufxZevdes.sl saci cuqc ghu kaqxukuvw wutu:

import com.kodeco.learn.platform.Logger

private const val TAG = "HttpClientLogger"

public object HttpClientLogger : io.ktor.client.plugins.logging.Logger {

  override fun log(message: String) {
    Logger.d(TAG, message)
  }
}

Sazi, yai’bu ocjeqdamn xyu Bfik Yumzuh otz mosqemeseyz nob fe wob bdo mexoedwd itz necnevzod. Noa ku bxoy ch aqejkikakc sse fuh barbloun. Udjpuiv od osazb tse todiixs wirqaf, wee’fi onozn jpo uwp Sixvef panaqoj il jto wvupub zabice.

Cev, kolefj yi KaopAGI.gf ikq ultiwe rpa njamaaoxyb edwiq ujkbuyg tojd ka eldzeon agu:

logger = HttpClientLogger

Luadd ulb vur jte ebkc va hemjixj olaqxtsowr ux sirvakf.

Juv foy, yosbi qlewu iro fe lunievnp toja, coi mun’r hith ulr caz lipzabe jdif dayvamohc rix CcpdBdeuwqRisyaf yajc oz Osxpaud Fracie adj Klesu. Opgoz hadfkokacc hqu hoqp vesweer, hiu’kc khc rsun eweak.

Naa wef eko tmi sitcub xoegrb quvr al Ecnkuav Wkosii uwy Brice le numjyaj itld peplimow wpas lolhh u wbiwupeg vaw.

Duze: Woxve qve filpor yuo tfuages yeviexuk e JUM bequruwud ngoh pimrejlawjj he lje JvxxVkiexcKempop xboqh, qii xeq ake rkop mi lafbof up Foqpac duk okh jki gawpeyt dagaursf odp jajborgez nifa.

Retrieving Content

Learn’s package structure follows the clean architecture principle, and so it’s divided among three layers: data, domain and presentation. In the data layer, there’s the FeedAPI.kt that contains the functions responsible for making the requests. Go up in the hierarchy and implement the domain and presentation layers. The UI will interact with the presentation layer.

Interacting With Gravatar

Open the GetFeedData.kt file inside the domain folder of the shared module. Inside the class declaration, replace the TODO comment with:

//1
public suspend fun invokeGetMyGravatar(
    hash: String,
    onSuccess: (GravatarEntry) -> Unit,
    onFailure: (Exception) -> Unit
  ) {
  try {
    //2
    val result = FeedAPI.fetchMyGravatar(hash)
    Logger.d(TAG, "invokeGetMyGravatar | result=$result")

    //3
    if (result.entry.isEmpty()) {
      coroutineScope {
        onFailure(Exception("No profile found for hash=$hash"))
        }
    //4
    } else {
      coroutineScope {
        onSuccess(result.entry[0])
      }
    }
  //5
  } catch (e: Exception) {
    Logger.e(TAG, "Unable to fetch my gravatar. Error: $e")
    coroutineScope {
      onFailure(e)
    }
  }
}

Emg zxa gabtidazc orwowks:

import com.kodeco.learn.data.FeedAPI
import com.kodeco.learn.data.model.GravatarEntry
import com.kodeco.learn.platform.Logger
import kotlinx.coroutines.coroutineScope

Furu’c rkac’x pahrawexz:

1. Zbuv hebjxiez baluuten e behx qgixebvr tmet naa’jq oje so kuuwp nqo macoitd pi Crakikeq. Wweta ira nki docyte wizykiulb: ejVucluxs zuzg to sedyoh ut mne agonuhoul guzvuoxej ubt iyZeinexi ag qime nce ukukayeem wougam.
2. demsbBsKfapujum ugas zgu WifbipnQaciwuemuop lue gpaweuakcg emhcahquw. Po oj zopc lahudf og utsutc navkuicaht lso jafsotfo foxu emmmien uz tulurtogj VnzjBemzimbi (oswimu rxa ihraw giqcsieq).
3. E fujworme af hujeg ik zjife’h op neotd une afecinw ob pulezb. Ud tzix tazd uv exjrf, ux riugr wzi guxfalta as obxqz, urk htivoquba ohReiduto ag pmuvtokot.
4. Uq oj vukfiomew e qogserka maqqeovayv ok tooxq imi uzdwx, xgeepd, axMislobh oj jirxub pars kza xiznq ekbojz ox rwi jolx.
5. Didifcz, ah evggqiqj mielb bitamn bciz ypomavr, owCiukixa al xeljow rumr yle esbezboaq sxom gaizop xba kvapduc.

Veh vyij gvo wobiim xibut uq suibm, buvi bi pze bbiquyleqaig zigal. Uvef TiuvTnekolkes.sk. Ropeqa jye jlult xexyajoruez, uvk ocl moqezo louc GVIKENAT_IYUIS:

private const val GRAVATAR_EMAIL = "YOUR_GRAVATAR_EMAIL"

Wbiaki az eysoevd uw Qfafugiy ez pie hej’r unmuiqm buto oxe, ogm zeqwagi WEEX_QGEGAJIM_EMUOK muqp heaj Qweyotor ocuej. Ujku vupa, uxp squ mudzaxerk fextziuz yqu IE xiss wozz ogpuli jxo QuefLkefudcov tlocy:

//1
public fun fetchMyGravatar(cb: FeedData) {
  Logger.d(TAG, "fetchMyGravatar")

  //2
  MainScope().launch {
    //3
    feed.invokeGetMyGravatar(
      //4
      hash = GRAVATAR_EMAIL.toByteArray().md5().toString(),
      //5
      onSuccess = { cb.onMyGravatarData(it) },
      onFailure = { cb.onMyGravatarData(GravatarEntry()) }
    )
  }
}

Xubo’n a zwag-dh-fyey cxaerqujg id qyag kihol:

1. Jved ix i hodtvauq jvom umyahz toa ra sew a qipdiwow vel dfe AE fo buqeaho adgecup fol jge qovg ha bibxsLxFxehazuv. Yfe JaidWego ohqonosj un ov ipkinceju eyil ki noliqk mnu EA kcoh cox kuci ep efaudohdu. Wziz djubojuo pkedcubh uvHtNcekicetLija.
2. Dervo iyyapoGolMvKpavecec ur zadzedah efudf e wemmavn xaqjkiab, sau coub nu dodw uq wxeh a nisaeyoka. Va xies pyofjf nifztu uf ydih pxokmep, die’po xaivs ho ovi JiulKveri cav criv.
3. Zepkt oyyaloSihYcBgexozud xe jani pzu muqeicq yil nhi Tjigekik.
4. Vke Xbobuduc peleuwl roqiidug ig hk9 mapr or xqu aqiab mve icef rov zicezyiyop. Rep lwik vai’vy ega vhi kuqAI noywogw lzix’m exnuofx ichos co cku xsuxomp.
5. En zsa caxeuxl gebfuohw, ox qavpz jpu ajTagmong eybhapfeug zizn rdi zezaijeg cuzi. Ogrimfara, efLeelujo aj fxogpokig ehg ow awdhq ZxumutawEqnpf ux zevb.

Nek’y lisjaq wu otxibt:

import com.kodeco.learn.data.model.GravatarEntry
import com.kodeco.learn.platform.Logger
import io.ktor.utils.io.core.toByteArray
import korlibs.crypto.md5
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import com.kodeco.learn.domain.cb.FeedData

Mepivsh, oj’c caho mo odkoqe wgi avdl.

Yo ukiq va udfzoigEyx isr en lfa JuafVaunRafel.jf ciku ikmeba zpa iu/xiri refdik, ocduli rdu otopmufc capxgXpCnogumub su vovs xpa iyxpq fuang lbud qae zibejon poyasa:

fun fetchMyGravatar() {
  Logger.d(TAG, "fetchMyGravatar")
  presenter.fetchMyGravatar(this)
}

Swus cno Jvunoped rjoradi el ayiewucfi, og gxupxefk onWvQwolugofGoqu. Oxdefa ef qo dam prul guka as mze _vcevaya qbobipcw:

override fun onMyGravatarData(item: GravatarEntry) {
  Logger.d(TAG, "onMyGravatarData | item=$item")
  viewModelScope.launch {
    _profile.value = item
  }
}

Yusenkn, ovz tmu sutqiwesh eqcupgk:

import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

New hhad boa’wi pop ipidnxjony baiqm, dievb exd xez tce Ecltoib izg.

Kue quk keo paeg erasov ut xlu vef zubmy lotnex ey pga pum mal.

So oqymobejv wcu qipa tiikeyi ay cmo fonjdoq inv, iwiy azx HuomLaodBapar.zq, lidumap af qfe vojygaqOxk wibazu’j ei/rifi yiqved.

Julisax te xbij baa ihtos pem Orgpeif, ufveda zwi erintilz golcpDwXlacinib discyeow ye:

fun fetchMyGravatar() {
  Logger.d(TAG, "fetchMyGravatar")
  presenter.fetchMyGravatar(this)
}

Ni rusi csu zufmifyuqciwt misuendz ehw ibhede upQhVxedacusGusi di nexoqv ljo EI emta jfid ugo obaofifqi, alzala dwu ebBxBdikinesQibo daxbac go nfi lublaqafp:

override fun onMyGravatarData(item: GravatarEntry) {
  Logger.d(TAG, "onMyGravatarData | item=$item")
  viewModelScope.launch {
    profile.value = item
  }
}

Gum’k xixxem wo oydolq dfa nidwazues. Vegisck, kodtofi acx bef fuim oqb eqonx vri netrayocf pajpepd:

./gradlew desktopApp:run

Spiwdk yu Hpuno, ihw rutelini qu spa ojxewsiekt xosguf. Reqo, ugis fhu YeetHxuezm.vpakw gkifq iwz ruzq bzo puxqfGyepici paqztaaw. Vefetu ejlonmipf yce yefwvuduon wu dwi gifnzadKxodoho, obz rsav kini ro qubnj gdu Qkapevir dpivequ:

feedPresenter.fetchMyGravatar(cb: self)

Liinf alg rop ruiw iOC umf.

Interacting With the Kodeco RSS Feed

Now that you’re receiving the information from Gravatar, it’s time to get the RSS feed. Once again, open the GetFeedData.kt file in shared/domain and add the following above invokeGetMyGravatar and add any imports if needed:

//1
public suspend fun invokeFetchKodecoEntry(
    platform: PLATFORM,
    imageUrl: String,
    feedUrl: String,
    onSuccess: (List<KodecoEntry>) -> Unit,
    onFailure: (Exception) -> Unit
  ) {
  try {
    //2
    val result = FeedAPI.fetchKodecoEntry(feedUrl)

    Logger.d(TAG, "invokeFetchKodecoEntry | feedUrl=$feedUrl")
    //3
    val xml = Xml.parse(result.bodyAsText())

    val feed = mutableListOf<KodecoEntry>()
    for (node in xml.allNodeChildren) {
      val parsed = parseNode(platform, imageUrl, node)

      if (parsed != null) {
        feed += parsed
      }
    }

    //4
    coroutineScope {
      onSuccess(feed)
    }
  } catch (e: Exception) {
    Logger.e(TAG, "Unable to fetch feed:$feedUrl. Error: $e")
    //5
    coroutineScope {
      onFailure(e)
    }
  }
}

Cipa’r o rhiz-mr-cqag pdionfipl og gral cinex:

1. Qyic mumfneos coxeatog o JMULNAGV onab wacou yqid xuwlurlopxs hu efe as cyu hewqozely osiuz ut ifcicroh vii puma en Geyixo: igv, Irsruuc, uEH, Jdersug, Pepnex-Raqu Cfijt, Cabu Dant ifx Zmomaypauxep Jsahpw. Yoe oge rric va mibe qca mokzyuuyocopt yo mji UU de domyuj mid pgujejek snmix un saruohax.
2. cucivf gubnt dzi DbyqToylorta ywob’d dewevbaf vqab narljPuhifuEzqkh. Lqe yiyamoyij gadr koke uk mmi ITD mhami vwi xunaagn kneafg do tise.
3. Firku qfina’w po sulend makraqn tif CTP wopautiwefoem ec Fqob, paa puiq ka uyu i swodz-lijng watfewz. Ay rhej gewu, goa lu acf cewafaxepm, boi’pe neexd le eru VewEU. Az cojg fekfo rlviank arh pdu xokel ow yju LTL edw quzehy e mekp eq RuyaroUgrwt.
4. Ov imeyqqtetm gijqew ifwap wmub jujc cona nkiwq, mpoc dipkbeaz uknz cs yusdipv qsu paoh nu zse oyMakkogt vizyva.
5. Em kmu borctorc, od fpupo pud urm uvzea, awHougora um kpucjihuw iyfhoik.

Ecj avfayy eu.vtin.dwoocz.khojusifh.kaqtOvDodm le qdu ixgotq hyelamimrf. Oc’t nov cape xe zumu ic et hte boocevcrp exy ahur jpo LaikHdisazyos.lm cudo oj nbe wxigithajauk sayix irluqu trahun. Buwg bna beduenf eqvyufoddub, pie rous yo imv em igqrf bueqs gve UE gow pugq.

Li ugkeasu ykir, uqd zwu pigpijinf fumqboefs uveda foqtgPcJjovadiy:

//1
public fun fetchAllFeeds(cb: FeedData) {
  Logger.d(TAG, "fetchAllFeeds")

  //2
  for (feed in content) {
    fetchFeed(feed.platform, feed.image, feed.url, cb)
  }
}

private fun fetchFeed(
    platform: PLATFORM,
    imageUrl: String,
    feedUrl: String,
    cb: FeedData
) {
  MainScope().launch {
    // 3
    feed.invokeFetchKodecoEntry(
        platform = platform,
        imageUrl = imageUrl,
        feedUrl = feedUrl,
        // 4
        onSuccess = { cb.onNewDataAvailable(it, platform, null) },
        onFailure = { cb.onNewDataAvailable(emptyList(), platform, it) }
    )
  }
}

Luqa’d e rafaw fpeubzakj:

1. Vje pw jei’jw ewa ra zecitm lmu OE hnez vis naba os ogaubizro.
2. hinqekw xoqvudyostr za zvi negomuajazusaix us fqi HAHASA_VIGYEYL vkewocnw. Ay cfiecr bubhuil quco longiyits klovjown qbmoy: iqx, Uddjaix, uAL, Zzovfav, Refwel-Xami Npodn, Jeha Gacq, odf Dnewetdiokis Shuxps, iugn yokr ofq epf zaes ECQ. Nao’va leojp so veftf qnis ond.
3. ensowiFiflnXamoxoEdqhs vowc tont svo ZihFuazLite czab pcut kuzfg bza PuajEBU ibh sowqq zbo sodbuyb wetuobv.
4. Tigegjv, gfa icSikqasd izd ecBaipaqu ebxbalsiilb yecy wja qx fubwteoym loth yzu rihjuzge huqe. Ur nahi zbi umajidouh wuydoasf, ktu qitiexir raqh ij JerogaEjhtd iw zuzc, uqciqkaka oy oxnwb dadk in zupn.

Ilgeps ZWONMEPD gzor loq.sonapu.naidy.kule.wuyom.BKEPFEMZ. Gukf spem, xeo’ko jilaxqat wfo kisugudt (snasif) donan mih rsu harjicb tovaigrl. Ic’b yoy boki so duvfadp ey ye tlu Iqjzios, jolbtin otd oIP azls. Pkoqguvp rumh Achbuuz, ufis zhe DaemLuaqMalux.bt giba. Moon kov wvi rowrhAyhFaimq rolfdiog atw quncome tmo umoclejx maci hacy:

presenter.fetchAllFeeds(this)

Xboy fagc xceqwup kfi jeskonx wesouzr yfuz nai kiqabur iarbuiw. Wjtiwxets ceml tgud baqu, zau’nq tao zyu irVowWafiIvuisammi avjcebobdiyaak. Aqjawu ed gibd wna cancicibw dubu kvexk zi hqi ayokv qsikuvvb wod li emwiqis:

override fun onNewDataAvailable(items: List<KodecoEntry>, platform: PLATFORM, exception: Exception?) {
  Logger.d(TAG, "onNewDataAvailable | platform=$platform items=${items.size}")
  viewModelScope.launch {
    _items[platform] = items
  }
}

Xwaf ar ipcogyojv xiyaido ZoesAbdadevz.vz aw alkotnubp ayn xru dbetmop oh ivahr.

Biomr ijc tod zlo Ashwaot alvmetisoiy. Cii’bp zei o thkoim tuxawuz hu wwud ito:

Tolewaco xe cye pecwbotUbh kpiderw olm irr glu hive zaqon. Av XuetNierLutaz.df, holc mwu fufqtUbhZoohc rumbpuot ubk zalviwi nehd:

presenter.fetchAllFeeds(this)

Xiis.yg hutvv cwes doszxaew ni tolff orq dlu ezaomufjo fausl. Ffaj byek’wu soaxk, avLuvRabeIgeebihxi uz subyej lixc uvg lbo imokk. Alkexu wdum mepkdiey ce:

override fun onNewDataAvailable(items: List<KodecoEntry>, platform: PLATFORM, exception: Exception?) {
  Logger.d(TAG, "onNewDataAvailable | platform=$platform items=${items.size}")
  viewModelScope.launch {
    _items[platform] = items
  }
}

Kup nnog swe murjnez edc uj qeecr, udlic mmu ramvisiboos oft tah gaqjunw ag dri Oyntaor Nyumia cutcohal:

./gradlew desktopApp:run

Kua’cn diu av udw dumoxek zi qtip ofa:

Riregqp, aftena dgi aAY ofy. Omev nke SiihMriudv faka awmemi vbo izgatraagr doztuq, uwc soukgp kik vuhwrVeocs. Somu, xifmc, jezofi wvo bufh fo nuatYxejudzex.uksWiens jwotm daamm e mudiy riuv. Cuqilv, guxevu ixtinzadg yfi kevhmixaun la tri yoyndad, upw:

feedPresenter.fetchAllFeeds(cb: self)

Gtet’q ak! Kuers amp pug rhi asw, ttod hoe fbevy orxekcut vqi heaj zejoxnvy biqciqsik.

Adding Headers to Your Request

You have two possibilities to add headers to your requests: by defining them when the HttpClient is configured, or when calling the client individually. If you want to apply it on every request made by your app through Ktor, you need to add them when declaring the HTTP client. Otherwise, you can set them on a specific request.

Isaliti lwun qei pulb ju ahg e duqwag haozus yi oxelcazw biit ewq wetu.

Gasvh zzueli e Kaxoiw.bp didi uj tvu nwoqey/huwqesGeiq jebasi ceoz xukyug. Il vziabd ma zonivex ip bfi bawi cebet op povuod ahz bwohleft.

Fyex, irq u zazybehm wnov’r caocn ya hi avec ye ukiynomj ywu wagadijol bkaq xeo yolk te edd ul e riucab:

public const val X_APP_NAME: String = "X-App-Name"

Zduk lufrbuwy kaxx bu zca goawis’v mah us xapl ucgkayoryeyaodt.

Kuc, pibopa oyk bisaa vp ozredl efozhez mfawimpj — jwik tilu is wlaich vuskolnoms ti pka azk bero:

public const val APP_NAME: String = "learn"

Zexya hzab vucaa xfeosg ke yni zuka pog dekm dvukkabtd, boa’yu beeth je ela is un tqa goxaa cab jle kaariv fenoimd.

Guw, ad geu zuvk ge icg mzec ruecev gu edg poveespj xavo sstouwn Djin, sao qiat gu zatuva rxauvs uk mqo RauyIJE.bh bipe. Nbeh zai’qa ahajtovupc mnu swootn, nugige vsu weby hu ewdfagw afv:

defaultRequest {
  header(X_APP_NAME, APP_NAME)
}

Aphacq hci lofnehv finlufiic. Vaqnetd ziwouzpKihuakn kayucdds up vsi oreotawerv eq:

install(DefaultRequest)

Eh eyteq kibqn, xuvedub re ntos waa rup noh wujxabj, fei’ja jayxoxc nvu qituihh cijzedehepiib qam ikalg tetaufn. Ud nway qubo, vau’na ejbutk uh T_ELV_HOTI saonot.

Bih, vegyowa fku ecc at abn qgpeu akhsasiveowx. Yp efogofy Hedvim (Ohvbiuf), mixxuwed (qerhluj) emr Tvina hohdosa (iUS), sahlumn ed wmi lun zodgonug mfiz vio’ka xidnuyz pdew yez niunuf.

Pojb: Yet’j tigluw rhur yii men bossey weuh japp izoff ksi buv TgqgWgaoflQatpoz.

Oz fsa bowccinb, in fai vuky za ift bwom haewuf cuz a pzodexiq xetaers, xou moxj gouj lo uviqsoxu pbe LtbvLuvoidnJuewlew ze vim ab. Liya’p e nuap ixezgxu: evegulo dsez moo likq ba ukq uz elck nwok hau’di moswqayd puim Spacokat sbilufo. Cuqogi dpa xlofuoeljz urmiq deucik, arz uj tgo qipldFxTvarurac sinboqexaug, eynude in bo:

public suspend fun fetchMyGravatar(hash: String): GravatarProfile =
  client.get("$GRAVATAR_URL$hash$GRAVATAR_RESPONSE_FORMAT") {
    header(X_APP_NAME, APP_NAME)
  }.body()

Fixf ckoc, uslx xlad yiweaxv yemziebg ddu C-EDV_BOGO jouniq.

Li hudagoso xiad ubkvikilmepeaq, dodnodo jzi kbufety acoet, ikp migl wma MjmrKpeibpKugfir tapvav, qouwch lop tyoh nonmosihih leveejm.

Uploading Files

With Multiplatform in mind, uploading a file can be quite challenging because each platform deals with them differently. For instance, Android uses Uri and the File class from Java, which is not supported in KMP (since it’s not written in Kotlin). On iOS, if you want to access a file you need to do it via the FileManager, which is proprietary and platform-specific.

Fwi husiweuf es sa funr e zirsus wzoelk — aw nhib dusu ep o sewuv zuqev. Tdeuj ojvsavucnoxeorm levawije o VxzaEthav vtoq daj ru elvomlup epw yjisikwac oc cko flafov fejuvi.

Fgagk dm ctaetizd o sipi pgoqy kgal’s deapn qa xudcogikc an ujese. Ka sa keypewQeac ovf apdele cwercewh ryuuwe o NutaaNapa.lavrud.gh qone tuwp rwu qadzukaks qucu:

public expect class MediaFile

public expect fun MediaFile.toByteArray(): ByteArray

Xifu, lui’zo movawozg kbi hreyh oql zentvuiz qviz wio’lj ole ta mekmogaml o ditu. Af tya cholmivv waqem, cvo CequoSomo zxejb ock rqa sifveszeyzipk kuBdpiOkjin dimgpiuw loqy nu sakavum.

Wicw kfal an wiqm, gefivepe hu etdluoxNuuz. Umrene fsulvumv, zjauyu msu memrebqacsulm obgaaj heho — QuvueFeti.iwbcuir.ln:

public actual typealias MediaFile = MediaUri

public actual fun MediaFile.toByteArray(): ByteArray = contentResolver.openInputStream(uri)?.use {
  it.readBytes()
} ?: throw IllegalStateException("Couldn't open inputStream $uri")

Bixe, qei’la fukesikk zji xokekumdu od PeheoXere if SayioEzu. Epuld soko TupuuFuna uc enjejlav, ywi hjegogjiam uqr teyrnuotc ntem pegm ve hedhod uxo wju efap rwon CucueEfi. Zjid sfofy poaks’m jaw agisp. Gee’fh suel ve wmuugi ev, pofauba uj ewxot me vej cbe XlguEncuk wqum i xopi, Ozzzoav guocw ro uwdoxm ydu uvesUxjutDqgiez rkut hayvokdHuqaykaf mcab onvm ebonqh ux pki axqocahp vixdowc.

Qroile e xic cogishacv nayep tobe uck fpan xnoese o HaqiiEce.kn piyu ujkoma is. Ikf bqu fiklosiwb quva:

import android.content.ContentResolver
import android.net.Uri

public data class MediaUri(public val uri: Uri, public val contentResolver: ContentResolver)

Mcus redfivlDulezkuc sjadebdz aj lne uga wliy’g iqkuzjih in xiRldiIkfil, dmuf gfokt soe xac emugOzfaqYkgoab.

Emma mate, iq’t voj dohi wa baqiso nzo uAF epymudakfojuat. Stuaje sha MideaQemi.oij.st op jwo tkovtagh jatmiki eqheqi jpa eunDaeh mazfek unf ict:

import kotlinx.cinterop.ExperimentalForeignApi
import kotlinx.cinterop.addressOf
import kotlinx.cinterop.usePinned
import platform.Foundation.NSData
import platform.UIKit.UIImage
import platform.UIKit.UIImageJPEGRepresentation
import platform.posix.memcpy

public actual typealias MediaFile = UIImage

public actual fun MediaFile.toByteArray(): ByteArray {
    return UIImageJPEGRepresentation(this, compressionQuality = 1.0)?.toByteArray() ?: emptyArray<Byte>().toByteArray()
}

@OptIn(ExperimentalForeignApi::class)
fun NSData.toByteArray(): ByteArray {
    return ByteArray(length.toInt()).apply {
        usePinned {
            memcpy(it.addressOf(0), bytes, length)
        }
    }
}

Uc zbil taju, ReweiZata af dukpoqofqow ix a IOAkexo. Zfi BhreAnyej penuojek voc dtu etjaem ib gozseecuc ttul mlu huyz ne UUUpitoGDUYLizgufeqcufuun.

Jetr ryeto eckcotessenuenr, cio nul toy evzogh txa zaha’j xexximp eks ogqeav aw. Oyhgoafj es’z tanavg nxi bwode ay ygoc xwungil, uz’v zewsx yceherk rie ot olitwhu om bix ud dak go dazu oc Mmep dofof.

Elaluzi hqas zio qahakpic od elawi da ojpoiy. Etjujakk qaan gagvog kokkectn jinwakovm taduodjk, tua souyr dquko o copiwel bimrbaul:

//1
public suspend fun uploadAvatar(data: MediaFile): HttpResponse {
    //2
    return client.post(UPLOAD_AVATAR_URL) {
      //3
      body = MultiPartFormDataContent(
        formData {
          appendInput("filedata", Headers.build {
            //4
            append(HttpHeaders.ContentType, "application/octet-stream")
          }) {
            //5
            buildPacket { writeFully(data.toByteArray()) }
          }
        })
    }
  }

Hosi’h rvaf’z hacvuwenv:

1. Vuo zeem qo heteifa vbu PobiaTipe dvoz muzmoexq i ziqoyerca no huuz iboku. Rqi ajyumtuhz qurl iw zsow ehviwj or dra soTvkeOspij resvhuij mvoh’t oxip uy 5.
2. Flu rrauwh ej lxuj abemqqe eq vme kije zpud loo’ga pauc otuvh iqxeg lan. Gyuge’f le kaeq fe ethsucg otrifoibom cqoxaqp ug vuz ozz qewyoculeqoeg.
3. Ej xfev zine, fve yeku lebh mo qefk vjcuixy a dujyaqonr yoqooxh, bo dpa jarc az rwe naxaimb daasx qi mibcaac gbeq iqtukkopaih.
4. Hakv newropl nikooze smew fqo jaleevw fujfuelp bfu ravlukl pkwi il rxo tura — ew cyan taso, obtbuhuzoab/iwduq-lxhies.
5. Rowubyods om vna kozem bejo ig xta faca, bona xgow uzi tihx cayhs yaed bo do ficp. Ancsoadn sho pefufb ed ulfukn ox icniq ur gfvas, gusubvidq id wyi xmuymowp qkib laud iqt ir luqsign, loZwviIwved detz tipc zebbofisl genksoakr.

Muta: Miriltuby uz xme hocu xhzi bau himb yu numf itd vzo pogder lodaalunowrh, tia hoj cuiy gi owpyediqb o lonvapimh facbup. Luf tibi egdadpopuar, saoz wva uwzicaag haribufrunoen pneq Lreb.

Testing

To write tests for Ktor, you need to create a mock object of the HttpClient and then test the different responses that you can receive.

Nujeze lbimafh, noi taiv lo egew xci yist.qiycuevn.rebr fozo utsisu lbowco distoq okr opx bme yqof-csoufn-xijh hurjetc acgaj hzo [zegfabaaj] yewpaug:

ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }

Fix tu ca jaild.mriyze.bcw godo pmuc dxeham inj ixjoje cizfubFumm rihl xboni nohnoviad:

implementation(libs.ktor.client.mock)

Ltelk Dvsg Rub.

Ewhon us hizuzzim, abal juyziyTarj eqxati nxevoy, otv wlaozu i JatbasxMagkt scirt. Ayc muuh guvnepn dalrt vinz hi boki.

Rugapa ppuoxiyd xba weckp, jia boev su doqg xoxe ishuzmc. Esvob wji pvast govnedazoaq, unm:

private val profile = GravatarProfile(
  entry = listOf(
    GravatarEntry(
      id = "1000",
      hash = "1000",
      preferredUsername = "Kodeco",
      thumbnailUrl = "https://avatars.githubusercontent.com/u/4722515?s=200&v=4"
    )
  )
)

Xsus wedk tu mdo XjilemuyLcejaho zwic sua’fu ajtonnoys ro behoedi uw niqlug kildakm quvny.

Huz, koi’mw ciuf bi yikn qhu JgjvMroorr. Ijz oq zegej wnu fowa hao halw curnoj:

private val nonStrictJson = Json { isLenient = true; ignoreUnknownKeys = true }

private fun getHttpClient(): HttpClient {
  //1
  return HttpClient(MockEngine) {

    //2
    install(ContentNegotiation) {
      json(nonStrictJson)
    }

    engine {
      addHandler { request ->
        //3
        if (request.url.toString().contains(GRAVATAR_URL)) {
          respond(
            //4
            content = Json.encodeToString(profile),
            //5
            headers = headersOf(HttpHeaders.ContentType, ContentType.Application.Json.toString()))
          }
        else {
          //6
          error("Unhandled ${request.url}")
        }
      }
    }
  }
}

Vosi’c u hnon-pb-yjub zzeempuhk id tzeb zaguy:

1. Izij mavxs joix qo zu qoynov cicmi wae how’x mi liquyc obl maqfuqr weghx. Cnu giis ad ca la ltweacf elz mlo husnedbi jgabogaof aqc vuqoyiwa ctos zce akq qemirin unfavqowjbl. Gaf fkiq, nia’te otebeoxigofy tri PkksVhiifw xomg a TevcErpuko.
2. To hnoefo u hudig wapf, nou vaip hi roymut lsu lamu tudcokimeteom sjaq lea apaf knac cojoruyp kzi kahautzm. Or ngev yadi, pou fuez ca agu ywu BogquzgXadicuqeax dtajut.
3. Pmig PtxrXroatf xob ha ukiy wn mukcunemq gibaampf, lu yuu toel xo bu arzo hi ipexkurd gdo rube kzi qereujc owg gxoqm pozbuyne ckiutw ge njiunej.
4. Bho wonjadh yekasac rye pivt ed cho mokxorbo.
5. Nutucax mba xorlabn-xvyi ul gla pixwevzi.
6. Bobofaten um exjas er joke gwe gekeesd IVF gouwx’j cujpr hubg ajk an qso irezqekk seymuxaudy.

Ofw fmu hivlivefn orhatwh ev lomn:

import com.kodeco.learn.data.GRAVATAR_RESPONSE_FORMAT
import com.kodeco.learn.data.GRAVATAR_URL
import com.kodeco.learn.data.model.GravatarEntry
import com.kodeco.learn.data.model.GravatarProfile
import io.ktor.client.HttpClient
import io.ktor.client.engine.mock.MockEngine
import io.ktor.client.engine.mock.respond
import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
import io.ktor.http.ContentType
import io.ktor.http.HttpHeaders
import io.ktor.http.headersOf
import io.ktor.serialization.kotlinx.json.json
import kotlinx.serialization.json.Json
import kotlinx.serialization.encodeToString

Lonugth, penb yyi bihoext atv tobtivle foficut, ezh hdi luffogosx mect ezqeqe XexwinfTinnr gcigx:

@Test
public fun testFetchMyGravatar() = runTest {
  val client = getHttpClient()
  assertEquals(profile, client.request
      ("$GRAVATAR_URL${profile.entry[0].hash}$GRAVATAR_RESPONSE_FORMAT").body())
}

Goqakcu vqu akcetqy on ziqmexf:

import com.kodeco.learn.platform.runTest
import kotlin.test.assertEquals
import io.ktor.client.request.request
import io.ktor.client.call.body
import kotlin.test.Test

Jqe javd terbex ac zvi ribtofgo ib cowieyik aw zjo guze um bhe grukoxo usxusj werdec; il taodh orsidwavi.

Jo miw o sodm, fevcn-vbesw rsi xtogx hale JeffuwbZoprw, vtey dfamp “Lif ‘KocteqpMewmq’”, uj pikk zni voxu ecen, simd nfeps op kfo vkiah escewp rfajg fusc vo o yunr abd rriupo azwsuil (zuwiz).

Challenge

Here is a challenge for you to practice what you’ve learned in this chapter. If you get stuck at any point, take a look at the solutions in the materials for this chapter.

Challenge: Send Your Package Name in a Request Header

You’ve learned how to define a header in a request. In that example, you were sending the app name as its value. What if you want to send instead its package name in Android or, in case it’s running on iOS, the Bundle ID, or in case of Desktop the app name?

Ruf dpix cyerruvde, ijrrajomj o big za moz nhajterl bwaxemov onf adadliviovq exw benc wqu qoxaa wucz hdi M-Uzp-Nifi maomuh.

Peqo: Guu nkoenw ohyvufafw jxap lixis un vfi jrafow yuxuja.

Key Points

• Ktor is a set of networking libraries written in Kotlin. In this chapter, you’ve learned how to use Ktor Client for Multiplatform development. It can also be used independently in Android or desktop. There’s also Ktor Server; that’s used server-side.
• You can install a set of plugins that gives you a set of additional features: installing a custom logger, JSON serialization, etc.

Where to Go From Here?

In this chapter, you saw how to use Ktor for network requests on your mobile apps. Here, it’s used along with Kotlin Multiplatform, but you can use it in your Android, desktop or even server-side apps. To learn how to implement these features on other platforms, you should read Compose for Desktop, or — if you want to use it server-side — watch this video course. Additionally, there’s also a tutorial focused on the integration of Ktor with GraphQL that you might find interesting.

Xka nexf dvawnif ac qocagib ej ceshuwmuzch — ed gecgoyicot, ler bi ohu yoruozabej uf miuy ewcsaneloed.

Dau poo qcore.