- R8 rimuove il codice e le risorse che nessuno utilizza, riscrive il resto e abbrevia i nomi per creare app più piccole con tempi di avvio più rapidi e meno problemi di reattività.
- Si consiglia di abilitare l'ottimizzazione nella build di rilascio e di regolare le regole di conservazione, che rappresentano il principale ostacolo al funzionamento a pieno regime di R8.
- R8 Configuration Analyzer misura la quantità di codice disponibile per essere ridotto, ottimizzato e offuscato, e segnala le regole generiche, duplicate o inutili.
- Completare l'operazione con App Bundle, immagini leggere, regolazioni di lingua e densità e misurazione costante delle dimensioni fa davvero la differenza nella velocità di download.
Comprimere un'app Android non significa semplicemente eliminare singoli file; è un delicato equilibrio tra dimensioni, velocità di avvio e utilizzo della memoria. L'ottimizzatore integrato di Android, R8, gestisce gran parte di questo lavoro senza che tu debba scrivere una sola riga di codice : analizza quale codice e quali risorse vengono effettivamente utilizzati, rimuove ciò che non serve e riscrive ciò che rimane per funzionare con un overhead inferiore. Gli utenti della tua app noteranno tempi di avvio più rapidi, un minore utilizzo della memoria, un'interfaccia più fluida e meno messaggi di arresto anomalo.
La chiave è dargli lo spazio per operare. Maggiore è la porzione di codice sorgente su cui R8 può intervenire, migliori saranno i risultati. Le regole di conservazione eccessivamente generiche rappresentano l'ostacolo più comune , perché bloccano classi e metodi che potrebbero non essere chiamati dinamicamente, insieme alle loro dipendenze. Perfezionare queste regole, misurare e ritestare è il ciclo che distingue un'applicazione rilasciata semplicemente da un'applicazione veramente ottimizzata.
Che cosa fa esattamente R8 e perché dovresti fidarti?
R8 funziona attraverso una serie di fasi interconnesse. Innanzitutto, analizza i punti di ingresso effettivi, come le attività o i servizi dichiarati nel manifest, crea una mappa di tutto ciò che viene referenziato e scarta tutto ciò che si trova al di fuori di tale mappa . Successivamente, passa alle ottimizzazioni logiche: sostituisce le chiamate con il corpo del metodo chiamato, unisce classi e interfacce, semplifica le strutture e riduce l'overhead di esecuzione. Infine, abbrevia i nomi di classi, campi e metodi, in modo che qualcosa come com.example.MyActivity possa finire per essere chiamato aba, con il conseguente risparmio di metadati.
- Meno codice mortoLe dipendenze che utilizzi solo in una piccola percentuale smettono di essere fondamentali.
- Esecuzione più efficienteL'inserimento di metodi e l'unione di classi riducono le chiamate e la pressione sulla memoria.
- File DEX più leggeriL'offuscamento consente di risparmiare metadati e velocizza il caricamento delle classi.
- Risorse modificateDalla versione 8.12 del plugin Gradle, anche R8 partecipa all'ottimizzazione delle risorse.
Dal punto di vista dell'utente, ciò si traduce in tempi di avvio più rapidi, consumo di memoria ridotto, rendering migliorato e meno problemi di mancata risposta dell'app. La raccomandazione ufficiale è chiara: abilitare l'ottimizzazione nella build di rilascio . Per i test quotidiani o lo sviluppo di librerie, di solito non ne vale la pena, perché i tempi di compilazione aumentano e il debug diventa più complicato quando cambiano i nomi.
Abilita l'ottimizzazione in base alla versione del plugin Gradle
Se stai lavorando con le versioni recenti del plugin Android per Gradle, le cose sono state notevolmente semplificate. È sufficiente abilitare un singolo flag all'interno del blocco di ottimizzazione del tipo di build di rilascio e posizionare le regole di mantenimento in un set di codice sorgente specifico, con file che terminano con .keep, ad esempio, in src/main/keepRules. Questo nuovo approccio comprende sia il codice che le risorse e include regole di piattaforma predefinite equivalenti alle precedenti regole ProGuard con ottimizzazione, quindi non è necessario dichiarare file aggiuntivi.
Nei progetti ancorati a versioni precedenti del plugin, l'approccio standard prevede due parametri nel tipo di build di rilascio: uno che abilita la minimizzazione del codice e un altro che abilita la riduzione delle risorse. L'approccio più sensato è quello di abilitarli entrambi simultaneamente e aggiungere il file delle regole ottimizzate generato dal sistema stesso, oltre al proprio file di regole se necessario. Combinare build di rilascio senza questi parametri è uno dei modi più subdoli per regalare megabyte ai propri utenti.
Modalità completa e riduzione ottimizzata delle risorse
La modalità completa di R8 è attiva di default da anni e applica presupposti più restrittivi sull'uso della reflection e delle chiamate dinamiche. Se qualcuno ha mai scritto una proprietà che la disabilita, è meglio eliminarla : mantenerla disattivata riduce il potenziale dell'ottimizzatore. Tuttavia, la modalità completa può richiedere regole aggiuntive in progetti con molto codice dinamico, quindi è sempre consigliabile testarla con una build di rilascio reale e non solo con i test unitari.
La riduzione ottimizzata delle risorse è stata introdotta con la versione 8.12 del plugin e, a partire dalla versione 9.0, viene applicata automaticamente quando la riduzione delle risorse è abilitata. L'idea è di trattare le risorse come parte del grafo del codice : in precedenza, lo strumento di packaging generava regole di conservazione che mantenevano attive risorse e codice inaccessibili che facevano riferimento l'uno all'altro; ora, se una raccolta di codice e risorse non viene utilizzata, non viene protetta e scompare. Nelle app con molte varianti di formato, sono state misurate riduzioni di dimensioni ben superiori al cinquanta percento.
L'analizzatore di configurazione R8 e i suoi tre punteggi
Questo analizzatore è lo strumento che ti dice se la tua configurazione è utile o dannosa. Genera statistiche sulla percentuale del tuo codice effettivamente soggetta a riduzione, ottimizzazione e offuscamento . Se il punteggio di riduzione è del 66%, significa che R8 può rimuovere codice da due terzi del tuo codice; se il punteggio di ottimizzazione è lo stesso, può applicare l'inserimento di metodi, l'unione di classi e altre tecniche solo ai restanti due terzi. Il punteggio di offuscamento misura quanto codice può essere accorciato per risparmiare metadati.
Oltre alle metriche generali, il report descrive in dettaglio l'impatto di ciascuna regola di conservazione e le proprietà di ottimizzazione che essa blocca. Identifica inoltre le regole provenienti da librerie di terze parti , il che è molto utile perché gli autori di queste librerie non hanno familiarità con la tua implementazione specifica e a volte scrivono regole così generiche da paralizzare l'ottimizzazione in parti della tua app che non hanno nulla a che fare con la sua funzionalità.
Come generare il report senza perdere tempo
Per iterare rapidamente sulle regole, esiste un'attività Gradle specifica che analizza la configurazione di rilascio senza creare il pacchetto APK o il bundle. Il ciclo di feedback è molto più breve e il report HTML viene visualizzato nella cartella "reports" del modulo, all'interno di una directory dedicata a R8. Questa è l'opzione consigliata quando si perfezionano le regole e si desidera visualizzare l'effetto immediato di ogni modifica.
Se preferisci l'analisi automatica, ogni build di rilascio genera anche un file HTML all'interno dei risultati della mappatura. Puoi disabilitare questa generazione automatica tramite l'apposita proprietà sperimentale se la trovi fastidiosa. Nelle versioni precedenti del plugin, la soluzione alternativa consiste nell'aggiungere una versione recente di R8 al classpath del progetto ed eseguire la build con una proprietà di sistema che specifica la directory in cui salvare il report.
Perfeziona le regole di conservazione senza compromettere il funzionamento dell'app.
L'obiettivo è preservare solo ciò che è realmente accessibile tramite la riflessione, niente di più, niente di meno. Iniziate esaminando le regole che bloccano l'ottimizzazione in un gran numero di classi , verificando quali elementi proteggono e accertandovi che vengano effettivamente invocate dinamicamente. Quindi restringete il campo: invece di preservare un intero pacchetto con tutti i suoi membri, limitate la regola a classi e membri specifici. E prima di implementare la modifica, eseguite dei test che coprano le classi, i campi e i metodi interessati.
Inoltre, fate attenzione alle regole subordinate. Se una regola protegge un intero pacchetto e un'altra protegge una classe all'interno di quel pacchetto, la seconda non apporta alcun contributo e la prima blocca ottimizzazioni che potrebbero non essere necessarie. Decidete quale delle due è corretta: se quella più specifica è ben scritta, rimuovete quella più generica e sbloccate il resto del pacchetto; se quella generica è corretta, rimuovetela comunque, ma riscrivetela in modo che influisca solo su ciò che è essenziale. Quindi eseguite nuovamente l'analizzatore e compilate una versione completa per verificare che tutto funzioni correttamente.
Regole relative a duplicati, oggetti non utilizzati e libri
L'analizzatore identifica due chiare fonti di confusione: regole che non corrispondono ad alcuna classe, metodo o campo nella build corrente e regole identiche ripetute nello stesso file o in file diversi. Le prime vengono spesso lasciate come spazzatura dopo il refactoring o la rimozione delle dipendenze ; le seconde complicano la manutenzione senza apportare alcun vantaggio. Eliminarle rende la configurazione più facile da leggere e da sottoporre a debug.
Con le librerie di terze parti, il margine di manovra è limitato perché le loro regole sono predefinite e non è possibile modificarle selettivamente. L'approccio più pratico consiste nel documentare l'impatto in un report e informare il manutentore , oppure replicare temporaneamente tali regole nel proprio progetto, escludendo quelle più generali e valutando i potenziali vantaggi prima di decidere se vale la pena correre il rischio.
ProGuard e R8: simili, ma non identici
Per anni, ProGuard ha svolto quattro funzioni principali: rimuovere gli elementi inutilizzati, ottimizzare il bytecode, offuscare i nomi e aggiungere informazioni di pre-verifica. R8 riprende da dove si era interrotto e va oltre: inserisce metodi in modo più aggressivo, unisce le classi, converte le enumerazioni in numeri interi quando possibile e ha una migliore comprensione delle funzionalità di Kotlin . Inoltre, compila più velocemente e, grazie alla semplificazione della libreria principale, consente l'utilizzo di API Java moderne anche su versioni precedenti di Android.
Per quanto riguarda le regole, R8 accetta quelle di ProGuard e aggiunge alcuni modificatori propri, come quelli che forzano o impediscono l'inserimento di un metodo specifico. La conversione dei nomi non cambia il comportamento, ma complica la lettura delle tracce dello stack : conserva sempre il file di mappatura per ogni release al fine di recuperare la traccia originale in caso di errore in produzione.
Errori tipici durante la minimizzazione e come uscirne
Gli stessi problemi continuano a ripresentarsi: "classe non trovata" a causa di una classe eliminata, "metodo inesistente" a causa di un metodo rinominato, modelli non serializzati perché hanno perso il nome o librerie che presuppongono che non ci saranno cambiamenti. La diagnosi quasi sempre prevede di verificare a cosa si accede tramite reflection e di aggiungere la regola minima necessaria . Per indagare, abilitare la stampa di utilizzo, seed e mapping su un file temporaneo oppure disabilitare temporaneamente ottimizzazioni specifiche per isolare il colpevole.
È inoltre importante notare che gli strumenti esterni che rigenerano o modificano i file DEX possono compromettere le ottimizzazioni implementate con cura da R8. Se la tua catena di compilazione include un passaggio di questo tipo, rivedila prima di dare la colpa all'ottimizzatore . E se le prestazioni di compilazione sono un problema, sono disponibili delle modifiche per adattare R8 al tuo ambiente senza sacrificarne i vantaggi.
Ridurre le risorse: immagini, densità e lingue
Le risorse costituiscono in genere una parte considerevole del pacchetto. La conversione delle bitmap in WebP riduce le dimensioni del file mantenendo la qualità , e le risorse vettoriali impediscono la duplicazione della stessa icona per ogni densità. Configurare solo i bucket di densità effettivamente utilizzati e limitare le lingue incluse riduce significativamente le dimensioni del file, soprattutto nelle applicazioni con molte traduzioni. Per i file PNG che non è possibile convertire, esistono utility di compressione con una perdita minima.
Aiuta inoltre a colorare programmaticamente una singola risorsa in scala di grigi anziché raggruppare più versioni colorate, a caricare immagini di grandi dimensioni e non necessarie su richiesta all'avvio e a rimuovere le risorse orfane utilizzando l'ispezione del codice dell'IDE. Se una risorsa viene referenziata solo da codice morto, la riduzione ottimizzata la rileva e la rimuove , cosa che prima non accadeva perché i due processi venivano eseguiti separatamente.
Layout, stili e gerarchie di visualizzazione
Appiattire le gerarchie non riduce le dimensioni dell'APK, ma migliora le prestazioni, che rappresentano l'altra metà dell'obiettivo. Sostituisci l'annidamento superfluo dei contenitori con un ConstraintLayout ben progettato , estrai i componenti comuni con l'include e definisci gli stili per evitare attributi duplicati. L'inspector del layout ti aiuta a individuare alberi di visualizzazione eccessivamente profondi che rallentano l'inflazione.
App Bundle, moduli dinamici e librerie native
Pubblicare in formato bundle è una vera rivoluzione: lo store genera pacchetti personalizzati per ogni dispositivo, in modo che ogni utente scarichi solo il codice e le risorse di cui ha bisogno. Il numero di download è significativamente inferiore rispetto a un APK universale, perché vengono filtrate le lingue, le densità dei dispositivi e le architetture non pertinenti. Inoltre, le funzionalità possono essere distribuite in moduli scaricabili su richiesta, in base a criteri condizionali o immediati.
Per quanto riguarda le librerie native, includere solo le architetture supportate e mantenere la compressione abilitata impedisce di includere binari che nessuno eseguirà. Se si compila con Bazel anziché con Gradle, è anche possibile integrare R8 nella pipeline, sebbene sia importante ricordare che questo supporto non è ufficialmente previsto per lo sviluppo di app Android.
Misurare le dimensioni e monitorare l'evoluzione
Senza misurazione, non c'è ottimizzazione. L'analizzatore APK dell'IDE mostra le dimensioni reali del pacchetto e un'attività Gradle personalizzata può segnalarne le dimensioni dopo ogni build. L'aggiunta di questo controllo all'integrazione continua automatizza il controllo delle dimensioni e impedisce che un paio di nuove dipendenze appesantiscano il binario senza che nessuno se ne accorga.
Come è cambiato il comportamento tra le diverse versioni?
Vale la pena esaminare la recente evoluzione perché spiega molte configurazioni obsolete che non sono più rilevanti. La versione 8.0 ha abilitato la modalità completa per impostazione predefinita ; la 8.6 ha migliorato il retracing, incluso il retracing di file e righe per qualsiasi minSdk; la 8.12 ha introdotto la riduzione ottimizzata delle risorse e il retracing automatico in Logcat; la 9.0 lo ha abilitato per impostazione predefinita, ha filtrato le opzioni globali nelle regole del consumatore e ha ottimizzato il controllo dei valori null di Kotlin; la 9.1 ha riconfezionato le classi per impostazione predefinita; e la 9.3 ha introdotto il blocco di ottimizzazione semplificato e il set di regole .keep.
Tenendo conto di tutto ciò, ciò che fa davvero la differenza è una semplice routine: abilitare l'ottimizzazione in fase di rilascio, rivedere periodicamente il report dell'analizzatore, eliminare le regole non necessarie, ripulire risorse e immagini, distribuire tramite bundle e misurare le dimensioni a ogni rilascio. Questi sono piccoli passaggi che, combinati, trasformano un'app pesante e lenta in un'app che si scarica in un lampo e si avvia all'istante . E poiché il codice e le dipendenze continuano a crescere, la revisione deve essere continua: ciò che è ottimizzato oggi diventa obsoleto non appena viene aggiunta una nuova libreria o incorporata una funzionalità con le proprie risorse.
Domande frequenti
Cosa fa esattamente R8 con il codice della mia applicazione?
Analizza i punti di ingresso dichiarati, crea una mappa di riferimento e rimuove tutto ciò che non è raggiungibile da essi. Quindi riscrive il codice rimanente per eseguirlo con un overhead inferiore e abbrevia i nomi di classi, campi e metodi per risparmiare spazio.
Come si abilita l'ottimizzazione R8 nelle ultime versioni del plugin Gradle?
Si attiva tramite un flag all'interno del blocco di ottimizzazione del tipo di build di rilascio, che riguarda sia il codice che le risorse. Le tue regole personalizzate vanno inserite in un set di codice sorgente specifico, in file con estensione .keep.
Qual è la differenza tra ridurre il codice e ridurre le risorse?
La riduzione del codice elimina classi, campi e metodi irraggiungibili, mentre la riduzione delle risorse rimuove immagini, layout e altri file non utilizzati. Nelle versioni moderne, entrambe le operazioni sono integrate in un unico grafo di riferimento, impedendo la conservazione di risorse collegate esclusivamente da codice obsoleto.
A cosa serve l'analizzatore di configurazione R8?
Misura la percentuale del tuo codice sorgente che rimane disponibile per la riduzione, l'ottimizzazione e l'offuscamento, e analizza l'impatto di ciascuna regola di conservazione. Con questi dati, puoi identificare regole troppo generiche, duplicati e regole che non corrispondono più a nulla.
Perché una regola di conservazione troppo generica influisce negativamente sulle prestazioni della mia app?
Perché impedisce a R8 di modificare non solo ciò che tale regola protegge, ma anche tutto ciò che ne dipende. Il risultato è più codice nel pacchetto, più metadati e meno spazio per applicare l'inserimento di metodi o la fusione di classi.
È meglio pubblicare con App Bundle anziché con un APK universale?
Sì, perché il negozio genera pacchetti personalizzati per ogni dispositivo e ogni utente scarica solo le risorse relative a lingua, densità e architettura di cui ha bisogno. Questa soluzione riduce significativamente le dimensioni del download senza richiedere la gestione di file separati.
Come posso leggere una traccia dello stack da una build offuscata?
È necessario il file di mappatura generato con ogni build di rilascio e applicare lo strumento di retrace di R8. Le versioni più recenti eseguono persino il retrace automatico delle tracce nella finestra Logcat dell'IDE.
Vale la pena ottimizzare una libreria che intendo pubblicare?
L'ottimizzazione completa funziona al meglio quando R8 ha accesso all'intero grafo dell'applicazione, quindi la maggior parte del lavoro viene svolta durante la compilazione dell'app finale. Ciononostante, una libreria può preparare con cura le proprie regole di utilizzo per evitare di bloccare le ottimizzazioni nei progetti che la integrano.
Indice
- 1 Che cosa fa esattamente R8 e perché dovresti fidarti?
- 2 Abilita l'ottimizzazione in base alla versione del plugin Gradle
- 3 Modalità completa e riduzione ottimizzata delle risorse
- 4 L'analizzatore di configurazione R8 e i suoi tre punteggi
- 5 Come generare il report senza perdere tempo
- 6 Perfeziona le regole di conservazione senza compromettere il funzionamento dell'app.
- 7 Regole relative a duplicati, oggetti non utilizzati e libri
- 8 ProGuard e R8: simili, ma non identici
- 9 Errori tipici durante la minimizzazione e come uscirne
- 10 Ridurre le risorse: immagini, densità e lingue
- 11 Layout, stili e gerarchie di visualizzazione
- 12 App Bundle, moduli dinamici e librerie native
- 13 Misurare le dimensioni e monitorare l'evoluzione
- 14 Come è cambiato il comportamento tra le diverse versioni?
- 15 Domande frequenti



