In our previous post StrictMode Part 1  we had discussed how to set up StrictMode in development environment and how to run your application with StrictMode enabled on emulator. In this tutorial we would be discussing more about dealing with StrictMode. The main topics that we are going to discuss are,

1. Turning off StrictMode When your application goes to production
2. StrictMode with older versions of Android(prior to Android 2.3)

• Buy: Hello, Android!!

Turning off StrictMode for Production purpose

I hope by now you have enough basic knowledge about what is StrictMode, how to enable it, and how to use it in production. Now we will discuss how to disable it when your application is ready to go on live failing which your application will crash on your users because of an alert. Below are the two ways by which you can disable StrictMode.

•  Comment out or Remove the StrictMode code when your application finishes its building, testing and debugging stage.
• You can use production flags to skip the StrictMode setup code when it is not needed.

If you start commenting out the StrictMode code, it would be difficult for you to continue development if anything else is left out in development. Hence the second approach to turnoff the StrictMode during production is better to use. This is done by simply declaring any flag and assigning it a boolean variable “true” in debugging mode and making it false once you are done with the development. You can make use of android:debuggable attribute that is present in AndroidManifest.xml for <application> Tag. Developer no longer need to add the android:debuggable attribute to the <application> tag in the manifest. The build tools add the attribute automatically. When exporting a signed release build, the tools do not add the attribute in the manifest. So it is enough for you to check whether android:debuggable attribute is true or false while setting up StrictMode.

Use the below code to check for debug mode,

// collects information from <application> tag
ApplicationInfo appInformation =context.getApplicationInfo();

//gives Flags associated with the application
int appFlags = appInformation.flags;

//Checks whether the application would like to allow debugging of its code
if ((appFlags & ApplicationInfo.FLAG_DEBUGGABLE) != 0)
{
// StrictMode setup goes here
}

Above code checks for debug mode and performs the StrictMode set up accordingly.

StrictMode with older versions of Android(prior Android 2.3)

Lets assume we have an application targetting android 4.0(API 14) and minimum SDK version set to Android 2.2(API 8). I have made StrictMode enabled by using setThreadPolicy() and setVmPolicy() static methods. Now if you test your application on emulator of android 2.2(API 8), your application crashes by displaying ANR dialog. This is because StrictMode is not available in versions below Android 2.3. But your application works fine on Android 4.0 supporting emulators.
Lets see how can we get rid of this particular problem.

Create a separate method to deal with the older versions of Android( prior to Android 2.3) as below

try {
//checks whether the strictMode class exists or what
Class class_obj = Class.forName("android.os.StrictMode");

//if the StrictMode class exists, the control comes here
Method enableDefaults = class_obj.getMethod("enableDefaults");

//dynamically invokes enableDefaults method which sets up StrictMode
enableDefaults.invoke(null);
}
catch(Exception e) {
// StrictMode not supported...
Log.v("STRICTMODE", " Lower version of android, StrictMode not supported");
}

As you can see in the above code, first you are checking whether android.os.StrictMode class is available or not. If it’s not, a ClassNotFoundException occurs which is caught by the catch block and we are writing a LogCat message by using Log class. You shouldn’t get any exceptions if StrictMode does exist, because enableDefaults() is one of its methods.The enableDefaults() method sets up StrictMode to detect everything and to write any violations to LogCat. If you run your application with this set up, on emulator supporting versions below Android 2.3, you get an Message logged in Logcat by your catch block and if you run on emulators supporting Android 2.3 and above, you will be alerted when you perform non-recommended things.

Another approach to deal with older versions of Android is using StrictMode wrapper class. This enables you to work with Higher and lower versions of Android while using StrictMode. If StrictMode is not available for your application, an
Error will be thrown if you try to access it. If you wrap StrictMode in a class and then catch the error, you can ignore when StrictMode is not available and get it when it is.

Lets us change the sample example that we have developed in our earlier post StrictMode Part 1. Add a StrictMode wrapper class to the project StrictModeTest by creating a class named StrictModeWrapper.java in the package my.app . the code of the StrictModeWrapper.java is as below.

package my.app;

import android.content.Context;
import android.os.StrictMode;

public class StrictModeWrapper {

public static void enableStrictMode(Context context) {
StrictMode.setThreadPolicy(
new StrictMode.ThreadPolicy.Builder()
.detectDiskReads()
.detectDiskWrites()
.detectNetwork()
.penaltyLog()
.build());
StrictMode.setVmPolicy(
new StrictMode.VmPolicy.Builder()
.detectLeakedSqlLiteObjects()
.penaltyLog()
.build());
}
}

In the above code I have simply wrapped up the code of StrictMode set up that we have discussed in our earlier post, inside a enableStrictMode() static method.

Change the StrictModeTestActivity.java code to the below code.

package my.app;

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;

public class StrictModeTestActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
Context context=StrictModeTestActivity.this;
//check whether debug mode is available
int applicationflags = context.getApplicationInfo().flags;
if ((applicationflags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
//check whether the Android version is >= 2.3.. if yes set up StrictMode by calling enableStrictMode() of wrapper class.
if (Build.VERSION.SDK_INT>=Build.VERSION_CODES.GINGERBREAD) {
StrictModeWrapper.enableStrictMode(this);
}
else{
//If the android version is less than 2.3 log a message to LogCat
Log.v("VERSION < Android 2.3", "StrictMode not supported");
}
}
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

//Code to perform FILE I/O which will be caught by StrictMode
try {
OutputStreamWriter output_writer= new OutputStreamWriter(openFileOutput("FILETEST", MODE_WORLD_WRITEABLE));
BufferedWriter writer = new BufferedWriter(output_writer);
writer.write("Hi This is my File to test StrictMode");
writer.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

In the above code we are just checking whether the SDK version is Android 2.3 or higher. If yes we would be calling enableStrictMode() method of the wrapper class, which sets up StrictMode. If your version is lesser tha Android 2.3 you are logging a error message to the LogCat.

Run your application on emulator supporting Android 4.0, you would get the below LogCat message while your Program runs well.

02-15 16:25:04.665: D/StrictMode(929): StrictMode policy violation; ~duration=47 ms: android.os.StrictMode$StrictModeDiskWriteViolation: policy=49 violation=1
02-15 16:25:04.665: D/StrictMode(929):  at android.os.StrictMode$AndroidBlockGuardPolicy.onWriteToDisk(StrictMode.java:1048)
02-15 16:25:04.665: D/StrictMode(929):  at libcore.io.BlockGuardOs.write(BlockGuardOs.java:178)
02-15 16:25:04.665: D/StrictMode(929):  at libcore.io.IoBridge.write(IoBridge.java:447)
02-15 16:25:04.665: D/StrictMode(929):  at java.io.FileOutputStream.write(FileOutputStream.java:187)
02-15 16:25:04.665: D/StrictMode(929):  at java.io.OutputStreamWriter.flushBytes(OutputStreamWriter.java:167)
02-15 16:25:04.665: D/StrictMode(929):  at java.io.OutputStreamWriter.close(OutputStreamWriter.java:140)
02-15 16:25:04.665: D/StrictMode(929):  at java.io.BufferedWriter.close(BufferedWriter.java:98)
02-15 16:25:04.665: D/StrictMode(929):  at my.app.StrictModeTestActivity.onCreate(StrictModeTestActivity.java:35)

Now run your application on emulator supporting Android 2.3 and see the LogCat entries. A log is being entered in LogCat where as the program runs well.

02-15 18:16:21.905: V/VERSION < Android 2.3(386): StrictMode not supported

This is how you can make your code run on all versions of Android with StrictMode enabled. Hope this tutorial helped you to work with StrictMode. If you have any queries, please post it in comments section.

• Buy: Hello, Android!!

• Buy: Hello, Android!!

StrictMode Policies

Currently there are two types of policies available with StrictMode.

• Thread Policy.
• VM(Virtual Machine) policy.

ThreadPolicy of StrictMode

Thread policies are concerned with the non-recommended things that are done on the main application thread(UI thread), notably flash I/O and Network I/O.

Violations you can look for using ThreadPolicy are,

• Disk reads
• Disk writes
• Network accesss
• Slow calls

The possible alerts that you can choose are,

• Write to LogCat
• Display a dialog
• Flash the screen
• write to the DropBox log file
• Crash the application

Setting up StrictMode’s ThreadPolicy

The below code tells you how to set up StrictMode for thread policies,

StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
.detectDiskWrites()
.penaltyLog() //Logs a message to LogCat
.build());

A good place to set policies is at the entry points to your application and activities. For instance, in a simple application, you may need to just put the code in the onCreate() method of the launch Activity class. setThreadPolicy is a static method so you don’t need to actually instantiate a StrictMode object. setThreadPolicy() method internally uses current thread for policy. The method bulid() returns a ThreadPolicy object. In the above code snippet, the policy is defined to alert on disk writes by logging the messages to LogCat. There are various detect and penalty methods available for ThreadPolicy which are listed below.

The various detect methods for Thread Policy are,

detectDiskWrites() //API level 9
detectDiskReads() //API level 9
detectNetwork() //API level 9
detectCustomSlowCalls()//Introduced in API level 11

Instead of specific detect methods you can use detectAll() which detects all possible violations. detectCustomSlowCalls() is available from API level 11 using which you can detect slow code in your application.

The possible alerts(penalties) for thread policy are,

penaltyLog() //Logs a message to LogCat
penaltyDeath() //Crashes application, runs at the end of all enabled penalties
penaltyDialog() //Show a dialog
penaltyDeathOnNetwork() //Crashes the whole process on any network usage
penaltyDropBox() //Enable detected violations log a stacktrace and timing data to the DropBox on policy violation
penaltyFlashScreen() //Introduced in API level 11 which Flash the screen during a violation

The above is the list of penalty methods available for ThreadPolicy. You can use two or more penalties while setting up the ThreadPolicy which will be executed based on priority. For example, you can make your system to Log your messages via penaltyLog() before crashing the process via penaltyDeath(). If no penalties are enabled before calling build, penaltyLog() is implicitly set.

VmPolicy of StrictMode

VM policy deals with bad coding practices resulting memory leaks like Detect leaks of Activity subclasses. Detects when SQLite object is finalized without having been closed or if any Closeable object is finalized before it has been closed. It is created via the same builder class as shown below.

StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
.detectActivityLeaks()
.detectLeakedClosableObjects()
.penaltyLog()
.build());

