Android Profiler: What It Is, CPU, Memory and Network Features

What Is Android Profiler?

Android Profiler is a component of Android Studio that replaced the legacy Android Monitor and DDMS tools. It provides a unified interface for profiling all aspects of an application: CPU Profiler for processor analysis, Memory Profiler for memory management, Network Profiler for network requests and Energy Profiler for energy consumption. Data is collected automatically when you launch an app through Android Studio.

The profiler works on both the emulator and a physical device connected via USB. According to Google I/O 2023, Android Profiler is used in more than 70% of Android projects and is considered the standard performance diagnostic tool. The main advantage over third-party solutions is zero integration: you don't need to add dependencies to build.gradle or modify the application code.

Android Profiler's architecture is built on Perfetto — Android's system tracer that collects data at the kernel and application level. Perfetto provides minimal overhead (less than 1% CPU) and supports long-term recording of up to 30 minutes. This allows profiling not only fast operations but also long-running scenarios — screen transitions, background synchronization, memory consumption over an hour of use.

What Data Does Android Profiler Collect

The profiler collects four types of data: CPU — load per core and thread, Memory — Java Heap, Native Heap, Stack, Graphics, Network — all incoming and outgoing requests, Energy — energy consumption categories (Idle, Light, Medium, Heavy). The data is synchronized on a timeline so you can simultaneously see how CPU changes affect Memory and energy consumption.

CPU Profiler: CPU and Thread Analysis

CPU Profiler shows processor load in real time on a timeline, broken down by application threads. Each thread is represented by a colored line or area — the wider the area, the more CPU time the thread consumes. Red areas indicate application work, blue indicates system calls, and gray indicates waiting.

For detailed analysis, CPU Profiler supports three recording modes: Trace Java Methods (tracing all Java methods), Trace C/C++ Functions (tracing native NDK functions) and Sample Java Methods (sampling, recommended mode). Sampling provides the least overhead and is suitable for everyday profiling, while full tracing is used for finding complex problems.

// Example: CPU Profiler analysis will show this method as a bottleneck
class DataProcessor {
    suspend fun processLargeDataset(items: List<Item>): List<Result> {
        // CPU Profiler will show high CPU load in inBackgroundThread
        return withContext(Dispatchers.Default) {
            items.map { it.computeHeavyTransformation() }
        }
    }
}

// Recommendation after profiling:
// computeHeavyTransformation takes 80% of the time — cache the result
class DataProcessorOptimized {
    private val cache = LruCache<String, Result>(100)

    suspend fun processLargeDataset(items: List<Item>): List<Result> {
        return withContext(Dispatchers.Default) {
            items.mapNotNull { cache.get(it.id) ?: it.computeHeavyTransformation().also { cache.put(it.id, it) } }
        }
    }
}

After recording, CPU Profiler shows a Top-Down Tree — a call tree with execution time for each method. Pay attention to the Self Time/Total column: if a method's Self Time exceeds 16 ms and it is called from the UI thread — this guarantees a frame drop. The solution is to move heavy computations to a background thread using Dispatchers.IO or Default.

CPU Tracing Modes

Sample Java Methods — recommended mode for daily profiling with 3-5% overhead. Trace Java Methods — full tracing of every call, overhead up to 15%, used for short recordings (5-10 seconds). Trace C/C++ Functions — tracing NDK code via Linux Perf, indispensable for analyzing games and C++ libraries. Switch modes depending on the type of problem.

Memory Profiler: Memory Management and Leak Detection

Memory Profiler tracks all memory categories of an application: Java Heap (JVM objects), Native Heap (C/C++ allocations via JNI), Stack (thread stacks) and Graphics (textures, GPU buffers). The main visualization is a time graph of memory consumption where each category is shown in its own color. If the graph does not decrease after garbage collection — suspect a leak.

To find leaks, use the Capture Heap Dump feature. At the moment of dump, Android Profiler pauses the application for ~100 ms and creates an HPROF file — a complete snapshot of all live Java Heap objects. After opening the dump, you can sort objects by Retained Size (the amount of memory that will be freed when the object is deleted) and look for instances of Activity, Fragment or Bitmap that should have been destroyed.

