R8: o que é, recursos e comparação com ProGuard

O que é R8?

R8 é um programa de processamento e transformação de bytecode desenvolvido pelo Google como substituto do ProGuard no ecossistema Android. Ao contrário do ProGuard, que funciona como uma ferramenta separada na fase de arquivos class, o R8 é integrado diretamente ao compilador DEX (D8/R8). Isso permite que o R8 realize análise e otimização em um nível mais profundo, inacessível para ferramentas externas.

Arquitetura do R8

R8 recebe bytecode Java no formato de arquivos class ou arquivos JAR como entrada e o converte em código DEX otimizado em uma única passagem. O otimizador integrado do R8 realiza mais de 50 tipos diferentes de transformações — desde simples (inlining de constantes) até complexas (análise de alcançabilidade de tipos com precisão de campo). De acordo com o Google, a arquitetura do R8 é especificamente projetada para operação multithread, garantindo alta velocidade de compilação.

Histórico de desenvolvimento

R8 foi anunciado no Google I/O 2018 e incluído pela primeira vez no Android Gradle Plugin 3.4 (2019) como substituto opcional do ProGuard. No AGP 7.0, o R8 se tornou a ferramenta padrão para todos os projetos, e no AGP 8.0 (2023), o suporte ao ProGuard foi completamente removido do plugin. A partir de 2025, o R8 é a única ferramenta oficial de ofuscação e otimização para Android recomendada pelo Google.

Principais recursos do R8

R8 oferece aos desenvolvedores um conjunto de capacidades poderosas que superam significativamente o ProGuard em eficiência. Vamos ver as principais.

Minificação e compressão de código

R8 realiza uma análise global do código do aplicativo e todas as suas dependências, determinando classes e métodos alcançáveis através de um grafo de chamadas a partir dos pontos de entrada. A análise do R8 é mais precisa que a do ProGuard graças ao acesso à representação DEX do código. O R8 pode remover não apenas classes e métodos inteiros, mas também campos individuais que nunca são usados. De acordo com os testes do Google, o R8 remove em média 15% mais código que o ProGuard nos mesmos projetos.

Desugaring Java 8+

O desugaring integrado é um recurso único do R8 ausente no ProGuard. O R8 converte automaticamente expressões lambda, referências a métodos, interfaces com métodos default e try-with-resources do Java 8+ em código compatível com versões anteriores que funciona em todos os níveis de API do Android. Isso elimina a necessidade de o desenvolvedor adicionar uma biblioteca separada desugar_jdk_libs e configurar manualmente o desugaring.

Otimização em nível DEX

Como R8 vê o formato DEX final, ele pode realizar otimizações impossíveis para o ProGuard. O R8 mescla constantes de string idênticas, remove exceções não utilizadas, otimiza construções switch e realiza inlining agressivo com reescrita do grafo de chamadas. Essas otimizações não apenas reduzem o tamanho do APK, mas também melhoram o desempenho da execução do código no ART.

// Ativar R8 explicitamente no build.gradle (opcional no AGP 8.0+)
android {
    compileSdk 34
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
                'proguard-android-optimize.txt'
            ), 'proguard-rules.pro'
        }
    }
}

// gradle.properties — forçar ativação do R8
android.enableR8.fullMode=true

Comparação R8 vs ProGuard

A escolha entre R8 e ProGuard só é relevante para projetos que usam AGP anterior ao 8.0. Para entender as diferenças arquiteturais, vejamos a comparação por parâmetros-chave.

Tamanho final do APK

Testes do Google em uma amostra de 100 aplicativos populares da Play Store mostraram que R8 reduz o tamanho do APK em média 18% em comparação com o ProGuard. Em alguns projetos com uso intensivo de sintaxe Java 8+ e bibliotecas de terceiros, a diferença chegou a 28%. Para um aplicativo de 40 MB, isso significa economia de 5 a 11 MB, o que é crítico para usuários com largura de banda limitada.

Compatibilidade com Kotlin

Ambas as ferramentas lidam corretamente com código Kotlin, mas R8 otimiza melhor construções específicas do Kotlin: lambdas, funções inline, corrotinas e tipos null-safe. O R8 entende a semântica dos metadados do Kotlin e pode remover com segurança verificações null desnecessárias e incorporar funções inline. Para projetos em Kotlin, o R8 é a ferramenta recomendada pelo Google.

Configuração do R8 em um projeto Android

A configuração do R8 requer mudanças mínimas na configuração de compilação, já que no AGP 8.0+ a ferramenta é usada por padrão. Vamos ver os principais aspectos de configuração.

Modo completo do R8

R8 full mode (android.enableR8.fullMode=true) ativa otimizações mais agressivas que proporcionam uma redução adicional de 5-10% no tamanho do APK. Neste modo, o R8 realiza uma análise de código mais profunda, removendo classes e métodos que o ProGuard consideraria alcançáveis. O modo completo pode exigir regras -keep adicionais para bibliotecas que usam reflection.

# gradle.properties — ativar o modo completo do R8
android.enableR8.fullMode=true

# Regras adicionais para full mode
-keep class com.example.reflection.** { *; }
-keep class * implements android.os.Parcelable {
    public static final android.os.Parcelable$Creator *;
}

Depuração de problemas do R8

Quando ocorrem erros em uma compilação release com R8, o Google recomenda: verificar o arquivo mapping para desofuscação de stack trace, desabilitar temporariamente o fullMode para isolar o problema, adicionar -whyareyoukeeping para entender por que uma classe não foi removida e usar a flag --info do Gradle para obter um log detalhado do processamento do R8.

Integração com CI/CD

Para automatizar compilações com R8 em CI/CD, é importante salvar os arquivos mapping como artefatos de compilação. Cada arquivo mapping deve estar vinculado ao número da versão e variante de compilação. O Google recomenda arquivar build/outputs/mapping/ junto com APK/AAB no sistema de gerenciamento de artefatos. Isso garantirá a capacidade de desofuscar crashes de qualquer versão do aplicativo.

Melhores práticas com o R8

Anos de experiência usando R8 na comunidade Android produziram um conjunto de práticas comprovadas que ajudam a evitar problemas típicos e obter o máximo benefício da ferramenta.

Adoção gradual

Ao migrar do ProGuard para R8, recomenda-se começar com AGP 7.x, onde o R8 está ativado por padrão mas o fullMode está desativado. Após verificar a estabilidade da compilação em um conjunto completo de dispositivos e cenários, o fullMode pode ser ativado. Cada etapa requer testar a compilação release em dispositivos físicos com diferentes versões do Android.

Monitoramento de arquivos mapping

Os arquivos mapping do R8 têm o mesmo formato que o ProGuard, mas contêm mais informações graças a uma análise mais detalhada. O Google recomenda: armazenar arquivos mapping indefinidamente — eles são necessários para desofuscar crashes de versões antigas; integrar arquivos mapping com Firebase Crashlytics através de upload automático; verificar regularmente se a desofuscação no console do Firebase restaura corretamente os nomes das classes.

Testes com R8 full mode

O modo completo do R8 pode remover código considerado alcançável no modo padrão. Áreas críticas para teste: telas com WebView (R8 pode remover classes de interfaces bridge), aplicativos com plugins via classLoader, bibliotecas de análise e relatório de crashes e visualizações personalizadas em arquivos layout criadas via inflate.

Monitoramento do tamanho da compilação

O Google recomenda rastrear o tamanho do APK após aplicar o R8 em cada compilação. Use o APK Analyzer no Android Studio para comparar o tamanho de componentes individuais: classes.dex, resources.arsc e bibliotecas de código nativo. O R8 pode afetar o tamanho dos arquivos DEX de forma não linear — às vezes a otimização agressiva leva ao aumento de tamanho devido ao inlining. O monitoramento regular ajuda a detectar oportunamente anomalias e ajustar as regras de ofuscação.

// Exemplo de classe preservada para Firebase Crashlytics
@Keep
class CrashLogger {
    fun logException(e: Throwable) {
        FirebaseCrashlytics.getInstance().recordException(e)
    }
}

// rules.pro — preservar todas as classes com @Keep
// -keep @androidx.annotation.Keep class * { *; }