Tutorial details

Android application (performance and more) analysis tools - Tutorial | App Code for Sale | Preview

Android application (performance and more) analysis tools - Tutorial | Android Tutorial

This tutorial describes the available tools in Android to perform a performance analysis of Android applications.

Overview PAGE TOP

Lars Vogel

Version 2.2

Copyright © 2011, 2012, 2013 Lars Vogel



Analyzing Android performance issues

This tutorial describes the available tools in Android to perform a performance analysis of Android applications. It is based on Eclipse 4.2, Java 1.6 and Android 4.2.

1. Overview PAGE TOP

It is very important for Android applications to perform all operations as fast as possible. This description lists the available tools to trace and optimize your Android application.

2. Android Basics PAGE TOP

The following assumes that you have already basic knowledge in Android development. Please check the Android development tutorial to learn the basics.

3. StrictMode PAGE TOP

You should avoid performing long running operations on the UI thread. This includes file and network access.

To ensure this you can use StrictMode. StrictMode is available as of API 9 (Android 2.3.3) and allows to setup thread policies for your application.

Via StrictMode you can instruct the Android system to crash your application if it performs long running operations, e.g. I/O in the user interface thread.

The following code shows how to use StrictMode. As the activity violates these settings it will crash.

package de.vogella.android.strictmode;

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;

import android.app.Activity;
import android.os.Bundle;
import android.os.StrictMode;

public class TestStrictMode extends Activity {
  public void onCreate(Bundle savedInstanceState) {
    // Activate StrictMode
    StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
         // alternatively .detectAll() for all detectable problems
    StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
        // alternatively .detectAll() for all detectable problems

    // Test code
    String eol = System.getProperty("line.separator");
    try {
      BufferedWriter writer = 
          new BufferedWriter(new OutputStreamWriter(openFileOutput("myfile", 
      writer.write("This is a test1." + eol);
      writer.write("This is a test2." + eol);
      writer.write("This is a test3." + eol);
      writer.write("This is a test4." + eol);
      writer.write("This is a test5." + eol);
    } catch (Exception e) {

StrictMode should only be used during development and not in your live application.

4. Developer Settings PAGE TOP

Developer Settings in your Setting application of your Android phone allow to set configurations which simplify the analysis of your application. For example you can enable that the touch area is highlighted.

If you have a Android 4.2 phone, try going to the About section in the Settings and tap the Build number entry 7 times.

If you phone does not have this option try using an emulator.

In some cases you need to restart the application to make the setting work.

5. Lint PAGE TOP

The Android lint tool is a static code analysis tool for Android applications. It provides command line and Eclipse supported checks for potential bugs and optimization improvements for Android applications.

Some checks are performed by default in Eclipse. To run active Lint checks in Eclipse on your Android application, right-click on your project and select Android Tools → Run Lint: Check for Common Errors.

You see the generated warnings in the Lint Warning view.

In the Eclipse Preferences you can configure the Lint checks under Window → Preferences → Android → Lint Error Checking.

You can run link also from the command line.

# run lint check for myproject
lint myproject 

6. Exercise: Lint PAGE TOP

Run a full lint check on a project of your choice. Try to solve all errors and warnings.

7.1. Introduction PAGE TOP

Traceview is a graphical viewer to see logs created by an Android application. Via Traceview you can measure the performance of your application to identify performance problems.

Traceview is located as standalone tool in the tools folder of your Android SDK installation folder and it also integrated into Eclipse via the Android development tools (ADT).

7.2. Using Traceview in Eclipse PAGE TOP

Eclipse supports tracing directly in the DDMS perspective.

To start tracing an application select your application process in the Devices view and select the Start Method Profiling button as depicted in the following screenshot.


Use your application and re-press the same button to stop profiling. This will open a new editor which shows you the tracing results.



You can zoom into the graphic to get more details.

7.3. Using TraceView from the command line PAGE TOP

To start tracing some code put the following code snippet around it.


// ... your code is here


The parameter "yourstring" tells the system that it should store the data under "/sdcard/yourstring.trace". To save data on the sdcard your application needs the WRITEEXTERNALSTORAGE permission. After running your application you can copy the results from the device via the adb command line tool.

adb pull /sdcard/yourstring.trace
traceview yourstring

This will start Traceview which allow you to analyze your performance data via a graphical way. The DDMS view has also a trace button available. This will trace the running application and does not require an additional authorization.

8.1. Create example project PAGE TOP

Create an Android application with the top level package called com.vogella.android.testing.traceview.

Add the following key to your values/strings.xml file.

<?xml version="1.0" encoding="utf-8"?>

    <string name="app_name">Traceview Example</string>
    <string name="action_settings">Settings</string>
    <string name="hello_world">Hello world!</string>
    <string name="number_template"><b>Random number: %1$s</b></string>


Create the following layout file called rowlayout.xml.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal" >

        android:orientation="vertical" >

            android:orientation="vertical" >

                android:textAppearance="?android:attr/textAppearanceListItem" />

                android:textAppearance="?android:attr/textAppearanceListItemSmall" />

        android:background="@android:color/black" />

        android:text="Medium Text"
        android:textAppearance="?android:attr/textAppearanceMedium" />


Implement the following adapter for your ListView.

package com.vogella.android.traceview;

import java.util.Collections;
import java.util.List;

import android.content.Context;
import android.content.res.Resources;
import android.os.Debug;
import android.text.Html;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;

public class MyArrayAdapter extends ArrayAdapter<String> {

  private List<String> values;
  private Context context;

  public MyArrayAdapter(Context context, List<String> values) {
    super(context, R.layout.rowlayout);
    this.context = context;
    this.values = values;

  public View getView(int position, View convertView, ViewGroup parent) {
    // Ensure sorted values
    LayoutInflater inflater = (LayoutInflater) context
    View view = inflater.inflate(R.layout.rowlayout, parent, false);
    Resources res = context.getResources();
    String text = String.format(res.getString(R.string.number_template),
    CharSequence styledText = Html.fromHtml(text);
    TextView textView = (TextView) view.findViewById(R.id.textView3);
    return view;

Implement a ListView in the activity which shows 1000 random generated strings.

package com.vogella.android.traceview;

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.List;

import android.app.ListActivity;
import android.os.Bundle;

public class MainActivity extends ListActivity {

  protected void onCreate(Bundle savedInstanceState) {
    List<String> list = createValues();
    MyArrayAdapter adapter = new MyArrayAdapter(this, list);

  private static List<String> createValues() {
    SecureRandom random = new SecureRandom();
    List<String> list = new ArrayList<String>();
    for (int i = 0; i < 1000; i++) {
      String string = new BigInteger(130, random).toString(32);
    return list;


Add the permission to write on external storage to your application.

8.2. Perform trace PAGE TOP

Run your application. Afterwards connect to your device via adb and copy the resulting performance trace to your drive. Analyze the result.

8.3. Solve performance problems PAGE TOP

Improve the performance based on the measurements of Traceview. Here are some pointers what to improve.

  • Replace the bold styling in the getView() method with the corresponding android:textStyle="bold attribute in your layout to avoid the Html.fromHtml() call.

  • Move the sorting to another place

  • Reuse convertView in your Adapter, if not null

  • Avoid the findViewById() method call by using the HolderPattern in your ListView


9. Hierarchy Viewer PAGE TOP

The Hierarchy View perspective allows you to visualize the View hierarchy of your Android application and helps you to identify unnecessary layers in this hierarchy.

You can open the Hierarchy View via Window → Open Perspective → Other... → Hierarchy View

In the Windows view you can select the process for which you want to analyze the view hierarchy.


The currently active layout is analyzed and displayed.


The Tree View view show three light bulbs for the views. The first one indicates the time for calculating the size of the view, the second one indicates the time for creating the layout and the third one for drawing the view. Performance intensive work is indicated with the yellow or red color.

10. Exercise: Hierarchy Viewer PAGE TOP

Continue to use the same example as in Section 8.1, “Create example project”. Open the Hierarchy View perspective and analyze the view layer.

While none of these layout layers is very performance intensive it contains redundant layers and unnecessary views. Remove the unnecessary view layers.

11. Memory Dumps PAGE TOP

You can create a memory snapshot and analyze it with the Eclipse Memory Analyzer .

12. Systrace PAGE TOP

Systrace allows to measure the performance directly at kernel level. To enable systrace, select the Developer options and select the Enable traces entry. In the next dialog you can define what type of events should be profiled, e.g. Graphics and View.



To use systrace, open a terminal and run systrace.py from the androidsdkinstalldir/tools/systrace directory. You may have to set it to executable (chmod 777 systrace.py on Linux).

You can also start Systrace directly from Eclipse via the DDMS perspective.



Systrace captures events for 5 seconds. As result Systrace creates a HTML file which allows you to analyze potential issues.

13. Pixel Perfect perspective PAGE TOP

Not performance related but still useful is the Pixel Perfect perspective which allow to display the screen of the currently running application on the emulator or device and magnify the image of that screen.

14. Simulating pixel density PAGE TOP

You can use the command line to simulate different device densities and display resolutions.

This allows you to use a device with a high device density and resolution to simulate other devices.

// Set the display size
adb shell am display-size 600x800

// Set the display density
adb shell am display-density 80

15. Android templates PAGE TOP

You can define your own templates for the Android project creation wizard. See the following links for more information.

Roman Nurik: https://plus.google.com/113735310430199015092/posts/XTKTamk4As8

Official documentation: https://dl.dropbox.com/u/231329/android/templatedocs/index.html

Additional code templates - https://github.com/jgilfelt/android-adt-templates

16. Profile GPU rendering PAGE TOP

In the Developer options in the Setting or your Android device you can activate Profile GPU rendering. With this option the system tracks the time it took to draw the last 128 frames.

After activating this and restarting your application you can get the information via the following command.

adb shell dumpsys gfxinfo your_package 

To measure the frame rate of your application, e.g. by scrolling on a list view. In most cases you need to interact with your application to trigger that it re-draws itself.

In the resulting log, look for a section called Profile data in ms.

17. Analyzing Overdraw PAGE TOP

Overdraw happens if you draw something on top of something else. For example an activity has a Window as background. If a TextView it added to the application, the TextView is drawn on top of the Window.

Overdrawn is therefore intended to happen. But unnecessary overdraw should be avoid to have the best performance possible.

Unnecessary overdraw can be caused by complex view hierarchies. In general a 2x overdraw (a pixel gets drawn three times) is standard and expected but more should be avoided.

You can enable a visualization of overdraw via the Development Settings with the Show GPU overdraw setting. This section adds colors to your screen based on the number of overdraws. The following table explains the used color schema.

Table 1. Overdrawn colors


After visualization of potential problematic areas, you can analyze your View hierarchy with the Hierarchy Viewer.

Reference PAGE TOP


0 Comments Leave a comment

Please login in order to leave a comment.

Newest first

to your Chupamobile Account.

The Easiest way to Launch your next App or Game.

Join Chupamobile and get instant access to thousands of ready made App and Game Templates.

Creating an account means you’re okay with Chupamobile’s Terms of Service and Privacy Policy.