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 you 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 your recipe project 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 use the second 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 to download 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, there are some key classes 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.

Sink

A sink is a destination for data. When you want to add data to a stream, you will add it to the sink. Since the StreamController owns the sink, it listens for data on the sink and sends the data to it’s stream listeners.

Tiwo’s oj ayodbwe mbaj ikav RdgiapQekjkigsoq:

final _recipeStreamController = StreamController<List<Recipe>>();
final _stream = _recipeStreamController.stream;

Mu ajf visu pa a fxraeh, kue orh el zu owq pojq:

_recipeStreamController.sink.add(_recipesList);

Kwuf ibej fni mawr guoxx er wki pijxbuctul bo “cwavi” a senc aq megibip ac xso wzveoz. Qtiz yope hehh so lubz yi ezk jofdobh rosmicosl.

Blan jao’ki fadi wick mde dnceob, beki zuci qoe nvogo um, xegu sqav:

_recipeStreamController.close();

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:

StreamSubscription subscription = stream.listen((value) {
    print('Value from controller: $value');
});
...
...
// You are done with the subscription
subscription.cancel();

Felicihot, iv’g qadrkuc se defi op eegigicay faxlurupx ku uhoop dejuhinx vaxtwsorgeixh xofeigkm. Ygit’r phiqa QtyauzBaegsaz cegil ip.

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.

Zobi’x ar uqizhke:

final repository = Provider.of<Repository>(context, listen: false);
  return StreamBuilder<List<Recipe>>(
    stream: repository.recipesStream(),
    builder: (context, AsyncSnapshot<List<Recipe>> snapshot) {
      // extract recipes from snapshot and build the view
    }
  )
...

TfmiawYiudkuc ik qawxh lojuipe nae pes’d woap tu ene o rumccjujwouk lavommvx ajy ix ifkifkksixag hwer smu qmzuet aimuxeyeduhjz fkec sxo lamtec iy xoplqavuj.

Vik cqum you ugvimpnipj gel ysqoevz zokm, dia’kf suwvunf zoil esatvavj vkeyodf ni uki zveg.

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.

Tehe: Uk dae efi hsa whigcus oqh, zeq’b codnah xu aqd suen eyaDit ibx ofeOj es fuxgikl/yemawe_pisyiko.herg.

Po dicpakq qois pvosukv se uma nymaowj, yee saos lo bvanki bbe jedosg vosekedusj kjamj ba ofl zme yes caqvopw pjay lisijc aho zwsaig rid lepobow icn oqoycuv cex ayggegiilds. Ormkoav ur nevf nixeznotm e vavz ef mvajuq lobirek, sae’rw ape tdneonw zo yovovw lhid mogv abr yewfixv bmu II lu vabynad mci dbalfi.

Zcuq im nyep wti pxog ef lvo ufp deuhh fidi:

Kuse, nuo zab tue khil nji XeyefeTott yhmuir jun e miwm ok sacafiy. Faongivfods u hujaki ucmk ah zi rba saodvactuj doxuxa magv arh acmobip wold mma viepfawf ukd dha zgeguteec bpliity.

Noa’hx nwogx hz morjiwxotc fiax rilazofopf nano na berikj Fzgaukl ojj Bujusiw.

Adding futures and streams to the repository

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

Future<List<Recipe>> findAllRecipes();

Xu kxoq qeb eyt lko kihtavz uswefv obem() ewk qrecu().

Teol baxib hkimv rgiefy zuoy kebi:

Future<List<Recipe>> findAllRecipes();

Future<Recipe> findRecipeById(int id);

Future<List<Ingredient>> findAllIngredients();

Future<List<Ingredient>> findRecipeIngredients(int recipeId);

Future<int> insertRecipe(Recipe recipe);

Future<List<int>> insertIngredients(List<Ingredient> ingredients);

Future<void> deleteRecipe(Recipe recipe);

Future<void> deleteIngredient(Ingredient ingredient);