The possible policy violations for VmPolicy are,

detectActivityLeaks() //API level 11. Detect leaks of Activity subclasses.
detectLeakedClosableObjects() //API level 11. Detect when an Closeable or other object with a explict termination method is finalized without having been closed.
detectLeakedSqlLiteObjects() //API level 9. Detect when an SQLiteCursor or other SQLite object is finalized without having been closed.
setClassInstanceLimit(Class.forName("my.app.sample.sampleclass"),10) //API level 11

setClassInstanceLimit(className, Limit) is introduced in API level 11 which Sets an upper bound on how many instances of a class can be in memory at once. Helps to prevent object leaks.

The penalties that are applicable for VmPolicy Violations are,

penaltyLog()
penaltyDeath()
penaltyDropBox()

Note most of the Penalties that I have listed for ThreadPolicy are not application for VmPolicy. For example, you cannot be alerted by showing a dialog if a VmPolicy is violated.

If you find any problematic violations, you can solve them using various approaches like threads and handlers , AsyncTask  atc. Don’t try to solve all violations that your StrictMode detects. For example, Sometimes the disk I/O is necessary in your activities Lifecycle. In such cases you have to temporarily allow your Activity to access the DISK.  Android provides some helper methods to make it easier to allow disk reads and writes from the main thread temporarily. Such helper methods are,

• allowThreadDiskReads()
• allowThreadDiskWrites()

allowThreadDiskWrites() permits both disk reads & writes. Whereas allowThreadDiskReads() permits only disk read. Use the below code to allow disk access.

StrictMode.ThreadPolicy myoldpolicy=StrictMode.allowThreadDiskWrites();
//The code to write the DISK goes here
StrictMode.setThreadPolicy(myoldpolicy);

In the above code snippet,on line number 1 allowThreadDiskWrites() takes the current StrictMode.ThreadPolicy from getThreadPolic(), modifies it to permit both disk reads & writes, and sets the new policy with setThreadPolicy(StrictMode.ThreadPolicy), returning the old policy. Now “myoldpolicy” has the old StrictMode thread policy which is used to set the old policy again on line numer 3 after performing the nececcary Disk I/O. Note that There is no method for temporarily allowing network access.

So far we have learnt how to set up StrictMode for your application. Let us now study how to run your application with StrictMode. For that let us create a sample application, which has StrictMode enabled in it.

Step 1: Set up an Android working environment

If you are not familiar with setting up working environment for android, please follow the post Environment. For this example I would be using Android 4.0( API level 14).

Step 2: Create an Android Project

Create an android project named StrictModeTest with launcher activity StrictModeTestActivity. If you are not familiar with creating android projects, please follow one of our earlier posts Create a simple project.

Step 3: Create the required layouts

In this example, We would be using main.xml layout file. If you want to know more about layout files, please refer to the post Layouts in android. You need not to alter your main.xml file code for this example.

Step 4: Create required Activities

In this example, we would be using launcher activity StrictModeTestActivity.java. Open this and paste the below code,

package my.app;

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import android.app.Activity;
import android.os.Bundle;
import android.os.StrictMode;

public class StrictModeTestActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {

//setThreadPolicy is a static method
StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
.detectDiskWrites()
.penaltyLog() //Logs a message to LogCat
.penaltyDialog() //Shows a dialog
.build());

//VmPolicy
StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
.detectActivityLeaks()
.detectLeakedClosableObjects()
.penaltyLog()
.build());

super.onCreate(savedInstanceState);
setContentView(R.layout.main);

//Code to perform FILE I/O which will be caught by StrictMode
try {
OutputStreamWriter output_writer= new OutputStreamWriter(openFileOutput("FILETEST", MODE_WORLD_WRITEABLE));
BufferedWriter writer = new BufferedWriter(output_writer);
writer.write("Hi This is my File to test StrictMode");
writer.close();
} catch (Exception e) {
e.printStackTrace();
}

}
}

Now you are done with setting up StrictMode for DiskWrites. In the above example you are trying to read and write the file. Hence you would be alerted by LogCat messages and via dialogs.

Step 4: Run your application

Select your project-> right click-> Run As-> Android Application

Now the Activity fires up with the Dialog which alerts saying, you are violating the StrictMode policies.

StrictMode is warning us that we are attempting  FILE write on application’s main thread. The same is being logged in LogCat since we have specified penaltyLog(). The LogCat stackTrace is as below.

02-14 19:08:57.419: D/StrictMode(30397): StrictMode policy violation; ~duration=29 ms: android.os.StrictMode$StrictModeDiskWriteViolation: policy=49 violation=1
02-14 19:08:57.419: D/StrictMode(30397):  at android.os.StrictMode$AndroidBlockGuardPolicy.onWriteToDisk(StrictMode.java:1048)
02-14 19:08:57.419: D/StrictMode(30397):  at libcore.io.BlockGuardOs.write(BlockGuardOs.java:178)
02-14 19:08:57.419: D/StrictMode(30397):  at libcore.io.IoBridge.write(IoBridge.java:447)
02-14 19:08:57.419: D/StrictMode(30397):  at java.io.FileOutputStream.write(FileOutputStream.java:187)
02-14 19:08:57.419: D/StrictMode(30397):  at java.io.OutputStreamWriter.flushBytes(OutputStreamWriter.java:167)
02-14 19:08:57.419: D/StrictMode(30397):  at java.io.OutputStreamWriter.close(OutputStreamWriter.java:140)
02-14 19:08:57.419: D/StrictMode(30397):  at java.io.BufferedWriter.close(BufferedWriter.java:98)
02-14 19:08:57.419: D/StrictMode(30397):  at my.app.StrictModeTestActivity.onCreate(StrictModeTestActivity.java:34)

You can observe the above LogCat messages, on Line number 1 it is saying the StrictMode policy is violated.

Note:  Do not use StrictMode in production code. It is designed for use when you are building,
testing, and debugging your application.

• Buy: Hello, Android!!

StrictMode was introduced in Android 2.3(API level 9) but more features were added in Android 3.0, so it is your duty to target the correct Android version and make sure your code is executed on the appropriate platforms. StrictMode is for android 2.3 and higher versions of android. Hence if in our application, the target API is 2.3 or higher and the MinSDK is below 9, this may crash your applications while testing on lower version emulator or devices.  We would be discussing how to support StrictMode in lower versions of android in our upcoming post StrictMode Part 2 . Stay Tuned. Hope this tutorial helped you to understand the usage of StrictMode. Please don’t forget to post your queries in comments section.

• Buy: Hello, Android!!

The AsyncTask class encapsulates the creation of Threads and Handlers. When an AsyncTask is created, it goes through 4 steps,

• onPreExecute()
• doInBackground(Params…)
• onProgressUpdates(Progress…)
• onPostExecute(Result)

