Android Academy · Aula

Medindo o desempenho

Ferramentas de análise, rastreamentos e testes de desempenho.

Medindo o desempenho é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

Meça antes de otimizar

A regra de ouro do trabalho de desempenho: meça primeiro, nunca chute. A intuição humana sobre o que está lento quase sempre está errada.

Nesta lição, você aprenderá a usar as ferramentas que o Android oferece para visualizar o desempenho: os criadores de perfil, os rastros do sistema e os microbenchmarks. Quando souber medir, toda otimização se tornará uma decisão orientada por dados, em vez de uma suposição.

Criadores de perfil mostram CPU, memória e energia em tempo real.
Rastros do sistema revelam exatamente onde o tempo de cada quadro é gasto.
Benchmarks fornecem números reproduzíveis que você pode comparar entre compilações.

O orçamento de 16 ms por quadro

Em uma tela de 60 Hz, o sistema desenha um novo quadro a cada 16,67 ms. Se o aplicativo não conseguir preparar um quadro nessa janela, ele será descartado e os usuários perceberão engasgos. Em dispositivos de 120 Hz, o orçamento diminui para cerca de 8 ms.

O trabalho de desempenho consiste, na prática, em permanecer dentro desse orçamento. O comentário abaixo mostra a matemática que você precisa ter em mente.

// Frame budget math
// 60 Hz  -> 1000ms / 60  = 16.67ms per frame
// 90 Hz  -> 1000ms / 90  = 11.11ms per frame
// 120 Hz -> 1000ms / 120 =  8.33ms per frame
//
// Exceed the budget on the UI thread = a dropped frame = visible jank.
fun frameBudgetMs(refreshHz: Int): Double = 1000.0 / refreshHz

fun main() {
    println("60Hz  -> %.2f ms".format(frameBudgetMs(60)))
    println("120Hz -> %.2f ms".format(frameBudgetMs(120)))
}

Profiler do Android Studio

O Profiler do Android Studio (View > Tool Windows > Profiler) se conecta a um aplicativo em execução e mostra linhas do tempo ao vivo da CPU, da memória, da energia e da rede.

CPU: grave rastreamentos de métodos e do sistema para encontrar os caminhos de código mais exigidos.
Memória: observe as alocações e capture despejos de memória para encontrar vazamentos.
Energia: identifique bloqueios de ativação e tarefas excessivas que consomem a bateria.

Sempre analise uma compilação no estilo de lançamento em um dispositivo real. Compilações de depuração e emuladores fornecem números enganosos porque as otimizações ficam desativadas.

Macrobenchmark para cenários reais

A biblioteca Jetpack Macrobenchmark mede jornadas completas do usuário (inicialização, rolagem e navegação) em um dispositivo real e informa métricas estáveis, como tempo dos quadros e tempo de inicialização.

Você escreve um teste que inicia o aplicativo e executa um fluxo; a biblioteca o executa várias vezes e fornece os valores da mediana e do percentil 99.

@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test
    fun coldStartup() = rule.measureRepeated(
        packageName = "com.example.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }
}

Microbenchmark para código mais exigido

Quando você precisa saber a velocidade de uma única função, use a biblioteca Microbenchmark. Ela executa seu código em um ciclo apertado, aquece o JIT e informa nanossegundos por operação, eliminando o ruído.

Use-a para analisadores, serializadores, ordenação ou qualquer auxiliar limitado pela CPU que seja chamado com frequência.

@RunWith(AndroidJUnit4::class)
class JsonParseBenchmark {
    @get:Rule val benchmarkRule = BenchmarkRule()

    @Test
    fun parseLargePayload() {
        val raw = loadSampleJson()
        benchmarkRule.measureRepeated {
            val parsed = parseUsers(raw) // code under test
            // assertEquals avoids the compiler dropping the result
            assertTrue(parsed.isNotEmpty())
        }
    }
}

Rastreamento do sistema com Perfetto

O rastreamento do sistema captura o que cada thread e o sistema fizeram, quadro a quadro. O profiler de CPU do Android Studio pode gravar um rastreamento, e você também pode capturá-lo com adb e abri-lo no Perfetto (ui.perfetto.dev).

Um rastreamento mostra os temidos quadros vermelhos, o trabalho na thread principal e o tempo gasto na GPU. É a melhor ferramenta individual para diagnosticar engasgos.

# Record a 5-second system trace from the command line
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace \
  -t 5s sched freq idle am wm gfx view

# Pull it to your machine, then open in https://ui.perfetto.dev
adb pull /data/misc/perfetto-traces/trace.perfetto-trace

Seções de rastreamento personalizadas

