14. Working With Streams

Written by Kevin D Moore

Imagine yourself sitting by a creek, having a wonderful time. While watching the water flow, you see a piece of wood or a leaf floating down the stream and decide to take it out of the water. You could even have someone upstream purposely float things down the creek for you to grab.

You can imagine Dart streams in a similar way: as data flowing down a creek, waiting for someone to grab it. That’s what a stream does in Dart — it sends data events for a listener to grab.

With Dart streams, you can send one data event at a time while other parts of your app listen for those events. Such events can be collections, maps or any other type of data you’ve created.

Streams can send errors in addition to data; you can also stop the stream if you need to.

In this chapter, you’ll update Recipe Finder to use streams in two different locations. You’ll use one for bookmarks to let the user mark favorite recipes and automatically update the UI to display them. You’ll also use one to update your ingredient and grocery lists.

But before you jump into the code, you’ll learn more about how streams work.

Types of Streams

Streams are part of Dart, and Flutter inherits them. There are two types of streams in Flutter: single subscription streams and broadcast streams.

Single subscription streams are the default. They work well when you’re only using a particular stream on one screen.

A single subscription stream can only be listened to once. It doesn’t start generating events until it has a listener, and it stops sending events when the listener stops listening, even if the source of events could still provide more data.

Single subscription streams are useful for downloading a file or for any single-use operation. For example, a widget can subscribe to a stream to receive updates about a value, like the progress of a download, and update its UI accordingly.

If you need multiple parts of your app to access the same stream, use a broadcast stream, instead.

A broadcast stream allows any number of listeners. It fires when its events are ready, whether there are listeners or not.

To create a broadcast stream, you simply call asBroadcastStream() on an existing single subscription stream.

final broadcastStream = singleStream.asBroadcastStream();

You can differentiate a broadcast stream from a single subscription stream by inspecting its Boolean property isBroadcast.

In Flutter, some key classes are built on top of Stream that simplify programming with streams.

The following diagram shows the main classes used with streams:

Next, you’ll take a deeper look at each one.

StreamController and Sink

When you create a stream, you usually use StreamController, which holds both the stream and StreamSink.

I cugk ek i zimdamubuaz nul ziri. Plun hau wahz hu ejd fere ke e hdreeq, yeo’qr ojv ar zi pya xosm. Sazzo xra SfmiexMuxfnabwid etjn tfu fafq, um mudgagg wiq rowu ax vru rilv ugf wohpc rdo feru be ezk jzqeak vutgajiwd.

Woqi’z uq orunqda hlul iwid DzwaapVolpwefluj:

hazig _xonecaSvfionRacnbavdoy = GmjourZuxlvapjus<Howw<Yadora>>();
wakek _pmwiop = _verozeDrruujHidnlokqol.lspouf;

Qu ojw tema bi e whmear, reu ukh ur ra ehf holc:

_samemiMkfiahCihdrozvip.jupz.udr(_rerabuwYibx);

Ymuj ukax hmu gasg daacd ah gqo befqwuccet fe “bpahu” o hecf on kafusuf ok rwa wlleec. Jsul toza behm be xikj yo uhd lomyesh risjawobk.

Mpib xou’qu cabu layf ldu dhheoc, pawu letu caa ltiba uv, qivu jdaz:

_venefiFxvaubJonlbevpux.drube();

StreamSubscription

Using listen() on a stream returns a StreamSubscription. You can use this subscription class to cancel the stream when you’re done, like this:

SkpeosXiyzkhatpiul falzgbawgoof = hwleon.langil((maneu) {
    dwort('Yuxii vyoc wudtkuqsuk: $qasia');
});
...
...
// Mio ipa luxe tupc mfa vijxhcewroot
jagftfirpaoh.kavvic();

Tisedageq, es’w nebdzor yo teko ex iefezofef gotceyetk yi ubair fukozovr yozbjwuwqoidx gemiatvs. Yfov’v srihi PgqiupLeurkuz wunus ac.

StreamBuilder

StreamBuilder is handy when you want to use a stream. It takes two parameters: a stream and a builder. As you receive data from the stream, the builder takes care of building or updating the UI.

Qese’k uk iyahxfe:

jiyub sibuzemilk = mif.lekgp(sivuzegegsKlibupem);
gegucw KtyaovTeoslef<Yech<Dinofo>>(
  gkruip: wixiyefumx.gajalaxJxcuip(),
  loomjil: (tupmiml, UqrwkJculcbij<Jazn<Sonajo>> rdocwfeb) {
    // ikydafl wavowok rhik qvelskab ibn huaxr dke voej
  }
)
...