The method doInBackgroung() executes automatically on a worker thread. The rest of the methods onPreExecute(), onPostExecute(), and onProgressUpdate() are all invoked on the UI thread. The value returned from the doInBackground() is sent to the onPostExecute() method. onProgressUpdate() method is executed by calling publishProgress() in doInBackground(). Do not call onPreExecute(), onPostExecute(Result), doInBackground(Params…), onProgressUpdate(Progress…) manually. Overriding onPreExecute(), onPostExecute(Result), onProgressUpdate(Progress…) is optional.

AsyncTask is defined by three generic types Params, Progress, Result,

class AsyncDemo extends AsyncTask<Params, Progress, Result> { ... } 

• Params
  It is the type of the parameters passed in to the doInBackground.
• Progress
  It is the type of the progress units published during the backgroung computation. These are passed in to the onProgressUpdate.
• Result
  It is the return type of doInBackground and argument type passed in to onPostExecute.

An AsyncTask must be subclassed to be used as below,

private class AsyncDemo extends AsyncTask<String, String, String>{

@Override
protected void onPreExecute() {
// keeps the user informed about the long running tasks example by showing progressbar etc.
super.onPreExecute();
}

@Override
protected String doInBackground(String... params) {
// The code of long running tasks goes here
return null;
}

@Override
protected void onProgressUpdate(String... values) {
//when the long running tasks is in progress, the code to update the progress example updating the progress bar
super.onProgressUpdate(values);
}

@Override
protected void onPostExecute(String result) {
//once the background work is done with execution, update the UI...
super.onPostExecute(result);
}
}

The above snippet shows how you can create An AsyncTask for your operations. Once created, the Task is executed using the below line,

new AsyncDemo().execute();

While calling execute() method, pass the parameters which your AsyncTask is using.

Working of an AsyncTask

When an AsyncTask is executed by calling execute() method, it goes through 4 steps as stated above,

1.  It first goes to onPreExecute() method, which is used to setup the Task. This can be used to keep the user informed about the Task that executes in background by showing a progressdialog.
2. Then the control goes to doInBackground() method where the expensive work takes place. This is invoked immediately after onPreExecute() finishes executing. The parameters of the AsyncTask are passed(if any) to this method. The results are returned and are passed to the onPostExecute() method which processess the result and updates the UI accordingly if necessary.
3. publishProgress(Progress…) can be called inside doInBackground() method which in turn calls the onProgressUpdate(Progress…) to publish one or more units of progress.
4. After the backgroud task finishes its computation, onPostExecute(Result) is invoked. The Result of the background computation is passed as parameter to this step from the doInBackground(Params…) step. onPostExecute(Result) updates the UI(Example: Cancelling the ProgressDialog etc);

Let us now look at a simple example on how to execute long running tasks using AsyncTask

Working of the below AsyncTask example

In this example we would be displaying numbers in regular intervals of time forming a counterdown timer. The number of numerics to count is obtained from the user using an EditText. When the user clicks on a button called “Count”, the textview in the layout file starts showing numbers from 1 to any numeric specied by the user.(say 1 to 10 if your input is 10). When the numeric say 10 is displayed, the countdown stops and displays a message “Your countDown timer has stopped”.

Follow the below steps to create the example,

Step 1: Set up an android working environment

If you are not familiar with setting up the android environment, please refer to one of our earliar post, Environment. I would be using Android2.2 for this example.

Step 2 : Create an android project

Create a project named “AsyncTaskDemo” with the activity “ActivityAsyncTask”. If you are not familiar with creation of android project, please refer the post Create an Android project.

step 3: Create a layout

When you create your project, the layout main.xml gets created automatically. Here in this example we are going to use this main.xml layout file. Open your main.xml and paste the below code.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:id="@+id/RelativeLayout01"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="<a href="http://schemas.android.com/apk/res/android">http://schemas.android.com/apk/res/android</a>">
<EditText android:id="@+id/EditText01" android:layout_height="wrap_content"
android:layout_width="90dip"></EditText>
<Button android:id="@+id/Button01" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_toRightOf="@+id/EditText01"
android:text="Count"></Button>
<TextView android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_centerInParent="true" android:textStyle="bold" android:textSize="18sp"></TextView>
</RelativeLayout>

Step 4: Create the required Activities

Here in this example I would be using the launcher activity ActivityAsyncTask.java. Open this activity and paste the below code,

package my.app;

import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class ActivityAsyncTask extends Activity {
EditText input_time;
TextView count_textview;
Button start_count;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

start_count=(Button)findViewById(R.id.Button01);
count_textview=(TextView)findViewById(R.id.TextView01);
input_time=(EditText)findViewById(R.id.EditText01);

start_count.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
//taking the input from the edittext
String input_number=input_time.getText().toString();
Integer input_time_int=Integer.parseInt(input_number);

//Starting CountDownStarterTask task by passing the parameter
new CountDownStarterTask().execute(input_time_int);
}
});
}

private class CountDownStarterTask extends AsyncTask<Integer, Integer, Void>{
@Override
protected void onPreExecute() {
// TODO Auto-generated method stub
super.onPreExecute();
}
@Override
protected Void doInBackground(Integer... params) {
// TODO Auto-generated method stub
for(int i=1;i<=params[0].intValue();i++){
try {

//calls onProgressUpdate to publish the progress
publishProgress(i);
Thread.sleep(1000);

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

return null;
}
@Override
protected void onProgressUpdate(Integer... values) {
// TODO Auto-generated method stub
super.onProgressUpdate(values);

Integer time_to_set=values[0].intValue();
count_textview.setText(time_to_set.toString());
}
@Override
protected void onPostExecute(Void result) {
// TODO Auto-generated method stub
super.onPostExecute(result);
count_textview.setText("Your countDown timer has stopped");
}
}
}

As you can observe in the above code, we have an Edittext which collects the user input. You have to enter a numeric input and click on “Count” button. Which starts counting number from 1 to max number that you have given as input.

Step 5: Declaring the Activities in Android Manifest file

Your launcher activity is declared automatically. If you want to know more about android Manifest xml file, please refer to the post AndroidManifest.xml.

Your manifest file has the below code,

<manifest xmlns:android="<a href="http://schemas.android.com/apk/res/android">http://schemas.android.com/apk/res/android</a>"
package="my.app"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".ActivityAsyncTask"
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>
<uses-sdk android:minSdkVersion="8" />
</manifest>

Step 6: Run your App

Select your project-> Right click-> Run As-> Android Application

Activity ActivityAsyncTask fires up as below.

Enter a number of your choice(say 10) in the EditText and click on the button “Count”. Now the countDown starts as below.

When the count reaches 10 it stops and the below message appears on screen.

This is how you can make your long running tasks to run using AsyncTask without blocking the main UI thread. AsyncTask starting with DONUT was offering multitasking by using pool of threads whereas starting with HONEYCOMB, it uses single threading model. If you truly want parallel execution, you can always use executeOnExecutor(java.util.concurrent.Executor, Object[]) instead of execute(). Hope this tutorial helped you. Please post your queries, doubts if any in the comments section.

• Buy: Hello, Android!!
• Google Reference