According to Google I/O 2022, Memory Profiler combined with LeakCanary covers 95% of memory leak detection scenarios on Android. LeakCanary works automatically — it detects leaks in the background. Memory Profiler is needed for manual analysis: you see the full picture of allocations, not just leaks.

How to Interpret an HPROF Dump

After capturing the dump, sort objects by Retained Size — this is the amount of memory that will be freed when the object is deleted. Look for instances of Activity, Fragment and Bitmap with large Retained Size that should not be in memory. Go to the Reference Tree tab to see the chain of references holding the object — most often it is a static field of a singleton or an uncleared callback. An important metric is Allocation rate (number of allocations per second). If the allocation rate exceeds 10,000 objects/s, the application spends too much time creating and deleting temporary objects, which strains the GC and causes micro-freezes. In this case, use View Inspector and find places with frequent object creation in loops.

Network Profiler: Network Request Monitoring

Network Profiler displays all application network requests in real time on a timeline. Each request is shown as a horizontal bar — its length corresponds to execution time, its color to the request type (GET, POST, PUT, DELETE). Scrolling the timeline allows you to see how requests are distributed over time and whether they are duplicated.

All popular libraries are supported: OkHttp, Retrofit, Volley, Ktor. For Ktor and OkHttp, the profiler shows the full call stack, including interceptors and converters. For each request, Request Headers and Response Headers are available, along with the response body (up to 1 MB), status code and duration.

Typical problems identified by Network Profiler: lack of caching (the same URL is requested on every open), duplicate requests (two components simultaneously load the same data), excessive response size (the server returns 5 MB when 50 KB is needed). Network Profiler helps you see such problems literally in one glance at the timeline.

To emulate slow networks, use Network Conditioning in Android Studio — it allows you to limit bandwidth to 3G/2G and add latency. This is critically important for testing application behavior in poor network conditions, especially for apps operating in regions with unstable internet.

Energy Profiler: Energy Consumption Analysis

Energy Profiler evaluates the impact of an application on battery charge based on Perfetto data. The tool does not measure actual consumption in milliamps, but classifies each operation into one of five energy consumption categories: Idle, Light, Medium, High and Overloaded. The Energy Profiler timeline is color-coded: green (light load), yellow (medium), red (high).

The main causes of red zones: WakeLock (the app keeps the processor active), Location GPS (constant high-accuracy coordinate requests), Keep-Alive connections (frequent data exchange with the server), large data transfers (file upload, streaming). Energy Profiler accurately shows which operation caused the energy consumption peak at which moment.

According to Android Developers, a typical application should spend no more than 5% of time in the High category. If Energy Profiler shows red zones for more than 10% of profiling time — the app will not pass review on the Battery Drain criterion. Recommendation: use WorkManager for background tasks, limit Location requests to the minimum necessary accuracy, and aggregate network requests into batches.

How to Use Android Profiler: A Practical Guide

Launching Android Profiler is one click away: in Android Studio open View → Tool Windows → Profiler or double-click the Profiler icon in the right panel. After launching the application on the connected device, Android Studio will automatically connect to the process and start collecting data. Graphs for CPU, Memory, Network and Energy will immediately appear on the timeline.

For detailed analysis, select the desired tab (CPU, Memory, Network or Energy) and start recording. For CPU, I recommend Sample Java Methods mode with a recording duration of 30 seconds — this is enough for a typical scenario. For Memory — capture a heap dump after completing the scenario (Capture Heap Dump). For Network, recording starts automatically, just press the Stop button after finishing the scenario.

After stopping recording, export the data: File → Save As saves the entire session to a .perf file. This is convenient for comparing metrics before and after optimization. Create a baseline session on the first stable version and compare each new session against it — this is the only way to objectively evaluate performance changes.

Automating Profiling in CI

Android Profiler can be run from the command line via Android Studio CLI and Firebase Test Lab. Firebase Test Lab supports performance profiling as part of UI tests: you get CPU, Memory and Network metrics along with the test result. Set up the pipeline so that if metrics drop by 10% relative to the baseline, the CI pipeline is blocked until reviewed by a developer.