Android: Android Binding - Introduction

Android Binding - Introduction

Introduction

Android Binding is a new Open Source Framework for Android-Java providing XML layout view binding mechanism. It helps development of Android Application by decoupling the View widgets and backend Activities. It works best with MVP or MVVM patterns.

Please also download fromMarket(Search "Markup Demo") the demo on most features of Android Binding.

A more fundamental, getting started toAndroid MVVM with android-binding tutorial seriesis up in my own blog.

UPDATE: v0.2 is released. Please visit the project homepage for details as it may not be compatible with previous versions.

Critical Changes (as of 30/1/2010)

If this is the first time you read this article, you may skip this section.

Version 0.11 of Android binding is released with this sample application. As the project evolves, a number of critical (yet would results breaking original codes) changes were made. Upon the release of 0.11, I suppose those changes should be final.

Thefirst time I wrote this article, Android Binding doesn't support binding to object collections, but now, it can bind to Cursor or Array, each 'row' of the records are treated as a View Model, which meansCommandandDependentObservablesare all functional, which would be covered later in this article.

The sample application is rewritten, as the Contacts list no longer binds to the raw Adapter but via a more declarative way. Action related binding renamed to have a 'on-' prefix, for example, click -> onClick to make it more distinctive.

Observable<T>now requires passing the class ofTas parameter: e.g.

Collapse|Copy Code

Observable<Boolean>(Boolean.class, true); 

Since this makes writing such code too verbose, some shorthand primitive observables are provided.

Sample Application

The following will briefly introduce how it is used. Where the sample application codes used here are obtainable at:

• http://code.google.com/p/android-binding/downloads/list

and the compiled application is available at Android Market (Search "Android Binding" in Market).

This sample isa modification based on Google's originalContact Manager Sample, the purpose of it is to show the differences in view binding and the benefits of using Android Binding.

Basic Configuration

To use Android Binding, all you need to do is to reference the library (in Eclipse, right click project -> Properties -> Android, reference the Android Binding Project as library). And then, inApplicationclass:

Collapse|Copy Code

public class ContactManagerApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Binder.init(this);
    }
}

TheBinder.init(Application)is required to run once and only once, across the application life cycle. During theinit()process, it is time for Android Binding to register and initialize the markup and binding providers, which can support custom view classes.

Activity

Activity is no longer required to be View-awared, even the view model doesn't. Android Binding is best supported for View Model First development in MVVM. So, no more presentation / user interaction logic inActivityand results in a cleanActivityclass:

Collapse|Copy Code

public final class ContactManager extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        ContactManagerModel model = new ContactManagerModel(this);
        Binder.setAndBindContentView(this, R.layout.contact_manager, model);
    }
}

You provide theModel(orViewModelto be precise) to binder, and it automatically wires up theviewwith theViewModel. This is how we markup thecontact_manager.xml:

Layout

Collapse|Copy Code

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:binding="http://www.gueei.com/android-binding/"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent">
    <ListView android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              binding:itemSource="ContactList"
              binding:itemTemplate="@layout/contact_entry"
              android:layout_weight="1"/>
    <CheckBox android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              binding:checked="ShowInvisible"
              binding:onCheckedChange="PopulateList"
              android:text="@string/showInvisible"/>
    <Button android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            binding:onClick="AddContact"
            android:text="@string/addContactButtonLabel"/>
</LinearLayout>

Layout looks pretty much the same as standard Android Layout, except that an extrabindingnamespace is imported.There's an issue with AAPT, that the binding namespace needed to reference to the "demo" project instead of the library. (Hope it can be solved in the coming future).The binding namespace should point tohttp://www.gueei.com/android-binding/.

As shown in the above layout file, the markup is done through the custom namespace (prefixed binding), and the attribute is pretty much reflecting to most originalViewattributes.

There are currently two kinds of bindable objects in a view. First is theProperty(likecheckedinCheckBox) and the second isCommand(checkedChangeinCheckbox), where both of them will be explained in thelater part of this article.

Also note that for theListView, it is binding toitemSourcewhich will be either someCursororArrayof View Models (and we will cover that later) and theitemTemplateis a standard Android Resource reference format, that tells what the layout ofeachitem should look like.

Following is thecontact_entry.xml:

Collapse|Copy Code

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
			  xmlns:binding="http://www.gueei.com/android-binding/"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              binding:onClick="ShowContact"
              >
    <TextView android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:textSize="20dip"
              binding:text="Name"
              />
</LinearLayout>

It is still fairly standard layout XML file with customized binding namespace. Notice that the layout root (i.e. theLinearLayout) defined an actiononClick.

ViewModel

TheViewModelis something that bridges theViewandModel(it will be the contact provider in this example). TheViewModelin Android Binding is a class defining all the 'bindable' data/command Fields for theViewto access. Following shows a portion of theViewModel:

Collapse|Copy Code

public class ContactManagerModel {
	private Activity mContext;
	
	public CursorSource<ContactRowModel> ContactList = 
		new CursorSource<ContactRowModel>
			(ContactRowModel.class, new Factory());
	
	public BooleanObservable ShowInvisible = new BooleanObservable(false);

	public Command PopulateList = new Command(){
		public void Invoke(View view, Object... args) {
			populateContactList();
		}
	};
	public Command AddContact = new Command(){
		public void Invoke(View view, Object... args) {
			launchContactAdder();
		}
	};

	private void populateContactList() {
            // Build adapter with contact entries
            Cursor cursor = getContacts();
            ContactList.setCursor(cursor);
        }

BooleanObservableis representing an object that is 'observable' by other objects, so, whatever changes are made on this object will keep its observers notified. There are quite someObservablesdefined in Android Binding, likeStringObservable,IntegerObservable, ... all of them are subclasses ofIObservable<T>which implement thefollowing methods:

1. set()
2. get()
3. notifyChanged()

Theget()andset()are a replacement for getter and setter methods in Java, which will, by default, notify the subscribers about the change on the object automatically (where this is a borrowed concept from .NET).

Commandis the interface that defines something that is "Executable". Normally they will be wired withEventfired from User Interface.

Finally, since our contact source is a cursor, we need to supply theCursorSource<?>to indicate how ourCursoris used.

Binding to Cursor

In Android Binding, each row of record in theCursor, is supposed to be a View Model. That means, you are applying the same layout each with a separate set of data. One of the most powerful features in Android Binding, is that it allows you to define Commands and more complicated logic even in the sub-view models. As mentioned before, you cannot just supply aCursorasitemSourceforAdapterViews(includingListView,Spinners...), but it must be either anArraySourceorCursorSource.

CursorSourcetakes two constructor parameters:

Collapse|Copy Code

public CursorSource<ContactRowModel> ContactList = 
		new CursorSource<ContactRowModel>
			(ContactRowModel.class, new Factory()); 

First one is the class of the sub-viewmodel that representing each 'row' of cursor data (so it is namedrowModel), the other one is a factory that actually knows how to 'construct' the row. Let's look at them one by one.

Collapse|Copy Code

public class ContactRowModel extends CursorRowModel {
    	public IdField Id = new IdField(0);
    	public StringField Name = new StringField(1); 
        public Command ShowContact = new Command(){
//...

TheRowModelis pretty much standard View Model, except it requires to extend fromCursorRowModel. TheIdField,StringFieldare simplyObservablesbut their value will be filled up automatically using theCursor; the number within the bracket tells which column you are mapping that field to.

Model Validation

Model validation (to be precise, validating the View Model) is also supported, this is also demonstrated in this sample application but you may read my otherarticlefor details.

Furthermore

Observableis quite restricted at the moment, as it requires the View Attribute and the Property of Model to be the same in type. That means, if you bind thechecked(which is boolean) attribute with anObservable<Integer>, it won't work, since implicit type casting is not allowed. Therefore, another two subclasses ofObservableare provided:

DependentObservable<?>

This denotes that anobservables' value is dependent on otherObservables. For example, we can rewrite the aboveViewModelto add anSelectedContact:

Collapse|Copy Code

DependentObservable<Contact> SelectedContact = new
      DependentObservable<Contact>(Contact.class, SelectedId){
         @Override
         public Contact calculateValue(Object... args){
            getContactFromDb((Integer)args[0]);
        }
    };

DependentObservablerequires only one override method, thecalculateValue. SinceDependentObservablecan depends on multiple dependents, the parameters length incalculateValueis open, and explicit typecast is required. The above example is similar to a one-way converter, that converts theIdto a real contact.

There's actually aConverterclass in Android Binding, and the only difference withDependentObservableis thatConvertercan allow two-way binding:

Converter<?>

Collapse|Copy Code

public abstract void ConvertBack(T value, Object[] outResult);

Indeed,Converteris a subclass ofDependentObservable. It depends on a list of otherobservables, it can convert a booleantrueto number1, and when the convert back when other changes the convert's value.

Progress and Plans

An Alpha version of the project is released. You can go to the project homepage to download it.

Future plan is to add support to more POJO (Plain Old Java Object) way of View Model declaration.

You are free to download the code from the Google Code project repository, reports and issues. Please drop in the discussion group:http://groups.google.com/group/androidbinding.

Conclusion

This article briefly introduces the functionality of the Android Binding. If you compare it to the original Contact Manager Sample, you will find that using Android Binding w/MVVM results in much cleaner code and thus, more friendly to Unit testing and better code quality. Active development is in progress and this is my first OSS. I really look forward to comments and suggestions on this framework.

Author Blog and Project Details

• Andy Tsui
• Blog:http://andytsui.wordpress.com
• Discussion on project:http://groups.google.com/group/androidbinding
• Project hosting:http://code.google.com/p/android-binding/

License

This article, along with any associated source code and files, is licensed underThe GNU Lesser General Public License (LGPLv3)

About the Author

xandytsui