   new Thread(new Runnable() {
public void run() {
//time consuming tasks
}
}).start();

Handler handler = new Handler() {

//handles the thread's messages and updates the UI
@Override
public void handleMessage(Message msg) {
//code to update the UI goes here....
}
};

@Override
public void onClick(View v) {
// TODO Auto-generated method stub

//starting a new thread on click of a button
new Thread(new Runnable() {
public void run() {
try {
/*long running tasks code is written here... I have made the thread to sleep for 4 seconds*/
Thread.sleep(4000);

//Sending an empty message to the handler indicating that the task has finished its execution
handler.sendEmptyMessage(0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
txt.setText("text updated by worker thread");
}
};

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
//starting a new thread on click of a button
new Thread(new Runnable() {
public void run() {
try {
/*long running tasks code is written here... I have made the thread to sleep for 4 seconds*/
Thread.sleep(4000);
Message msg = new Message();
Bundle bundle = new Bundle();
bundle.putString("Message", "Data transfered");
msg.setData(bundle);
// send message to the handler
handler.sendMessage(msg);

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
// get the bundle and extract data by key
Bundle bundle = msg.getData();
String message = bundle.getString("Message");
txt.setText(message);
}
};

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
final Runnable r=null;
//starting a new thread on click of a button
new Thread(new Runnable() {
public void run() {
try {
/*long running tasks code is written here... I have made the thread to sleep for 4 seconds*/
Thread.sleep(4000);

handler.post(r);

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}).start();
}

When you create any worker threads for your application to perform any time consuming tasks, it is recommended to keep the user informed saying that they will have to wait for sometime to get their work done. This is done by showing a progress dialog or a progress bar to the user. Please refer to the post ProgressDialog to know how to use threads and handlers in an application and how to keep the user informed about the background task. By using worker threads you can run time consuming tasks without blocking the User interface, however the long running tasks can be handled easily using AsyncTask. We would be discussing about AsyncTask in our next tutorial AsyncTask. Hope this tutorial helped you to understand the usage of Threads and handlers. Feel free to post your queries regarding this tutorial in comments section.

A progress dialog can be opened by calling ProgressDialog.show(). This can be easily done without managing the dialog inside onCreateDialog() callback as used in the post AlertDialog while creating an AlertDialog which has lists,Checkboxes and RadioButtons.

The syntax of ProgressDialog.show() is as below.

ProgressDialog.show(ActivityProgressDialog.this,
"Please wait", "Your result is being calculated", true);

where the first parameter represents the context, second represents the title, third is the message and the last parameter tells whether the ProgressDialod is indeterminate or not. We have passed true since we are creating a spinning wheel ProgressDialog. The default style of the ProgressDialog is Spinning Wheel. Hence you can use the show() method without the last parameter.

Let us now discuss a simple example which explains the steps to create a Spinning wheel Progress Dialog.

In this example we are building a result calculation system. When the user clicks on the submit button, a ProgressDialog is shown, which asks him to wait till the result is being calculated. Then the result is shown to the user. Here the emphasis is more on creating a ProgressDialog and not on result calculation. Hence the “score” String is hardcoded with some value to display it to the user.

Step 1: Set up the android working environment

If you are not familiar with setting up an android environment, please have a look at the post, Environment. This example is built using API level 8.

Step 2: Create an Android Project

Create an android project named ProgressDialogDemo with the launcher activity ActivityProgressDialog.java. If you are not familiar with the android project creation, please refer to the post Simple android project.

Step 3: Create the required layouts

In this example, We would be using main.xml layout file. If you want to know more about layout files, please refer to the post Layouts. Open the main.xml file and paste the below code.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:id="@+id/RelativeLayout01"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>">

&lt;TextView android:id=&quot;@+id/TextView01&quot; android:layout_width=&quot;wrap_content&quot;
android:layout_height=&quot;wrap_content&quot; android:text=&quot;Press Submit button to get your results&quot;
android:layout_centerHorizontal=&quot;true&quot; android:textStyle=&quot;bold&quot;
android:textSize=&quot;15sp&quot; android:layout_marginTop=&quot;30dip&quot;&gt;&lt;/TextView&gt;

&lt;Button android:id=&quot;@+id/Button01&quot; android:layout_below=&quot;@id/TextView01&quot;
android:layout_width=&quot;wrap_content&quot; android:layout_height=&quot;wrap_content&quot;
android:layout_centerHorizontal=&quot;true&quot; android:text=&quot;Submit&quot;
android:layout_marginTop=&quot;15dip&quot;&gt;&lt;/Button&gt;

&lt;TextView android:id=&quot;@+id/TextView02&quot; android:layout_below=&quot;@id/Button01&quot;
android:layout_width=&quot;wrap_content&quot; android:layout_height=&quot;wrap_content&quot;
android:layout_centerHorizontal=&quot;true&quot; android:visibility=&quot;gone&quot;
android:textSize=&quot;16sp&quot; android:textStyle=&quot;bold&quot;
android:text=&quot;congratulations!! Your score is &quot;&gt;&lt;/TextView&gt;
&lt;/RelativeLayout&gt;

The main.xml has a “Submit” button which triggers a ProgressDialog. It has 2 textviews.The first one is Textview01, which tells the user to click “Submit” button. Textview02 is made invisible in the beginning.

Step 4: Create the required Activities

Here in this example, we would be using launcher activity ActivityProgressDialog.java. Open ActivityProgressDialog.java and paste the below code.

package my.app;

import android.app.Activity;
import android.app.ProgressDialog;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

public class ActivityProgressDialog extends Activity {
ProgressDialog progressdialog;
Button Spinner_progress, Progress_bar;
ProgressDialog progressbar;
Handler mHandler;
TextView instruction,marks_update;
String score;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Spinner_progress=(Button)findViewById(R.id.Button01);
instruction=(TextView)findViewById(R.id.TextView01);
marks_update=(TextView)findViewById(R.id.TextView02);
Spinner_progress.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
progressdialog=ProgressDialog.show(ActivityProgressDialog.this,
"Please wait", "Your score is being calculated");

//creating a separate thread
new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub

try {
Thread.sleep(4000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
getResults();
}
}).start();

mHandler = new Handler()
{
public void handleMessage(android.os.Message msg)
{
super.handleMessage(msg);
switch (msg.what)
{
case 10:
progressdialog.dismiss();
marks_update.setVisibility(View.VISIBLE);
marks_update.append(score);
instruction.setVisibility(View.GONE);
Spinner_progress.setVisibility(View.GONE);

break;
}
}
};

}
});
}
private void getResults() {
// TODO Auto-generated method stub
try {
/*Write the code of your long
*running tasks here*/

//assigned 80% to score string, to display the results
score="80%";

mHandler.sendEmptyMessage(10);

} catch (Exception e) {
// TODO: handle exception
mHandler.sendEmptyMessage(1);
}
}

}

Let us now try to understand the flow of the above code. In the onCreate() function we create the ProgressDialog on click of the button “submit” using the method ProgressDialog.show(). As you can notice, we have created a separate thread to calculate the result. when the thread.start() is executed, it creates a new thread and executes the run() function, which inturn calls the method getResults(). Before calling getResults() I have made the thread to sleep for some time. This is done to make the ProgressDialog visible for more time.

The getResults() method calculates your score(does long running tasks in other case) and sends an Empty message to the handler. Sometimes its difficult to update the UI when you are running separate threads hence here we use handlers to update the UI. When the handler receives the message, it dismisses the ProgressDialog and does the UI updations.

Step 5: Declare the activities in AndroidManifest.xml

Your launcher activity is declared automatically. If you want to know more about AndroidManifest.xml file, please refer to our earlier post, Manifest.

Your Manifest file has the below code.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>"

package=&quot;my.app&quot;
android:versionCode=&quot;1&quot;
android:versionName=&quot;1.0&quot;&gt;
&lt;application android:icon=&quot;@drawable/icon&quot; android:label=&quot;@string/app_name&quot;&gt;
&lt;activity android:name=&quot;.ActivityProgressDialog&quot;
android:label=&quot;@string/app_name&quot;&gt;
&lt;intent-filter&gt;
&lt;action android:name=&quot;android.intent.action.MAIN&quot; /&gt;
&lt;category android:name=&quot;android.intent.category.LAUNCHER&quot; /&gt;
&lt;/intent-filter&gt;
&lt;/activity&gt;

&lt;/application&gt;
&lt;uses-sdk android:minSdkVersion=&quot;8&quot; /&gt;

&lt;/manifest&gt;

Step 6: Run your project

Select your project->right click->Run As->Android Application.

Your project runs and the activity fires up as below.

Press the submit button to see your progress Dialog.

Then the score displays as below.

So far we have seen how to develop an android Spinning Wheel ProgressDialog to make the users involved when a long running tasks need to be done in the background. We would be studying about Horizontal Progress Bar( the other type of ProgressDialog) in our upcomming posts. I Hope this tutorial served your purpose. Feel free to post your comments if you have any queries.

In the previous post Task Execution and Scheduling in Spring, I explained basic interfaces for task execution and scheduling. In this post I shall demonstrate an example for the same using annotations @Scheduled and @Async. Let us have working Eclipse IDE in place and follow the steps to create a scheduled Spring application:

1. Create a project: Create a project with a name SpringScheduler and create a package com.javabeat under the src directory in the created project.
2. Add Libraries: Add required Spring libraries using Add External JARs option as explained in the article Customizing callback methods. Along with these libraries also add aopalliance-1.0.jar to the build path.
3. Create source files: Create Java classes SchedulerSample,TaskSample and MainApp under the com.javabeat package.
4. Create configuration file: Create XML based configuration file Beans.xml under src directory.

follow us on @twitter and @facebook

• Spring Framework Books
• Spring Tutorials ( Collection for Spring reference tutorials)
• Spring Framework Interview Questions
• Introduction to Spring LDAP
• How to write Custom Spring Callback Methods?

The content of SchedulerSample.java file are:

package com.javabeat;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class SchedulerSample {

	  @Autowired
	  private TaskSample task;

	  @Scheduled(fixedDelay = 3000)
	  public void processScheduledJob() {
	    task.execute();
	  }

	  public TaskSample getTask() {
	    return task;
	  }

	  public void setTask(TaskSample task) {
	    this.task = task;
	  }
}

Here you can note that we have scheduled the task for a time of 3000 milliseconds.

The content of TaskSample.java file are:

package com.javabeat;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class TaskSample {
	@Async
	public void execute() {
		System.out
		.println("Executing asynchronous task for every fixedDelay of 3000millisecond.");
	}
}

The execute() method will be called every 3000 milliseconds.

The content of Beans.xml file are:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:task="http://www.springframework.org/schema/task"
 xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd


http://www.springframework.org/schema/task


http://www.springframework.org/schema/task/spring-task-3.0.xsd


http://www.springframework.org/schema/context


http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<context:component-scan base-package="com.javabeat" />

<task:annotation-driven executor="executor" scheduler="scheduler" />

<task:executor id="executor" pool-size="5" />

<task:scheduler id="scheduler" pool-size="5" />

</beans>

Here we need to note few things:

• To enable the annotation driven scheduling we have added the annotation-driven element from the task namespace.
• Schema http://www.springframework.org/schema/task, http://www.springframework.org/schema/task/spring-task-3.0.xsd, are added to the above file.
• task:executor – creates an instance of ThreadPoolTaskExecutor.
• task:scheduler – creates an instance of ThreadPoolTaskScheduler.

To execute the application the MainApp.java is as follows:

package com.javabeat;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
	public static void main(String[] args) {
	    new ClassPathXmlApplicationContext("Beans.xml");
	  }
}

Execute the code

The final step is run the application. Once all the above code is ready execute and the below output appears on the console:

Executing asynchronous task for every fixedDelay of 3000millisecond.
Executing asynchronous task for every fixedDelay of 3000millisecond.

As you can see the message is printed at a delay of 3000millisecond. You need to stop the application to stop the printing of message.

Summary

In this section I demonstrated an example of scheduling the Spring application using the annotation.If you are interested in receiving the future articles, please subscribe here. follow us on @twitter and @facebook

Spring 2.0 introduced abstractions for asynchronous execution and scheduling of tasks. The key interfaces for scheduling and task execution are as listed as TaskExecutor, TaskScheduler, Trigger, TriggerContext and ScheduledFuture. Let take a look at each of these interfaces. This article explores spring’s scheduler related APIs in detail. You can read the official explanation for this API’s here.

follow us on @twitter and @facebook

• Spring Framework Books
• Spring Tutorials ( Collection for Spring reference tutorials)
• Spring Framework Interview Questions
• Introduction to Spring LDAP
• How to write Custom Spring Callback Methods?

TaskExecutor

TaskExecutor was introduced as an abstraction for dealing with executors. Executors are the Java 5 name for the concept of thread pools. The primary aim of TaskExecutor is to abstract away the need for Java 5 when using thread pools. The interface has only a single method as shown below:

public interface TaskExecutor extends java.util.concurrent.Executor {
void execute(Runnable task);
}

TaskExecutor Implementation Classes

• SimpleAsyncTaskExecutor: Does not reuse threads. It starts a new thread and is asynchronus.
• SyncTaskExecutor: No thread reuse and is synchonous. Instead, each invocation takes place in the calling thread.
• ConcurrentTaskExecutor: Exposes the Java 5 java.util.concurrent.Executor.
• SimpleThreadPoolTaskExecutor: It is a subclass of Quartz’s SimpleThreadPool which listens to Spring’s lifecycle callbacks.
• ThreadPoolTaskExecutor: It exposes bean properties for configuring a ThreadPoolExecutor configuration and and wraps it in a TaskExecutor.
• TimerTaskExecutor: This implementation uses a single TimerTask as its backing implementation. It’s different from the SyncTaskExecutor in that the method invocations are executed in a separate thread, although they are synchronous in that thread.
• WorkManagerTaskExecutor: This implementation uses the CommonJ WorkManager as its backing implementation

TaskScheduler

This interface has a variety of methods for scheduling tasks to run at some point in the future, as seen below:

public interface TaskScheduler {
ScheduledFuture schedule(Runnable task, Trigger trigger);

    ScheduledFuture schedule(Runnable task, Date startTime);

    ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);

    ScheduledFuture scheduleAtFixedRate(Runnable task, long period);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}

FixedRate – period will be measured from the start time
FixedDelay – period will be measured from the completion time

TaskScheduler Implementation Classes

• TimerManagerTaskScheduler: Delegates to a CommonJ TimerManager instance, typically configured with a JNDI-lookup.
• ThreadPoolTaskScheduler: Used whenever external thread management is not a requirement. Internally, it delegates to a ScheduledExecutorService instance.

Trigger

Using Trigger the execution times may be determined based on past execution outcomes or even arbitrary conditions. The Trigger interface is as follows:

public interface Trigger {
Date nextExecutionTime(TriggerContext triggerContext);
}

TriggerContext is an interface and encapsulates all of the relevant data.

Trigger Implementation Classes

• CronTrigger: It enables the scheduling of tasks based on cron expressions.
• PeriodicTrigger: It accepts a fixed period, an optional initial delay value, and a boolean to indicate whether the period should be interpreted as a fixed-rate or a fixed-delay.

Bootstrapping the scheduler

Since Spring 3.0, XML namespace for configuring TaskExecutor and TaskScheduler instances is available. It also provides a convenient way to configure tasks to be scheduled with a trigger. Add the following schema to the spring configuration file(xml file):

http://www.springframework.org/schema/task


http://www.springframework.org/schema/task/spring-task-3.0.xsd

Task Namespace
Add the following configuration :

<task:executor id="executor" pool-size="8-25" queue-capacity="100" />
<task:scheduler id="scheduler" pool-size="10" />

• task:executor – Create instance of ThreadPoolTaskExecutor
• task:scheduler – Create instance of ThreadPoolTaskScheduler
• pool-size – If the value is not provided, then the default thread pool will only have a single thread.
• queue-capacity – Number of tasks held back. Default value is Unbound
• rejection-policy – This another attribute not mentione the above example. Used for to throw exception when a task is rejected. Its default value is AbortPolicy. Other possbile values are – DiscardPolicy , DiscardOldestPolicy , and CallerRunsPolicy.

Scheduling the Tasks

Tasks can be scheduled in the following three ways:

1. Annotation Driven
2. XML Driven
3. Programmatically

1. Annotation Driven

The @Scheduled annotation can be added to a method along with trigger metadata for task scheduling. The @Async annotation can be provided on a method so that invocation of that method will occur asynchronously.

Add following to your spring configuration file:

<context:component-scan annotation-config="true" base-package="com.javabeat"/>
<task:annotation-driven executor="executor" scheduler="scheduler" />

The following example will only execute on weekdays.:

@Scheduled(cron="*/5 * * * * MON-FRI")
public void doSomeTask(){
 // some task that should execute on weekdays only
}

Scheduled methods must have void returns and must not expect any arguments.

Syntax for @Async annotation is:

@Async
void doSomething() {
    // this will be executed asynchronously
}

2. XML Driven

Add the following configuration to the spring configuration file :

<task:scheduled-tasks scheduler="sampleScheduler">
   <task:scheduled ref="someObject"
      method="someMethod" fixed-delay="5000"/>
</task:scheduled-tasks>

3. Programmatically

Go for programmatic way when your application desire more control on scheduling. For example :

ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) appContext.getBean("scheduler");
CronTrigger trigger = new CronTrigger("*/5 * * * * MON-FRI");

