- Tinatanggal ng R8 ang code at mga resource na hindi ginagamit ng sinuman, isinusulat muli ang natitira, at pinapaikli ang mga pangalan upang lumikha ng mas maliliit na app na may mas mabilis na oras ng pagsisimula at mas kaunting mga isyu sa kawalan ng kakayahang tumugon.
- Maipapayo na paganahin ang pag-optimize sa release build at ayusin ang mga panuntunan sa konserbasyon, na siyang pangunahing balakid na pumipigil sa R8 na gumana nang buong kapasidad.
- Sinusukat ng Configuration Analyzer ng R8 kung gaano karaming code ang magagamit upang paliitin, i-optimize, at palabnawin, at minamarkahan ang malawak, doble, o walang silbi na mga panuntunan.
- Ang pagkumpleto ng gawain gamit ang mga App Bundle, magaan na larawan, pagsasaayos ng wika at densidad, at pare-parehong pagsukat ng laki ay malaki ang naitutulong sa bilis ng pag-download.
Ang pag-compress ng isang Android app ay hindi lamang tungkol sa pagbura ng mga indibidwal na file; ito ay isang maselang pagbabalanse sa pagitan ng laki, bilis ng pagsisimula, at paggamit ng memorya. Ang built-in na optimizer ng Android, ang R8, ang humahawak sa halos lahat ng gawaing ito nang hindi mo na kailangang magsulat ng kahit isang linya ng code : sinusuri nito kung aling code at mga mapagkukunan ang aktwal na ginagamit, inaalis ang hindi ginagamit ng sinuman, at muling isinusulat ang natitira upang tumakbo nang may mas kaunting overhead. Ang napapansin ng mga gumagamit ng iyong app ay ang mas mabilis na oras ng pagsisimula, mas kaunting paggamit ng memorya, mas maayos na interface, at mas kaunting mga mensahe ng pag-crash.
Ang susi ay bigyan ito ng espasyo para gumana. Mas malaki ang bahagi ng iyong codebase na maaaring hawakan ng R8, mas maganda ang mga resulta. Ang masyadong malawak na mga panuntunan sa konserbasyon ang pinakakaraniwang balakid , dahil nilo-lock nito ang mga klase at pamamaraan na maaaring hindi tinatawag nang pabago-bago, kasama ang kanilang mga dependency. Ang pagpino ng mga panuntunang ito, pagsukat, at muling pagsubok ay ang loop na naghihiwalay sa isang simpleng inilabas na app mula sa isang tunay na pinong app.
Ano nga ba ang eksaktong ginagawa ng R8 at bakit mo ito dapat pagkatiwalaan?
Gumagana ang R8 sa isang serye ng magkakaugnay na mga yugto. Una, sinusuri nito ang iyong aktwal na mga entry point, tulad ng mga aktibidad o serbisyong idineklara sa manifest, bumubuo ng mapa ng lahat ng na-reference, at itinatapon ang anumang nasa labas ng mapa na iyon . Pagkatapos, lilipat ito sa mga lohikal na pag-optimize: pinapalitan ang mga tawag gamit ang katawan ng tinawag na method, pagsasama ng mga klase at interface, pagpapasimple ng mga istruktura, at pagbabawas ng overhead sa pagpapatupad. Panghuli, pinapaikli nito ang mga pangalan ng mga klase, field, at method, kaya ang isang bagay tulad ng com.example.MyActivity ay maaaring tawaging aba, na nagreresulta sa mga matitipid sa metadata.
- Mas kaunting patay na codeAng mga dependency na ginagamit mo lamang sa isang maliit na porsyento ay humihinto sa pagdadala ng lahat ng kanilang bigat.
- Mas mahusay na pagpapatupad: Ang pagsingit ng mga method at pagsasama ng mga klase ay nakakabawas ng mga tawag at pressure sa memorya.
- Mas magaan na mga DEX fileNakakatipid ng metadata ang obfuscation at nakakapagpabilis ng paglo-load ng klase.
- Mga naayos na mapagkukunanSimula noong bersyon 8.12 ng Gradle plugin, nakikilahok na rin ang R8 sa resource optimization.
Mula sa pananaw ng gumagamit, nangangahulugan ito ng mas mabilis na oras ng pagsisimula, nabawasang pagkonsumo ng memorya, pinahusay na rendering, at mas kaunting mga isyu sa hindi pagtugon na app. Malinaw ang opisyal na rekomendasyon: paganahin ang pag-optimize sa release build . Para sa pang-araw-araw na pagsubok o pagbuo ng library, kadalasan ay hindi ito sulit, dahil tumataas ang oras ng compilation at nagiging mas kumplikado ang pag-debug kapag nagbago ang mga pangalan.
Paganahin ang pag-optimize batay sa bersyon ng plugin ng Gradle
Kung gumagamit ka ng mga bagong bersyon ng Android plugin para sa Gradle, mas pinadali ang mga bagay-bagay. I-enable lang ang isang flag sa loob ng optimization block ng release build type at ilagay ang iyong keep rules sa isang partikular na source code set, na may mga file na nagtatapos sa .keep, halimbawa, sa loob ng src/main/keepRules. Saklaw ng bagong pamamaraang ito ang parehong code at mga resource at kasama ang mga default na platform rules na katumbas ng mga dating ProGuard rules na may optimization, kaya hindi na kailangang magdeklara ng mga karagdagang file.
Sa mga proyektong nakaangkla sa mga nakaraang bersyon ng plugin, ang karaniwang pamamaraan ay nagsasangkot ng dalawang parameter sa uri ng release build: isa na nagbibigay-daan sa pagpapaliit ng code at isa pa na nagbibigay-daan sa pagbabawas ng resource. Ang makatwirang pamamaraan ay ang paganahin ang pareho nang sabay-sabay at idagdag ang na-optimize na rules file na nabuo mismo ng system, kasama ang iyong sariling rules file kung kinakailangan. Ang paghahalo ng mga release build nang walang mga switch na ito ay isa sa mga pinaka-banayad na paraan upang magbigay ng mga megabyte sa iyong mga user.
Buong mode at na-optimize na pagbabawas ng mapagkukunan
Ang full mode ng R8 ay aktibo bilang default sa loob ng maraming taon at naglalapat ng mas agresibong mga pagpapalagay tungkol sa paggamit ng reflection at dynamic calls. Kung may sumulat na ng property na nagdi-disable nito, pinakamahusay na burahin ito : ang pag-off nito ay nakakabawas sa potensyal ng optimizer. Gayunpaman, ang full mode ay maaaring mangailangan ng mga karagdagang panuntunan sa mga proyektong may maraming dynamic code, kaya palaging subukan ito gamit ang isang totoong release build at hindi lamang sa mga unit test.
Dumating ang na-optimize na resource shrinkment kasama ang bersyon 8.12 ng plugin, at simula noong bersyon 9.0, awtomatiko itong inilalapat kapag pinagana ang resource shrinkment. Ang ideya ay ituring ang mga resource bilang bahagi ng code graph : dati, ang packaging tool ay bumuo ng mga panuntunan sa pangangalaga na nagpapanatiling buhay sa mga hindi maa-access na resource at code na tumutukoy sa isa't isa; ngayon, kung hindi ginagamit ang isang koleksyon ng code at resources, hindi ito protektado at nawawala. Sa mga app na may maraming pagkakaiba-iba ng form factor, nasukat ang mga pagbawas ng laki na mahigit limampung porsyento.
Ang R8 Configuration Analyzer at ang tatlong marka nito
Ang analyzer na ito ang tool na magsasabi sa iyo kung ang iyong configuration ay nakakatulong o nakakasagabal. Bumubuo ito ng mga istatistika kung ilang porsyento ng iyong codebase ang aktwal na sumasailalim sa pagbawas, pag-optimize, at pagpapalabo . Kung ang reduction score ay 66 porsyento, nangangahulugan ito na maaaring mag-alis ang R8 ng code mula sa dalawang-katlo ng iyong codebase; kung pareho ang optimization score, maaari lamang nitong ilapat ang method insertion, class merging, at iba pang mga pamamaraan sa dalawang-katlo. Sinusukat ng obfuscation score kung gaano karaming code ang maaaring paikliin upang mai-save ang metadata.
Bukod sa pangkalahatang mga sukatan, idinedetalye rin ng ulat ang epekto ng bawat panuntunan sa konserbasyon at ang mga katangian ng pag-optimize na hinaharangan nito. Kinikilala rin nito ang mga panuntunang nagmumula sa mga third-party library , na lubhang kapaki-pakinabang dahil ang mga may-akda ng mga library na ito ay hindi pamilyar sa iyong partikular na pagpapatupad at kung minsan ay nagsusulat ng mga panuntunan nang napakalawak na kaya't napaparalisa nila ang pag-optimize sa mga bahagi ng iyong app na ganap na walang kaugnayan sa functionality nito.
Paano gumawa ng ulat nang hindi nagsasayang ng oras
Para mabilis na makapag-ulit sa iyong mga panuntunan, mayroong isang partikular na gawain sa Gradle na sumusuri sa configuration ng release nang hindi isinasama ang APK o bundle. Mas maikli ang feedback loop , at ang ulat ng HTML ay lumalabas sa folder ng mga ulat ng module, sa loob ng isang direktoryo na nakatuon sa R8. Ito ang inirerekomendang opsyon kapag inaayos mo ang mga panuntunan at gusto mong makita ang agarang epekto ng bawat pagbabago.
Kung mas gusto mo ang awtomatikong pagsusuri, ang anumang release build ay bubuo rin ng HTML file sa loob ng mga resulta ng pagmamapa. Maaari mong i-disable ang awtomatikong pagbuong ito gamit ang kaukulang experimental property kung sa tingin mo ay nakakaabala ito. Sa mga mas lumang bersyon ng plugin, ang solusyon ay ang pagdaragdag ng isang kamakailang bersyon ng R8 sa classpath ng proyekto at patakbuhin ang build gamit ang isang system property na tumutukoy sa direktoryo kung saan dapat i-save ang ulat.
Pinuhin ang mga patakaran sa konserbasyon nang hindi nilalabag ang app
Ang layunin ay pangalagaan lamang ang tunay na maa-access sa pamamagitan ng repleksyon, wala nang iba pa, wala nang iba pa. Magsimula sa pamamagitan ng pagsusuri sa mga panuntunang humaharang sa pag-optimize sa napakaraming klase , pagsusuri sa mga elementong pinoprotektahan ng mga ito, at pag-verify kung ang mga ito ay talagang ginagamit nang pabago-bago. Pagkatapos ay paliitin ang saklaw: sa halip na pangalagaan ang isang buong pakete kasama ang lahat ng miyembro nito, limitahan ang panuntunan sa mga partikular na klase at miyembro. At bago ipatupad ang pagbabago, magpatakbo ng mga pagsubok na sumasaklaw sa mga apektadong klase, larangan, at pamamaraan.
Mag-ingat din sa mga subsumed rule. Kung ang isang rule ay nagpoprotekta sa isang buong package at ang isa naman ay nagpoprotekta sa isang klase sa loob ng package na iyon, ang pangalawa ay walang maidudulot na kahit ano, at ang una ay humaharang sa mga optimization na maaaring hindi mo kailangan. Magpasya kung alin sa dalawa ang tumpak: kung ang makitid ay mahusay ang pagkakasulat, alisin ang malawak at i-unlock ang natitirang bahagi ng package; kung ang malawak ay tama, alisin pa rin ito ngunit isulat muli ito upang ang mahalaga lamang ang maapektuhan nito. Pagkatapos ay patakbuhin muli ang analyzer at i-compile ang isang buong release upang mapatunayan na gumagana pa rin ang lahat.
Mga duplikado, hindi nagamit, at mga panuntunan sa library
Tinutukoy ng analyzer ang dalawang malinaw na pinagmumulan ng kalat: mga panuntunang hindi tumutugma sa anumang klase, pamamaraan, o field sa kasalukuyang build, at magkaparehong mga panuntunang inuulit sa parehong file o sa iba't ibang mga file. Ang mga nauna ay kadalasang naiiwan bilang basura pagkatapos ng refactoring o pag-alis ng dependency ; ang huli ay nagpapakomplikado sa pagpapanatili nang walang anumang dagdag na benepisyo. Ang paglilinis sa mga ito ay ginagawang mas madaling basahin at i-debug ang configuration.
Sa mga third-party library, kakaunti ang espasyo para sa maniobra dahil ang kanilang mga patakaran ay naka-package at hindi mo maaaring piliing i-edit ang mga ito. Ang praktikal na pamamaraan ay idokumento ang epekto sa isang ulat at abisuhan ang maintainer , o pansamantalang kopyahin ang mga patakarang iyon sa iyong proyekto, hindi kasama ang mas malawak na mga patakaran at sukatin ang potensyal na pakinabang bago magpasya kung sulit bang sumugal.
ProGuard at R8: magkatulad, ngunit hindi magkapareho
Sa loob ng maraming taon, apat na bagay ang ginawa ng ProGuard: inalis nito ang mga hindi nagamit na elemento, in-optimize ang bytecode, nilagyan ng obfuscate na mga pangalan, at nagdagdag ng impormasyon tungkol sa pre-checking. Nagpapatuloy ang R8 kung saan ito tumigil at mas nagpapatuloy: mas agresibo nitong inilalagay ang mga method, pinagsasama ang mga klase, kino-convert ang mga enumerasyon sa mga integer kung maaari, at mas nauunawaan ang mga feature ng Kotlin . Mas mabilis din itong nagko-compile at, dahil sa de-sweetening ng core library, pinapayagan nito ang paggamit ng mga modernong Java API sa mga mas lumang bersyon ng Android.
Tungkol sa mga patakaran, tinatanggap ng R8 ang mga patakaran ng ProGuard at nagdaragdag ng ilan sa sarili nitong mga modifier, tulad ng mga pumipilit o pumipigil sa pagpasok ng isang partikular na pamamaraan. Hindi binabago ng conversion ng pangalan ang pag-uugali, ngunit pinapakomplikado nito ang pagbabasa ng mga stack trace : palagi nitong pinapanatili ang mapping file para sa bawat release upang mabawi ang orihinal na trace kapag naganap ang isang pagkabigo sa produksyon.
Karaniwang mga pagkakamali kapag nagpapaliit at kung paano makawala sa siksikan
Patuloy na lumalabas ang parehong mga problema: "hindi natagpuan ang klase" dahil sa isang tinanggal na klase, "walang ganoong pamamaraan" dahil sa isang pinalitan ng pangalan na pamamaraan, mga modelong hindi naka-serialize dahil nawala ang kanilang mga pangalan, o mga library na nag-aakalang walang magbabago. Ang diagnosis ay halos palaging kinabibilangan ng pagsuri kung ano ang ina-access sa pamamagitan ng reflection at pagdaragdag ng minimum na kinakailangang panuntunan . Upang siyasatin, paganahin ang paggamit, seed, at mapping printing sa isang pansamantalang file, o pansamantalang i-disable ang mga partikular na pag-optimize upang ihiwalay ang salarin.
Mahalaga ring tandaan na ang mga panlabas na tool na nagre-regenerate o nag-patch ng mga DEX file ay maaaring makasira sa mga optimization na maingat na ipinatupad ng R8. Kung ang iyong build chain ay may kasamang ganitong hakbang, suriin ito bago sisihin ang optimizer . At kung ang performance ng build ay isang alalahanin, may mga tweak na magagamit upang iakma ang R8 sa iyong kapaligiran nang hindi isinasakripisyo ang mga benepisyo nito.
Bawasan ang mga mapagkukunan: mga imahe, densidad, at mga wika
Karaniwang bumubuo ng malaking bahagi ng package ang mga resources. Binabawasan ng pag-convert ng mga bitmap sa WebP ang laki ng file habang pinapanatili ang kalidad , at pinipigilan ng mga vector drawable ang pagdoble ng parehong icon para sa bawat density. Ang pag-configure lamang ng mga density bucket na aktwal mong ginagamit at paglimita sa mga kasama na wika ay lubos na nakakabawas sa laki ng file, lalo na sa mga app na maraming pagsasalin. Para sa mga PNG na hindi mo ma-convert, may mga compression utility na may kaunting pagkawala.
Nakakatulong din ito sa programming na kulayan ang isang resource sa grayscale sa halip na pagsama-samahin ang maraming kulay na bersyon, pag-load ng malalaki at hindi kinakailangang mga imahe on demand sa startup, at pag-alis ng mga naulilang resource gamit ang code inspection ng IDE. Kung ang isang resource ay tinutukoy lamang mula sa dead code, tinutukoy at inaalis ito ng optimized reduction , isang bagay na hindi nangyari noon dahil ang dalawang proseso ay tumakbo nang magkahiwalay.
Mga layout, estilo, at hierarchy ng view
Ang pagpapatag ng mga hierarchy ay hindi nakakabawas sa laki ng APK, ngunit pinapabuti nito ang performance, na siyang kalahati ng layunin. Palitan ang hindi kinakailangang container nesting ng isang mahusay na dinisenyong ConstraintLayout , kunin ang mga karaniwang component gamit ang include, at tukuyin ang mga style upang maiwasan ang mga duplicate na attribute. Tinutulungan ka ng layout inspector na matukoy ang mga hindi kapani-paniwalang deep view tree na nagpapabagal sa inflation.
Mga App Bundle, dynamic module, at native library
Ang pag-publish sa bundle format ay isang game-changer: ang store ay bumubuo ng mga package na iniayon sa bawat device, kaya ang bawat user ay nagda-download lamang ng code at mga resource na kailangan nila. Ang mga download ay mas mababa nang malaki kaysa sa isang universal APK dahil sinasala nito ang mga wika, densidad ng device, at mga arkitektura na hindi naaangkop. Bukod pa rito, ang mga feature ay maaaring ipamahagi sa mga feature module na dina-download on demand, batay sa conditional o instant criteria.
Tungkol sa mga native library, ang pagsasama lamang ng mga arkitekturang sinusuportahan mo at pagpapanatiling naka-enable ang compression ay pumipigil sa iyo na magsama ng mga binary na hindi patatakbuhin ninuman. Kung magko-compile ka gamit ang Bazel sa halip na Gradle, maaari mo ring i-integrate ang R8 sa pipeline, bagama't mahalagang tandaan na ang suportang ito ay hindi opisyal na sinusuportahan para sa pagbuo ng Android app.
Sukatin ang laki at subaybayan ang ebolusyon
Kung walang pagsukat, walang pag-optimize. Ipinapakita sa iyo ng APK analyzer ng IDE ang tunay na laki ng package, at maaaring iulat ng isang custom na Gradle task ang laki pagkatapos ng bawat build. Ang pagdaragdag ng pagsusuring ito sa patuloy na integrasyon ay nag-a-automate ng pagkontrol sa laki at pinipigilan ang ilang bagong dependency na lumaki ang binary nang hindi napapansin ng sinuman.
Paano nagbago ang gawi sa pagitan ng mga bersyon?
Sulit na suriin ang kamakailang ebolusyon dahil ipinapaliwanag nito ang maraming legacy configuration na hindi na mahalaga. Pinagana ng Bersyon 8.0 ang full mode bilang default ; pinahusay ng 8.6 ang retracing, kabilang ang file at line retracing para sa anumang minSdk; ipinakilala ng 8.12 ang na-optimize na resource reduction at automatic retracing sa Logcat; pinagana ito ng 9.0 bilang default, sinala ang mga global option sa mga consumer rule, at na-optimize ang Kotlin null checking; ni-repackage ng 9.1 ang mga klase bilang default; at ipinakilala ng 9.3 ang simplified optimization block at ang .keep rule set.
Kung isasaalang-alang ang lahat ng ito, ang tunay na nakakagawa ng pagkakaiba ay isang simpleng gawain: pagpapagana ng pag-optimize sa paglabas, pana-panahong pagsusuri sa ulat ng analyzer, pagbabawas ng mga hindi kinakailangang panuntunan, paglilinis ng mga mapagkukunan at mga imahe, pamamahagi gamit ang mga bundle, at pagsukat ng laki sa bawat paglabas. Ito ay maliliit na hakbang na, kung pagsasama-samahin, ay magbabago sa isang mabigat at mabagal na app tungo sa isa na mabilis na nada-download at agad na inilulunsad . At dahil patuloy na lumalaki ang code at mga dependency, dapat na tuloy-tuloy ang pagsusuri: ang mga pino-tune ngayon ay nagiging wala sa tono sa sandaling maidagdag ang isang bagong library o maisama ang isang feature na may sarili nitong mga mapagkukunan.
Mga madalas itanong
Ano nga ba ang eksaktong ginagawa ng R8 sa application code ko?
Sinusuri nito ang mga idineklarang entry point, bumubuo ng reference map, at inaalis ang anumang hindi maabot mula sa mga ito. Pagkatapos, muling isinusulat nito ang natitirang code upang tumakbo nang may mas kaunting overhead at pinapaikli ang mga pangalan ng class, field, at method upang makatipid ng espasyo.
Paano ko paganahin ang R8 optimization sa mga pinakabagong bersyon ng Gradle plugin?
Ito ay ina-activate gamit ang isang flag sa loob ng optimization block ng release build type, na sumasaklaw sa parehong code at mga resources. Ang sarili mong mga rules ay nasa isang partikular na source code set, sa mga file na may .keep extension.
Ano ang pagkakaiba sa pagitan ng pagbabawas ng code at pagbabawas ng mga mapagkukunan?
Tinatanggal ng pagbabawas ng code ang mga hindi maabot na klase, field, at method, habang tinatanggal naman ng pagbabawas ng resource ang mga hindi nagamit na imahe, layout, at iba pang mga file. Sa mga modernong bersyon, ang parehong gawain ay isinama sa isang reference graph, na pumipigil sa pagpapanatili ng mga naka-link na resource mula lamang sa hindi na ginagamit na code.
Para saan ginagamit ang R8 Configuration Analyzer?
Sukatin ang porsyento ng iyong codebase na nananatiling available para sa pagpapaliit, pag-optimize, at pagpapalabo, at hatiin ang epekto ng bawat panuntunan sa pagpapanatili. Gamit ang datos na ito, matutukoy mo ang mga panuntunang masyadong malawak, mga duplikado, at mga panuntunang hindi na tumutugma sa kahit ano.
Bakit nakasasama sa performance ng app ko ang malawak na conservation rule?
Dahil pinipigilan nito ang R8 na mahawakan hindi lamang ang pinoprotektahan ng panuntunang iyon, kundi pati na rin ang lahat ng bagay na nakasalalay dito. Ang resulta ay mas maraming code sa package, mas maraming metadata, at mas kaunting espasyo para ilapat ang method insertion o class merging.
Mas mainam ba ang mag-publish gamit ang mga App Bundle sa halip na isang universal APK?
Oo, dahil ang tindahan ay bumubuo ng mga pakete na iniayon sa bawat device, at ang bawat user ay nagda-download lamang ng mga mapagkukunan ng wika, densidad, at arkitektura na kailangan nila. Ang pagsasaayos na ito ay makabuluhang nagpapababa sa laki ng pag-download nang hindi mo kinakailangang magpanatili ng magkakahiwalay na artifact.
Paano ko mababasa ang isang stack trace mula sa isang obfuscated build?
Kailangan mo ang mapping file na nabubuo sa bawat release build at para mailapat ang R8 retrace tool. Awtomatikong sinusubaybayan muli ng mga bagong bersyon ang mga trace sa Logcat window ng IDE.
Sulit ba ang pag-optimize ng isang library na ilalathala ko?
Pinakamahusay na gumagana ang buong pag-optimize kapag nakikita ng R8 ang buong graph ng aplikasyon, kaya ang karamihan ng trabaho ay nagagawa kapag kino-compile ang pangwakas na app. Gayunpaman, maingat na maihahanda ng isang library ang mga panuntunan nito para sa mga mamimili upang maiwasan ang pagharang sa mga pag-optimize sa mga proyektong nagsasama nito.
Talatuntunan
- 1 Ano nga ba ang eksaktong ginagawa ng R8 at bakit mo ito dapat pagkatiwalaan?
- 2 Paganahin ang pag-optimize batay sa bersyon ng plugin ng Gradle
- 3 Buong mode at na-optimize na pagbabawas ng mapagkukunan
- 4 Ang R8 Configuration Analyzer at ang tatlong marka nito
- 5 Paano gumawa ng ulat nang hindi nagsasayang ng oras
- 6 Pinuhin ang mga patakaran sa konserbasyon nang hindi nilalabag ang app
- 7 Mga duplikado, hindi nagamit, at mga panuntunan sa library
- 8 ProGuard at R8: magkatulad, ngunit hindi magkapareho
- 9 Karaniwang mga pagkakamali kapag nagpapaliit at kung paano makawala sa siksikan
- 10 Bawasan ang mga mapagkukunan: mga imahe, densidad, at mga wika
- 11 Mga layout, estilo, at hierarchy ng view
- 12 Mga App Bundle, dynamic module, at native library
- 13 Sukatin ang laki at subaybayan ang ebolusyon
- 14 Paano nagbago ang gawi sa pagitan ng mga bersyon?
- 15 Mga madalas itanong



