# Analyze a frame from an Android application with Frame Advisor

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/)
- [Understand Frame Advisor and get support](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/what_is_frame_advisor/)
- [Capture a trace in Frame Advisor](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/capture_a_trace/)
- [Analyze draw calls in Frame Advisor](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/analyze/)
- [Analyze frame construction with the Render Graph in Frame Advisor](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/analyze_render_graph/)
- [Analyze mesh geometry with Content Metrics on Frame Advisor](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/analyze_geometry/)
- [Next Steps](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/analyze_a_frame_with_frame_advisor/_next-steps/)

## About this Learning Path

| Skill level:      | Introductory            |
|-------------------|------------------------|
| Reading time:     | 10 min                 |
| Last updated:     | 12 Aug 2026            |

| Author:           | Julie Gaskin, Arm      |
|-------------------|------------------------|
| Arm IP:           | [Mali](https://support.arm.com/?tab=compute-ip&Product%20Type=Graphics%20Processors), [Immortalis](https://support.arm.com/?tab=compute-ip&Product%20Type=Graphics%20Processors) |
| Tags:             | [Performance and Architecture](/tag/performance-and-architecture), [Android](/tag/android), [Frame Advisor](/tag/frame-advisor) |

### Who is this for?
This Learning Path is for Android application developers who want to learn how to use Frame Advisor.

### What will you learn?
Upon completion of this Learning Path, you will be able to:
- Capture data from a significant frame in your Android application
- Inspect draw calls for rendering inefficiencies
- Use the Render Graph to analyze how the frame is constructed
- Analyze mesh geometry for inefficiencies

### Prerequisites
Before starting, you will need the following:
- An Android device in developer mode with USB debugging enabled. These [Arm Performance Studio supported devices](https://developer.arm.com/Tools%20and%20Software/Arm%20Mobile%20Studio#Supported-Devices) have been tested internally within Arm and confirmed to work with Arm Performance Studio.
- A debuggable build of your application. The application must be installed on your device and built with OpenGL ES versions 2.0 to 3.2 or Vulkan versions 1.0 to 1.2. For OpenGL ES applications, your device must be running Android 10 or later. For Vulkan applications, your device must be running Android 9 or later.
- Arm Performance Studio downloaded and installed from [Product Download Hub](https://developer.arm.com/downloads/view/MOBST-PRO0). It’s supported on Windows, Linux, and macOS host platforms. For installation instructions, see the [Arm Performance Studio install guide](/install-guides/ams/).
- Android SDK Platform tools [downloaded and installed](https://developer.android.com/studio/releases/platform-tools.html). SDK Platform tools is required for [Android Debug bridge (adb)](https://developer.android.com/studio/command-line/adb). Add the path to ADB to your `PATH` environment variable.
- The device connected through USB and accessible through ADB. To test the connection, open a command prompt and enter the `adb devices` command.

### Summary
You’ll capture and analyze a representative frame with Frame Advisor in Arm Performance Studio. First, you’ll choose the graphics API, record a problem area, and inspect render passes and draw calls in the Analysis view. Then, you’ll use the Render Graph view to find unnecessary work. Finally, you’ll use the Content Metrics view to locate complex geometry and navigate to its draw call in the framebuffer.

### Frequently asked questions
<details>
<summary>How do I confirm Frame Advisor sees my device and app before capturing?</summary>
Open **New Trace** and check that your device and the target application appear in the lists.
</details>

<details>
<summary>Which API setting should I choose for my application?</summary>
Select **Vulkan** for Vulkan applications and **OpenGL ES** for OpenGL ES applications. Set this under **API settings** before starting the capture session.
</details>

<details>
<summary>What result should I expect after I start the capture session?</summary>
After you start the session, you can play to the problem area while the application launches automatically on the device and captures. When analysis completes, you’ll see the Frame hierarchy with frames, render passes, and draw calls.
</details>

<details>
<summary>How do I know which render pass produces the on-screen image?</summary>
In the **Render Graph**, follow the flow from left to right and look for the pass that outputs to the swapchain. That pass is the final stage that renders to the screen.
</details>

<details>
<summary>How can I find and inspect expensive geometry?</summary>
Open **Content Metrics**, choose **Draws**, and sort by the highest number of primitives to surface complex objects. Right-click a candidate and select **Navigate to call** to highlight it in the Frame hierarchy and view it in the framebuffer.
</details>