ScheduledFuture<Object> scedulefuture= scheduler.schedule(taskObject, trigger );

In the above example instead of schedule() method, you can use scheduleAtFixedRate(.. , ..) or scheduleWithFixedDelay(.. , ..).

Summary

In this post we saw the basics of task execution and scheduling in Spring. We studied the interfaces TaskExecutor, TaskScheduler, and Trigger and their implementation classes. We also saw methods of scheduling the tasks, annotation driven, XML driven and programmatically. In the next article I shall demonstrate this with an example. If you are interested in receiving the future articles, please subscribe here. follow us on @twitter and @facebook.

A Dialog is a small window that appears in front of the current Activity.  An AlertDialog is a Dialog which can have zero, one, two or three buttons. We have discussed about creating a simple AlertDialog in one of our earlier posts AlertDialog.  The previous tutorial on AlertDialog demonstrated how to create an AlertDialog which has  title, simple message and buttons.  This tutorial demonstrates how to add lists, CheckBoxes and Radio Buttons to an AlertDialog.

Prerequisites:

You must have enough knowledge on how to create an AlertDialog. If you are not familiar with creating an AlertDialog, please refer to the post Create an AlertDialog .Unlike the previous post, here in this tutorial we would be using  few methods of the Activity

• onCreateDialog()
• onPrepareDialog()
• showDialog()

When you want to show a dialog, call showDialog(int) method and pass in an integer variable that uniquely identifies your dialog.
When the dialog is requested for the first time, Android calls onCreateDialog(int) from your Activity. You should instantiate your dialog inside onCreateDialog method. This callback returns the Dialog object.

