Whenever a user launches an Android application, a thread called “main” is automatically created. This main thread, also called the UI thread, is crucial since it’s responsible for dispatching events to various widgets, including the drawing events. For careless Android developers, this single thread can be the overarching reason for poor app performance. With so much riding on a single thread performing long operations like network access or database queries, any interference on this thread will block up the entire user interface. No events can be dispatched – including drawing events – while long operations are underway, and from the user’s perspective, the application appears hung. Even worse, if the UI thread is blocked for more than a few seconds (about 5 seconds currently) the user will encounter the dreaded “application not responding” (ANR) dialog.

BaseAdapter is an Adapter object that acts as a bridge between an AdapterView and the underlying data for that view. The Adapter provides access to specific data points and is also responsible for making a View for each point in the data set. So, taking the example of downloading an image over HTTP, there may be some slowdown in our application with the Main UI thread getting blocked for more than a few seconds, and users might be presented with the ANR dialog. To avoid this situation I have some suggestions:

1. Use ExecuterService (Thread pool)
2. Use AsynTask
3. Use SoftReference Drawable Object
4. Create the ListView first, then download images
5. Make use of OnScrollListener Interface

I’ve written a sample application to help Android developers visualize this implementation.

Here we have AbastractListAdapter, an extension of BaseAdapterClass:

public abstract class AbstactListAdapter extends BaseAdapter {
	public AbstactListAdapter(Context context) {
		this.context = context;
	}
	public abstract void setScrollStatus(boolean scroll);
	public abstract void scrollIdle(AbsListView view);
}

There are two methods of implementation for Class ListAdapterScrollListener and Onscrollistner.

public void onScroll(AbsListView view, int firstVisibleItem,int visibleItemCount, int totalItemCount) {
		adapter.setScrollStatus(true);
	}
public void onScrollStateChanged(AbsListView view,intSrollState) {
		switch (scrollState) {
		case OnScrollListener.SCROLL_STATE_IDLE:
			adapter.scrollIdle(view);
			break;
		case OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:
			adapter.setScrollStatus(true);
			break;
		case OnScrollListener.SCROLL_STATE_FLING:
			adapter.setScrollStatus(true);
			break;
		}
}

In my onCreate method I set up and configure the list view to load the views and set the listner for Scroll.

public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Adapter mAdapter=new Adapter(this);
        setListAdapter(mAdapter);
        getListView().setOnScrollListener(new 		ListAdapterScrollListener(mAdapter));
      }

I use an Adapter class to extend AbstractAdapterClass and implement BaseAdapter, both of which help to load images when scrolling is idle.

The image is loaded in a separate threadpool. I have used Executerservice and assign a threadpool to download images. This method employs a runnable which will extend Assigntask. This ImageLoader class has a subclass, workerthread, which extends Assyntask and implements runnables. This class uses ExecutorService, and assigns 5 threads to do the work. Other implementations of this kind launch a separate thread per image, meaning that the network connection will become clogged with any image load. Assigning the task to the workerthread subclass and using onprogressupdate to notify the adapter to display the image reduces the burden.

