Saturday, July 30, 2011

Service LifeCycle

A service is an application component that can run some long running task in the background without the need for a user interface. Some other application component can start the service and this service will then keep on running even if the user switches to another application.

A service can essentially take two forms:

A service is "started" when an application component (such as an activity) starts it by calling startService(). Once started, a service can run in the background indefinitely (unbounded), even if the component that started it is destroyed. Usually, a started service performs a single operation and does not return a result to the caller. For example, it might download or upload a file over the network. When the operation is done, the service should stop itself.

A service is "bound" when an application component binds to it by calling bindService(). A bound service offers a client-server interface that allows components to interact with the service, send requests, get results, and even do so across processes with interprocess communication (IPC). A bound service runs only as long as another application component is bound to it. Multiple components can bind to the service at once, but when all of them unbind, the service is destroyed.

As you can see in diagram there some method in  Unbounded service class for life cycle :

startService(Intent Service)
This you must call to start un-bounded serviec

This method is Called when the service is first created

onStartCommand(Intent intent, int flags, int startId)
This method is called when service is started

onBind(Intent intent)
This method you must call if you want to bind with activity

onUnbind(Intent intent)
This method is Called when the service will un-binded from activity

onRebind(Intent intent)
This method is called when you want to Re-bind service after calling un-bind method

This method is called when The service is no longer used and is being destroyed

Let's create a small app to understand this..

App Name: ServiceLifeCycle
Package Name: com.rdc
Android SDK: Android SDK 2.3.3 / API 10
Default Activity Name: MyActivity

package com.rdc;