If you want to do change any properties of your dialog each time it is opened, you can make use of an optional callback onPrepareDialog(int,dialog), which is called every time your dialog is opened whereas onCreateDialog(int) is only called for the very first time your dialog is opened. If you donot define onPrepareDialog method, your dialog’s selection state remains unchanged(such as items checked in the checkbox or radio button remains checked even when the dialog is opened for the second time).

Your job is to call the method showDialog with the unique integer that identifies your dialog. Android calls the rest of the methods onCreateDialog and onPrepareDialog.

It is recommended to use switch statement inside onCreateDialog and onPrepareDialog callbacks that checks the id parameter that is passed as parameters to these methods and creates the dialog accordingly.

@Override
protected Dialog onCreateDialog(int id) {
// TODO Auto-generated method stub
switch (id) {
case LIST_ALERTDIALOG:

break;
case CHECKBOX_ALERTDIALOG:

break;
case RADIOBUTTON_ALERTDIALOG:

break;

}
return null;
}

Creating an AlertDialog with a list of items

Above is the picture of an AlertDialog with a list of items. To create an AlertDialog with a list of selectable items, use the method setItems().

public AlertDialog.Builder setItems (CharSequence[] items,
DialogInterface.OnClickListener listener);

The setItems() method takes 2 parameters, first one is the list of items to be displayed in the dialog as its content and the next is the listener which notifies about the selected item.

When you call showDialog(LIST_ALERTDIALOG) method, where LIST_ALERTDIALOG is the variable representing your list AlertDilaog, Android calls the onCreateDialog(LIST_ALERTDIALOG) where in it goes to the first case statement which matches your List AlertDialog. The below code snippet is used to define and create your dialog inside the first case .

case LIST_ALERTDIALOG:

AlertDialog.Builder builder=new AlertDialog.Builder(AlertDialogDemo.this)
.setTitle("Choose a Color")
.setItems(colors_list, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(),
"The selected color is "+colors_list[which], Toast.LENGTH_LONG).show();
}
});
AlertDialog alertdialog=builder.create();
return alertdialog;

In the above code colors_list is the array of items to display.

final CharSequence[] colors_list={"Green","Black","White"};

Here in the case statement, we are displaying a Toast message on click of a list item. The toast displays the selected item. If you want more information about how to create a toast message, please go through the post Toast . Finally the case statement returns the Dialog object.

Note: Few lines in the above case statement are not explained here, since it has been covered in one of our previous posts.  Please refer to the post How to create an AlertDialog to know how to create a simple Alertdialog.

Creating an AlertDialog with Checkboxes

Now we would be discussing about the second case statement “case CHECKBOX_ALERTDIALOG:” An AlertDialog with checkBoxes is as shown below.

As you can see in the above screen of alertDialog, I have added a button “OK” to get the checked item details. However adding “OK” button is optional.

To create an AlertDialog with a list of multiple-choice items, you have to make use of the method setMultiChoiceItems(). The code is as same as the previous code snippet, but setItems() method is replaced with the setMultiChoiceItems() method. This method takes 3 parameters. The syntax of the method setMultiChoiceItems() is as below.

public AlertDialog.Builder setMultiChoiceItems (CharSequence[] items,
boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener);

First parameter is the text of the items to be displayed in the list, second parameter specifies which items are checked. It should be null in which case no items are checked. If non null it must be exactly the same length as the array of items. you will be notified of the selected item via the supplied listener as the third parameter. Clicking on an item in the list will not dismiss the dialog hence I have added a button “OK” which takes the items that you have checked and dismisses the dialog on click of it.

Creating an AlertDialog with RadioButtons

The alertDialog with a list of single-choice items is as shown below.

We have to use setSingleChoiceItems() method to create such AlertDialogs. This method takes three parameters. The syntax is as below.

public AlertDialog.Builder setSingleChoiceItems (CharSequence[] items,
int checkedItem, DialogInterface.OnClickListener listener);

First parameter is the list of items to be displayed. Second is the “checkedItem”  specifies which item is checked. If -1 no items are checked. The third parameter is a “listener”  notified when an item on the list is clicked. The dialog will not be dismissed when an item is clicked.

Add the below code to the third case statement of the onCreateDialog method to create an AlertDialog with radiobuttons.

case RADIOBUTTON_ALERTDIALOG:

AlertDialog.Builder builder2=new AlertDialog.Builder(AlertDialogDemo.this)
.setTitle("Choose a Color")
.setSingleChoiceItems(colors_radio, -1, new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(),
"The selected color is "+colors_radio[which], Toast.LENGTH_LONG).show();

//dismissing the dialog when the user makes a selection.
dialog.dismiss();
}
});
AlertDialog alertdialog2=builder2.create();
return alertdialog2;

As you see in the above code, We have used dialog.dismiss inside onclick() of the list since clicking on the list item do not dismisses the dialog. colors_radio is the list of items to be displayed.

final CharSequence[] colors_radio={"Green","Black","White"};

If you create any one of the above selectable lists(checkbox or radiobuttons) in the onCreateDialog() callback method, the state of the selected item is managed by Android as long as the Activity is active.

So far we have seen details on AlertDialog with lists, CheckBoxes and RadioButtons. Let us now learn how to create a project which has all these types of dialogs.

Required layouts

• main.xml which has three buttons namely “List”(shows a List AlertDialog), “CheckBox” and “RadioButton”.

Required Activity

• AlertDialogDemo

Step 1: Set up the android developement evvironment

This topic has already been discussed in one of our previous posts Environment. Please refer the post for more queries. I would be using Android 2.2 for this example.

Step 2: Create the Project

Create a project named “AlertDialog” with the launcher activity AlertDialogDemo.java. For more information on how to create a new project in android, please refer to the post Create an android project.

Step 3: Create the required layouts

As i said earlier, I would be using main.xml layout file. To know more about layout xml files, please go through the post Layouts. Open the main.xml file and paste the below code.

main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:id="@+id/RelativeLayout01"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>">

<Button android:id="@+id/Button01" android:layout_height="wrap_content"
android:text="List" android:layout_width="90dip"
android:layout_marginLeft="20dip" android:layout_centerVertical="true"></Button>
<Button android:id="@+id/Button02" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_toRightOf="@+id/Button01"
android:text="CheckBox" android:layout_centerVertical="true"></Button>
<Button android:id="@+id/Button03" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_toRightOf="@+id/Button02"
android:text="RadioButton" android:layout_centerVertical="true"></Button>
</RelativeLayout>

As you can notice, I have used three buttons to trigger your three AlertDilaogs.

Step 4: Create the required Activities

Here in this example, I would be using the launcher activity “AlertDialogdemo”. Open the activity and paste the below code.

package my.app;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;

public class AlertDialogDemo extends Activity implements OnClickListener {
/** Called when the activity is first created. */

final int LIST_ALERTDIALOG=0,CHECKBOX_ALERTDIALOG=1,RADIOBUTTON_ALERTDIALOG=2;
final boolean checked_state[]={false,false,false}; //The array that holds the checked state of the checkbox items
final CharSequence[] colors_check={"Green","Black","White"}; //items in the alertdialog that displays checkboxes
final CharSequence[] colors_list={"Green","Black","White"}; //items in the alertdialog that displays list
final CharSequence[] colors_radio={"Green","Black","White"}; //items in the alertdialog that displays radiobuttons
Button list,check,radio;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

list=(Button)findViewById(R.id.Button01);
check=(Button)findViewById(R.id.Button02);
radio=(Button)findViewById(R.id.Button03);

list.setOnClickListener(this);
check.setOnClickListener(this);
radio.setOnClickListener(this);
}

/*triggered by showDialog method. onCreateDialog creates a dialog*/
@Override
public Dialog onCreateDialog(int id) {
switch (id) {
case LIST_ALERTDIALOG:

AlertDialog.Builder builder=new AlertDialog.Builder(AlertDialogDemo.this)
.setTitle("Choose a Color")
.setItems(colors_list, new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "The selected color is "+colors_list[which], Toast.LENGTH_LONG).show();
}
});
AlertDialog alertdialog=builder.create();
return alertdialog;

case CHECKBOX_ALERTDIALOG:

AlertDialog.Builder builder1=new AlertDialog.Builder(AlertDialogDemo.this)
.setTitle("Choose a Color")
.setMultiChoiceItems(colors_check, null, new DialogInterface.OnMultiChoiceClickListener() {

@Override
public void onClick(DialogInterface dialog, int which, boolean isChecked) {
// TODO Auto-generated method stub

//storing the checked state of the items in an array
checked_state[which]=isChecked;
}
})
.setPositiveButton("OK", new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
String display_checked_colors = "";
for(int i=0;i<3;i++){
if(checked_state[i]==true){
display_checked_colors=display_checked_colors+" "+colors_check[i];
}
}
Toast.makeText(getApplicationContext(), "The selected color(s) is
"+display_checked_colors, Toast.LENGTH_LONG).show();

//clears the String used to store the displayed text
display_checked_colors=null;

//clears the array used to store checked state
for(int i=0;i<checked_state.length;i++){
if(checked_state[i]==true){
checked_state[i]=false;
}
}

//used to dismiss the dialog upon user selection.
dialog.dismiss();
}
});
AlertDialog alertdialog1=builder1.create();
return alertdialog1;

