Kapag nagsimula tayong mag-develop gamit ang Jetpack Compose, madaling maakit sa mahika ng mga declarative interface. Gayunpaman, kung hindi tayo mag-iingat, maaari tayong magkaroon ng application na parang mabagal o nakakaranas ng nakakainis na pagkautal. Ang susi sa maayos na pagtakbo ng lahat ay nakasalalay sa pagkadalubhasa sa... recomposition, ang prosesong iyon kung saan nagpapasya ang Compose kung aling mga bahagi ng screen ang dapat i-update kapag nagbago ang data.
Ang pag-optimize ng performance ay hindi usapin ng intuwisyon o bulag na pagbabago ng code, kundi ng paglalapat ng siyentipikong diskartePara makamit ang isang tunay na maayos na karanasan ng gumagamit, kailangan nating maunawaan na hindi lahat ng code ay isinasagawa sa parehong paraan at may mga partikular na trick upang maiwasan ang labis na pagtatrabaho ng processor sa mga gawaing hindi nagbibigay ng agarang visual na halaga.
Ang lifecycle ng pag-render sa Compose
Para maiwasan ang pagkapa sa dilim, kailangan mo munang maunawaan kung paano iginuguhit ng Compose ang interface. Nangyayari ang lahat sa tatlong yugto: una ang yugto ng komposisyonkung saan mo tinutukoy kung aling mga elemento ang ipapakita at lilikhain ang node tree. Pagkatapos ay darating ang yugto ng disenyo (layout)na siyang responsable sa pagsukat ng mga bahagi at pagsasabi sa kanila nang eksakto kung saan ilalagay ang mga ito sa screen. Sa wakas, nakarating tayo sa yugto ng pag-render, na siyang panahon kung kailan pisikal na iginuguhit ang mga pixel.
Ang problema ay ang komposisyon ang pinakamahal na yugto. Kung magbabago ang isang estado at magiging sanhi ng muling pagbuo ng buong puno, magiging mabagal ang app. Ang sikreto ng mga propesyonal ay ihiwalay ang estado upang tanging ang mga bahaging mahigpit na nangangailangan ng bagong halaga ang muling itayo, na pumipigil sa sunod-sunod na mga update na makarating sa mga bahagi ng UI na hindi nagbago.
Mga estratehiya upang mabawasan ang workload ng processor
Isa sa mga pinakakaraniwang problema ay ang pagsasagawa ng mabibigat na kalkulasyon nang direkta sa loob ng katawan ng isang composable. Dahil ang mga function na ito ay maaaring isagawa nang hindi mabilang na beses (kahit sa bawat frame ng isang animation!), dapat nating gamitin ang tandaan para i-cache ang mga resulta. Kung mayroon kang listahan na kailangang ayusin, huwag itong gawin sa loob ng LazyColumn; gawin ito sa labas at iimbak ito sa memorya upang muling kalkulahin lamang ito kapag ang pinagmulang datos ay aktwal na nagbago.
Kapag nagtatrabaho sa mga listahan, mahalagang magtalaga ng matatag na mga susi sa mga elemento. Kung wala ang mga ito, kung ang isang item ay lumipat ng posisyon, maaaring isipin ng Compose na ang lahat ng mga sumusunod na elemento ay nagbago at muling binubuo ang lahat ng mga ito. Gamit ang isang natatanging key, nauunawaan ng system na ang elemento ay lumipat lamang, pagtitipid ng oras ng pagpapatupad nang malaki, na nag-o-optimize ng Paggawa ng mga mahusay na listahan gamit ang LazyColumn.
Ang kapangyarihan ng derivedStateOf at deferred reading
Minsan, ang isang estado ay mabilis na nagbabago kaya't nagti-trigger ito ng mga walang kabuluhang recomposition. Ang isang tipikal na halimbawa ay ang pag-scroll ng isang listahan. Kung gusto nating ipakita ang isang button na "bumalik sa itaas" kapag ang gumagamit ay nag-scroll pababa nang kaunti, hindi tayo interesado na malaman ang bawat pixel na gumagalaw, kundi kung ang index ng unang nakikitang item ay mas malaki sa zero. Dito natin makikita... hinango na EstadoNg Ito ay tumutulong, nagsisilbing filter na nag-aalerto lamang sa Compose kapag nagbago ang resulta ng kundisyon, na lubhang binabawasan ang dalas ng mga pag-update.
Ang isa pang advanced na pamamaraan ay ipagpaliban ang mga pagbasa ng estadoSa halip na direktang magpasa ng isang halaga, maaari tayong magpasa ng isang lambda signal. Sa ganitong paraan, ang pagbabasa ng halaga ay hindi nangyayari sa panahon ng yugto ng komposisyon, kundi ipinagpapaliban. Kung gagamitin natin mga modifier na nakabatay sa lambda (bilang offset { ... } sa halip ng offset(dp)), maaari nating laktawan ang yugto ng komposisyon at disenyo, at dumiretso sa pagguhit, na isang tunay na tulong para sa pagganap at kinis ng baterya.
Katatagan ng data at default na mode
Napakatalino ng Compose at kayang laktawan ang recomposition kung alam nitong stable ang mga input parameter. Ang isang uri ay matatag Kung ito ay immutable, o kung magagarantiyahan ng compiler na kung ang value ay hindi nagbago, hindi na kailangang i-update ang UI. Kung gagamit ka ng mga klase mula sa mga external library o mga uri na itinuturing ng Compose na unstable, ang function ay palaging magre-recompose, kahit na pareho ang data.
Para malutas ito, maaari nating gamitin ang anotasyon @Mabago o @Katatagan sa ating mga klase ng datos. Kung ang code ay nasa isang panlabas na module na hindi ginagamit ng Compose compiler, maaari tayong gumamit ng file ng pagsasaayos ng katatagan para mano-manong markahan ang mga paketeng iyon bilang matatag. Bukod pa rito, paganahin ang malakas na paglaktaw na mode Sa configuration ng Gradle, pinapayagan nito ang Compose na gumamit ng instance equality para laktawan ang mga function kahit na may mga unstable parameter, na nag-o-optimize sa app nang hindi halos naaapektuhan ang code.
Pagsusuri at pagsusuri gamit ang mga totoong kagamitan
Hindi natin ma-optimize ang hindi natin masusukat. Inspektor ng Layout Ang pangunahing kagamitan ng Android Studio para sa pagtukoy ng mga "hot spot" sa pamamagitan ng pagbibilang ng mga recomposition ay [pangalan ng kagamitan]. Kung makakita ka ng numerong patuloy na tumataas habang nagsasagawa ng isang simpleng aksyon, mayroon kang problema. Para sa mas malalim na pagsusuri, gamitin ang [pangalan ng kagamitan]. Macrobenchmark at ang mga log ng Perfetto ay nagbibigay-daan sa iyo na makita nang eksakto kung gaano karaming oras ang kinokonsumo ng bawat function sa pangunahing thread.
Mahalagang maiwasan ang pangunahing sinulid Naghihinto ito sa mabibigat na gawain. Naglo-load ng malalaking imahe gamit ang painterResource Ang pagrehistro ng mga system receiver ay maaaring magdulot ng mga maliliit na pagkawala ng kuryente. Ang solusyon ay ilipat ang mga operasyong ito sa mga coroutine kasama ang Dispatchers.IO at, kung maaari, iangat ang estado sa pamamagitan ng KomposisyonLokal upang ang impormasyon ay magagamit sa buong puno nang hindi kinakailangang manu-manong ipasa ito sa bawat parameter, sa gayon ay nililinis ang arkitektura ng interface.
Ang pagkakaroon ng fluid application ay nangangailangan ng balanse sa pagitan ng paggamit ng remember, ang tamang pamamahala ng class stability, at ang kakayahang ipagpaliban ang mga reading states gamit ang lambdas upang samantalahin ang mga phase ng disenyo at pagguhit, na laging umaasa sa mga measurement tool upang mapatunayan na ang bawat pagbabago ay talagang nakakabawas ng load sa sistema. Ibahagi ang gabay na ito at tulungan ang ibang mga gumagamit na manatiling may kaalaman tungkol sa paksang ito.