NFC on mobile phone will not only enable with card payment solutions, but it will also enable other solutions like device as Tag reader or in Peer to Peer data transfer.

Android latest release 2.3 has some set of API exposed for card reading, which is capable of reading various tags like Text record, URL record, or smart poster tag. The support for P2P communication is not yet available through the API.

With this limited set of capability available, one could still build some interesting use cases. If you have NFC equipped phone like Nexus-S and get hold of Some tags. In below video, we have tried to make use of the available API to read the Tag info of smart poster and retrieve the information from background web server.

Click here to Watch Video

Interesting applications can be built around the current capability of Andriod device like:

Provide the personal advertisement tags in conferences, so that your client can directly go to your website with simple swipe.
Stick the tags in shops, so user carrying the phone can swipe on tag to get the details of the product may see some promotion video on the product.
Enabling the Guest carrying NFC tag reader app to hook into your wifi network if you have tag storing needed access parameter.
Change the device setting, like stick tag in meeting room door, so when user swipes there phone while entering the device goes to silent automatically.
True sharing applications can be easily be built once we have full support like Peer to Peer share, instant BT paring, touch triggered sharing, Vcard exchange, and many others.

Easy access of tags to general public coupled with full support by leading OS vendors will bring the NFC into mainstream in wider markets quickly.

More info on NFC can be obtained at

http://www.nfc-forum.org/home/

1. Google I/O talk – Android UI design patterns

In this session, the Android User Experience team will show the types of patterns you can use to build a great Android application. The talk directly comes from the Google UI/UX team and is really worth looking at!

2. Android Patterns

This website provides a set of interaction patterns that can help you design Android apps. You can view various patterns related to user input, navigation, notifications, screen interactions, personalization and social media interaction.

3. Android UI Design Patterns – Presentation

This presentation is given by Mike Wolfson of Phoenix Android Developers Group. It gives you a nice overview of Android UI Design Patterns and Best Practices.

Android 3.0 comes with a new UI designed from the ground up for tablets. With so many tablets in the market, UI is going to be a crucial factor to attract consumers to your device and the Google team has nailed it this time by providing an altogether new UI framework for developers, which will allow developers to create a richer, more interactive experience for users. We’re really excited about Activity fragments, which provide greater control of content and design flexibility.

This will allow developers to come up with apps, which are more intuitive and engaging thereby increasing the overall user experience. The Activity fragment feature is supplemented by redesigned UI widgets which can now be used as remote views in application widgets displayed on the home screen. Other exciting features of Android 3.0 Platform include Persistent Action Bar and Richer Notifications. It’s really a neat idea to provide each application with its own instance of the Action Bar at the top of the screen. This will allow developers to expose more features of their applications to users in a familiar location.

We know that the notification mode is arguably better on Android devices as compared to iOS. And this just got better with Android 3 SDK, which includes new builder class thereby allowing developers to quickly create notifications that include large and small icons, a title, a priority flag, and any properties already available in previous versions. In Android, all notifications are neatly organized in an expandable menu. So, whenever any of these notifications appear, they are quickly displayed for some time in a small strip that always stays at the top of the screen. iOS 4 still follows pop-up notifications, which may occasionally interfere with whatever apps you’re running at the time.

There’s also some good news for Android Game Developers. Android 3.0 offers a new hardware-accelerated OpenGL renderer that gives a performance boost to many common graphics operations for applications running in the Android framework. And if this was not enough, Google has also included RenderScript with Android 3.0, which is a runtime 3D framework for accelerating graphics operations and data processing. It seems like we are going to see some really exciting games for Android in the near future!

Android 3.0 also includes some other smart features likes HTTP Live streaming and Digital Media file transfer. Overall, it’s an impressive release and we hope that the developers will make full use of it!

1. Wikitude World Browser

2. 3D Compass

3. Tweeps Around

So, what exactly is AR?
Wikipedia defines AR as a live direct or indirect view of a physical real-world environment whose elements are augmented by virtual computer-generated sensory input such as sound or graphics. Simply speaking, AR is the ability to overlay location data points on the live view of a mobile device’s camera.Thus, AR applications combine virtual data into the real world by utilizing the phone’s compass, camera, and GPS system.
You can get more information about AR here and here.
In this article, we will provide you some resources which will help you in developing your own AR applications for Android devices.

Android AR-Kit (Recommended)
An open source, Geographical based, Augmented Reality library.

Layar
The Layar Reality Browser shows what is around you by displaying real time digital information on top of the real world as seen through the camera of your mobile phone.You can use the Layar Platform to create your own AR Applications.

Mixare
mixare (mix Augmented Reality Engine) is a free open source augmented reality browser. It works as a completely autonomous application and is available as well for the development of own implementations.

Qualcomm Augmented Reality Platform
The Qualcomm Augmented Reality Platform provides developers the ability to create high-performance Android applications with C++ APIs.

Tutorial
Chris Haseman has also put together a nice tutorial for developing AR applications using the Android AR-Kit. Experienced Android Developers will find this tutorial very helpful.

We hope that you’ll find these resources useful. Let us know about your thoughts on AR application development in the comments section.

AndroidBook delivers the complete Facebook experience in a vastly superior mobile interface optimized specifically for the legion of Android-based handsets and hardware configs.

Speed, reliability, and best-in-class user interface are the AndroidBook keywords. Switch seamlessly between status updates, viewing video in the News Feed, uploading and browsing photos, and posting comments on friends’ Walls. You’re never more than a tap or two from where you’re going next.
Version 2.0 also brings some crucial new features and updates to the table:
1. Intelligent notifications
2. Improved Friend Finder
3. Upload and caption photos direct from camera or gallery
4. Easy password retrieval
5. Watch videos without ever leaving the app
AndroidBook boasts powerful functionality and hands down the best user experience for Facebook on Android – far better than even the ‘official’ app. For Android-toting Facebook mavens, AndroidBook is the clear choice.
Learn more about AndroidBook at the following URL:
http://www.spoonjuice.com/androidbook

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.