Android modifies the user
interface and handles input events from one single user
interface thread which is
also called the main
thread.

If the programmer does
not use any concurrency constructs, all code of an Android application runs
in this thread.

If you perform a long
lasting operation, e.g. loading a file or accessing data from the Internet,
the user interface of your Android Application will block until the
corresonding code has finished.

To provide a good user
experience all potentially slow running operations in an Android application
should run asynchronously, e.g. via some way of concurrency constructs of
the Java language or the Android framework. This includes all potential slow
operations, like network, file and database access and complex calculations.

Android enforced that
with an Application
not responding (ANR) dialog
if an Activity does
not react within 5 seconds to user input. From this dialog the user can
choose to stop the application.

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

In this example we use
the Handler class
to update a ProgressBar view
in a background Thread.

Create a new Android
project called "de.vogella.android.handler" with the Activity"ProgressTestActivity".
Create the following layout main.xml.
This layout contains the ProgressBar and sets its appearance via a style.

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >



    <ProgressBar

        android:id="@+id/progressBar1"

        style="?android:attr/progressBarStyleHorizontal"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:indeterminate="false"

        android:max="10"

        android:padding="4dip" >

    </ProgressBar>



    <Button

        android:id="@+id/button1"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:onClick="startProgress"

        android:text="Start Progress" >

    </Button>



</LinearLayout> 

Change your Activity to
the following:

package de.vogella.android.handler;



import android.app.Activity;

import android.os.Bundle;

import android.os.Handler;

import android.view.View;

import android.widget.ProgressBar;



public class ProgressTestActivity extends Activity {

  private Handler handler;

  private ProgressBar progress;



  

Run your application.
Once you press your button the ProgressBar will get updated from the
background thread.

In this example we will
use an instance of the AsyncTask class
to download the content of a webpage. We use Android
HttpClient for this. Create a
new Android project called de.vogella.android.asynctaskwith
an Activity called ReadWebpageAsyncTask.
Add the android.permission.INTERNETpermission
to your <filenname>AndroidManifest.xml</filenname> file.
.

Create the following
layout.

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >



    <Button

        android:id="@+id/readWebpage"

        android:layout_width="match_parent"

        android:layout_height="wrap_content"

        android:onClick="readWebpage"

        android:text="Load Webpage" >

    </Button>



    <TextView

        android:id="@+id/TextView01"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:text="Example Text" >

    </TextView>



</LinearLayout> 

Change your activity to
the following:

package de.vogella.android.asynctask;



import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;



import org.apache.http.HttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.impl.client.DefaultHttpClient;



import android.app.Activity;

import android.os.AsyncTask;

import android.os.Bundle;

import android.view.View;

import android.widget.TextView;



public class ReadWebpageAsyncTask extends Activity {

  private TextView textView;



  

If you run your
application and press your button then the content of the defined webpage
should be read in the background. Once this process is done your TextView will
be updated.

The following example
will download an image from the Internet in a thread and displays a dialog
until the download is done. We will make sure that the thread is preserved
even if the activity is restarted and that the dialog is correctly displayed
and closed.

For this example create
the Android project "de.vogella.android.threadslifecycle" and the Activity
"ThreadsLifecycleActivity". Also add the permission to use the Internet to
your app. Details for this can found here: Networking
with Android.

You should have the
following AndroidManifest.xml file.

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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="de.vogella.android.threadslifecycle"

    android:versionCode="1"

    android:versionName="1.0" >



    <uses-sdk android:minSdkVersion="10" />



    <uses-permission android:name="android.permission.INTERNET" >

    </uses-permission>



    <application

        android:icon="@drawable/icon"

        android:label="@string/app_name" >

        <activity

            android:name=".ThreadsLifecycleActivity"

            android:label="@string/app_name" >

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />



                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

    </application>



</manifest> 

Change the layout main.xml to
the following.

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical" >



    <LinearLayout

        android:id="@+id/linearLayout1"

        android:layout_width="match_parent"

        android:layout_height="wrap_content" >



        <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:onClick="downloadPicture"

            android:text="Click to start download" >

        </Button>



        <Button

            android:layout_width="wrap_content"

            android:layout_height="wrap_content"

            android:onClick="resetPicture"

            android:text="Reset Picture" >

        </Button>

    </LinearLayout>



    <ImageView

        android:id="@+id/imageView1"

        android:layout_width="match_parent"

        android:layout_height="match_parent"

        android:src="@drawable/icon" >

    </ImageView>



</LinearLayout> 

Now adjust your activity.
In this activity the thread is saved and the dialog is closed if the
activity is destroyed.

package de.vogella.android.threadslifecycle;



import java.io.IOException;



import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.StatusLine;

import org.apache.http.client.HttpClient;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpUriRequest;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.util.EntityUtils;



import android.app.Activity;

import android.app.ProgressDialog;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.os.Bundle;

import android.os.Handler;

import android.view.View;

import android.widget.ImageView;



public class ThreadsLifecycleActivity extends Activity {

  // Static so that the thread access the latest attribute

  private static ProgressDialog dialog;

  private static ImageView imageView;

  private static Bitmap downloadBitmap;

  private static Handler handler;

  private Thread downloadThread;



  

Run your application and
press the button to start a download. You can test the correct lifecycle
behavior in the emulator via pressing "Ctrl+F11" as this changes the
orientation.

It is important to note
that the Thread is a static inner class. It is important to use a static
inner class for your background process because otherwise the inner class
will contain a reference to the class in which is was created. As the thread
is passed to the new instance of your activity this would create a memory
leak as the old activity would still be referred to by the Thread.

StrictMode is available
as of API 9, therefore make sure to use Android 2.3.3. As discussed you
should avoid performing long running operations on the UI thread. This
includes file and network access. It is sometimes difficult to remember to
make all the right things in your application during development. That is
were StrictMode comes in. It allows to setup policies in your application to
avoid doing incorrect things. For example the following setup will crash
your application if it violates some of the Android policies. StrictMode
should only be used during development and not in your live application.

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 {

  @Override

  public void onCreate(Bundle savedInstanceState) {

    StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()

        .detectAll().penaltyLog().penaltyDeath().build());

    StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll()

        .penaltyLog().penaltyDeath().build());



    super.onCreate(savedInstanceState);

    setContentView(R.layout.main);

    super.onCreate(savedInstanceState);

    setContentView(R.layout.main);

    String eol = System.getProperty("line.separator");

    try {

      BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(openFileOutput("myfile", MODE_WORLD_WRITEABLE)));

      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);

      writer.close();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }

} 

Traceview is a graphical
viewer to see logs created by an Android application. Via Traceview you can
find errors in your application and measure its performance.

8.1. USING TRACEVIEW IN ECLIPSE

Eclipse supports
tracing directly in the DDMS perspective. In the devices view select
your application process and select "Start Method Profiling".

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

You can zoom into the
graphic to get more details.

android.os.Debug.startMethodTracing("yourstring");



// ... your code is here



android.os.Debug.stopMethodTracing(); 

adb pull /sdcard/yourstring.trace

traceview yourstring 

Please help me to support
this article:

Before posting questions,
please see the vogella
FAQ. If you have questions or find an error in this article please use
the www.vogella.com
Google Group. I have created a short list how
to create good questions which
might also help you.