case RADIOBUTTON_ALERTDIALOG:

AlertDialog.Builder builder2=new AlertDialog.Builder(AlertDialogDemo.this)
.setTitle("Choose a Color")
.setSingleChoiceItems(colors_radio, -1, new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(),
"The selected color is "+colors_radio[which], Toast.LENGTH_LONG).show();

//dismissing the dialog when the user makes a selection.
dialog.dismiss();
}
});
AlertDialog alertdialog2=builder2.create();
return alertdialog2;
}
return null;

}

@Override
protected void onPrepareDialog(int id, Dialog dialog) {
// TODO Auto-generated method stub

switch (id) {
case CHECKBOX_ALERTDIALOG:
AlertDialog prepare_checkbox_dialog=(AlertDialog)dialog;
ListView list_checkbox=prepare_checkbox_dialog.getListView();
for(int i=0;i<list_checkbox.getCount();i++){
list_checkbox.setItemChecked(i, false);
}
break;
case RADIOBUTTON_ALERTDIALOG:
AlertDialog prepare_radio_dialog=(AlertDialog)dialog;
ListView list_radio=prepare_radio_dialog.getListView();
for(int i=0;i<list_radio.getCount();i++){
list_radio.setItemChecked(i, false);
}
break;

}
}
@Override
public void onClick(View v) {
// TODO Auto-generated method stub

switch (v.getId()) {
case R.id.Button01:
//triggering the List alertdialog
showDialog(LIST_ALERTDIALOG);
break;
case R.id.Button02:
//triggering the checkbox alertdialog
showDialog(CHECKBOX_ALERTDIALOG);
break;
case R.id.Button03:
//triggering the radio alertdialog
showDialog(RADIOBUTTON_ALERTDIALOG);
break;

default:
break;
}

}
}

I have used onPrepareDialog() method to change the selection state of the selected list items. Since Android manages the state of the selectable list, doing this is recommended.

Step 5: Declare the activities in AndroidManifest.xml

Your launcher activity is registered automatically. If you want to know more on Manifest file, please follow the post on Manifest. Your AndroidManifest.xml has the below code.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>"

package="my.app"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".AlertDialogDemo"
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>
<uses-sdk android:minSdkVersion="8" />
</manifest>

Step 6: Run your Project

Select your project->Right click->Run As->Android Application. Your first activity pops up as below.

your activity is displaying three buttons. Click on the button “List” which displays your first AlertDialog with List of items “Green”, “Black” and “White” as below.

Select any one of the item from the list displayed inside your AlertDialog. I would be selecting “Black” from the list. You will get a Toast message showing the selected item as below.

Now click on the button “CheckBox”, It displays an AlertDialog with list having checkBoxes.

Select any number of items and click on “OK”. The checked items are displayed in the toast as below.

Click the button “RadioButton” which displays the Dialog with list having radioButtons.

select any item. The AlertDialog is closed and a toast is displayed showing the checked item name.

This is how you can create AlertDialog with different content areas. If you have any queries, please post it in comments section.

If you are not familiar with setting up an android environment, please refer to one of our previous posts Android Environment. Note: This example is build using android 2.2

Step 2: Create an android Project

Create an android project named datepicker with the launcher activity DatepickerDialog.java. Please refer the post Create a sample app to know more on how to create a new android project. Now your project has an activity “DatePickerDialog.java” and a layout xml file “main.xml”. The complete project structure is as below.

Step 3: Create a layout xml file

In this example we would be using main.xml layout file, which gets created when you create an android project. The main.xml layout file has the below Views,

• TextView- Which has the text “DatePicker Demo”.
• EditText- Which displays the current date when you run your project and then it displays the date that you set using datePickerDialog.
• Button named “Change”- on click of this button, a DatePickerDialog appears which allows the user to change the date displayed in the edittext.

Open the main.xml file and paste the below code.

<RelativeLayout android:id="@+id/RelativeLayout01"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>">

<TextView android:id="@+id/TextView01" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:text="DatePicker Demo"
android:layout_marginTop="30dip" android:layout_centerHorizontal="true"
android:textStyle="bold" android:textSize="20sp"></TextView>
<EditText android:text="@+id/EditText01" android:id="@+id/EditText01"
android:layout_below="@id/TextView01" android:layout_height="50dip"
android:layout_width="150dip" android:layout_marginTop="15dip"></EditText>
<Button android:id="@+id/Button01" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:layout_below="@+id/TextView01"
android:layout_toRightOf="@+id/EditText01" android:text="Change"
android:layout_marginTop="15dip"></Button>
</RelativeLayout>

Step 4: Create the required activities

In this Example, the launcher activity “DatePickerDialog.java” is used. Open the activity and paste the below code.

package com.infy;
import java.util.Calendar;
import android.app.Activity;
import android.app.DatePickerDialog;
import android.app.Dialog;
import android.app.DatePickerDialog.OnDateSetListener;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;

public class DatepickerDialog extends Activity{
/** Called when the activity is first created. */
EditText etDate;
Button change_date;
final int Date_Dialog_ID=0;
int cDay,cMonth,cYear; // this is the instances of the current date
Calendar cDate;
int sDay,sMonth,sYear; // this is the instances of the entered date
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
etDate=(EditText)findViewById(R.id.EditText01);
change_date=(Button)findViewById(R.id.Button01);
change_date.setOnClickListener(new OnClickListener() {

@Override
public void onClick(View v) {
// TODO Auto-generated method stub
//triggers the DatePickerDialog
showDialog(Date_Dialog_ID);
}
});
//getting current date
cDate=Calendar.getInstance();
cDay=cDate.get(Calendar.DAY_OF_MONTH);
cMonth=cDate.get(Calendar.MONTH);
cYear=cDate.get(Calendar.YEAR);
//assigning the edittext with the current date in the beginning
sDay=cDay;
sMonth=cMonth;
sYear=cYear;
updateDateDisplay(sYear,sMonth,sDay);
}
@Override
protected Dialog onCreateDialog(int id) {

switch (id) {
case Date_Dialog_ID:
return new DatePickerDialog(this, onDateSet, cYear, cMonth,
cDay);
}
return null;
}

private void updateDateDisplay(int year,int month,int date) {
// TODO Auto-generated method stub
etDate.setText(date+"-"+(month+1)+"-"+year);
}
private OnDateSetListener onDateSet=new OnDateSetListener() {
@Override
public void onDateSet(DatePicker view, int year, int monthOfYear,
int dayOfMonth) {
// TODO Auto-generated method stub
System.out.println("2");
sYear=year;
sMonth=monthOfYear;
sDay=dayOfMonth;
updateDateDisplay(sYear,sMonth,sDay);
}
};
}

As you can see in the above code, The DatePickerDialog is created as below

1. a DatePickerDialog is defined using a member variable “Date_Dialog_ID”. This should be unique.
2. updateDateDisplay is called to set the Edittext with the date that we pass as parametes to this method.
3. The DatePickerDialog is created using the method “onCreateDialog(int id)”. you must provide a case for your dialog if you are using more than one Dailog. When showDialog(Date_Dialog_ID) method is called, it triggers onCreateDialog method which returns an appropriate Dialog instance.
4. In onCreateDialog method, we create an instance of DatePickerDialog.
5. OnDateSetListener interface has to be implemented with onDateSet callback, which is called when you select a date from the Dialog.

Step 5: Declare the activity in AndroidManifest.xml file

Our launcher activity “DatePickerdialog.java” is declared automatically when we create our project. If you want to know more about Manifest file, please refer to the post Manifest.

Our Androidmanifest.xml file has the below code.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="<a href="http://schemas.android.com/apk/res/android">http://schemas.android.com/apk/res/android</a>"
package="com.infy"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".DatepickerDialog"
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>
<uses-sdk android:minSdkVersion="8" />
</manifest>

Step 6: Run your application

Select the project->right click->Run As->Android Application

Now your activity “DatePickeDialog.java” opens up as below.

As you can see in the above screen, The Edittext has the current date in the beginning. Click on the button “Change” to fire a DatePickerDialog, which takes you to the below screen.

You can now see the displayed DatePickerDialog. Change the current date to new date of your choice. For example I would change the Date to 22 jan 2013. Click on Set button to set the new date to Edittext. Cancel button simply closes your Dialog without changing the Edittext contents. On click of “Set” button, the EditText contents changes as below.