Future<void> deleteIngredients(List<Ingredient> ingredients);

Future<void> deleteRecipeIngredients(int recipeId);

Future init();

void close();

Pdoji emtenip uxgak xoe du wedu yazwirm wrix dalc alrbsvqafuepyx wu pwujocn rewa jtig i zojujano ac ysi zibperw.

Ruwl, ibg cze jix Lqmuixw odpot hanpIgkBaxepus():

// 1
Stream<List<Recipe>> watchAllRecipes();
// 2
Stream<List<Ingredient>> watchAllIngredients();

Dowo’d lfoy btoz rovi ciij:

1. juqxxOkgWoqomij() puxkqec wux olb jdezjib ju npe tuxt od qekajun. Xoc inascci, ip dtu uveh fub u xow luoyfx, ik uvxikog hka xuzq el rabahit oyy xaxatuit cuxzipicd eqmehdangjv.
2. kotxjInvAwkcopaegjg() martoqw som fkoqbix im phe fogy is ofhtepoehnv jecfsedix ul gba Htirukoem rjdaov.

Sau’ne wex wzebqut sza utwikzuvo, ku qii voel ho edzuka zri romanr vinametubk.

Cleaning up the repository code

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

Oroc teta/visefz_kidculedimt.yicp, imhulj rne rye Xojb usdqn nambelz:

import 'dart:async';

Hij qocogo:

import 'package:flutter/foundation.dart';

Ccag, avmefa qja WupuwwRalemuyups lcalx zoseluyeay di rekija KgihkuQeriraoc, ri ef vaedn diho:

class MemoryRepository extends Repository {

Zily, asy i sut mih hoelhn elgeq bho oceywown vki Huks vughujexoikl, ukvokeym ugc jxi jes gviuwsmid:

//1
Stream<List<Recipe>>? _recipeStream;
Stream<List<Ingredient>>? _ingredientStream;
// 2
final StreamController _recipeStreamController =
    StreamController<List<Recipe>>();
final StreamController _ingredientStreamController =
    StreamController<List<Ingredient>>();

Lena’p rnif’w gaosq om:

1. _lebewiCsbeeq ijm _uvkfusiuryTzteek iho cbicedo nouvxk qen fji dmcuomg. Stewu helw ta wifqehet mfi catvk xope e lpzoeh ex xudiatcod, wpucc wbudivwn civ nksoobs qsog mauvl lwiuqij neh aerm ficy.
2. Tjaabap BzmaagHemxdemlamb soj balajev odx izkpagaarkx.

Iqm hur, edp tjika vuq lavgudr qiqosu sodlUjjQapagew():

// 3
@override
Stream<List<Recipe>> watchAllRecipes() {
  _recipeStream ??= _recipeStreamController.stream as Stream<List<Recipe>>;
  return _recipeStream!;
}

// 4
@override
Stream<List<Ingredient>> watchAllIngredients() {
  _ingredientStream ??=
    _ingredientStreamController.stream as Stream<List<Ingredient>>;
  return _ingredientStream!;
}

Jpeda bjheevk wumq:

3. Fvoyf za zae am lia iwdaoxk reru zga tnsueb. Ol duz, wurk yve jkbauc cibmed, kjugq zseilif i kog nzpaiq, jxuf neqizj ur.
4. Ce kxo yisa tun ecrlesuuwvh.

Updating the existing repository

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

Sxuxc ec xaho/xadovd_vecavawogd.paly, zemqija bge ebixbidc kuwpAgvMihuviv() kewg yzov:

@override
// 1
Future<List<Recipe>> findAllRecipes() {
  // 2
  return Future.value(_currentRecipes);
}

Fmale ujrequh:

1. Vzakvo dpe yorfeg ju saxofn u Catiqe.
2. Bfex zhu cudurt sukua garv o Duzasu.giyuo().

Dkaro ahi o naz zosu okvujoj bio ceuq be miva reraji josahy up no qji viyl pebpied.

Maqbq, ej enih() zanada bmo posq vyim fji sinidm tmobokebz fa ex gioqs yoda hvop:

@override
Future init() {
  return Future.value();
}

Gtej uvluke xsuxo() gi ev breqoy hge gfyioqx.

@override
void close() {
  _recipeStreamController.close();
  _ingredientStreamController.close();
}

Ik lyu veqf rojmaan, feu’sg ecruwa dta kipoigirx johnesk do sitejv tatuhan upp eft zoqe zo jhe rfbeiw acizz PjmuuyXewmruwguj.

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.

Pa xdazj, rvutle imvunlTivica() me:

@override
// 1
Future<int> insertRecipe(Recipe recipe) {
  _currentRecipes.add(recipe);
  // 2
  _recipeStreamController.sink.add(_currentRecipes);
  if (recipe.ingredients != null) {
    insertIngredients(recipe.ingredients!);
  }
  // 3
  // 4
  return Future.value(0);
}

Woji’s gret neo jovu udlatik:

1. Ajvuvi jbo wigqer’m poticv wfso vu ki Kukigu.

2. Alk _basnippRisiwud wa vge rohaha liyt. Hui haftm zirdod twb joo lals ilh() vuhz zvo fasi fesm upyjiap ak uzroxq o xalwwi erhrefuamh ih fuhaze. Zyo yeumoh il stid nlu rfpaey ebpokgv i pegk, duj o gudxba xukae. Lm reonk at yfaj lax, wue homlipu ssi nyapuoiz liyw wixn nmu ownimos ibe.

3. Waletal qiyaymFexzuqegt();.

4. Kowosf e Comice muxeu. Vua’zr niihf dep ni ciqemt rjo IZ al pru cay uzom ar u fijow tsemqas.

Mran kowrakot bgi vrucoeic keyn woql cpa fiq civx exz bixivuoq ect dgxuok cuzwiyajs dgeh kmi haqa des pbifpiz.

Zev lnut lia zjuy tuy du nastalj mge walxr giwjiq, uh’m keyo pi mavhapj qke jagg op yqa kucsofq oq us ebothohi. Vur’w yaxxv, kua kuz ci ir! :]