You’ll notice the use of SoftReference here. While this appears to work well, I haven’t done any significant load or performance testing, so it may not be necessary. Since bitmap/drawable objects require memory, and Android supports 16mb of heap, it’s better to classify those objects as SoftReference objects. SoftReferences pointing to softly reachable objects are guaranteed to be cleared before the VM triggers an OutOfMemoryError. This can be written as follows:

 public class ImageLoader {

private class WorkerThread extends AsyncTask implements Runnable{
		public WorkerThread(String url,int pos) {
			this.url=url;
			intex=pos;
			}
		@Override
		protected void onProgressUpdate(Void... values) {
			mAdapter.notifyDataSetChanged();
			super.onProgressUpdate(values);
		}
		@Override
		public void run() {
			Cache.put(intex,new SoftReference(readDrawableFromNetwork(this.url)));
			publishProgress();
		}
	}

	public Drawable getDrawble(int pos)
	{
		SoftReference mReference=Cache.get(pos);;
		if(mReference!=null)
			return mReference.get();
		else
			return null;
	}

/*method to get Image if already or to start new task to download*/
	public void loadImage(int First,int Last) {
			try{
					_exec = Executors.newFixedThreadPool(5);
				for(int pos=First;pos<=Last;pos++){
					if(Cache.containsKey(pos)){
						if(Cache.get(pos).get()==null)
							_exec.execute(new  WorkerThread(Dataset.mStrings[pos],pos));
					}else{
						_exec.execute(new  WorkerThread(Dataset.mStrings[pos],pos));
					}
				}
			}catch (Exception e) {
				_exec.shutdown();
			}

	}//end of method

	private static Drawable readDrawableFromNetwork(String url ) {
	   Write code here to downlaod image from network.
	}//end of method
}

And that’s it!

For your reference, the code has been packaged for you to download and inspect here.

Compared to investments of Apple, which has a $100 million fund to seed iPhone applications, and RIM, which has $150 million fund to seed Blackberry applications, the Google investment is a far cry away.

Judging for ADC 2 is different from ADC 1 in that there will be 30 winners against the 50 last year, and 45% of weightage for an application is decided by the community vote and 55% by the judges.
It is mandatory to submit applications that run on Android 1.5 and be in English, and those that are unpublished and non-upgraded.

ADC2 will have two rounds of judging, the first round results in 200 apps total(in 10 categories), that will proceed to the second round. Out of which 30 entries will be winners with 3 entries within the 30 picking up the prizes in the overall winners category.

The contest is expected to start in August 09 and winning entries declared by November 09. We could see a drop in the Android market uploads, as the opportunity cost of waiting is pretty high. We could also see a host of entries in the Lite version (Full-featured with expiry time), so popular applications could potentially rake in money in both places (ADC 2 and The Android Market).

One bone of contention is the ‘Supposed ban on Open Source apps ‘ My comments here.

More details on creation of AVDs and version notes detailing the usage of minSDKVersion for developers.

Compiling our source with a build target of 1.1, went smoothly and hardly any change in code was needed for a build target of 1.5. However, moving to build target of Android 1.5 would not suffice for a project that used Maps, we had to select the ‘Google APIs’ build target (understandable as the maps package was moved out).  Respective Deployment targets were selected for running the apk in the emulator.

It was a joy to see the soft-keys come up when I hit the text box, I have to admit!.

Prominent features of the new SDK are :
Speech Recognition, Soft keyboard, Improved accelerometer and Video recording and uploading capability.
A complete list of the Android 1.5 Highlights.

The biggest improvement from a developers perspective is the AVD Concurrency. Developers can now create Android Virtual Devices with different names and work with emulators in parallel. Also, the choice of multiple targets (including Android 1.1 and Android 1.5), means that developers can continue to test their compilations for older targets (1.1 and earlier), but the catch is, you lose network connectivity (known issue in this SDK). So if you are developing an application which uses network access, then you have to wait for the release version of Android 1.5 SDK.

Eclipse developers, will have to uninstall the ADT 0.8 plugin and install the ADT 0.9 plugin to make use of the new SDK.

It is not yet clear if the team has enhanced the code to handle errors such as – memory overrun that needs ‘bitmap recycle’ and ‘audio flinger ‘ when looping sound files, atleast in this release.

For the user, however, the question remains how far the G1 will continue. With the 1.5 SDK onslaught, we are definitely looking at a G3 (as per the API Level). There are inherent limitations to firmware upgrades, as it needs a supporting underlying hardware. Also, with the addition of the soft keypad, can we expect the new device be thinner ?

The G1 device certainly needs more RAM (55MB ? come on guys – the iPhone 3G will have 128MB, what is Google thinking?)

But for now, it is hoping for rosy days ahead for our favourite platform – Android.