import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MyActivity extends Activity 
                    implements OnClickListener {
	private final static String TAG = "In this method: ";
	private Button startSerivce = null;
	private Button stopSerivce = null;

	public void onCreate(Bundle savedInstanceState) {

		startSerivce = (Button) findViewById(;
		stopSerivce = (Button) findViewById(;

	public void onClick(View v) {
		if (startSerivce == v) {
			Log.i(TAG, "Activity starting service..");
			Intent serviceIntent = new Intent(this, MyService.class);
		} else {
			Intent in = new Intent(this, MyService.class);

package com.rdc;

import android.content.Intent;
import android.os.IBinder;
import android.util.Log;
import android.widget.Toast;

public class MyService extends Service {

	private final static String TAG = "In this method: ";
	int mStartMode; // indicates how to behave if the service is killed
	IBinder mBinder; // interface for clients that bind
	boolean mAllowRebind; // indicates whether onRebind should be used

	public void onCreate() {
		Log.i(TAG, "Service created");
		// The service is being created

	public int onStartCommand(Intent intent, int flags, int startId) {
		Log.i(TAG, "Service started");
		Toast.makeText(getBaseContext(), "Service has been started..",
		return mStartMode;

	public IBinder onBind(Intent intent) {
		// A client is binding to the service with bindService()
		Log.i(TAG, "Service binded");
		return mBinder;

	public boolean onUnbind(Intent intent) {
		// All clients have unbound with unbindService()
		Log.i(TAG, "Service un-binded");
		return mAllowRebind;

	public void onRebind(Intent intent) {
		// A client is binding to the service with Re-bindService(),
		// after onUnbind() has already been called
		Log.i(TAG, "Service re-binded");

	public void onDestroy() {
		// The service is no longer used and is being destroyed
		Log.i(TAG, "Service destroyed");



<?xml version="1.0" encoding="utf-8"?>
			android:text="Start Service"></Button>
			android:text="Stop Serivce"></Button>

<?xml version="1.0" encoding="utf-8"?>
	<uses-sdk android:minSdkVersion="8" />

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

			<action android:name="com.rdc.MyService">


The output Screen will be like this..

You can download the complete source code zip file here : ServiceLifeCycle


I'd love to hear your thoughts!

Thursday, July 28, 2011

Activity Lifecycle

I’m just starting with Android App Development, and if you are a beginner like me, you probably want to understand two of main concepts of Android: Activities and Intents.
After Hello World Example i wanted to know Activity Life-cycle so i learn this and sharing with you..
This is the Android Activity Life Cycle Diagram described by Google

 As you can see in diagram there 7 method in activity base class for life cycle :
onCreate(Bundle savedInstanceState)
This method is Called when the activity is first created.

This method is Called when activity is becoming visible to the user.

This method is Called when the activity will start interacting with the user.

This method is Called when the system is about to start resuming a previous activity.

This method is Called when the activity is no longer visible to the user, because another activity has been resumed and is covering this one.
This method is Called after your activity has been stopped, prior to it being started again.

This method is The final call you receive before your activity is destroyed.

Other Methods:
onSaveInstanceState(Bundle outState)
This method is called before an activity may be killed so that when
it comes back some time in the future it can restore its state.

onRestoreInstanceState(Bundle savedInstanceState)
This method is called after onStart() when the activity is being
re-initialised from a previously saved state.
The default implementation of this method performs a restore of any
view state that had previously been frozen by onSaveInstanceState(Bundle).

Create a simple android app with default activity "MyActivity" then put the code like this
package com.rdc;

import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;

public class MyActivity extends Activity {
 private final static String TAG="In this method: ";
    public void onCreate(Bundle savedInstanceState) {
        Toast.makeText(this, "onCreate", Toast.LENGTH_SHORT).show();
        Log.i(TAG,"Activity created");
    protected void onStart() {    
    Toast.makeText(this, "onStart",Toast.LENGTH_SHORT).show();
    Log.i(TAG,"Activity started and visible to user");
    protected void onResume() {
    Toast.makeText(this, "onResume", Toast.LENGTH_SHORT).show();
    Log.i(TAG,"Activity interacting with user");

    protected void onPause() {
     Toast.makeText(this, "onPause", Toast.LENGTH_SHORT).show();
     Log.i(TAG,"current activity got paused");
    protected void onStop() {    
    Toast.makeText(this, "onStop", Toast.LENGTH_SHORT).show();
    Log.i(TAG," current activity got stopped");
    protected void onRestart() {
    Toast.makeText(this, "onRestart", Toast.LENGTH_SHORT).show();
    Log.i(TAG,"activity again restarted");
    protected void onDestroy() {    
    Toast.makeText(this, "onDestroy", Toast.LENGTH_SHORT).show();
    Log.i(TAG,"activity destored");
    protected void onSaveInstanceState(Bundle outState) {
    Log.i(TAG,"activity data saved");
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
    Toast.makeText(getBaseContext(), "onRestoreInstanceState ..BUNDLING", 
    Log.i(TAG,"activity previous saved data restored");

and main.xml is


the most important is AndroidManifest.xml




you can find the example zip file is here


I'd love to hear your thoughts! 

Monday, July 25, 2011

What is Android ?

Android is an operating system based on Linux with a Java programming interface for mobile devices such as smartphones and tablet computers. It is developed by the Open Handset Alliance led by Google.

Who founded Android, Inc?
Andrew E. Rubin (key person) at Open Handset Alliance.

Android, Inc. was founded in Palo Alto, California, United States in October, 2003 by Andrew E. Rubin (co-founder of Danger), Rich Miner (co-founder of Wildfire Communications, Inc.), Nick Sears (once VP at T-Mobile),and Chris White (headed design and interface development at WebTV) at Open Handset Alliance.

Google Purchased the Android
Google purchased the initial developer of the Android software, Android Inc., in 2005, making Android Inc. a wholly-owned subsidiary of Google Inc. Key employees of Android Inc., including Andy Rubin, Rich Miner and Chris White, stayed at the company after the acquisition.

Android competes with Sambian OS, Apple's iOS (for iPhone/iPad), RIM's Blackberry, Microsoft's Windows Phone (previously called Windows Mobile), and many other proprietary mobile OSes.

Android Architecture

Basically Android has the following layers:
  • applications (written in java, executing in Dalvik)
  • framework services and libraries (written mostly in java)
    • applications and most framework code executes in a virtual machine
  • native libraries, daemons and services (written in C or C++)
  • the Linux kernel, which includes
    • drivers for hardware, networking, file system access and inter-process-communication 
Android Application Components
There are four different types of application components. Each type serves a distinct purpose and has a distinct lifecycle that defines how the component is created and destroyed.

An activity represents a single screen with a user interface. For example, an email application might have one activity that shows a list of new emails, another activity to compose an email, and another activity for reading emails.
An activity is implemented as a subclass of Activity.

A service is a component that runs in the background to perform long-running operations or to perform work for remote processes. A service does not provide a user interface. For example, a service might play music in the background while the user is in a different application. Another component, such as an activity, can start the service and let it run or bind to it in order to interact with it.

A service is implemented as a subclass of Service.

Content providers
A content provider manages a shared set of application data. You can store the data in the file system, an SQLite database, on the web, or any other persistent storage location your application can access. Through the content provider, other applications can query or even modify the data (if the content provider allows it). For example, the Android system provides a content provider that manages the user's contact information.

A content provider is implemented as a subclass of ContentProvider.

Broadcast receivers
A broadcast receiver is a component that responds to system-wide broadcast announcements. Many broadcasts originate from the system—for example, a broadcast announcing that the screen has turned off, the battery is low,message has been received or a picture was captured.

A broadcast receiver is implemented as a subclass of BroadcastReceiver.

Android Version history
Android Beta 
The Android beta was released on November 5, 2007, while the software developer's kit (SDK) was released on November 12, 2007.

Android 1.0
Android 1.0, the first commercial version of the software, was released on September 23, 2008. The first Android device, the HTC Dream,which was following Android 1.0 features.

Android 1.1
On February 9, 2009, the Android 1.1 update was released, initially for the T-Mobile G1 only. The update resolved bugs, changed the API and added a number of other features.

Android 1.5 ( Cupcake )
On April 30, 2009, the Android 1.5 update, dubbed Cupcake, was released, based on Linux kernel 2.6.27.

Android 1.6 ( Donut )
On September 15, 2009, the Android 1.6 SDK – dubbed Donut – was released, based on Linux kernel 2.6.29.

Android 2.0/2.1 ( Eclair )
On October 26, 2009, the Android 2.0 SDK – codenamed Éclair – was released, based on Linux kernel 2.6.29.and updated on January 12, 2010 as 2.1 version.

Andrid 2.2.x (Froyo)
On May 20, 2010, the Android 2.2 (Froyo) SDK was released, based on Linux kernel 2.6.32.

Android 2.3.x ( Gingerbread )
On December 6, 2010, the Android 2.3 (Gingerbread) SDK was released, based on Linux kernel 2.6.35.

Android 3.x (Honeycomb)
On February 22, 2011, the Android 3.0 (Honeycomb) SDK – the first tablet-only Android update – was released, based on Linux kernel 2.6.36.The first device featuring this version, the Motorola Xoom tablet, was released on February 24, 2011.

Android 4.0.x (Ice Cream Sandwich)
The SDK for Android 4.0.1 (Ice Cream Sandwich), based on Linux kernel 3.0.1,was publicly released on October 19, 2011.

Android 4.1  (Jelly Bean)
Google announced the next Android version on June 27, 2012, 4.1 Jelly Bean. Jelly Bean is an incremental update, with the primary aim of improving the user interface, both in terms of functionality and performance.