Blog do Desenvolvedor Android: Priorizando Eficiência de Memória: Passos Essenciais para o Android 17

Cenário	Exemplo baseado em Compose	Exemplo baseado em View
Contexto Vazando

Exemplo de vazamento de contexto:
Passando LocalContext.current para um ViewModel

Correção:
Manter a lógica dependente de Context dentro da camada UI. Para as camadas não-UI, refatorar para usar injeção de dependência ou observar o estado da IU usando Kotlin flow.

Exemplo:
Armazenando um Activity em um objeto companion ou variável estática.

Correção:
Não mantenha referências estáticas a componentes de IU. Refatorar para usar injeção de dependência ou observar o estado da IU usando Kotlin flow.

Vazamento de Listeners

Exemplo:
Usando DisposableEffect para iniciar um listener, mas deixando o bloco onDispose vazio.

Correção:
Realizar a desassociação e a limpeza dentro do bloco onDispose.

Exemplo:
Registrando para atualizações do SensorManager e esquecendo de desassociar.

Correção:
Chamar manualmente o método unregisterListener() nos métodos do ciclo de vida onStop() ou onDestroy().

Vazamento de Views

Exemplo:
Manter uma referência a um legado View dentro de um AndroidView sem estratégia de liberação.

Correção:
Usar o bloco release do composable AndroidView para limpar o legado View.

Exemplo:
Manter uma referência ao objeto de vinculação de visualização após a destruição do Fragment.

Correção:
Definir a variável de vinculação para null dentro do método do ciclo de vida onDestroyView().

Reduza a memória quando o aplicativo sai do estado visível

O Android pode recuperar memória do seu aplicativo ou interromper completamente o aplicativo se necessário para liberar espaço de memória para tarefas críticas, conforme explicado em Visão geral da gestão de memória. O Android geralmente recuperará a memória do seu aplicativo quando este não estiver visível ao usuário, como por exemplo descartando parte do código e páginas de dados do seu aplicativo ou comprimindo suas alocações na pilha. Quando o usuário retoma o seu aplicativo e o aplicativo tenta acessar alguma memória que foi recuperada, o sistema operacional substituirá essa memória sob demanda. Este comportamento de troca pode ser lento e causar jank ou estalos inesperados no seu aplicativo.

Se você deixar que o SO decida qual memória recuperar do seu aplicativo, é possível que o OS tenha recuperado a memória que você precisará logo após retomar o seu aplicativo. Em vez disso, o seu aplicativo pode voluntariamente descartar alocações de memória que podem ser regeneradas posteriormente, sob demanda e com baixo custo. Para fazer isso, você pode implementar a interface ComponentCallbacks2. Você pode implementar onTrimMemory em seu Activity, Fragment, Service ou até mesmo na sua classe personalizada Application. Usá-lo na classe Application é altamente eficaz para a gestão de cache global.

O método de retorno de chamada fornecido onTrimMemory() notifica o seu aplicativo sobre eventos do ciclo de vida ou relacionados à memória que apresentam uma boa oportunidade para que o seu aplicativo reduza voluntariamente o uso da sua memória.

No gerenciamento do ciclo de vida da memória, a implementação deve focar exclusivamente em TRIM_MEMORY_UI_HIDDEN e TRIM_MEMORY_BACKGROUND. Desde o Android 14, o sistema deixou de enviar notificações para outras constantes legadas, que foram formalmente depreciadas no Android 15.

TRIM_MEMORY_UI_HIDDEN: Esta sinalização indica que a interface do seu aplicativo foi transicionada fora da visão do usuário. Isso oferece uma oportunidade para liberar grandes alocações de memória vinculadas estritamente à interface, como Bitmaps, buffers de reprodução de vídeo ou recursos complexos de animação.

TRIM_MEMORY_BACKGROUND: Neste nível, o seu processo está residindo em segundo plano e agora é um candidato para terminar para atender às necessidades globais do sistema. Para prolongar a duração que o seu processo permanece no estado cacheado e reduzir o número de inicializações frias do aplicativo, você deve agressivamente liberar quaisquer recursos que possam ser facilmente reconstruídos uma vez que o usuário retome sua sessão.

