- Az R8 eltávolítja a senki által nem használt kódot és erőforrásokat, átírja a többit, és lerövidíti a neveket, hogy kisebb, gyorsabb indítási idejű és kevesebb lefagyási problémával járó alkalmazásokat hozzon létre.
- Célszerű engedélyezni az optimalizálást a kiadási buildben, és módosítani a megőrzési szabályokat, amelyek a fő akadályt jelentik az R8 teljes kapacitással való működésében.
- Az R8 konfigurációelemzője méri, hogy mennyi kód áll rendelkezésre a zsugorításhoz, optimalizáláshoz és obfuszkáláshoz, és megjelöli a tág, ismétlődő vagy haszontalan szabályokat.
- A feladat elvégzéséhez szükséges alkalmazáscsomagok, könnyű képek, nyelvi és sűrűségbeli beállítások, valamint állandó méretmérés valódi különbséget jelent a letöltési sebességben.
Egy Android-alkalmazás tömörítése nem csak az egyes fájlok törléséről szól; ez egy kényes egyensúlyozás a méret, az indítási sebesség és a memóriahasználat között. Az Android beépített optimalizálója, az R8, a munka nagy részét anélkül végzi el, hogy egyetlen sor kódot is kellene írnod : elemzi, hogy mely kódot és erőforrásokat használják valójában, eltávolítja azt, amit senki sem használ, és átírja a maradékot, hogy kevesebb terheléssel fusson. Az alkalmazás felhasználói gyorsabb indítási időt, kisebb memóriahasználatot, simább felületet és kevesebb összeomlási üzenetet vesznek észre.
A kulcs az, hogy teret adjunk neki a működéshez. Minél nagyobb részét tud az R8 elérni a kódbázisnak, annál jobbak az eredmények. A túl tág konzervációs szabályok jelentik a leggyakoribb akadályt , mivel olyan osztályokat és metódusokat zárolnak le, amelyeket esetleg nem lehet dinamikusan meghívni, a függőségeikkel együtt. Ezen szabályok finomítása, mérése és újratesztelése az a ciklus, amely elválaszt egy egyszerűen kiadott alkalmazást egy valóban finomhangolttól.
Mit csinál pontosan az R8, és miért érdemes megbízni benne?
Az R8 összekapcsolt fázisokban működik. Először elemzi a tényleges belépési pontokat, például a manifestben deklarált tevékenységeket vagy szolgáltatásokat, felépít egy térképet a hivatkozott összes elemről, és elveti a térképen kívüli dolgokat . Ezután logikai optimalizálásokra tér át: a hívásokat a meghívott metódus törzsével helyettesíti, osztályokat és interfészeket egyesít, egyszerűsíti a struktúrákat és csökkenti a végrehajtási terhelést. Végül lerövidíti az osztályok, mezők és metódusok nevét, így valami, például a com.example.MyActivity, aba néven is ismertté válhat, ami metaadatok megtakarítását eredményezi.
- Kevesebb halott kódAzok a függőségek, amelyeket csak kis százalékban használsz, nem viselik teljes súlyukat.
- Hatékonyabb végrehajtásA metódusok beszúrása és az osztályok egyesítése csökkenti a hívásokat és a memória terhelését.
- Könnyebb DEX fájlokA ködösítés elmenti a metaadatokat és felgyorsítja az osztályok betöltését.
- Kiigazított erőforrásokA Gradle bővítmény 8.12-es verziója óta az R8 is részt vesz az erőforrás-optimalizálásban.
A felhasználó szemszögéből ez gyorsabb indítási időket, csökkent memóriafogyasztást, jobb renderelést és kevesebb lefagyó alkalmazásproblémát jelent. A hivatalos ajánlás egyértelmű: engedélyezze az optimalizálást a kiadási buildben . Napi teszteléshez vagy könyvtárfejlesztéshez ez általában nem éri meg, mert a fordítási idő megnő, és a hibakeresés bonyolultabbá válik, amikor a nevek változnak.
Optimalizálás engedélyezése a Gradle bővítmény verziója alapján
Ha a Gradle Android bővítményének újabb verzióival dolgozol, a dolgok jelentősen leegyszerűsödtek. Egyszerűen engedélyezz egyetlen jelzőt a kiadási build típus optimalizálási blokkján belül , és helyezd el a keep szabályokat egy adott forráskódkészletben, például .keep végződésű fájlokkal az src/main/keepRules könyvtáron belül. Ez az új megközelítés magában foglalja mind a kódot, mind az erőforrásokat, és az alapértelmezett platformszabályokat is tartalmazza, amelyek egyenértékűek a korábbi ProGuard szabályokkal optimalizálással, így nincs szükség további fájlok deklarálására.
A bővítmény korábbi verzióihoz lehorgonyzott projektekben a standard megközelítés két paramétert tartalmaz a kiadási build típusában: az egyik a kódminimalizálást, a másik az erőforrás-csökkentést teszi lehetővé. Az ésszerű megközelítés az, ha mindkettőt egyszerre engedélyezed , és hozzáadod a rendszer által generált optimalizált szabályfájlt, valamint a saját szabályfájlodat, ha szükséges. A kiadási buildek keverése ezen kapcsolók nélkül az egyik legkifinomultabb módja annak, hogy megabájtokat adj a felhasználóknak.
Teljes mód és optimalizált erőforrás-csökkentés
Az R8 teljes módja évek óta alapértelmezés szerint aktív, és agresszívabb feltételezéseket alkalmaz a reflexió és a dinamikus hívások használatával kapcsolatban. Ha valaki valaha is írt olyan tulajdonságot, amely letiltja ezt, a legjobb, ha törli : a kikapcsolt állapotban tartása csökkenti az optimalizáló lehetőségeit. A teljes mód azonban extra szabályokat igényelhet a sok dinamikus kódot tartalmazó projektekben, ezért mindig egy valódi kiadású builddel teszteld, ne csak egységtesztekkel.
Az optimalizált erőforrás-zsugorítás a bővítmény 8.12-es verziójával érkezett, és a 9.0-s verzió óta automatikusan alkalmazódik, amikor az erőforrás-zsugorítás engedélyezve van. Az ötlet az, hogy az erőforrásokat a kódgráf részeként kezeljék : korábban a csomagolóeszköz olyan megőrzési szabályokat generált, amelyek életben tartották a hozzáférhetetlen erőforrásokat és a kódot, amelyek egymásra hivatkoztak; most, ha egy kód- és erőforrásgyűjteményt nem használnak, az nem lesz védve és eltűnik. A sokféle formátumváltozattal rendelkező alkalmazásokban több mint ötven százalékos méretcsökkenést mértek.
Az R8 konfigurációelemző és három pontszáma
Ez az analizátor az az eszköz, amely megmutatja, hogy a konfigurációd segít vagy akadályoz. Statisztikákat generál arról, hogy a kódbázisod hány százaléka van valójában kitéve csökkentésnek, optimalizálásnak és obfuszkálásnak . Ha a csökkentési pontszám 66 százalék, az azt jelenti, hogy az R8 a kódbázis kétharmadából tud kódot eltávolítani; ha az optimalizálási pontszám ugyanaz, akkor csak a kétharmadra tud metódusbeszúrást, osztályösszevonást és más technikákat alkalmazni. Az obfuszkálási pontszám azt méri, hogy mennyi kódot lehet lerövidíteni a metaadatok mentése érdekében.
Az általános mérőszámok mellett a jelentés részletezi az egyes megőrzési szabályok hatását és az általuk blokkolt optimalizálási tulajdonságokat. Azonosítja a harmadik féltől származó könyvtárakból származó szabályokat is , ami nagyon hasznos, mivel ezeknek a könyvtáraknak a szerzői nem ismerik az adott implementációt, és néha olyan általános szabályokat írnak, hogy megbénítják az optimalizálást az alkalmazás olyan részein, amelyek teljesen függetlenek a funkcionalitásától.
Hogyan készítsünk jelentést időpazarlás nélkül?
A szabályok gyors iterálásához létezik egy speciális Gradle-feladat, amely a kiadási konfigurációt elemzi az APK vagy a csomag becsomagolása nélkül. A visszacsatolási ciklus sokkal rövidebb , és a HTML-jelentés a modul jelentésmappájában jelenik meg, az R8-nak dedikált könyvtárban. Ez az ajánlott beállítás, ha finomhangoljuk a szabályokat, és minden módosítás azonnali hatását szeretnénk látni.
Ha az automatikus elemzést részesíti előnyben, minden kiadású build egy HTML-fájlt is generál a leképezési eredmények között. Ha zavarónak találja, letilthatja ezt az automatikus generálást a megfelelő kísérleti tulajdonsággal. A bővítmény régebbi verzióiban a megkerülő megoldás az, hogy hozzáad egy újabb R8-as verziót a projekt osztályútvonalához, és a buildet egy system tulajdonsággal futtatja, amely megadja azt a könyvtárat, ahová a jelentést menteni kell.
Finomítsa a természetvédelmi szabályokat az alkalmazás meghibásodása nélkül
A cél az, hogy csak azt őrizzük meg, ami valóban hozzáférhető a reflexió révén, semmi többet, semmi kevesebbet. Kezdjük azzal, hogy megvizsgáljuk azokat a szabályokat, amelyek blokkolják az optimalizálást számos osztályon , áttekintjük, hogy mely elemeket védik, és ellenőrizzük, hogy valóban dinamikusan meghívódnak-e. Ezután szűkítsük le a hatókört: a teljes csomag összes tagjával együtt történő megőrzése helyett korlátozzuk a szabályt bizonyos osztályokra és tagokra. A változtatás bevezetése előtt pedig futtassunk teszteket, amelyek lefedik az érintett osztályokat, mezőket és metódusokat.
Légy óvatos az összevont szabályokkal is. Ha az egyik szabály egy teljes csomagot véd, a másik pedig egy osztályt a csomagon belül, akkor a második nem járul hozzá semmihez, az első pedig olyan optimalizálásokat blokkol, amelyekre esetleg nincs szükséged. Döntsd el, hogy a kettő közül melyik a helyes: ha a szűkebb szabály jól megírt, távolítsd el az általánost, és oldd fel a csomag többi részét; ha az általános helyes, távolítsd el akkor is, de írd át úgy, hogy csak a lényeges dolgokat érintse. Ezután futtasd újra az analizátort, és fordíts le egy teljes kiadást, hogy ellenőrizd, minden még mindig működik-e.
Ismétlődő, nem használt és könyvtári szabályok
Az analizátor két egyértelmű rendetlenségi forrást azonosít: azokat a szabályokat, amelyek nem illeszkednek egyetlen osztályhoz, metódushoz vagy mezőhöz sem az aktuális buildben, és azokat az azonos szabályokat, amelyek ugyanabban a fájlban vagy különböző fájlokban ismétlődnek. Az előbbiek gyakran szemétként maradnak a refaktorálás vagy a függőségek eltávolítása után ; az utóbbiak bonyolítják a karbantartást anélkül, hogy bármilyen előnnyel járnának. Tisztításuk megkönnyíti a konfiguráció olvasását és hibakeresését.
A harmadik féltől származó függvénykönyvtárakkal kevés a mozgástér, mivel a szabályaik csomagban érkeznek, és nem lehet őket szelektíven szerkeszteni. A gyakorlati megközelítés az, hogy egy jelentésben dokumentáljuk a hatást, és értesítjük a karbantartót , vagy ideiglenesen replikáljuk ezeket a szabályokat a projektben, kizárva az általánosabb szabályokat, és mérve a potenciális hasznot, mielőtt eldöntenénk, hogy megéri-e vállalni a kockázatot.
ProGuard és R8: hasonlóak, de nem azonosak
A ProGuard évekig négy dolgot csinált: eltávolította a nem használt elemeket, optimalizálta a bájtkódot, obfuszkálta a neveket, és előzetes ellenőrző információkat adott hozzá. Az R8 ott folytatja, ahol abbahagyta, és továbbfejleszti a technológiát: agresszívabban illeszti be a metódusokat, egyesíti az osztályokat, lehetőség szerint egész számokká alakítja a felsorolásokat, és jobban megérti a Kotlin funkcióit . Gyorsabban is fordul, és az alapkönyvtár egyszerűsítésével lehetővé teszi a modern Java API-k használatát az Android régebbi verzióin.
A szabályokat illetően az R8 elfogadja a ProGuard szabályait, és hozzáad néhány saját módosítót, például olyanokat, amelyek kikényszerítik vagy megakadályozzák egy adott metódus beszúrását. A névkonverzió nem változtatja meg a viselkedést, de bonyolítja a veremkövetések olvasását : mindig megőrzi az egyes kiadások leképezési fájlját, hogy éles hiba esetén helyreállíthassa az eredeti nyomkövetést.
Tipikus hibák a minifóliázás során és hogyan lehet kimászni a dugulásból
Ugyanazok a problémák jelentkeznek újra és újra: törölt osztály miatt „osztály nem található”, átnevezett metódus miatt „nincs ilyen metódus”, nevük elvesztését okozó, szerializált modellek, vagy olyan könyvtárak, amelyek feltételezik, hogy semmi sem fog változni. A diagnózis szinte mindig magában foglalja a reflexión keresztül elért elemek ellenőrzését és a minimálisan szükséges szabály hozzáadását . A vizsgálathoz engedélyezze a használatot, a seed-et és a nyomtatás leképezését egy ideiglenes fájlba, vagy ideiglenesen tiltsa le az egyes optimalizálásokat a tettes elkülönítése érdekében.
Azt is érdemes megjegyezni, hogy a DEX fájlokat regeneráló vagy javító külső eszközök tönkretehetik az R8 által gondosan megvalósított optimalizálásokat. Ha a build láncod tartalmaz ilyen lépést, tekintsd át, mielőtt az optimalizálót hibáztatod . És ha a build teljesítménye aggodalomra ad okot, vannak olyan finomhangolások, amelyekkel az R8 a környezetedhez igazítható anélkül, hogy feláldoznád az előnyeit.
Csökkentsd az erőforrásokat: képeket, sűrűséget és nyelveket
Az erőforrások jellemzően a csomag hatalmas részét teszik ki. A bitképek WebP-vé konvertálása csökkenti a fájlméretet a minőség megőrzése mellett , a vektoros rajzolható fájlok pedig megakadályozzák, hogy ugyanaz az ikon minden sűrűséghez másodpéldányt használjunk. Ha csak a ténylegesen használt sűrűségi gyűjtőket konfiguráljuk, és korlátozzuk a benne foglalt nyelveket, az jelentősen csökkenti a fájlméretet, különösen a sok fordítást tartalmazó alkalmazásokban. A nem konvertálható PNG-khez minimális veszteséggel rendelkező tömörítő segédprogramok állnak rendelkezésre.
Az is segít, ha egyetlen erőforrást programozottan színezünk szürkeárnyalatosra a több színes verzió összevonása helyett, igény szerint betöltünk nagy, felesleges képeket indításkor, és eltávolítjuk az árva erőforrásokat az IDE kódellenőrzésével. Ha egy erőforrásra csak halott kódból hivatkoznak, az optimalizált csökkentés észleli és eltávolítja azt , ami korábban nem történt meg, mert a két folyamat külön futott.
Elrendezések, stílusok és nézethierarchiák
A hierarchiák lapítása nem csökkenti az APK méretét, de javítja a teljesítményt, ami a cél másik fele. Cseréld le a felesleges konténer-beágyazást egy jól megtervezett ConstraintLayout-tal , vond ki a közös komponenseket az include függvénnyel, és definiálj stílusokat az ismétlődő attribútumok elkerülése érdekében. Az elrendezés-ellenőr segít észlelni az abszurd módon mély nézetű fákat, amelyek lassítják a felfújást.
Alkalmazáscsomagok, dinamikus modulok és natív könyvtárak
A csomag formátumban történő közzététel forradalmi változást hoz: az áruház minden eszközhöz testreszabott csomagokat generál, így minden felhasználó csak a szükséges kódot és erőforrásokat tölti le. A letöltések száma jelentősen alacsonyabb, mint egy univerzális APK esetében, mivel kiszűri a nem releváns nyelveket, eszközsűrűségeket és architektúrákat. Továbbá a funkciók eloszthatók a funkciómodulok között, amelyek igény szerint töltődnek le, feltételes vagy azonnali kritériumok alapján.
A natív könyvtárakat illetően, ha csak a támogatott architektúrákat használod, és engedélyezve tartod a tömörítést, akkor nem fogsz olyan bináris fájlokat beletenni, amelyeket senki sem fog futtatni. Ha Bazel-lel fordítasz Gradle helyett, akkor az R8-at is integrálhatod a folyamatba, bár érdemes megjegyezni, hogy ez a támogatás hivatalosan nem támogatott Android alkalmazásfejlesztéshez.
Mérd meg a méretet és figyeld meg az evolúciót
Mérés nélkül nincs optimalizálás. Az IDE APK-elemzője megmutatja a csomag valódi méretét, és egy egyéni Gradle-feladat minden egyes build után jelentheti a méretet. Ennek az ellenőrzésnek a folyamatos integrációhoz való hozzáadása automatizálja a méretszabályozást, és megakadályozza, hogy néhány új függőség felduzzassza a bináris fájlt anélkül, hogy bárki észrevenné.
Hogyan változott a viselkedés a verziók között?
Érdemes áttekinteni a legújabb fejleményeket, mert számos olyan régi konfigurációt ismertetnek, amelyek már nem relevánsak. A 8.0-s verzió alapértelmezés szerint engedélyezte a teljes módot ; a 8.6-os verzió javította a visszakövetést, beleértve a fájlok és sorok visszakövetését bármely minSdk esetében; a 8.12-es verzió optimalizált erőforrás-csökkentést és automatikus visszakövetést vezetett be a Logcatben; a 9.0-s verzió alapértelmezés szerint engedélyezte, szűrte a globális beállításokat a felhasználói szabályokban, és optimalizálta a Kotlin nullellenőrzést; a 9.1-es verzió alapértelmezés szerint újracsomagolta az osztályokat; és a 9.3-as verzió bevezette az egyszerűsített optimalizáló blokkot és a .keep szabálykészletet.
Mindezt szem előtt tartva, egy egyszerű rutin teszi igazán különlegessé a dolgokat: az optimalizálás engedélyezése a kiadáskor, az elemző jelentés rendszeres ellenőrzése, a felesleges szabályok eltávolítása, az erőforrások és képfájlok tisztítása, csomagokban történő terjesztés, és a méret mérése minden kiadásnál. Ezek apró lépések, amelyek együttesen egy nehézkes, lassú alkalmazást olyanná alakítanak, amely villámgyorsan letöltődik és azonnal elindul . És mivel a kód és a függőségek folyamatosan bővülnek, a felülvizsgálatnak folyamatosnak kell lennie: ami ma finomhangolt, az elrontja a hangolást, amint egy új könyvtárat adnak hozzá, vagy egy saját erőforrásokkal rendelkező funkciót építenek be.
Preguntas frecuentes
Pontosan mit csinál az R8 az alkalmazáskódommal?
Elemzi a deklarált belépési pontokat, létrehoz egy referencia térképet, és eltávolít mindent, ami nem érhető el belőlük. Ezután átírja a fennmaradó kódot, hogy kevesebb többletterheléssel fusson, és lerövidíti az osztály-, mező- és metódusneveket a helytakarékosság érdekében.
Hogyan engedélyezhetem az R8 optimalizálást a Gradle bővítmény legújabb verzióiban?
Egy jelzővel aktiválható a kiadás build típusának optimalizálási blokkján belül, amely a kódot és az erőforrásokat is lefedi. A saját szabályaid egy adott forráskódkészletben, .keep kiterjesztésű fájlokban találhatók.
Mi a különbség a kódcsökkentés és az erőforrások csökkentése között?
A kódcsökkentés kiküszöböli az elérhetetlen osztályokat, mezőket és metódusokat, míg az erőforrás-csökkentés eltávolítja a nem használt képeket, elrendezéseket és egyéb fájlokat. A modern verziókban mindkét feladat egyetlen referenciagráfba van integrálva, megakadályozva, hogy a csatolt erőforrások kizárólag az elavult kódból maradjanak meg.
Mire használják az R8 konfigurációanalizátort?
Mérd meg a kódbázisod azon százalékát, amely még elérhető a zsugorításhoz, optimalizáláshoz és obfuszkáláshoz, és bontsd le az egyes megőrzési szabályok hatását. Ezen adatok segítségével azonosíthatod a túlságosan tág szabályokat, a duplikátumokat és azokat a szabályokat, amelyek már semmivel sem egyeznek.
Miért rontja az alkalmazásom teljesítményét egy általános megőrzési szabály?
Mert megakadályozza, hogy az R8 ne csak azt érintse, amit a szabály véd, hanem mindent, ami attól függ. Az eredmény több kód a csomagban, több metaadat, és kevesebb hely a metódusok beszúrásának vagy osztályok összevonásának alkalmazására.
Jobb App Bundles csomagokkal közzétenni, mint univerzális APK-val?
Igen, mivel az áruház minden eszközhöz testreszabott csomagokat generál, és minden felhasználó csak a számára szükséges nyelvi, sűrűségi és architektúra-erőforrásokat tölti le. Ez a beállítás jelentősen csökkenti a letöltési méretet anélkül, hogy különálló összetevőket kellene fenntartani.
Hogyan tudok egy obfuszkált buildből veremkövetést olvasni?
Szükséged lesz a minden egyes kiadással generált leképezési fájlra és az R8 retrace eszköz alkalmazására. A legújabb verziók automatikusan újrakövetik a nyomkövetéseket az IDE Logcat ablakában.
Érdemes optimalizálni egy olyan könyvtárat, amit publikálni fogok?
A teljes optimalizálás akkor működik a legjobban, ha az R8 látja a teljes alkalmazásgráfot, így a munka nagy részét a végső alkalmazás fordításakor végzik el. Ennek ellenére egy könyvtár gondosan előkészítheti a felhasználói szabályait, hogy elkerülje az optimalizálások blokkolását az azt integráló projektekben.
Index
- 1 Mit csinál pontosan az R8, és miért érdemes megbízni benne?
- 2 Optimalizálás engedélyezése a Gradle bővítmény verziója alapján
- 3 Teljes mód és optimalizált erőforrás-csökkentés
- 4 Az R8 konfigurációelemző és három pontszáma
- 5 Hogyan készítsünk jelentést időpazarlás nélkül?
- 6 Finomítsa a természetvédelmi szabályokat az alkalmazás meghibásodása nélkül
- 7 Ismétlődő, nem használt és könyvtári szabályok
- 8 ProGuard és R8: hasonlóak, de nem azonosak
- 9 Tipikus hibák a minifóliázás során és hogyan lehet kimászni a dugulásból
- 10 Csökkentsd az erőforrásokat: képeket, sűrűséget és nyelveket
- 11 Elrendezések, stílusok és nézethierarchiák
- 12 Alkalmazáscsomagok, dinamikus modulok és natív könyvtárak
- 13 Mérd meg a méretet és figyeld meg az evolúciót
- 14 Hogyan változott a viselkedés a verziók között?
- 15 Preguntas frecuentes



