- R8 tar bort kod och resurser som ingen använder, skriver om resten och förkortar namn för att skapa mindre appar med snabbare starttider och färre problem med att apparna inte svarar.
- Det är lämpligt att aktivera optimering i versionsversionen och justera bevarandereglerna, vilka är det största hindret som hindrar R8 från att fungera med full kapacitet.
- R8:s konfigurationsanalysator mäter hur mycket kod som finns tillgänglig för att krympa, optimera och obfuskatera, och flaggar breda, duplicerade eller oanvändbara regler.
- Att slutföra uppgiften med App Bundles, lättviktiga bilder, språk- och densitetsjusteringar och konstant storleksmätning gör en verklig skillnad i nedladdningshastigheten.
Att komprimera en Android-app handlar inte bara om att radera enskilda filer; det är en delikat balansgång mellan storlek, starthastighet och minnesanvändning. Androids inbyggda optimerare, R8, hanterar mycket av detta arbete utan att du behöver skriva en enda rad kod : den analyserar vilken kod och vilka resurser som faktiskt används, tar bort det som ingen använder och skriver om det som återstår att köra med mindre overhead. Det som användare av din app märker är snabbare starttider, mindre minnesanvändning, ett smidigare gränssnitt och färre kraschmeddelanden.
Nyckeln är att ge det utrymme att fungera. Ju större del av din kodbas som R8 kan beröra, desto bättre resultat. Alltför breda bevaranderegler är det vanligaste hindret , eftersom de låser klasser och metoder som kanske inte kan anropas dynamiskt, tillsammans med deras beroenden. Att förfina dessa regler, mäta och testa om är loopen som skiljer en enkelt släppt app från en verkligt finjusterad.
Vad gör R8 egentligen och varför ska man lita på det?
R8 fungerar i en serie länkade faser. Först analyserar den dina faktiska startpunkter, såsom de aktiviteter eller tjänster som deklareras i manifestet, bygger en karta över allt som refereras till och ignorerar allt utanför den kartan . Sedan går den vidare till logiska optimeringar: ersätter anrop med den anropade metodens brödtext, slår samman klasser och gränssnitt, förenklar strukturer och minskar exekveringskostnader. Slutligen förkortar den namnen på klasser, fält och metoder, så att något i stil med com.example.MyActivity kan anropas aba, med resulterande besparingar i metadata.
- Mindre död kodBeroenden som du bara använder i en liten procentandel slutar bära all sin tyngd.
- Effektivare utförandeAtt infoga metoder och sammanfoga klasser minskar anrop och belastning på minnet.
- Lättare DEX-filerObfuskering sparar metadata och snabbar upp inläsningen av klasser.
- Justerade resurserSedan version 8.12 av Gradle-pluginet deltar R8 även i resursoptimering.
Ur användarens perspektiv innebär detta snabbare starttider, minskad minnesförbrukning, förbättrad rendering och färre problem med appar som inte svarar. Den officiella rekommendationen är tydlig: aktivera optimering i versionen . För daglig testning eller biblioteksutveckling är det vanligtvis inte värt det, eftersom kompileringstiden ökar och felsökning blir mer komplicerad när namnen ändras.
Aktivera optimering baserat på Gradle-pluginversionen
Om du arbetar med nyare versioner av Android-pluginet för Gradle har saker och ting förenklats avsevärt. Aktivera bara en enda flagga i optimeringsblocket för versionstypen och placera dina keep-regler i en specifik källkodsuppsättning, med filer som slutar på .keep, till exempel inom src/main/keepRules. Denna nya metod omfattar både kod och resurser och inkluderar standardplattformsregler motsvarande de historiska ProGuard-reglerna med optimering, så det finns inget behov av att deklarera ytterligare filer.
I projekt som är förankrade i tidigare versioner av plugin-programmet involverar standardmetoden två parametrar i versionstypen: en som möjliggör kodminimering och en annan som möjliggör resursreduktion. Det kloka tillvägagångssättet är att aktivera båda samtidigt och lägga till den optimerade regelfilen som genereras av själva systemet, plus din egen regelfil om det behövs. Att blanda versionsversioner utan dessa växlar är ett av de mest subtila sätten att ge bort megabyte till dina användare.
Fullt läge och optimerad resursreduktion
R8:s fullständiga läge har varit aktivt som standard i flera år och tillämpar mer aggressiva antaganden om användningen av reflektion och dynamiska anrop. Om någon någonsin har skrivit en egenskap som inaktiverar den är det bäst att ta bort den : att hålla den avstängd minskar optimerarens potential. Fullständigt läge kan dock kräva extra regler i projekt med mycket dynamisk kod, så testa det alltid med en riktig version och inte bara med enhetstester.
Optimerad resursminskning kom med version 8.12 av pluginet, och sedan version 9.0 tillämpas den automatiskt när resursminskning är aktiverad. Tanken är att behandla resurser som en del av koddiagrammet : tidigare genererade paketeringsverktyget bevaranderegler som höll oåtkomliga resurser och kod vid liv som refererade till varandra; nu, om en samling kod och resurser inte används, skyddas den inte och försvinner. I appar med många formfaktorvariationer har storleksminskningar på över femtio procent uppmätts.
R8 Configuration Analyzer och dess tre poäng
Den här analysatorn är verktyget som berättar om din konfiguration hjälper eller hindrar. Den genererar statistik om hur mycket procentandel av din kodbas som faktiskt är föremål för reduktion, optimering och obfuskering . Om reduktionspoängen är 66 procent betyder det att R8 kan ta bort kod från två tredjedelar av din kodbas; om optimeringspoängen är densamma kan den bara tillämpa metodinsättning, klasssammanslagning och andra tekniker på två tredjedelar. Obfuskeringspoängen mäter hur mycket kod som kan förkortas för att spara metadata.
Förutom övergripande mätvärden beskriver rapporten effekten av varje bevaranderegel och de optimeringsegenskaper den blockerar. Den identifierar också regler som kommer från tredjepartsbibliotek , vilket är mycket användbart eftersom författarna till dessa bibliotek inte är bekanta med din specifika implementering och ibland skriver regler så generella att de förlamar optimeringen i delar av din app som är helt relaterade till dess funktionalitet.
Hur man genererar rapporten utan att slösa tid
För att snabbt kunna iterera med dina regler finns det en specifik Gradle-uppgift som analyserar releasekonfigurationen utan att paketera APK:en eller paketet. Feedback-slingan är mycket kortare och HTML-rapporten visas i modulens rapportmapp, i en katalog dedikerad till R8. Detta är det rekommenderade alternativet när du finjusterar regler och vill se den omedelbara effekten av varje ändring.
Om du föredrar automatisk analys genererar alla versioner av versionen även en HTML-fil i mappningsresultaten. Du kan inaktivera denna automatiska generering med motsvarande experimentella egenskap om du tycker att det är besvärligt. I äldre versioner av plugin-programmet är lösningen att lägga till en aktuell R8-version i projektets klassväg och köra versionen med en systemegenskap som anger katalogen där rapporten ska sparas.
Förfina bevarandereglerna utan att bryta mot appen
Målet är att endast bevara det som verkligen är tillgängligt genom reflektion, varken mer eller mindre. Börja med att undersöka reglerna som blockerar optimering över ett stort antal klasser , granska vilka element de skyddar och verifiera om de faktiskt anropas dynamiskt. Begränsa sedan omfattningen: istället för att bevara ett helt paket med alla dess medlemmar, begränsa regeln till specifika klasser och medlemmar. Och innan du implementerar ändringen, kör tester som täcker de berörda klasserna, fälten och metoderna.
Var också försiktig med underordnade regler. Om en regel skyddar ett helt paket och en annan skyddar en klass inom det paketet, bidrar den andra inte med någonting, och den första blockerar optimeringar som du kanske inte behöver. Bestäm vilken av de två som är korrekt: om den smala är välskriven, ta bort den breda och lås upp resten av paketet; om den breda är korrekt, ta bort den ändå men skriv om den så att den bara påverkar det som är väsentligt. Kör sedan analysatorn igen och kompilera en fullständig version för att verifiera att allt fortfarande fungerar.
Duplicerade, oanvända och biblioteksregler
Analysatorn identifierar två tydliga källor till skräp: regler som inte matchar någon klass, metod eller fält i den aktuella versionen, och identiska regler som upprepas i samma fil eller i olika filer. De förra lämnas ofta som skräp efter omstrukturering eller borttagning av beroenden ; de senare komplicerar underhåll utan att ge några fördelar. Att rensa dem gör konfigurationen lättare att läsa och felsöka.
Med tredjepartsbibliotek finns det lite manöverutrymme eftersom deras regler kommer paketerade och du kan inte redigera dem selektivt. Det praktiska tillvägagångssättet är att dokumentera effekten i en rapport och meddela ansvariga , eller tillfälligt replikera dessa regler i ditt projekt, exkludera de bredare och mäta den potentiella vinsten innan du bestämmer dig för om det är värt att ta risken.
ProGuard och R8: liknande, men inte identiska
I åratal gjorde ProGuard fyra saker: det tog bort oanvända element, optimerade bytekod, obfuskerade namn och lade till förkontrollinformation. R8 tar vid där det slutade och går vidare: det infogar metoder mer aggressivt, slår samman klasser, konverterar uppräkningar till heltal när det är möjligt och har en bättre förståelse för Kotlins funktioner . Det kompilerar också snabbare och, med avsötningen av kärnbiblioteket, tillåter användning av moderna Java API:er på äldre versioner av Android.
När det gäller reglerna accepterar R8 ProGuards regler och lägger till några egna modifierare, till exempel de som tvingar eller förhindrar infogning av en specifik metod. Namnkonvertering ändrar inte beteendet, men det komplicerar läsning av stackspår : den bevarar alltid mappningsfilen för varje utgåva för att återställa det ursprungliga spåret när ett produktionsfel inträffar.
Vanliga misstag vid minifiering och hur man tar sig ur problemet
Samma problem fortsätter att dyka upp: "klassen hittades inte" på grund av en borttagen klass, "ingen sådan metod" på grund av en omdöpt metod, modeller som inte serialiseras eftersom de har förlorat sina namn, eller bibliotek som antar att ingenting kommer att ändras. Diagnosen innebär nästan alltid att kontrollera vad som nås via reflektion och lägga till den minsta nödvändiga regeln . För att undersöka, aktivera användning, seed och mappning av utskrift till en temporär fil, eller inaktivera tillfälligt specifika optimeringar för att isolera boven i dramat.
Det är också värt att notera att externa verktyg som regenererar eller patchar DEX-filer kan förstöra de optimeringar som R8 noggrant har implementerat. Om din byggkedja inkluderar ett sådant steg, granska den innan du skyller på optimeraren . Och om byggprestanda är ett problem finns det justeringar tillgängliga för att anpassa R8 till din miljö utan att offra dess fördelar.
Minska resurser: bilder, densiteter och språk
Resurser utgör vanligtvis en stor del av paketet. Att konvertera bitmappar till WebP minskar filstorleken samtidigt som kvaliteten bibehålls , och vektorritbara objekt förhindrar att samma ikon dupliceras för varje densitet. Att bara konfigurera de densitetsintervall du faktiskt använder och begränsa de inkluderade språken minskar filstorleken avsevärt, särskilt i appar med många översättningar. För PNG-filer som du inte kan konvertera finns det komprimeringsverktyg med minimal förlust.
Det hjälper också att programmatiskt färglägga en enskild resurs till gråskala istället för att bunta ihop flera färgade versioner, ladda stora, onödiga bilder på begäran vid start och ta bort överblivna resurser med hjälp av IDE:ns kodinspektion. Om en resurs endast refereras från död kod, upptäcker och tar optimerad reduktion bort den , något som inte hände tidigare eftersom de två processerna kördes separat.
Layouter, stilar och vyhierarkier
Att platta ut hierarkier minskar inte APK-storleken, men det förbättrar prestandan, vilket är den andra halvan av målet. Ersätt onödig containerkapsling med en väl utformad ConstraintLayout , extrahera vanliga komponenter med include och definiera stilar för att undvika dubbletter av attribut. Layoutinspektören hjälper dig att upptäcka absurt djupa vyträd som saktar ner inflationen.
App-paket, dynamiska moduler och inbyggda bibliotek
Att publicera i paketformat är banbrytande: butiken genererar paket skräddarsydda för varje enhet, så varje användare laddar bara ner den kod och de resurser de behöver. Nedladdningarna är betydligt lägre än med en universell APK eftersom den filtrerar bort språk, enhetstätheter och arkitekturer som inte gäller. Dessutom kan funktioner distribueras över funktionsmoduler som laddas ner på begäran, baserat på villkorliga eller omedelbara kriterier.
Angående nativa bibliotek, om du bara inkluderar de arkitekturer du stöder och håller komprimering aktiverad, förhindrar du att du inkluderar binärfiler som ingen kommer att köra. Om du kompilerar med Bazel istället för Gradle kan du också integrera R8 i pipelinen, även om det är värt att komma ihåg att detta stöd inte officiellt stöds för Android-apputveckling.
Mät storleken och övervaka utvecklingen
Utan mätning sker ingen optimering. IDE:ns APK-analysator visar paketets verkliga storlek, och en anpassad Gradle-uppgift kan rapportera storleken efter varje build. Att lägga till denna kontroll i kontinuerlig integration automatiserar storlekskontrollen och förhindrar att ett par nya beroenden överbelastar binärfilen utan att någon märker det.
Hur har beteendet förändrats mellan versionerna?
Det är värt att granska den senaste utvecklingen eftersom den förklarar många äldre konfigurationer som inte längre är relevanta. Version 8.0 aktiverade fullständigt läge som standard ; 8.6 förbättrade återspårning, inklusive fil- och radåterspårning för alla minSdk; 8.12 introducerade optimerad resursreduktion och automatisk återspårning i Logcat; 9.0 aktiverade det som standard, filtrerade globala alternativ i konsumentregler och optimerade Kotlin null-kontroll; 9.1 ompaketerade klasser som standard; och 9.3 introducerade det förenklade optimeringsblocket och .keep-regeluppsättningen.
Med allt detta i åtanke är det som verkligen gör skillnad en enkel rutin: att aktivera optimering i releasen, granska analysrapporten regelbundet, trimma onödiga regler, rensa resurser och bilder, distribuera med paket och mäta storleken med varje release. Dessa är små steg som tillsammans förvandlar en tung, långsam app till en som laddas ner blixtsnabbt och startas direkt. Och eftersom koden och beroendena fortsätter att växa måste granskningen ske kontinuerligt: det som är finjusterat idag blir ointaktat så fort ett nytt bibliotek läggs till eller en funktion med egna resurser införlivas.
Vanliga frågor
Vad gör R8 egentligen med min applikationskod?
Den analyserar de deklarerade startpunkterna, bygger en referenskarta och tar bort allt som inte är nåbart från dem. Sedan skriver den om den återstående koden för att köras med mindre overhead och förkortar klass-, fält- och metodnamn för att spara utrymme.
Hur aktiverar jag R8-optimering i de senaste versionerna av Gradle-pluginet?
Den aktiveras med en flagga inom optimeringsblocket för versionstypen, vilket täcker både kod och resurser. Dina egna regler placeras i en specifik källkodsuppsättning, i filer med .keep-tillägget.
Vad är skillnaden mellan att minska kod och att minska resurser?
Kodreduktion eliminerar oåtkomliga klasser, fält och metoder, medan resursreduktion tar bort oanvända bilder, layouter och andra filer. I moderna versioner är båda uppgifterna integrerade i en enda referensgraf, vilket förhindrar att länkade resurser enbart från föråldrad kod behålls.
Vad används R8-konfigurationsanalysatorn till?
Mät andelen av din kodbas som fortfarande är tillgänglig för krympning, optimering och obfuskering, och bryt ner effekten av varje bevaranderegel. Med dessa data kan du identifiera alltför breda regler, dubbletter och regler som inte längre matchar någonting.
Varför skadar en bred bevaranderegel min apps prestanda?
Eftersom det hindrar R8 från att vidröra inte bara det som den regeln skyddar, utan även allt som är beroende av den. Resultatet blir mer kod i paketet, mer metadata och mindre utrymme för att tillämpa metodinsättning eller klasssammanslagning.
Är det bättre att publicera med apppaket istället för en universell APK?
Ja, eftersom butiken genererar paket som är anpassade för varje enhet, och varje användare laddar bara ner de språk-, densitets- och arkitekturresurser de behöver. Denna justering minskar nedladdningsstorleken avsevärt utan att du behöver underhålla separata artefakter.
Hur kan jag läsa ett stackspår från en obfuskerad version?
Du behöver mappningsfilen som genereras med varje version och för att kunna använda R8-återspårningsverktyget. Nyare versioner spårar till och med automatiskt om spårningarna i IDE:ns Logcat-fönster.
Är det värt att optimera ett bibliotek som jag ska publicera?
Full optimering fungerar bäst när R8 ser hela applikationsgrafen, så huvuddelen av arbetet görs när den slutliga appen kompileras. Ändå kan ett bibliotek noggrant förbereda sina konsumentregler för att undvika att blockera optimeringar i projekt som integrerar det.
Index
- 1 Vad gör R8 egentligen och varför ska man lita på det?
- 2 Aktivera optimering baserat på Gradle-pluginversionen
- 3 Fullt läge och optimerad resursreduktion
- 4 R8 Configuration Analyzer och dess tre poäng
- 5 Hur man genererar rapporten utan att slösa tid
- 6 Förfina bevarandereglerna utan att bryta mot appen
- 7 Duplicerade, oanvända och biblioteksregler
- 8 ProGuard och R8: liknande, men inte identiska
- 9 Vanliga misstag vid minifiering och hur man tar sig ur problemet
- 10 Minska resurser: bilder, densiteter och språk
- 11 Layouter, stilar och vyhierarkier
- 12 App-paket, dynamiska moduler och inbyggda bibliotek
- 13 Mät storleken och övervaka utvecklingen
- 14 Hur har beteendet förändrats mellan versionerna?
- 15 Vanliga frågor



