Engenheiro de desempenho do Android
Os apps Android geralmente são enviados sem otimização devido a regras de manutenção excessivamente conservadoras, muitas vezes de bibliotecas de terceiros, o que leva a APKs inchados, inicializações a frio mais lentas e desempenho de execução degradado.
Com os novos limites de performance do Google Play para otimização de DEX, a visibilidade do app agora depende diretamente de ficar à frente da curva de otimização.
Esta palestra apresenta um fluxo de trabalho moderno do R8 para lidar com o excesso de regras. Você vai aprender a:
Transcrição
Olá a todos!
Meu nome é Breana, faço parte da equipe de DevRel do Android.
E eu sou Chris Craik, da equipe de desempenho do Android.
Este é o curso sobre regras de manutenção com segurança de tipos e otimização de DEX.
Hoje, vamos falar sobre o que é a otimização de DEX, por que ela é importante e algumas atualizações recentes e interessantes.
Por muito tempo, a otimização de DEX foi tratada como algo que é apenas bom ter.
Talvez você configure uma vez e deixe como está, ou talvez faça isso quando tiver um tempo livre.
No entanto, com o setor de dispositivos móveis enfrentando restrições significativas de fornecimento de hardware que estão alterando a disponibilidade de memória do dispositivo, um DEX bem otimizado é essencial para que seu app use menos memória, seja iniciado mais rapidamente, reduza os ANRs e melhore o desempenho de renderização e de execução em geral.
Para manter um ecossistema Android saudável e garantir que seus apps continuem oferecendo experiências premium, o Google Play anunciou o novo requisito de qualidade de apps com limites de desempenho que entram em vigor em fevereiro.
Isso inclui limites para a otimização de código DEX.
Os apps precisam atingir mais de 25% de redução, otimização e ofuscação.
O que isso significa para você como desenvolvedor Android?
O código DEX não otimizado não só afeta negativamente a experiência do usuário, mas também pode ter implicações na visibilidade e nos recursos de publicação do app na Google Play Store.
No entanto, você está no lugar certo. Ao final desta palestra, você terá as ferramentas para não apenas atender, mas superar esses requisitos.
A otimização de código DEX pode ser feita com o R8, o otimizador de apps do Android.
Embora o R8 não seja estritamente obrigatório se outro otimizador de apps puder colocar seu app acima desses limites, ele é o caminho recomendado, integrado diretamente ao conjunto de ferramentas do Android.
Embora um pacote de app DEX bem otimizado use menos memória, os principais benefícios ainda estão relacionados ao desempenho: menos ANRs, inicialização mais rápida e melhor desempenho de execução.
E otimizar seu app tem resultados reais, comprovados e positivos para ele e para os usuários.
Por exemplo, ao adotar o modo completo do R8 e refinar as regras de manutenção, o Grab conseguiu 78% de otimização, 79% de redução e 82% de ofuscação no app.
Você pode estar olhando para este slide e pensando: "Ok, esses números são bem altos, mas o que isso realmente significa?"
Como resultado dessas melhorias, combinadas com os perfis de referência, eles reduziram os ANRs em 32% e melhoraram a inicialização em 35%.
Quando os principais apps adotam o R8, eles têm uma redução média de 38% no tamanho do DEX e de 16% nos ANRs percebidos pelo usuário.
E se você já usa o R8, temos ótimas notícias.
Os apps que já ativaram o R8 e, em seguida, tomaram medidas para melhorar ainda mais os níveis de otimização, redução e ofuscação para mais de 50% tiveram, em média, uma redução adicional de 25% no tamanho do DEX, uma redução de 4% no tempo de inicialização e uma redução adicional de 17% nos ANRs percebidos pelo usuário, além dos 16% que mostramos no slide anterior.
Hoje, vamos mostrar como você pode alcançar números como esses.
Vamos falar sobre as ferramentas que podem ajudar você a otimizar seu código DEX e mudar de regras de manutenção excessivamente amplas e mal configuradas para regras específicas e restritas.
Primeiro, queremos mencionar que o R8 já existe há muitos anos.
E reconhecemos que, embora tenha permitido uma otimização de alto impacto, ainda é preciso ter muito cuidado ao configurar.
As chamadas reflexivas significam que as entradas são imprevisíveis e podem causar falhas no tempo de execução.
Isso já levou as equipes de apps e de bibliotecas a adicionar regras de manutenção excessivamente amplas para garantir a segurança.
Sabemos que 41% dos principais apps estão abaixo dos níveis de otimização de 25% definidos pelo Google Play, mas também sabemos que 13% dos principais apps já estão alcançando o triplo desse limite.
E são apps de uma grande variedade de setores e jornadas do usuário que conseguem atingir esse número.
E é possível alcançar pontuações altas de otimização para seu app, desde que você tenha as ferramentas e a visibilidade certas para gerenciar as regras de manutenção próprias e as herdadas de bibliotecas.
Antes de falarmos sobre as novas ferramentas e melhorias que vão ajudar com isso, também queremos destacar algumas outras melhorias do R8 do ano passado que também facilitam essa otimização.
Primeiro, os novos modelos de app incluem um escopo de pacote, o que é útil para garantir um nível mínimo de otimização desde o início.
O analisador de configuração do R8, que vamos abordar em breve, agora é compatível com versões mais antigas do AGP.
Ele também tem suporte não oficial para o Bazel.
E no AGP 9.2, as primitivas de corrotina ficaram duas vezes mais rápidas.
E, como resultado das melhorias do R8 feitas no AGP 9.2, o Tinder teve uma redução de 13% nos ANRs após o upgrade da versão 9.0.1.
O AGP 9.3 também traz uma API R8 reformulada com nomes mais claros, padrões mais simples para regras padrão e redução de recursos, além de suporte ao diretório de origem do AGP para regras de manutenção.
android {
buildTypes {
release {
optimization {
// no need to specify default
// rules and resource shrinking
enabled = true
}
}
}
...
}android {
buildTypes {
release {
// Enables code optimizations.
isMinifyEnabled = true
// Enables resource shrinking.
isShrinkResources = true
proguardFiles(
// Default rules.
getDefaultProguardFile(
"proguard-android-optimize.txt"
),
... // list out each file with keep rules
)
...
}
}
...
}As atualizações que vamos abordar hoje também são melhorias na experiência do desenvolvedor.
Vamos começar explicando como usar o Analisador de Configuração do R8 e a habilidade do R8 para identificar a sobrecarga de regras legadas e determinar um caminho para melhorias.
Em seguida, Chris vai explicar como fazer a transição de regras de manutenção amplas e curingas para as novas anotações precisas, com segurança de tipos e geradas automaticamente.
Por fim, vamos analisar como usar as novas ferramentas de validação da CLI para garantir uma otimização agressiva sem introduzir falhas.
O analisador de configuração do R8 é o lugar ideal para começar sua investigação de otimização do DEX.
Se você ainda não usou a ferramenta, ela é assim.
É um relatório HTML que mostra informações sobre sua configuração do R8.
Este relatório é para meu app, que inclui uma biblioteca chamada Analytics Bloat.
Como você pode imaginar, esse não é um app ou uma biblioteca de verdade, mas está destacado em azul na parte de cima.
O Config Analyzer mede o seguinte: redução, que é a porcentagem de classes, métodos e campos que o R8 não é impedido de reduzir pelas regras de manutenção.
Isso é calculado depois que o R8 realiza a primeira passagem de redução.
Ele também mede a otimização, que é a porcentagem de código aberta para otimizações de todo o programa, como inserção de métodos e mesclagem de classes.
E a ofuscação, que é a porcentagem de membros que podem ser ofuscados ou renomeados para identificadores mais curtos.
Como o R8 Config Analyzer calcula essas pontuações antes das otimizações finais e da compilação DEX, os valores que você vê nesse relatório para otimização, redução e ofuscação não vão corresponder exatamente aos valores que você vê no Play Console.
Isso ocorre porque o Google Play mede a saída final do DEX.
O motivo dessa discrepância é garantir que, durante o desenvolvimento, você possa acessar um loop de feedback local rápido.
Mas as pontuações que você vê no Analisador de Configuração do R8 ainda são muito úteis para validar o potencial de otimização do DEX antes de fazer o upload para a Google Play Store.
O relatório também inclui a tabela "Análise da regra de retenção", que é a visualização principal que você vê ao entrar no relatório.
Depois, clique em qualquer regra para ver o número exato de classes, métodos e campos que ela está mantendo. Assim, você pode identificar quais regras estão mantendo mais do que deveriam.
Ele também tem regras subsumidas, que é o que está ampliado aqui.
Essas regras se sobrepõem a uma regra mais ampla.
Eles são destacados para que você possa remover o amplo e manter apenas o mais restrito.
Ele também mostra regras não utilizadas, que podem ser excluídas sem riscos para a estabilidade do app.
Por isso, o Config Analyzer foi projetado para resolver alguns problemas, começando com o acúmulo de regras legadas.
Antes, sem a visibilidade por regra, era um pouco arriscado excluir regras antigas.
Por isso, as equipes os deixavam de lado ou adicionavam caracteres curinga mais amplos.
Segundo, ele ajuda a descobrir pontos cegos nas regras da biblioteca.
Por isso, ao adicionar um SDK, sempre foi difícil saber se uma regra incluída nessa biblioteca é muito ampla ou se ela ainda é necessária, por exemplo, 10 versões depois.
Também vamos falar mais sobre bibliotecas em breve.
Terceiro, ele ajuda a avaliar o impacto da otimização.
Antes, não era fácil saber se uma regra estava mantendo duas classes ou 2.000.
Vamos ver como o R8 funciona no contexto do meu app e da biblioteca que analisamos anteriormente.
Aqui, tenho um módulo de app e três bibliotecas.
Preste atenção na biblioteca três à direita.
Essa é a biblioteca Analytics Bloat, que inclui uma regra de manutenção para todo o pacote.
Primeiro, o R8 identifica o ponto de entrada raiz de todas as regras de manutenção mescladas, que estão destacadas em amarelo.
Em geral, esses devem ser os principais pontos de entrada do app, como classes no manifesto.
E, devido à regra de manutenção de caracteres curinga da biblioteca Analytics Bloat, cada classe na biblioteca é tratada como um ponto de entrada.
Em seguida, o R8 rastreia a acessibilidade no gráfico de chamadas dessas raízes.
Qualquer classe que possa ser acessada de uma raiz é marcada para retenção em verde, enquanto as classes não referenciadas são classificadas como código morto e marcadas em vermelho aqui.
Em seguida, o R8 realiza o tree shaking e remove o código morto não referenciado.
Após essa remoção de código morto, ou a primeira passagem de redução, é isso que resta.
E nosso app tem uma pontuação de redução de 42,5%, que está acima do limite de 25% do Google Play, mas ainda não é o ideal.
Isso se deve principalmente à regra de manutenção em todo o pacote da biblioteca de análise.
Isso faz com que apenas 17 das 40 classes restantes possam ser reduzidas ainda mais.
O que quero dizer com isso é que uma regra de manutenção ruim pode causar grandes problemas para a otimização do app.
Com isso em mente, vamos nos concentrar rapidamente nas bibliotecas.
No ano passado, nossa equipe investiu muito para entender como as regras de manutenção do consumidor da biblioteca estão afetando a otimização do ecossistema.
Muitas bibliotecas são enviadas com regras excessivamente amplas em nome da estabilidade.
Ou também especificam regras gerais na documentação para que os desenvolvedores de apps as adicionem aos próprios aplicativos.
No entanto, o envio com regras amplas não é necessário para a estabilidade e afeta negativamente o desempenho, em que os custos são principalmente seus, como desenvolvedores de apps.
Já vimos casos em que toda a biblioteca é preservada por uma regra de manutenção em todo o pacote, como a biblioteca de análise de dados, e, no caso dessa biblioteca, isso teve impactos de longo alcance no potencial de otimização do meu app.
Também quero mencionar que nem mesmo os SDKs do Google estavam imunes a isso, e mais de uma dúzia de bibliotecas do Google corrigiram regras de manutenção excessivamente amplas no ano passado.
Se você quiser usar o analisador de configuração, ele está integrado diretamente ao AGP 9.3, mas também está disponível para versões mais antigas se você fizer upgrade da versão do R8.
Portanto, a execução desse comando vai gerar o relatório HTML que mostramos, com as regras de manutenção, os impactos na redução, otimização e ofuscação para regras individuais e para o app como um todo.
Se você estiver executando um build de lançamento completo do R8, o relatório será gerado automaticamente e poderá ser encontrado neste caminho de arquivo.
O benefício dessa tarefa independente é que ela leva menos tempo para ser gerada do que o build completo.
A equipe da WHOOP, que pode estar aqui em algum lugar, executou o analisador de configuração e conseguiu 74% de redução, 74% de ofuscação e 0% de otimização.
Como você pode imaginar, a equipe ficou muito surpresa com esse valor de otimização.
A visibilidade do analisador de configuração ajudou a descobrir que o build estava usando um arquivo ProGuard legado que desativava a otimização. Ao mudar para a versão atualizada, eles conseguiram ativar a otimização para o app.
Isso levou a uma otimização de 55% e uma redução de 4% no tamanho do APK.
Combinados com os perfis de referência, eles melhoraram os horários de início a frio em 38% e reduziram os frames congelados em excesso em 28%.
A tela à esquerda não tem perfis de referência, e a tela à direita tem. Como você pode ver, a inicialização do app é mais rápida com a adição de perfis de referência.
Vamos repetir mais uma vez.
Legal.
Este link leva ao guia do analisador de configuração. Analisar o relatório manualmente é ótimo, mas, dependendo do estado da configuração do R8 do seu app, isso pode levar muito tempo.
Para acelerar as coisas, temos uma habilidade do R8 Analyzer.
$ android skills list
$ android skills add r8-analyzerVocê pode pedir ao agente para analisar sua configuração do R8, e a habilidade não apenas gera o relatório do analisador de configuração do R8, mas também indica as regras mais impactantes.
Veja um exemplo de saída. Para destacar alguns detalhes, ela mostra a pontuação de otimização de 42%, o que significa que 58% da base de código não pode ser otimizada pelo R8.
E se olharmos especificamente para a seção de regras de retenção, a regra de retenção para todo o pacote da biblioteca de análise de dados impede que 22% da base de código seja otimizada. A habilidade também recomenda que refinemos essa regra de retenção, já que, como já sabemos, ela é muito ampla.
Agora você pode diagnosticar o que está causando o aumento do tamanho do app e bloqueando a otimização do DEX usando o analisador de configuração do R8 e a habilidade.
Mas, depois de encontrar uma regra de manutenção excessivamente ampla, como substituí-la com segurança sem introduzir acidentalmente uma falha inesperada?
Vou passar a palavra para o Chris, que vai mostrar como fazer a transição das regras de manutenção legadas para as novas anotações de manutenção geradas automaticamente com segurança de tipos.
Obrigada, Breana.
Certo, vamos falar sobre como chegamos até aqui.
Com essa biblioteca de análise inchada, com todas essas regras de manutenção que estão, com essa regra de manutenção que está mantendo basicamente tudo, o problema principal que estamos enfrentando é a reflexão.
Vamos dar uma olhada em um pouco do código reflexivo para lembrar.
fun createWithReflection(className: String): MyObject {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as MyObject
}Essa é uma função de instanciação de objeto que apenas infla um objeto específico de forma reflexiva.
A desvantagem disso, no contexto da otimização de DEX, é que todas essas chamadas estáticas são atrasadas até o ambiente de execução.
Ao analisar o código, dependendo de onde o nome da classe vem, o otimizador R8 não consegue ver o que está acontecendo.
Essas são as situações que interrompem a otimização do Dex por padrão. Portanto, normalmente é necessário adicionar uma regra de manutenção.
O ideal é evitar isso, certo?
O ideal é evitar totalmente a reflexão, especialmente agora em 2026, quando temos ferramentas incríveis de geração de código para serialização e injeção de dependência, que podem eliminar completamente essa categoria de problema.
Mas não é tudo, certo?
Ainda precisamos da reflexão em alguns casos.
Vamos analisar como isso aconteceu nessa biblioteca inchada.
Este é um exemplo específico e comum de dependência opcional.
// Problem 1 - optional dependency
fun tryInitCrashReporter(context: Context): EventTransport? {
return runCatching {
Class.forName("com.example.analytics.bloat.crash.CrashReporterTransport")
.getDeclaredConstructor(Context::class.java)
.newInstance(context) as? EventTransport
}.getOrNull()
}
// Problem 2 - dynamically instantiate subclass
fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}
// Problem 3 - serialization
fun serializeEvent(event: UserActionEvent): JSONObject {
val json = JSONObject()
for (field in event.javaClass.declaredFields) {
field.isAccessible = true
json.put(field.name, field.get(event))
}
return json
}Aqui, estamos inflando um tipo específico que não pode ser acessado no caminho de classe da biblioteca. Por isso, precisamos fazer isso com uma string.
Isso faz referência a essa classe específica que pode ou não estar presente no momento em que a biblioteca foi criada. Portanto, é muito razoável que essa biblioteca esteja usando a reflexão para encontrar um membro em uma biblioteca relacionada.
Outro caso que temos aqui é a instanciação dinâmica de subclasses.
Portanto, especialmente se for algo que vem de um arquivo de manifesto ou que está sendo enviado do lado do servidor, estamos informando ao app local: "Ei, por favor, infle isso, crie isso mais tarde".
E essa terceira categoria que vemos aqui é a serialização embaraçosa.
Quero dizer, tenho uma serialização JSON que está acontecendo ao iterar por todos os membros.
Isso é absolutamente nojento, mas, você sabe, esse tipo de coisa às vezes fica por aí.
Nem sempre é corrigido no momento em que é necessário.
Mas vamos falar sobre o resultado disso, certo?
À medida que essas chamadas reflexivas se acumulam, você se sente mais motivado a fazer o que é mais fácil e otimizar a experiência do desenvolvedor em vez da experiência do usuário.
Isso é bem ruim, então vou adicionar uma tarefa e vai ficar tudo bem.
# TODO: clean this up
-keep com.example.analytics.bloat.** { * };Algum dia, eu vou voltar e consertar, certo?
Então, vamos falar sobre o que devemos fazer, o que deveríamos fazer pelo menos antes de hoje, como você escreveria uma regra Keep ideal aqui.
fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}Então, aperte os cintos.
A primeira parte é que queremos manter a classe específica que estamos retornando dessa função reflexiva.
### Keep the EventFilter
-keep class com.example.analytics.bloat.EventFilter {
*
}Não, espera.
Quer saber?
Isso não está correto.
Esta é uma classe Kotlin, preciso garantir que ela seja do tipo string. Deixe-me colocar o KT ali.
### Keep the actual EventFilter
-keep class com.example.analytics.bloat.EventFilterKt {
*
}Na verdade, o importante aqui é que não estou retornando um EventFilter, mas sim uma subclasse de EventFilter. Por isso, preciso manter as classes que estendem EventFilter para poder inflar isso corretamente.
### Keep the EventFilter subclasses
-keep class ** extends com.example.analytics.bloat.EventFilterKt {
*
}E, se eu quiser fazer isso de forma mais eficiente, o que funcionaria, mas para tornar mais eficiente, como um bom desenvolvedor de bibliotecas, o que eu deveria fazer?
Bem, eu deveria dizer -keepclasseswithmembers e manter apenas as classes que têm esse construtor <init> específico que estou usando para inflar o objeto.
### Keep the EventFilter subclasses, if they have this constructor
-keepclasseswithmembers class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}E, se eu quiser ser muito legal, vou adicionar allowaccessmodification para permitir que ainda mais otimização aconteça em todas as APIs que estão sendo visadas por essa regra Keep, porque eu não quero impedir que o R8 faça mais otimizações. Quero tentar ser um bom cidadão.
### Keep the EventFilter subclasses, if they have this constructor, allow more optimization
-keepclasseswithmembers,allowaccessmodification class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}E, por fim, a última etapa que quase ninguém faz, porque é um trabalho extra, mas é ótima para uma biblioteca, é torná-la condicional.
### -if makes this conditional, critical for libraries
-if class com.example.analytics.bloat.EventToolsKt {
class com.example.analytics.bloat.EventFilterKt createEventFilter(java.lang.String);
}
### Keep the EventFilter subclasses, if they have this constructor, allow more optimization
-keepclasseswithmembers,allowaccessmodification class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}Conceitualmente, não é necessário manter todas essas subclasses, a menos que você esteja chamando essa função, e é isso que essa instrução if faz na parte de cima de uma regra Keep.
Eu poderia pedir para vocês levantarem as mãos, mas sei que quase ninguém faz isso, certo?
Como escrever e tornar condicional.
E se pudéssemos melhorar um pouco mais?
Vamos Vamos primeiro ver, tipo, ok.
Talvez haja outra maneira de fazer isso.
Então, falamos sobre o que acontece se eu escrever uma regra de Keep restrita e manual.
Bem, é possível tecnicamente, mas é difícil de escrever, ler e manter, porque há muitos pequenos bits de string que são fáceis de quebrar quando algo acontece por baixo.
Por baixo, algo muda.
E temos alternativas.
Temos anotações como @Keep.
A anotação @Keep está no pacote de anotações do AndroidX há muito tempo, mas não é mais recomendada.
@androidx.annotation.Keep
class EventFilter { … }
@androidx.annotation.Keep
class SizeBasedEventFilter { … }
@androidx.annotation.Keep
class DropLogsEventFilter { … }Não é uma boa solução para desenvolvedores de bibliotecas e, na verdade, é meio que proibido internamente, porque, embora seja mais fácil de manter, é muito inflexível e não apresenta algumas das otimizações que mencionei antes.
Não tem como.
Ele não permite essa análise do site de chamada.
Agora, se analisarmos o caso específico que tínhamos antes, "Ah, posso colocar @Keep no meu EventFilter, tudo bem, certo?"
@Keep
class EventFilter { … }Bem, não.
A anotação @Keep não segmenta subclasses, apenas a classe em questão.
@Keep
class EventFilter { … }
@Keep
class SizeBasedEventFilter { … }
@Keep
class DropLogsEventFilter { … }Na verdade, preciso segmentar todas as subclasses, e agora estou escrevendo mais anotações @Keep do que com aquela única regra Keep que era difícil de escrever.
Ambas as abordagens têm problemas, certo?
É fácil esquecer deles, você só descobre que eles existem tarde demais e eles não são condicionais ao autor da chamada por padrão.
Especialmente para bibliotecas, queremos uma maneira melhor.
Queremos que seja mais fácil fazer as coisas funcionarem de forma imediata.
E um dos grandes problemas que vemos aqui é que essas coisas estão longe da reflexão contra a qual estamos nos protegendo.
No fim das contas, a solução que queremos é algo que fique bem ao lado do código de reflexão que está inflando os itens de destino.
Vamos falar sobre o Jetpack Keep, a nova biblioteca e plug-in do AndroidX projetada para ajudar exatamente com esse problema.
Então, para usar, o objetivo do Jetpack Keep é começar gerando regras de retenção com base em anotações, mas indo além disso, gerando anotações diretamente da reflexão que já está na base de código.
A configuração é muito simples.
plugins {
id("com.android.library")
id("androidx.annotation.keep")
}
dependencies {
implementation("androidx.annotation.keep:keep")
...
}É um plug-in do Gradle, uma biblioteca de anotações.
Mas vamos ver como isso realmente é executado no momento da criação.
Então, se eu tiver esse exemplo anterior em que estou inflando uma subclasse de um tipo conhecido, o que preciso fazer?
Basta executar lintFix.
./gradlew analyticsbloat:lintFixO Lint analisa toda a reflexão que está acontecendo dentro desse método e diz: "Ei, você precisa dessa anotação".
@UsesReflectionToConstruct(
classConstant = EventFilter::class,
parameterTypes = []
)
fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}Essa anotação expressa exatamente o que a reflexão dentro dessa chamada está fazendo.
Ele diz: "Estou inflando uma classe desse tipo".
Nesse caso específico, EventFilter é uma classe conhecida.
Não estou usando uma string para fazer referência a ele porque não é necessário.
Isso é uma segurança extra, e eu estou até codificando o parameterTypes para que ele diga exatamente qual construtor está sendo mantido.
Mas o que isso faz?
Como isso informa um eventual build do R8?
Bem, ele gera a regra de manutenção e, como você viu antes, essa é exatamente a mesma regra de manutenção ideal que tínhamos antes.
# Generated Keep Rule
-if class com.example.analytics.bloat.EventTools {
class com.example.analytics.bloat.EventFilter createEventFilter(java.lang.String);
}
-keepclasseswithmembers,allowaccessmodification class ** extends class com.example.analytics.bloat.EventFilter {
void <init>();
}Ele segmenta exatamente as mesmas classes, as subclasses, e é condicional a esse ponto de reflexão.
E não preciso me preocupar em anotar todas as subclasses.
Não preciso manter um arquivo de regras de retenção separado em nenhum outro lugar.
Essa é uma maneira muito mais fácil de gerenciar suas regras de retenção.
Vamos voltar ao exemplo de dependência opcional.
@UsesReflectionToConstruct(
className = "com.example.analytics.bloat.crash.CrashReporterTransport",
parameterTypes = [Context::class]
)
fun tryInitCrashReporter(context: Context): EventTransport? {
return runCatching {
Class.forName("com.example.analytics.bloat.crash.CrashReporterTransport")
.getDeclaredConstructor(Context::class.java)
.newInstance(context) as? EventTransport
}.getOrNull()
}Nesse caso, a classe não estava no caminho de classe, mas ainda posso fazer referência a ela.
Eu faço isso usando uma string, mas todo o resto, os tipos de parâmetro, podem ser referenciados por referências de classe, então eu faço isso.
E, novamente, geramos a regra de manutenção ideal para esse caso.
# Generated Keep Rule
-if class com.example.analytics.bloat.CrashConnection {
class com.example.analytics.bloat.EventTransport tryInitCrashReporter(android.content.Context);
}
-keepclasseswithmembers,allowaccessmodification class com.example.analytics.bloat.crash.CrashReporterTransport {
void <init>(android.content.Context);
}Ela é condicional, específica e direcionada, além de permitir otimizações sempre que possível nessas classes direcionadas.
Aqui está a reflexão sobre os campos. Nesse caso específico, eu estava iterando em todos os campos dentro de um objeto, mas aqui, novamente, lidamos com isso de forma adequada, dizendo para segmentar todos os campos com esse operador de estrela.
// TODO: migrate to Kotlinx Serialization or Moshi codegen.
@UsesReflectionToAccessField(
classConstant = UserActionEvent::class,
fieldName = "*"
)
fun serializeEvent(event: UserActionEvent): JSONObject {
val json = JSONObject()
for (field in event.javaClass.declaredFields) {
field.isAccessible = true
json.put(field.name, field.get(event))
}
return json
}Isso me permite segmentar todos os campos e, veja, ele gera a regra de manutenção exata que você esperaria para essa reflexão, sabe, incrivelmente infeliz que não deveria estar no meu app, mas, ei, vou voltar e limpar isso, eu prometo.
# Generated Keep Rule
-if class com.example.analytics.bloat.serialization.EventSerializer {
class org.json.JSONObject serializeEvent(com.example.analytics.bloat.model.UserActionEvent);
}
-keepclasseswithmembers,allowaccessmodification class com.example.analytics.bloat.model.UserActionEvent {
<fields>;
}Então, o que o Jetpack Keep faz?
Reduz drasticamente a manutenção das regras de retenção.
Tudo o que pode ser gerado automaticamente é removido da sua área de preocupação e da sua área de risco para manter as regras de manutenção.
Ele também oferece o determinismo do lint.
Ele não apenas corrige as coisas para você enquanto você itera e tenta migrar, mas também detecta novas reflexões e mudanças reflexivas sempre que o código muda, e essa segurança é absolutamente essencial.
Posso usar?
Então, quais são as dependências aqui?
O plug-in e o lint exigem o AGP 8.7.
Isso deve ser quase todo mundo.
Mas também é muito flexível em relação a onde você pode usar isso.
Você pode usar isso em apps.
Você pode usar isso em bibliotecas do Android, AARs, bibliotecas KMP e JARs, com um pouco de fiação manual nesse caso.
Mas o principal recurso aqui é que ele é seguro para uso como desenvolvedor de bibliotecas.
Mesmo que alguém esteja usando uma versão antiga do R8 ou até mesmo uma ferramenta de terceiros que esteja consumindo sua biblioteca, ainda exportamos regras de consumidor padrão reais para que qualquer pessoa possa usar você e não precise se preocupar em consumir algum tipo de novo formato incompatível.
Agora que já falei sobre como o Jetpack Keep pode ajudar você a otimizar e se preocupar menos com a proteção das chamadas de código reflexivo, vamos falar sobre os novos recursos que lançamos recentemente na CLI do Android para verificar a última etapa de lançamento.
A Breana mencionou antes que as Descobertas do Google Play mostram informações sobre o tamanho do app, o tamanho do DEX e as porcentagens de otimização.
Agora, começamos a disponibilizar isso também pela CLI do Android.
Ele usa exatamente a mesma lógica da Google Play Store. Assim, sem precisar fazer upload de um pacote para a Google Play Store, você pode usar a CLI para analisar seu pacote.
$ android analyze <mybundle.aab>
$ android analyze <mybundle.apk>E você recebe as mesmas informações diretamente e de imediato com a análise local.
Neste caso específico, o app está recebendo um aviso sobre uma taxa de otimização muito baixa e também uma mensagem: "Este é o tamanho do DEX, e estas são as porcentagens de otimização", exatamente como a Google Play Store faria.
Mas também temos uma saída JSON. Se você quiser escrever um script para automatizar os testes de regressão em relação a qualquer um desses valores que caem drasticamente, porque, novamente, esses são os números que o Google Play aplica, você quer acompanhar esses números, pode fazer isso facilmente com esse valor JSON, esses relatórios JSON.
{
"optimization": {
"bundleAnalysisResult": {
"agpVersion": "9.3.2",
"r8Json": {
"version": "9.3.16",
"options": {
"isRepackageClassesEnabled": true,
"isProguardCompatibilityModeEnabled": false
},
"stats": {
"shrinkingRatio": 0.2306,
"optimizationRatio": 0.2351,
"obfuscationRatio": 0.2322
},
...
}
"mappingObfuscationRatio": 0.21631891,
"dexHeuristicObfuscationRatio": 0.25118626,
"uncompressedDexSizeBytes": "16198152"
}Aqui, vemos que os mesmos números também estão presentes.
Mas esse não é o único recurso do android analyze.
O android analyze também pode ser executado em bibliotecas.
$ android analyze <library.aar>
$ android analyze <library.jar>E, como a Breana mencionou, há muitos problemas com bibliotecas que são enviadas com regras de manutenção inadequadas.
Vamos usar isso para analisar alguns desses problemas.
Então, quando executo isso em um determinado AAR que tenho, posso ver que essa biblioteca tem vários problemas destacados na parte de cima.
Essa biblioteca tem uma alta proporção de retenção, o que significa que ela está retendo demais com regras de retenção ilimitadas.
Ela contém regras de manutenção amplas que impedem que ela seja otimizada, e há alguns números abaixo que mostram exatamente o quanto isso é ruim. Ela também contém regras de manutenção que, talvez o mais assustador de tudo isso, não estão segmentando nada, o que provavelmente significa que estão segmentando outra pessoa de alguma forma ilimitada.
Code smells muito perigosos.
Você pode verificar tudo isso em um AAR, principalmente como editor de biblioteca. Essa é uma ótima maneira de garantir que você não está enviando regras de manutenção ruins e que elas não vazem quando alguém que não é especialista em escrever regras de manutenção estiver trabalhando na biblioteca.
Aqui, você pode ver que também geramos uma proporção de retenção.
Essa é uma boa maneira de pensar na qualidade geral da sua biblioteca.
Se eu otimizar uma biblioteca individual de forma totalmente independente, sem referências, com o R8, o tamanho dela vai ser de zero bytes, certo?
Ele deve estar basicamente vazio, porque não há nada retido nele.
Isso seria o ideal.
Nesse caso, não é.
Você pode ver o tamanho do R8 e do D8 diretamente.
Além disso, destacamos algumas das piores regras de manutenção para que fiquem mais visíveis para você.
Isso também tem um formato JSON. Portanto, se você é um desenvolvedor de apps que quer controlar as atualizações de bibliotecas ou um desenvolvedor de bibliotecas que quer evitar grandes regressões na qualidade da biblioteca, pode fazer essa mesma análise e evitar que esses problemas aconteçam com um script simples que envolve a CLI do Android.
{
"optimization": {
"libraryAnalysisResult": {
"dex": {
"d8CompileResult": {
"dexSizeBytes": 4523352
},
"r8CompileResult": {
"dexSizeBytes": 3266596,
"configuration": {
"usedPackageWideKeepRules": [
{
"source": "-keep class com.example.analytics.bloat.** { *; }",
"keptItemCount": 125579,
},
...
],
"unusedPackageWideKeepRules": [
{
"source": "-keep class some.other.library.** { *; }",
},
...
]
},
...
}Se você encontrar um problema em uma biblioteca, tente atualizá-la.
Como a Breana mencionou, corrigimos mais de uma dúzia de bibliotecas do Google para corrigir algumas regras de manutenção muito infelizes, e outras bibliotecas por aí que tiveram correções, mas não estão sendo atualizadas pelos apps que as usam.
É um ótimo primeiro passo.
Em segundo lugar, você pode procurar um problema e entrar em contato com o desenvolvedor da biblioteca e, possivelmente, anexar um relatório do analisador que diga: "Ei, você está mantendo muita coisa.
Me ajude a otimizar meu app."
Para recapitular, falamos sobre o R8 Config Analyzer, que ajuda a analisar tudo o que está acontecendo no build do R8, tudo o que informa o que é otimizável e o que não é.
Falamos sobre o Jetpack Keep, a nova biblioteca que ajuda a escrever regras de manutenção automaticamente sem que você precise fazer nada.
E a CLI do Android, a nova ferramenta para ajudar você a verificar e garantir, conferir novamente a última etapa e garantir que você, seu agente e o engenheiro júnior da sua equipe não tenham estragado nada para os consumidores.
Se quiser saber mais, consulte a documentação do R8, do analisador de configuração e do Jetpack Keep.
E há uma documentação sobre a CLI do Android que fala sobre o comando analyze e como usá-lo.
Muito obrigado.
android {
buildTypes {
release {
optimization {
// no need to specify default
// rules and resource shrinking
enabled = true
}
}
}
...
}android {
buildTypes {
release {
// Enables code optimizations.
isMinifyEnabled = true
// Enables resource shrinking.
isShrinkResources = true
proguardFiles(
// Default rules.
getDefaultProguardFile(
"proguard-android-optimize.txt"
),
... // list out each file with keep rules
)
...
}
}
...
}$ android skills list
$ android skills add r8-analyzerfun createWithReflection(className: String): MyObject {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as MyObject
}// Problem 1 - optional dependency
fun tryInitCrashReporter(context: Context): EventTransport? {
return runCatching {
Class.forName("com.example.analytics.bloat.crash.CrashReporterTransport")
.getDeclaredConstructor(Context::class.java)
.newInstance(context) as? EventTransport
}.getOrNull()
}
// Problem 2 - dynamically instantiate subclass
fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}
// Problem 3 - serialization
fun serializeEvent(event: UserActionEvent): JSONObject {
val json = JSONObject()
for (field in event.javaClass.declaredFields) {
field.isAccessible = true
json.put(field.name, field.get(event))
}
return json
}# TODO: clean this up
-keep com.example.analytics.bloat.** { * };fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}### Keep the EventFilter
-keep class com.example.analytics.bloat.EventFilter {
*
}### Keep the actual EventFilter
-keep class com.example.analytics.bloat.EventFilterKt {
*
}### Keep the EventFilter subclasses
-keep class ** extends com.example.analytics.bloat.EventFilterKt {
*
}### Keep the EventFilter subclasses, if they have this constructor
-keepclasseswithmembers class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}### Keep the EventFilter subclasses, if they have this constructor, allow more optimization
-keepclasseswithmembers,allowaccessmodification class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}### -if makes this conditional, critical for libraries
-if class com.example.analytics.bloat.EventToolsKt {
class com.example.analytics.bloat.EventFilterKt createEventFilter(java.lang.String);
}
### Keep the EventFilter subclasses, if they have this constructor, allow more optimization
-keepclasseswithmembers,allowaccessmodification class ** extends com.example.analytics.bloat.EventFilterKt {
void <init>();
}@androidx.annotation.Keep
class EventFilter { … }
@androidx.annotation.Keep
class SizeBasedEventFilter { … }
@androidx.annotation.Keep
class DropLogsEventFilter { … }@Keep
class EventFilter { … }@Keep
class EventFilter { … }
@Keep
class SizeBasedEventFilter { … }
@Keep
class DropLogsEventFilter { … }plugins {
id("com.android.library")
id("androidx.annotation.keep")
}
dependencies {
implementation("androidx.annotation.keep:keep")
...
}./gradlew analyticsbloat:lintFix@UsesReflectionToConstruct(
classConstant = EventFilter::class,
parameterTypes = []
)
fun createEventFilter(className: String): EventFilter {
return Class.forName(className)
.getDeclaredConstructor()
.newInstance() as? EventFilter
}# Generated Keep Rule
-if class com.example.analytics.bloat.EventTools {
class com.example.analytics.bloat.EventFilter createEventFilter(java.lang.String);
}
-keepclasseswithmembers,allowaccessmodification class ** extends class com.example.analytics.bloat.EventFilter {
void <init>();
}@UsesReflectionToConstruct(
className = "com.example.analytics.bloat.crash.CrashReporterTransport",
parameterTypes = [Context::class]
)
fun tryInitCrashReporter(context: Context): EventTransport? {
return runCatching {
Class.forName("com.example.analytics.bloat.crash.CrashReporterTransport")
.getDeclaredConstructor(Context::class.java)
.newInstance(context) as? EventTransport
}.getOrNull()
}# Generated Keep Rule
-if class com.example.analytics.bloat.CrashConnection {
class com.example.analytics.bloat.EventTransport tryInitCrashReporter(android.content.Context);
}
-keepclasseswithmembers,allowaccessmodification class com.example.analytics.bloat.crash.CrashReporterTransport {
void <init>(android.content.Context);
}// TODO: migrate to Kotlinx Serialization or Moshi codegen.
@UsesReflectionToAccessField(
classConstant = UserActionEvent::class,
fieldName = "*"
)
fun serializeEvent(event: UserActionEvent): JSONObject {
val json = JSONObject()
for (field in event.javaClass.declaredFields) {
field.isAccessible = true
json.put(field.name, field.get(event))
}
return json
}# Generated Keep Rule
-if class com.example.analytics.bloat.serialization.EventSerializer {
class org.json.JSONObject serializeEvent(com.example.analytics.bloat.model.UserActionEvent);
}
-keepclasseswithmembers,allowaccessmodification class com.example.analytics.bloat.model.UserActionEvent {
<fields>;
}$ android analyze <mybundle.aab>
$ android analyze <mybundle.apk>{
"optimization": {
"bundleAnalysisResult": {
"agpVersion": "9.3.2",
"r8Json": {
"version": "9.3.16",
"options": {
"isRepackageClassesEnabled": true,
"isProguardCompatibilityModeEnabled": false
},
"stats": {
"shrinkingRatio": 0.2306,
"optimizationRatio": 0.2351,
"obfuscationRatio": 0.2322
},
...
}
"mappingObfuscationRatio": 0.21631891,
"dexHeuristicObfuscationRatio": 0.25118626,
"uncompressedDexSizeBytes": "16198152"
}$ android analyze <library.aar>
$ android analyze <library.jar>{
"optimization": {
"libraryAnalysisResult": {
"dex": {
"d8CompileResult": {
"dexSizeBytes": 4523352
},
"r8CompileResult": {
"dexSizeBytes": 3266596,
"configuration": {
"usedPackageWideKeepRules": [
{
"source": "-keep class com.example.analytics.bloat.** { *; }",
"keptItemCount": 125579,
},
...
],
"unusedPackageWideKeepRules": [
{
"source": "-keep class some.other.library.** { *; }",
},
...
]
},
...
}