import android.content.ComponentCallbacks2
// Outras declarações de importação.

class MainActivity : AppCompatActivity(), ComponentCallbacks2 {
    
    /**
     * Libere a memória quando a interface do usuário se torna oculta ou quando os recursos do sistema ficam baixos.
     * @param level o evento relacionado à memória que é levantado.
     */
    override fun onTrimMemory(level: Int) {
        
        if (level >= ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
            // Libere a memória relacionada aos elementos de interface do usuário, como caches de bitmap.
        }

        if (level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) {
            // Libere a memória relacionada ao processamento em segundo plano, como por exemplo
            // fechando uma conexão com o banco de dados.
        }
    }
}

Nota: A integração onTrimMemory pode depender do suporte da SDK. Por exemplo, certos jogos dependem de sua engine de jogo para habilitar essa capacidade. Consulte os documentos sobre otimização de memória para jogos.

Observabilidade avançada com ProfilingManager

Para capturar e diagnosticar problemas de memória em campo que não podem ser reproduzidos localmente, você deve aproveitar a API ProfilingManager. Introduzida no Android 15, esta API de observabilidade avançada permite coletar programaticamente perfis do Perfetto dos usuários reais.

Para equipes que não possuem uma infraestrutura dedicada para gerenciar e hospedar artefatos de desempenho, a Crashlytics está explorando uma solução especializada para otimizar este fluxo de trabalho. Eles estão convidando desenvolvedores a fornecer feedback.

O Android 17 introduz novos gatilhos baseados em eventos, notavelmente TRIGGER_TYPE_OOM e TRIGGER_TYPE_ANOMALY:

• O gatilho OOM coleta automaticamente um dump de heap Java no exato momento em que ocorre uma falha OutOfMemoryError, fornecendo estados de alocação precisos. Um perfil OOM coletado é fornecido na próxima vez que o aplicativo inicia e registra a chamada de retorno registerForAllProfilingResults.
• O gatilho Anomalia detecta problemas graves de desempenho, como spam excessivo do binder ou limiares de memória excedidos. A anomalia de memória entrega um dump de heap imediatamente antes que o sistema interrompa o aplicativo.

val profilingManager = 
applicationContext.getSystemService(ProfilingManager::class.java)
    val triggers = ArrayList<profilingtrigger>()  


    triggers.add(ProfilingTrigger.Builder(
                 ProfilingTrigger.TRIGGER_TYPE_ANOMALY))
    val mainExecutor: Executor = Executors.newSingleThreadExecutor()
    val resultCallback = Consumer<profilingresult> { profilingResult ->
        if (profilingResult.errorCode != ProfilingResult.ERROR_NONE) {
            // upload profile result to server for further analysis           
            setupProfileUploadWorker(profilingResult.resultFilePath)
        }  

    profilingManager.registerForAllProfilingResults(mainExecutor, resultCallback)
    profilingManager.addProfilingTriggers(triggers)

Uma vez que você tenha coletado o dump de heap, pode baixar o perfil do servidor ou localmente via adb pull e arrastar e soltar o arquivo no Perfetto UI. Para otimizar seu fluxo de trabalho de depuração de memória, use o Heap Dump Explorer, esta é a nova visualização padrão para dumps de heap no Perfetto UI. Esta ferramenta fornece uma interface intuitiva para inspecionar dumps de heap Java, permitindo que você visualize hierarquias de alocação de objetos, calcule tamanhos de memória reteridos e identifique o caminho mais curto a partir de raízes de coleta de lixo. Ao aproveitar o Heap Dump Explorer, você pode rapidamente localizar vazamentos de memória, objetos reteridos inchados como alocações excessivas de bitmap e analisar todas as alocações de objetos da pilha em um único lugar.

Conclusão

Otimizar o bytecode com R8, adotar práticas recomendadas de carregamento de imagens e resolver vazamentos de memória são passos críticos para entregar uma experiência do usuário de alta qualidade enquanto gerencia efetivamente os recursos sob pressão. Adotar essas medidas proativas ajuda a manter a estabilidade e o desempenho do aplicativo, prevenindo terminações inesperadas enquanto protege o contexto do usuário. Para expandir seus conhecimentos sobre performance, explore nossa guia revisada de memória.