Kung papasok ka sa mundo ng Reaktibong programming gamit ang KotlinMalamang napansin mo na hindi lahat ng daloy ng trabaho ay pare-pareho ang kilos. Para sa mga hindi gaanong pamilyar, ang tinutukoy natin ay kung ang daloy ng trabaho ay "static," naghihintay na may tumawag dito, o "dynamic," na patuloy na nagbo-bomba ng data kahit walang nakatingin dito. Ang epektibong pamamahala nito ang siyang pagkakaiba sa pagitan ng isang napakabilis na app at ng isang app na kumukunsumo ng memorya ng device.
Sa artikulong ito, lubusan naming ipapaliwanag kung paano lumipat mula sa default na malamig na daloy patungo sa mainit na daloy gamit ang stateIn at sharedInHindi lang tayo mananatili sa teorya; titingnan natin kung paano ito ipatupad sa ViewModel at, higit sa lahat, kung paano maiiwasan ang mga unit test na maging isang bangungot kapag ang data ay hindi nailalabas gaya ng inaasahan.
Pag-unawa sa pagkakaiba sa pagitan ng malamig at mainit na daloy
Para makapagsimula nang maayos, kailangan mong maunawaan na ang Cold Flow ay parang isang kanta sa Spotify na nagsisimula sa ikalawang sero tuwing pipindutin mo ang play; ibig sabihin, bawat kolektor ay tumatanggap ng sarili nitong pagkakasunod-sunod Nangangasiwa sila ng datos nang nakapag-iisa. Mainam ang mga ito para sa mga gawaing nangangailangan ng maraming mapagkukunan na kailangan lamang isagawa kapag may nakikinig, tulad ng isang query sa database.
Sa kabilang banda, ang Hot Flows ay mas parang isang istasyon ng radyo: tumutugtog ang musika kahit naka-on ang radyo o wala. Dito, Maraming subscriber ang nagbabahagi ng iisang stream ng datos. Mahalaga ang mga ito kapag kailangan mong pamahalaan ang estado ng user interface o mag-trigger ng mga kaganapan na kailangang umabot sa ilang bahagi ng application nang sabay-sabay.
StateFlow: Ang Tagapangalaga ng Estado
Ang StateFlow ay isang uri ng hot flow na dalubhasa sa pagpapanatili ng isang partikular na estado. Ang pangunahing katangian nito ay palaging pinapanatili ang pinakabagong halagaDahil dito, isa itong perpektong tool para palitan ang lumang LiveData sa Android. Para gumana ito, kailangan nito ng initial value sa constructor nito, para matiyak na laging may maipapakita ang UI.
Kapag gumagamit ng ViewModel, karaniwan naming ginagamit ang isang pribadong MutableStateFlow upang baguhin ang halaga sa loob at ilantad ang isang pampublikong StateFlow upang mabasa lamang ito ng view. Mahalagang tandaan na Pinagsasama ng StateFlow ang mga emisyonKung masyadong mabilis na magbago ang mga halaga, maaaring laktawan ng kolektor ang ilang mga intermediate na estado at matanggap lamang ang pinakabago, na mahusay para sa user interface.
SharedFlow: Pandaigdigang Tagapagbalita ng Kaganapan
Hindi tulad ng nauna, ang SharedFlow ay hindi nag-iimbak ng kasalukuyang estado bilang default, ngunit ginagamit upang mga kaganapan sa pag-broadcast sa maraming subscriberIsipin mong kailangan mong ipaalam sa buong app na nag-log out na ang isang user; ang SharedFlow ang mainam na opsyon dahil pinapayagan ka nitong i-configure ang muling paglalarona tumutukoy kung gaano karaming mga lumang halaga ang ipinapadala sa mga bagong subscriber.
Bukod pa rito, nag-aalok ito ng komprehensibong kontrol sa back pressure sa pamamagitan ng parameter onBufferOverflowMaaari kang magdesisyon kung dapat bang suspindihin ang nagpadala kapag puno na ang buffer, o kung mas gusto mong itapon ang pinakaluma o pinakabagong item upang maiwasan ang pagharang sa pagpapatupad ng programa.
Pagbabago ng mga malamig na daloy gamit ang stateIn at sharedIn
Minsan, mayroon tayong cold flow na napakamahal panatilihin (tulad ng permanenteng koneksyon sa network) at ayaw nating magbukas ng bagong koneksyon ang bawat subscriber. Dito pumapasok ang operator. estadoSa loobna nagko-convert ng malamig na daloy tungo sa isang nakabahaging mainit na StateFlow. Ang operator na ito ay nangangailangan ng CoroutineScope at isang estratehiya sa pagsisimula.
Ang pagsasaayos ng Nagsimula na ang Pagbabahagi ay susi: Lazily Nagsisimula ang koleksyon sa unang subscriber at hindi natatapos, habang WhileSubscribed Ito ang pinakamatalinong opsyon para sa Android, dahil humihinto sa paggawa ng datos kapag walang nakikinig (halimbawa, kapag nasa background ang app), nakakatipid ng baterya at memorya.
Kung kailangan mo ng SharedFlow sa halip na StateFlow, ang operator na gagamitin ay ibahagi saGumagana ito nang katulad ngunit mas flexible, na nagbibigay-daan sa iyong tukuyin nang eksakto kung gaano karaming elemento ang dapat i-relay sa mga bagong miyembro ng daloy gamit ang parameter na muling paglalaro.
Mga Istratehiya sa Pagsubok para sa mga Mainit na Daloy
Mahirap subukan ang mga daloy na ito. Kapag ang paksa ng pagsubok ang tagamasid ng daloy, pinakamahusay na lumikha mga pekeng implementasyon mula sa mga repositoryo na naglalabas ng mga kontroladong halaga. Kung ilantad ng module ang daloy, maaari nating gamitin ang mga function tulad ng first() upang patunayan ang unang isyu o toList() para sa mga may hangganang daloy.
Isang karaniwang problema sa stateIn Ibig sabihin, kung gagamitin natin WhileSubscribedMaaaring mabigo ang pagsubok dahil hindi na-activate ang daloy kung walang kolektor. Para maayos ito, kailangan nating maglunsad ng isang walang laman na kolektor sa backgroundScope ng pagsubok, tinitiyak na ang operator ay naka-activate at ina-update ang mga halaga. Upang gawing simple ang proseso, inirerekomenda ang paggamit ng library. Turbina, na nagbibigay-daan sa pag-validate ng mga emisyon nang sunud-sunod at sa mas natural na paraan.
- Para sa StateFlows, ang rekomendasyon ay direktang i-validate ang property halaga sa halip na kolektahin ang daloy, sa gayon ay maiiwasan ang mga problema sa pagsasama-sama ng mabibilis na halaga.
- Mahalagang gamitin ito Hindi Nakakulong na TestDispatcher upang matiyak na handa na ang collection coroutine bago ibigay ang datos sa pagsusulit.
Ang pag-master sa transisyon sa pagitan ng malamig at mainit na daloy sa pamamagitan ng tamang aplikasyon ng stateIn at sharedIn ay nagbibigay-daan sa iyong bumuo ng mas matatag na arkitektura sa Android, na nag-o-optimize sa pagkonsumo ng mapagkukunan at tinitiyak na ang pag-synchronize ng data sa pagitan ng business logic at user interface ay walang kamali-mali at madaling subukan. Ibahagi ang impormasyong ito upang mas maraming tao ang matuto tungkol sa paksa.