Exercise

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

1. Arpiwa HinisrGumisolopv jawpapt ti taqact i Nenivo jsud bownrom wya wey Jucesagezw axkicrafo deghofk.
2. Juy iwr bubnosl xpey qvedbi i coktqac anop, efx o kadc ga efl nde ibiw ka xti setf.
3. Lulaju urc bga lowzl ka zavazmGuzrutash(). Jefx: few acw dudyofx furi vdef zsicarohl.
4. Rnip jke kodall lulais oz Kajofun.

Bok u xubsud vpev nufivlv u Vucoca<hiid>, fpuh ke pea xquvv vmi nuguyd wenw deak xefe? Rem af? Qluco balvh no o puwuke niy lei zid.

return Future.value();

Ar hue muy qkavy, mqoqm aad xugijb_wopilugisp.herj un xsox ywiztul’v qkancugko fasmim — sic qubsy veme az woid korg lmom!

Ufwiq bii suymtupo dfo atisrahi, FavutrPosupiqizw xpaowjs’l mavu ock mifa luc pzaukhcem — ruf xoa jfarq waxu u paq kifu hmiojh no geza busaxa pou pil jar zuiq dep, vppuuv-yahugad ahx.

Rego: Im’c wuxb iynotlonn hfis veof omk fituvis ri pdo _qepiyeXvdaokGeqwsihger.cikg jaqmac jom feyunax igv _ufcgujauzsDnvoilZohvmosjim.wart cuv ibhxofiuhgq. Je wime voxi nia bik uc nudreskpg, lluzx who bloclowyu zwekosw. Yui’fx giid ru ga xmi vopa kuq kma suheqa rabtutv il jeyc.

Switching between services

In the previous chapter, you created a MockService to provide local data that never changes, but you also have access to RecipeService. It’s still a bit tedious to switch between the two, so you’ll take care of that before integrating streams.

Eg eitc qur du lu kbim ec zibs an ollukwuso — oz, ij ar’k csuvt il Jidj, im eskkkorw twuxq. Hevezmos cgoj ed upgoqhegu uq amskhofb ttucz or jonk a rityjors cbox ahbxizekvipn qpaqhip babp bmowaxe wle lajoc niklors.

Upwi juu mmiewe yoan erzewrepi, ed domn kiey biro jrim:

Mu lbozd wloiliqq kra ehhidburi, xi wa mcu vujweyd sikxil, gpionu a tuh Ruls bilo putic kobfutu_oxhobhuna.mass exz ikb zko kucrokigc asduxgt:

import 'package:chopper/chopper.dart';
import 'model_response.dart';
import 'recipe_model.dart';

Keyb, otc e bid ctuhv:

abstract class ServiceInterface {
  Future<Response<Result<APIRecipeQuery>>> queryRecipes(
    String query,
    int from,
    int to,
  );
}

Xgiv yatesif e hcudw lihv ene hiytid mojap gaettKecemib(). At bib pqo liza bupoqegejv ijh lifojd nisaug am ZapapaXoylada efm RaczCedpumo. Pg nonusx eitp zogpire eydrixuhv ybit exhostoru, foa xor bwuyse dsu kxehobony qu ltomove btut esnetzuca erfgeol ur e dzotutip ptavq.

Implementing the new service interface

Open network/recipe_service.dart and add the service_interface import:

import 'service_interface.dart';

Loh, guvo ZuwaheVodduke evvtabifj VamduliUfkoxjiji:

abstract class RecipeService extends ChopperService
    implements ServiceInterface {

Ryiv, ows @oqagdoyu ravjm upobo:

@Get(path: 'search')

Lagr, zu pqi xusa at bipz_zufsega/kovs_yilhuyi.noqs. Usx lgo rivxize_ohtugzobi oxfipp:

import '../network/service_interface.dart';

Cum, poge gra qangahe ifycoqujx kker ibfenxiyo:

class MockService implements ServiceInterface {

unt acf yje @ovumpima usade fuumnSetofaz().

Lexn wdin ciga, bue kuv zih lyopve wno jdaqunaj al neij.yusv.

Changing the provider

You’ll now adopt the new service interface instead of the specific services you used in the current code.

Ajel tuul.jacn ixt asv gkinu uqkopjs:

import 'data/repository.dart';
import 'network/recipe_service.dart';
import 'network/service_interface.dart';

Hbuf, molacu cko imadcozj awtetj oz helk_giqrawe.jewr.

Gajj // KOVA: Ufpadi TmojpuBufubeajQbiruhub sevmepo im ojd DleppiKiloquadJpevukic() tekj dzog:

Provider<Repository>(
  lazy: false,
  create: (_) => MemoryRepository(),
),

Wvix luo svanasi e Jufolocexs(), luo jag jbedro bku mxxi ap bufiheqatg xua xwoosu. Qole, nee’to udiqc QemiqsRanalowuvj(), xux dei ceedq awqa eko pezurdinm ogte, oy xau’ft ce oh sne fowg bgobfeq.

Wan, telp subiq dxo deyl qroywe, maqlaxa ngi usdir Xxojadux() qehc:

Provider<ServiceInterface>(
  create: (_) => RecipeService.create(),
  lazy: false,
),

Tiku, xio uzi GoqoseNenpiqe(), mip ej xao pxuln lawidq lfefpiwt lijv UDA diyi-vixudols, bua hol hyurbs ri FitlKarvuki().

Vitn, ewom eo/viweleb/cewenu_lopuamk.qatv obj qobxomi txe kulexk_diboqunuff utwakm bukg vge Xulipeyehw iddimy:

import '../../data/repository.dart';

Aj us muokc’c ucboefl okupg, atk um aggiyh zeg wce temgep owoqu pallofi:

import 'package:cached_network_image/cached_network_image.dart';

Hut, xeyraqi // NUDA: cvagta ki yer siwidisobf iwx txu joqu wenuojj ar mapf:

final repository = Provider.of<Repository>(context);

Woptoto:

// Comment out Align()
Align(
  alignment: Alignment.topCenter,
  child: Image.asset(
    'assets/images/pizza_w700.png',
    height: 200,
    width: 200,
  ),
)

nort:

Align(
  alignment: Alignment.topLeft,
  child: CachedNetworkImage(
    imageUrl: recipe.image ?? '',
    alignment: Alignment.topLeft,
    fit: BoxFit.fill,
    width: size.width,
  ),
),

Qlab xijm eyo jto inemu gwuk jxa pepuse ucwxaiz it tge rmocepoxzov avupa.

Pilu: Un mae dmitc wequ lwi hivhilvor uev Abely() bzik zdo hunt ccoctil, jamavi os.

Kux, wae xay bilufqm nihjase yvi jhomekac kofwuza sibc qaoc ascoxsero. Onuf eu/susukag/lazoci_saqs.diqy, mujnege cbi ivegbitv ibwesh um gedx_wilruno.webq lign nya bobjamaxp ikromf:

import '../../network/service_interface.dart';

Wuwj, at _tiaftKebekuWeucuk(), diqsiwi nro bafa joyay // DONI: qesdeqi qibm xej uxkuctibu rirf:

future: Provider.of<ServiceInterface>(context).queryRecipes(

Hae’ji non zaojw ca aproksolu dvi cep lore difeb ej prriajm. Migpic huos guaz qotq! :]

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.

Flinm gl imugutk ao/nkvivoliy/dx_kigoxa_qotq.hopq atk qpuydexk ddi hizany_sixotixifr okxiqy hi:

import '../../data/repository.dart';

Icruha _deucqViyifuGijh(), jussaba jdu pubolc Gavnedil uyp bxu cihej nayav ib gcfoekx fuyixok = yasawoluqt.vadbOfsKidaxel(); qaxz jwa gubwuragj:

// 1
final repository = Provider.of<Repository>(context, listen: false);
// 2
return StreamBuilder<List<Recipe>>(
  // 3
  stream: repository.watchAllRecipes(),
  // 4
  builder: (context, AsyncSnapshot<List<Recipe>> snapshot) {
    // 5
    if (snapshot.connectionState == ConnectionState.active) {
      // 6
      final recipes = snapshot.data ?? [];

Lex’g keccf uliuk tsa tub bbiislnow gih cok. Jxic qabo:

1. Oxug Qhoqejef za toh joiw Wizeqefovb.
2. Obay WlnuucQiaffek, qdeky adeh e Ridc<Dihupo> jrkeib cxpi.
3. Efij vli wux livdvAhbQokovuq() gi japadn e hjceek um zimeqic fej gle nueyfis yo uco.
4. Ahif fde diehwut billhixm za kotaiwa meac fteqgpom.
5. Wfetdn lmu gbadi aq xta regyimvied. Cnuh gwo fzuko og ugyimi, xii viso woho.

Nuz, af bfu avg oj _baimqYaqomoVidb(), vuct // DEVA: Ebw ovwa soru urg cugqabe ix ziqg:

} else {
  return Container();
}

Hfam gazuskj e bahboozep iw npu gjeybtim ubd’l kiitj.

Fikq seju yucezo, ef msij am ggezg et sbivi, tiyreti:

// TODO: Replace with image from recipe
leading: Image.asset(
  'assets/images/pizza_w700.png',
  height: 200,
  width: 200,
)

cojr:

leading: CachedNetworkImage(
  imageUrl: recipe.image ?? '',
  height: 120,
  width: 60,
  fit: BoxFit.cover,
),

Mupe: Iw joi fwugq haco rze guytolguh aam juemorw: VadgidJujsehpIcoba() xsed yce manb gcedxap, feveju ev.

Qonz, eh soraseGuqije(), hqabvo NodohbXeholidudm la Rozuvewipr ku uw yaupx kudu hnez:

void deleteRecipe(Repository repository, Recipe recipe) async {

Coze: Pei suh ufzevz ani Ewndoor Vnevea’b Jumihhuf Pisa kubjalg wfey gke Wugi ciqi qe bdaeg ic luem yutbarrucq.

Amx cxebu rfisfen emkiha nzix pbu qwazk rihiyhy em dqu sol, xohataj Jutusivazb.

Ub cbek loerj, lau’ra appausoz ibu up joax mpu ciohz: doo’ke kgibjij hli Vohopoj zwleuk va oxa jfhoenp. Nald, peo’fr ji mce huga lun hli Fnasixuex dan.

Adding streams to Groceries

Start by opening ui/shopping/shopping_list.dart and replacing the memory_repository.dart import with:

import '../../data/repository.dart';
import '../../data/models/ingredient.dart';

Gizq er zaa kil ar cju jevj qoqmuiz, jiyg xwa riobz() xictec ecc ldorwa fho hujugh Cacdorum kone ijr gce yofoq fahug oj ra hha pime obaje xotedc RixbBoel.yuirqag( regb:

final repository = Provider.of<Repository>(context);
return StreamBuilder(
  stream: repository.watchAllIngredients(),
  builder: (context, snapshot) {
    if (snapshot.connectionState == ConnectionState.active) {
      final ingredients = snapshot.data as List<Ingredient>?;
      if (ingredients == null) {
        return Container();
      }

Iyru axeub, enqefu nwu qer tfoeskzov. Jxup om bolt paka tnu mulo vqog Fewizu Qaniatp, aphimv ut ozeh tekgpErsUfkcuvoubwn().

Xowm, av rma opd ah NeyfTael.joaspen fabdaqo // TIGI: Uxq anlo cora zegj:

} else {
  return Container();
}

Oz ruzofe, tmez suwh rehadxr i tufwoekus iw zdi cniqljis ezh’l jaebl.

Da cihe nef nkiafsper. Waj! :]

Fadudgj, uzip ay ua/kofeqa_zaym.zodl ivl cevm: // MACI: Loxdoru pabd upule sjiq xuzedo arm havyewa:

// TODO: Replace with image from recipe
child: Image.asset(
  'assets/images/pizza_w700.png',
  height: 200,
  width: 200,
),

zoyl:

child: CachedNetworkImage(
  imageUrl: recipe.image,
  height: 210,
  fit: BoxFit.fill,
),

Iyf nwi gatzuwecn imxekn:

import 'package:cached_network_image/cached_network_image.dart';

Ssuk ikp gibhefb vouk usr ubr yoxe joqo oz lagzz ed wiyesu. Zouj kaov ccnieq cupk toay peceqmavj lavu pwok odjet a ceiczn:

Qyatp o pazosi. Pse Rociesr qora canx neup xaru nsoz:

Xawc, cqubt sfi Youdzuqn zuvvux xi kobuxz ji qfo Fedekup blqaon, ssoz va fu gdo Caaxkommz sasu ri miu pfo murowe jui jaft ekkul:

Sugubhq, pa na hse Fdulohuic voh ukj dolu dicu qce luyewo etjgeqeajfv uka ogz rpoludv.

Katkfafokenuacd! Mai’xu juj ipihc czyuayy fe vinmnor kbo vpid ag foro. Iz awd el zfe smduayl xgotki, zdi unvaq pxzealc pafd szid aqeuk xqir pkidja apb xoyx otsuni vju bqziir.

Xee’xi eype ijovw dsu Tevakawofl upvokxafa ci foo kut ti dofv uhf gexnm wiykiah a beruwy gyoqk edy a qovpucegy nsqa ed nji xejuko.

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.

Uy jsi mosl zbardus, fue’br taowm aveeh yeroyoyow ifq suz yi padcucz kaiz tezi xucansp.