Try clicking the “Change” button once again(second time), It displays the DatePickerDialog which shows the DatePicker Widget with the date chosen previous time (ie. 22 jan 2013) as below.

If you want to reuse the Dialog that you have created, you want to reset it to the current date each time the dialog is shown. To do this, use onPrepareDialog method of the Activity. Add the below onPrepareDialog method to your activity, to make your DatePicker display the current date each time it is shown.

@Override
protected void onPrepareDialog(int id, Dialog dialog) {
// TODO Auto-generated method stub
switch (id) {
case Date_Dialog_ID:
((DatePickerDialog)dialog).updateDate(cYear,cMonth,cDay);
break;

}
}

This is how you can allow user to choose date using android DatePickerDialog. You can always add a DatePicker component to your layout that displays a DatePicker widget to the user. We would be discussing about DatePicker Widget in our upcomming Posts. If you have any doubts, please post it in the comment section.

Step 1: Creating a status bar notification

In the below code we create a notification object.

Notification notification=new Notification(R.drawable.icon,"Saanvi Birthday!",
System.currentTimeMillis());

Here we have passed three parameters ,

1. int icon-we set the icon to one of the system icons.
2. The ticker text displayed briefly in the status bar.
3. The time-to show the user when the notification occurred.

Step 2: Customizing expanded View

notification.setLatestEventInfo(this, "Reminder: Saanvi Birthday",
"Today is your friend Saanvi's Birthday, please wish her", null);

The above code is used to customize the notification’s expand view. The expanded view contains a notification title and a text(Notification message) that tells the user about the notification.

Step 3: Passing a pendingIntent

PendingIntent: PendingIntent wraps the regular intent inside an object.This is the intent that can be fired at a later point of time. In our case the pendingIntent Intent(StartActivity) is fired when the user clicks on the Notification.

Intent intent=new Intent(getApplicationContext(), SecondActivity.class);
PendingIntent pendingIntent=PendingIntent.getActivity(getApplicationContext(), 0, intent, 0);
notification.setLatestEventInfo(this, "Reminder: Saanvi Birthday",
"Today is your friend Saanvi's Birthday, please wish her", pendingIntent);

In the above code the activity “SecondActivity” is fired when the user clicks on the expanded view of the notification.

Step 4: Triggering the Notification via NotificationManager

NotificationManager is a system service. To create notification we use the NotificationManager class which can be retrieved from the Activity via the getSystemService() method. The NotificationManager has following methods,

1. notify(int,Notification)
   • This is used to trigger a particular notification which is identified by the first parameter “Notification ID”,
2. cancel(int)
   • This is used to cancel a particular notification by passing notification Id.
3. cancelAll()
   • Used to cancel all notifications.

The notification is triggered as below

private static final int NOTIFICATION_ID=1;
final NotificationManager mgr=(NotificationManager)getSystemService(NOTIFICATION_SERVICE);
mgr.notify(NOTIFICATION_ID,notification);

So far we have seen the steps to create a notification. Let us now look at a simple example of creating a notification in Android 2.2

Required layouts:

• main.xml
• second.xml

Required Activities:

• Activity_Notification.java
• SecondActivity.java(Which is fired when the user clicks on the notification’s expanded view)

Working of this example:

The layout main.xml contains two buttons named “start” and “clear”. Start button to create a notification and clear buton to clear the notification. To see the created notification you have to swipe your finger down from the top of the screen. Inorder to respond to the notification, you have to touch it. Then the second activity “Second_Activity” is fired up. Follow the below steps to create the example.

Step 1: Set up the android working environment

To know about how to set up a working environment, please refer to the post Set up environment.

Step 2: Create an android project

Create an android project named “NotificationDemo” with the activity “Activity_Notification.java”. To know how to create an android project, please refer to the post create an android project.

Step 3: Create the required layouts

As I said earlier I will be using two layouts main.xml and second.xml. If you have any doubts on how to create a layout xml file, please refer to one of our earlier posts Create a layout.

Open the main.xml which gets created automatically when you create your project, and paste the below code.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:id="@+id/RelativeLayout01"
android:layout_width="fill_parent" android:layout_height="fill_parent"
xmlns:android="<a href="http://schemas.android.com/apk/res/android">http://schemas.android.com/apk/res/android</a>">
<TextView android:id="@+id/TextView01" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:text="Notification Demo"
android:layout_centerHorizontal="true" android:layout_marginTop="30dip"
android:textStyle="bold"></TextView>
<Button android:layout_below="@id/TextView01"
android:layout_width="wrap_content" android:text="Start" android:id="@+id/start"
android:layout_centerHorizontal="true" android:layout_height="50dip"
android:layout_marginTop="20dip"></Button>
<Button android:layout_width="wrap_content" android:text="Clear"
android:layout_below="@+id/start" android:id="@+id/clear"
android:layout_centerHorizontal="true" android:layout_height="50dip"
android:layout_marginTop="20dip"></Button>
</RelativeLayout>

You can always pass the pendingIntent null if you are not willing to start a second activity on click of the notification. If you want to do something then you need to create second.xml layout file. I would be creating second.xml for your reference to show how a pendingIntent works.

Open second.xml and paste the below code. Here I would just include a textview which just says you have clicked on notification.

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

http://schemas.android.com/apk/res/android</a>"

android:layout_width="wrap_content" android:layout_height="wrap_content">
<TextView android:id="@+id/TextView01" android:layout_width="wrap_content"
android:layout_height="wrap_content" android:text="You just clicked on a notification"></TextView>
</LinearLayout>

Step 4: Create the required activities

Here in this example I would be using the activity “Activity_Notification.java” and “SecondActivity.java”.

Open Activity_Notification.java and paste the below code.

package my.app;
import android.app.Activity;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class Activity_Notification extends Activity {
Button start,clear;
Notification notification;
private static final int NOTIFICATION_ID=1;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
start=(Button)findViewById(R.id.start);
clear=(Button)findViewById(R.id.clear);

final NotificationManager mgr=(NotificationManager)getSystemService(NOTIFICATION_SERVICE);
notification=new Notification(R.drawable.icon,"Saanvi Birthday!", System.currentTimeMillis());
//Intent to start new activity on click of expanded view
Intent intent=new Intent(getApplicationContext(), SecondActivity.class);
PendingIntent pendingIntent=PendingIntent.getActivity(getApplicationContext(), 0, intent, 0);
notification.setLatestEventInfo(this, "Reminder: Saanvi Birthday",
"Today is your friend Saanvi's Birthday, please wish her", pendingIntent);

start.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
//to notify the user
mgr.notify(NOTIFICATION_ID,notification);
}
});
clear.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
//to clear the notification
mgr.cancel(NOTIFICATION_ID);
}
});
}
}

Create a new activity “SecondActivity.java”. If you are not familiar with creating a new activity, please go through the post Create a Activity.

package my.app;
import android.app.Activity;
import android.os.Bundle;
public class SecondActivity extends Activity{
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.second);
}
}

If you want to do nothing on click of notification’s view, just pass the intent object as null to the PendingIntent method as below.

PendingIntent pendingIntent=PendingIntent.getActivity(getApplicationContext(), 0, null, 0);

Please make a note that passing a pendingIntent object to setLatestEventInfo() method is a must failing which you will get a force close. If you don’t want to do anything on click of notification, just pass the intent object null.

Step 5: Declare the Activities in manifest file

Your first activity “Activity_Notification” would be automatically declared when you create your application. Declare the second activity “SecondActivity”. If you want to know more about AndroidManifest.xml, please refer to the post manifest.

Now your manifest file contains the below code.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="<a href="http://schemas.android.com/apk/res/android">

http://schemas.android.com/apk/res/android</a>"

package="my.app"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".Activity_Notification"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

<activity android:name="SecondActivity"></activity>
</application>
<uses-sdk android:minSdkVersion="8" />
</manifest>

Step 6: Run your application

Select your project ->right click->Run As->Android application

Now your first activity gets fired up as below.

Click the highlighted “Start” button to raise the notification. Your notification fires up as below.

Swipe your finger down from the top of the screen. You can now see your notification’s expanded view as below.

Android provides you a default ”Clear” button to clear the notification or you can clear it programmatically using cancel() method of Notification Manager. Click on the notification to start a new activity SecondActivity.java”.

If you don’t want to start the new activity just click the “Clear” button in the first image, which clears the Notification as below.

This is how you can raise and clear the notifications in android. If you have any issues regarding this article, please post it in comment section. I hope this article would have provided more detailed explanation on how to create a notification using the NotificationManager API and create a sample application. If you have any questions, please post it in the comments section.