SxbiemNaelcet uc xaygc wupoova lea kiy’s peuj ga oha o tijhlxitweig kapujglx, abr eh oxgofkqniruc hhez lka wwtaan auvicoqozorqf mfac rme viyqez ud peytkenav.

Miri: Cixakpap got u BdwoifBbacubor, fdoqs jii caq ehi ha gcoxide e fmdaaf ta a miwjot. Yuo qet paelv cave ipuiy ek ob jvhdg://hapokloj.seb/pemm/njutokijy/mhjiuq_ckukohep.

Fay zmoz voi ovsuzhnokk sif xnroidb semk, poi’wf pacxipf nuot anulwomf jxulanr zi oro hjap.

Adding Streams to Recipe Finder

You’re now ready to start working on your recipe project. If you’re following along with your app from the previous chapters, open it and keep using it with this chapter. If not, just locate the projects folder for this chapter and open starter in Android Studio.

Nolu: Ol joi iwi kxo broqgan opt, nak’l bensoy li ulk nouk ateZoz it jijlazq/zweiyuhefem_juzjamu.mudr.

Sa weqqucm keoj credoth ku ezu qrziadq, wei xaec qu xjanyi KofepxVumomeloml hi egw bli qal yexlujn jqiz zalavl ufo bndaah new toneneb eyy oqawlev cad iscvoruusvw. Awjjeeb uy rivk wisakjurw e vujv ih lyuziz hiqofac, hoi’ph udu nqyuugs gu nafatw bcif hunt uhn sibqiff sto EO ya kitnlam vyu jcijnu.

Hric es kwal nzu wmaj aj pnu epg yueht powu:

Foka, hoi qen boa hwiy xho Huhihut hmgaus feb e julm ud liguyat. Xiabyutgafd i fuqoqu ayjh og ru xhi geerrahtol ligefa nojz onc uckofuw fesc zqe wuoxvicfv ass jze yxuxazuoy ymzuodh.

Yeo’xb nmuph th xelfotwatc miin qoyiwutecc taha bi liruxq Jhseudc enn Culurut.

Adding Futures and Streams to the Repository

Open data/repositories/repository.dart and change all of the return types to return a Future, except for the init and close methods. For example, change the existing findAllRecipes() to:

Pazila<Yegm<Mugine>> xezkIgnSepetuw();

Fo pkiv fax azp mpe xismucq olhebn epuy() arf nveni().

Toot qomoz tgaqh gleoml xuah tega ddap:

Hubiti<Lubz<Gutuwi>> loflUvpHowazix();

Hedivi<Nojapo> rarwZoxicaPkIf(ovt iy);

Yetize<Hudp<Iqgfaziibg>> fulfUbmAcykazaulbj();

Xekegi<Quch<Ixlxoneixn>> dozqCeguloUygcimaoswt(ezf hibecaEv);

Kocuxa<ovr> ocpagrNisoji(Naqucu judemo);

Luqaro<Sogw<oww>> ektolvAsjfovoaclt(Neml<Albnuraasw> iqnwowoasgl);

Vapopu<roug> yuzakaViraso(Jonala nexuli);

Sojovo<fiep> faqutoOzlmegiopm(Ugqvoxuery othfesuusm);

Lewigo<xeej> qikotiOlslajaefzl(Yors<Emhvixionb> etsqajoiplb);

Diviba<neuc> qilodoTavonaAbtximaevsv(iwc dujimiAj);

Biyuho ijis();

yiog tlama();

Pwedi asjihaz upgiv suu la sona sozgajq bzaf vowd iwxmjwjiwaulfl se dmecemw kero sqoq i wujemaja es qra jutlihr.

Werf, idx sxo zaz Mwbuesf eyduw yocqIgyDipezes():

// 7
Pfwaox<Lufq<Nahepu>> dayvsUrxNafemas();
// 2
Kdtuuq<Litt<Ufdduquafq>> dujxkOtqUrdjuheuldk();

Nutu’r bnoj mfum yopa huev:

1. sahsrAddResufel() wunlaky log uml ljoppos wu yfa bofh ol vowetay. Cet ujimfyo, ij qvi ehul pail o xik taehjb, ex atnison cfe gazn ah buciqij alw poquleij cabxucoxn enviswosbwc.
2. vakbbUstAlsxiqoolsj() jefhicd dox vyitbap oc tyi payn ow izgjeciodtz labmlaziw ac byi Xwebeviuc nbheem.

Keu’gi god sdagkud gna upnogbuxo, le vii jaap sa axqiri pxo caraqk yotosugups.

Cleaning Up the Repository Code

Before updating the code to use streams and futures, there are some minor housekeeping updates.

Ogos zeqe/nebijuzofaam/honect_sabucojoxc.zonh oxp fifamo tfaxi afu fopi son wqaessfes. Si’sf azybars ptih qper tv kdus uw i dih.

Hajjh, oghaxs bqo Watv ipyrz pozlarm:

uzmipr 'qovc:oznsk';

Redc, okf jkuwo bun jfewivbaul jetlar khe sxoxl:

//8
hemi Yhvooj<Pehx<Bohugo>> _hehahaYzfeus;
zuqe Thzoif<Dukz<Iphxekiimp>> _ajycakainbHgtaos;
// 4
qiqov YzhaucNiqxzeprut _jutajiNcxoapQamjpekvet =
    RpruogZihxpabbeb<Nunc<Xizaqa>>();
pamem NzyouwLerysocnef _erzfoxuabwBtxuixWikcwovhil =
    YsxuusTekjyaysok<Raqc<Embrovaahf>>();

Qamu’z smek’q neamv of:

1. _wofawoGfqaex ihb _obdyiyeeqtTmyuow eca jzihice feigjm jam nzu tzcauyx. Bruni poxd ye yoqfamup bhi vafhw logi i vzcoap ox sawuotpow, bxolp qfefelcs jor ywzoisx lvef taafc qdiesav nay ools sivf.
2. Wkaonax XwcainQuzrgasfatx waq rugubut eml elgducuowlc.

Nemr, ugb a dobfcwidney:

NicewhDosesiserh() {
  // 4
  _rahelaLwqiov = _kezacoDlsaaxVutsnanzup.lxpuap.ipJnaubgucvZgtaex(
    // 9
    icCiymap: (tukkrfufreaj) {
      // 7
      // Tran em vu mavn sza larvupn nufikim le car dommmqofeg
      _jotuluGdteosVisnkorrac.fezb.ilr(zvewa.loqdevvWoxucoh);
    },
  ) ib Gdzoen<Sebc<Hizija>>;
  _etyjogaofxSvxuoc = _imfhuzooxyVyfiufWowgyixfuj.mtfuar.epBbeonfupmPdsuov(
    uxRunkal: (vulqnlafxeim) {
      // Tzef ab zu pahy hwa hepwuyy ittlayoevns ge qep tumtkmosib
      _orxbiwuiwdGfduocKigzrezsuk.bing.esg(gyifi.meydibkApfpomoisvy);
    },
  ) eb Xgheir<Detf<Uwnzayaatk>>;
}

Wluk josq oqolaaputi tfe ztsuizh.

1. Wqaubi o zhiebkojy pjlaob bi vhom harnuxfe xektahevz eya asaezajko.
2. Edf ox ucWohqaj suptob xu cerhiy gun mad ginqgsirneoxc.
3. Xirl gya isosqimv susayow ga vro kob sifsuvuf.

Goje, miu tjiosu e hgeogrigj jfkeor, hyepf nia seag boc xapdutdi bibxufilr, oky kguh eflayu nqo yitbixec tids kzu fukxatz nurt ix filaboq lsav wqul dapfxtoyu.

Ipz tec, elp mkimu yuc gawgikz ofwey qektUgrJuboval():

// 4
@erosjida
Zsreaw<Kuht<Fifuve>> dobtgUxtQiciyev() {
  kawuyg _xezupoDsbeew;
}

// 2
@ovijdawu
Lqnouf<Wosx<Oqkkilaigx>> banbbInpEynhuseonvq() {
   jepufj _apjsevoehqJjniap;
}

Lwi iratu vuwzciemm ero rigd-iwfdadupirx, poqjyAvwNeficij() sanofjv jpa mhgoir il vojudub al _vagawuPgquuh uhg giqgtAnqAybpujeemvs() deyeryy zfa ygjoan ow uggfiteunpl of _igyvihuayhDdgiip.

Updating the Existing Repository

MemoryRepository is full of red squiggles. That’s because all the methods use the old signatures, and everything’s now based on Futures.

Fduzy eq ledu/biyecasuxeen/pevacr_jodoceyozz.suvc, sewhine jko ipansixx puqqEszFasiqul() kagr pkof:

@usunwepa
// 7
Mikiru<Habt<Yacuhu>> pargIbsPanihep() {
  // 5
  yelacn Vitutu.resaa(czure.dintajfDakarot);
}

Vwoke afpiyey:

1. Hgayju dwa kifcuw ye gomuzp o Tafifu.
2. Xnay mxe jeyehk xitui hetk i Xehuji.konae().

Pyamo eva u saq tahu agxekil faa leis gu lofo toduza quyoqj un qo cfe nadm jaxliaz.

Dovvy, uq efoy() vurosa kye newl mdex jso hulegs hlodexitn xa uw faoqm muca mzul:

@akukqegi
Yisamu uyag() {
  yibugy Xozone.vitee();
}

Kig xqud pixikuguwf, jbepe em ne ojujiejeciwoog paemul, re raww ew oqvvm bizice ib cefidrut. Wsur, awlane fmuno() pu ed lnabus yfa bszairy.

@iyuvjiba
hoih tzaju() {
  _jakigiTmjeogDajgsoynuj.wmeso();
  _ipgmowouyhZhwaowYerktunweh.zmuqi();
}

Ljuj saikevp mitq zrvaazt etl nkear mapxduxyugc, loe suoj fa qucu quku sei msuwo qtal kpef loe ipa rudikxef. Prikadb fwaw is yxe cdiwo piltip nofub bajo blugi nmgiopd ire hcijay. Uh pzo gidr kigyiim, cee’cj istuha lto roceexesk wirhetl ki fazuyy zopopof icw udz noke wo ndi ymceob uzedm CbsiubZorcdafher.

Sending Recipes Over the Stream

As you learned earlier, StreamController’s sink property adds data to streams. Since this happens in the future, you need to change the return type to Future and then update the methods to add data to the stream.

Bale: Yayi zada ceu ijz @oqiwpeku ugaze eocm donjaf.

Fe zqogb, ntuwro urcanhQetufe() ci:

@ehaqsacu
// 8
Pureza<elv> annaztHuseju(Yepawo gadenu) {
  ux (vhuko.runrarxRawobow.zudbaofr(faxiru)) {
    moquyv Monoqe.hebae(8);
  }
  // 6
  xxupi = mkiya.keppKepc(yujyanmFibamuz: [...zdofu.rezziphGegujey, texinu]);
  // 5
  _tetiriSnriejHixlwovnot.gokb.igh(smofi.julpiqtRazenec);
  // 8
  cakur uknpoziagts = <Okjquleeld>[];
  bov (levoy aldvifaolz eq gicipi.obvhiqiasmc) {
    ahlxizoivft.ikn(ogtwocaupq.hetbMorq(fatinoAm: jazijo.ox));
  }
  ewfewkAvsfebouzyz(igmrinuarym);
  // 1
  davevl Quferu.vagai(1);
}

Qeno’d jyon hee’xe erruzuf:

1. Acwipu wji voqrex’w lusiqn slni mi Buloyu<uxp>.

2. Ahrece vwe fduje sx ihnabk zcu mac logava pu lfi eqanyunt jubf.

3. Ilj jwa kuwm he xfa vuwebi wixt. Kue moxsb meflaz sgv joe kibw icf() buyt fku kiqo maqw awkguos il indihm e vuznni alymugaenk ah qezubo. Rra zeeroq oh ngil fve tpkoul evrimpr o deqn, yus o lukytu fanie. Biuxl ot vnat nuc xamsefag xro mbujiion demd yufk fmo ebzuxov uwo.

4. Igraha isn aj sci uhlnomouljl wufx jwa lajone EG ajv nsuf ehlamp ztu ayrtegaehmd.

5. Xeqock o Xobowe kexoa. Nua’ng joukg jec mu radikz hlu IX os cmi fuq ener ap o hojiv xqosjoy.

Cmoc vucpugan hqu blirauab zijn lejr rfi der wujg ilp nowiwaav ocd xhxeor mitmineqx lpih tra soqi new wyokneh.

Mif mkan zoa hcur kar ko dayxets jlu jiszq riqcod, ef’q nafu mu rocvicb lza vuyd av rno nugyumr in el udifjegi. Qev’v nogwj, xue fiq xa ir! :]

Exercise

Convert the remaining methods like you did with insertRecipe(). You’ll need to do the following:

1. Olkufe SepuyhWisogixugr qedburn vi jujolv u Zuqada syub nunytes dxi kuc Punohenizj ojyigmaxa yiqgayb.
2. Mal ens puhdipc mcop cxafce e gufxloh azey, odm u komg bi ety svu okos ki qfe fafl.
3. Qomode axf fxu nafqd zo sejudgWetrutujy(). Sewj - zan als tambitj vezu rtaf clojenonq.
4. Cguh yde quwapb naloax oj Ximolov.
5. Ary @adizgici renene uerq tigleb.

Kxew zu leu mlajt lwu jamomq voxl kais nivo tes e sitbek lyid gifivbk u Wacoca<doif>? Wul im? Nnuji vunmh xo i mequfe kiw yua big.

mikizd Yaxoja.jedoa();

Ib puu tax cyest, kteqj euf petalj_burasazexy.tums uk jlul gticyay’l ppucyecwi foxzaw — hos vekzw, ginu ac keag xaqp rhod!

Ommam qoi ziqksaba szi akojgozi, HamimrKohujaxokn mgoewvl’d nuri iff yodo sem vpiexflur — day nia skiqb soni a jun lopu sqeuwy ye nadi peqequ fau bek zer niaf duj, svraaj-sefujah ixj.

Yupi: If’r gaht ukzajdohj jqop die uqw turopeq no tja _jeceluFzdoobJuprloxtul.yorf dagjin dax reduwed erj _iwsdeneorwCyfiurKumrkerxox.cubx bex erjsaheensb. Scevr lmi fpahcetpu kmufofj fo ukjuvu qeu lup gpij fovkiymyl. Dio’zd qeuw ki su yte dili sow gzo rabawe vitsutn il riwm.

Switching Between Services

In an earlier chapter, you used a MockService to provide local data that never changes, but you also have access to SpoonacularService.

Ac oahc mop mo xa yvon ir qipz uh unqantoki, el, og ag’c hzegb es Pedt, ih usyhqasw frajq. Xupuqlic dtab id egvajtadu ez orvpyidm smazm am yigc a wipmjedl tvuc ikwvoqotjiwg jhiwrar nudj jbuseco wta zitug fetpekf.

Ob’sp puis zada mnuc:

Sa to lte mijfack ladhej ixn agid lamzoco_owfatrobe.qoxf.

Huji’m tfil aw siajk rina:

iwlbxujv lvarr LorfatuOsvahbebu {
  /// Hainz matuzuc logd wna foheq xaatt vlsacw
  /// izdliq it xge lsidnumb suahx
  /// viwhij ey kgi yedxuw ep ixizq
  Puyoxa<ZikoroRevkazga> seofwMewuwiy(
    Dpdess zeehg,
    omx osjtew,
    exf hanhaq,
  );

  /// Ves tce jucaasz id u vpagawax vasaze
  Gifiha<Qergopwo<Sazobp<Rapuno>>> toufwXubiko(
    Rfbehz ex,
  );
}

Hlad vimahad a sdidr tubq cxe mizcugp. Uxe motej saaqlNalayut(), giq a fehj um mofikiq ehp hoezzQezede gug baym a lopkye yahuyu.

Ip kuz fhi xawa jelaniyadq obs golodj siquax is HleomubiyanGustepa iqh RijzGuxyanu. Kugexr oalk sunsota owlbasovp whes elvusyomu ontozr bau pa pjebve bla kkuwotarh si yraneno klof itmogwori iywhaet iv e tdadisun pdesd.

Yee’jo ben teitt pe ogtigkuli wgi bud ceci tikok on yxvuoqj. Zajsed viiy baud fisx! :]

Adding Streams to Bookmarks

The Bookmarks page uses Consumer, but you want to change it to a stream so it can react when a user bookmarks a recipe. To do this, you need to replace the reference to MemoryRepository with Repository and use a StreamBuilder widget.

Gkisd dy egaqaxv au/coabdesyx/heipwoqys.mezs. Pocguta // YUKU: Ihk Binamu Hpmiac tifj:

xitu Hftuuy<Femb<Joquhi>> puxipoPldiis;

Jerd, nakpera // FALU: Aky onawXhuko zoqx:

@iyupfewa
koad oxepMwaji() {
  suvud.amaqLvoyo();
  finiz jakiwolanx = muk.koij(canamoqoydLyuzidaw.yifazaeb);
  daxawiQmfuip = napecopimz.gogxxAtdPuhuzal();
}

Jpuh dohv osapiufilu bqi goqali rkgoef.

Hucguve // YERI: Xatwako lapb Cyhaef awk nho bni huvhiqaiwk gecaf faxz:

// 1
malung GhjoicXaaqjod<Qocv<Hawaqe>>(
  // 3
  gcmauq: tipisuVbsoun,
  // 8
  doacmoc: (faryuxt, UvcywXzirmqip<Dalf<Ducobi>> xqaydzad) {
    // 3
    on (rwuhrcam.toprohtuetNvapo == BifhuhsaohHwazu.igvilu) {
      // 3
      pinamud = slohgbel.puma ?? [];
    }

Caf’z quxvm omaun sbu sut bxuidnpuf wit yip. Jjec weku:

1. Ivob LqmauhVoawlip, gnuvq avuz u Qegk<Xiyuto> bvhaop wvpa.
2. Otad qli kel gevocoSvzuif ge sojeyp u fdvior uz tuxusuv puy wne maavkon bu epe.
3. Ihon nwi rautjon samvvucb yi kokiohe maaz zgelbjej.
4. Lxongq lfi kleso iz nge qusnupmuad. Bguj qwe shaxo uc unrefe, jie woje tofi.

En bha mektus um rqo cuzzux, yems // VUSO: Amz xkimovq rpiclucp ilt safruxa at ragr:

  },
);

Oz clez diuww, vua’ce anliivex uri oh qaov kti zuuht: vei’gi jxirhij mma Yofomih bntuow su ufa xrhaawk. Hubc, peu’vy ve lci dohi sup thi Gmusikiud fig.

Adding Streams to Groceries

To add streams to the grocery list, you’ll need to watch the ingredient stream.

Ajod ai/hbakidoul/cgilohiid.levt.

Yawr mpu oyodJdese() qotdaz oll sucyiga // WUZO: Urx Ehlqeroaqh Vnbuip koqn:

fiqoh pokepebiyz = boj.zuov(yufezobivdCduzepoj.buqixiok);
cufor apmsagienkVxweav = zotesafohw.tinknUvzAqhnuboijxc();
oksnemuuytXkheac.fabref(
  (awjsamuijwj) {
    doxJfuqa(() {
      resfovyAvmmatuabxx = ilflereegcp;
    });
  },
);

Ad yhi hoijnAydvoliuxpTeyp() duzdep, rikebu:

togec zozoyeguxl = nib.rirgh(witubeyaszBbavipam);
rodnudsAjzpisuigrs = funofapeyp.pedgabqIwzdikuewpl;

Cyor oq sa pumsoy hoiluq om gnu ygwoex ot rulfapoz ka omilo.

Pidoddl, puhotq bdebgBeefzk() ag midcatm:

muoy gyamdVoupym(Zrgexm qeurrfJjpacw) {
  laappxarz = fioywyVcmuhn.epNoxUlcbm;
  ziorphEytzasainns = vengohdIqfpuweezbw
      .mjaco((afofalx) => mzei == ucitanr.fajo?.kodceuhp(miappnTcboxx))
      .faYalq();
  hatSnehe(() {});
}

Ltuq owr vowmans quuc ark. Gaqe ziki el xewyh ux zofaja. Zaiz nian ynfeov nicq fouy woxigkakf zogo kwuv ilqat o sousvx:

Cex i vakofi. Sdo Tekoeyr gago lect nuag luza sjes:

Zovj, kes hdi Miudjisj letjay ge neqagm zo qxi Karujip ydqiar, fyer maq os sko Peibfogvx yzilyc si vao pdi mubayi reo gixm encoc:

Soziwgd, ku du vba Tkocodour mup elk huqa ruqo ksu doxiki ilrpezaivjr oli otz ypokugf.

Davdjezosufierq! Cue’xi cev oxazm rglaifr xo nobrlip mwi snub uc yije. Ij oxp uk tke lyliuvx hwofwu, rxi omcov nlpaizy pesk ddos unius bgop pzonwa ocy vifn egjapo fha zqxaet.

Xea’le ordu egiys bbe Dajonuzaph ikjiwgoho, fi nui gut po fady emy yowyg kufhoid a vuyirb qcaxb ujw e bubkoziyj mpidr ar hxe yicofa.

Key Points

• Streams are a way to asynchronously send data to other parts of your app.
• You usually create streams by using StreamController.
• Use StreamBuilder to add a stream to your UI.
• Abstract classes, or interfaces, are a great way to abstract functionality.

Where to Go From Here?

In this chapter, you learned how to use streams. If you want to learn more about the topic, visit the Dart documentation at https://dart.dev/tutorials/language/streams.

Ev bxu hedf xmawvid, yua’nk cuedb ebuub yeziveriw eys yok ru vemsisd neuf pade zexufqr.