Por padrão, os rastreamentos mostram o trabalho da estrutura. Para identificar seu próprio código, envolva-o em uma seção de rastreamento nomeada. Esses nomes aparecem como blocos identificados no Perfetto, facilitando a localização dos pontos críticos.

Use a API androidx.tracing para que as seções apareçam tanto nos rastreamentos de depuração quanto nos de benchmark.

import androidx.tracing.trace

fun loadDashboard(repo: Repo): Dashboard {
    return trace("loadDashboard") {
        val user = trace("fetchUser") { repo.user() }
        val feed = trace("fetchFeed") { repo.feed() }
        Dashboard(user, feed)
    }
}
// In Perfetto you will now see named slices:
// loadDashboard > fetchUser, fetchFeed

Acompanhamento de quadros descartados em tempo de execução

Você nem sempre terá um profiler conectado. O JankStats é uma biblioteca do Jetpack que informa os quadros com engasgos dentro do aplicativo em execução, para que você possa registrá-los ou enviar agregados para a análise.

Ele se conecta à janela e chama você sempre que um quadro ultrapassa seu orçamento.

val jankStats = JankStats.createAndTrack(window) { frameData ->
    if (frameData.isJank) {
        Log.w("Jank", "Janky frame: ${frameData.frameDurationUiNanos} ns")
        analytics.logJank(frameData.frameDurationUiNanos)
    }
}

// Pause/resume with your screen lifecycle
override fun onResume() { super.onResume(); jankStats.isTrackingEnabled = true }
override fun onPause() { super.onPause(); jankStats.isTrackingEnabled = false }

Leitura dos números: percentis

Uma única média esconde os problemas. Se o quadro médio leva 10 ms, mas o percentil 99 é de 40 ms, 1% dos quadros apresenta engasgos, e os usuários percebem isso. Observe sempre P50, P90 e P99, não apenas a média.

Os benchmarks informam esses valores para você. O auxiliar abaixo mostra a ideia usando amostras brutas de quadros.

fun percentile(samplesMs: List<Double>, p: Int): Double {
    val sorted = samplesMs.sorted()
    val index = ((p / 100.0) * (sorted.size - 1)).toInt()
    return sorted[index]
}

fun main() {
    val frames = listOf(8.0, 9.0, 10.0, 9.5, 11.0, 40.0, 9.0, 10.5)
    println("P50 = %.1f ms".format(percentile(frames, 50)))
    println("P99 = %.1f ms".format(percentile(frames, 99)))
}

Um fluxo de medição repetível

Números confiáveis vêm de um processo disciplinado. Siga esta lista de verificação sempre:

Use uma compilação de lançamento / não depurável (R8 ativado).
Execute em um dispositivo físico, conectado à tomada e com um estado térmico estável.
Repita o cenário várias vezes e informe a mediana.
Altere uma coisa por vez e faça uma nova medição.
Compare com uma linha de base salva para comprovar a melhoria.

Se você ignorar essas etapas, perseguirá o ruído em vez de corrigir problemas reais.

Para onde o tempo realmente vai

A maior parte dos engasgos no Android vem de um pequeno conjunto de causas. Conhecê-las indica para onde direcionar suas ferramentas:

Trabalho na thread principal: disco, rede ou JSON na thread da interface.
Recomposição excessiva: o Compose redesenha muito mais do que deveria.
Excesso de alocações: pausas da coleta de lixo.
Passagens de layout: layouts profundamente aninhados ou medidos repetidamente.

As próximas lições deste curso abordam diretamente recomposição, vazamentos de memória e inicialização. A medição é o que informa qual problema corrigir primeiro.

Verificação rápida

Você quer uma medição estável e repetível do tempo de inicialização a frio do seu aplicativo em um dispositivo real, ao longo de várias execuções. Qual ferramenta é mais adequada?

Recapitulação: agora você sabe medir

Você aprendeu a tornar o desempenho visível antes de alterar qualquer coisa:

O orçamento de 16 ms por quadro define a diferença entre uma experiência fluida e uma com engasgos.
O Profiler do Android Studio mostra CPU, memória e energia ao vivo.
Macrobenchmarks e Microbenchmarks fornecem números repetíveis.
Rastreamentos do Perfetto e seções trace() personalizadas revelam para onde o tempo vai.
O JankStats informa os engasgos dentro do aplicativo em execução.
Leia P50/P90/P99, analise compilações de lançamento em dispositivos reais e altere uma coisa por vez.

A seguir, aplicaremos isso a uma das maiores fontes de engasgos do Compose: a recomposição.

Perguntas Frequentes

A aula “Medindo o desempenho” é grátis?

Sim — o texto completo de “Medindo o desempenho” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Medindo o desempenho”?

Ferramentas de análise, rastreamentos e testes de desempenho. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Medindo o desempenho”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy