Asynchronous code testing in Android

Testing asynchronous calls it is not always an easy task.

Let's take as reference this simple interface:

	public interface SampleClass {
	void doAsync(Listener l);
	public interface Listener{
	void onValueChanged(int i);
	}
	}

view raw Sample.java hosted with ❤ by GitHub

The first thing is: how can we test it through an Android unit test class?

	public class TestSample extends AndroidTestCase{
	public void testDoAsync(){
	SampleClass s = new SampleClass();
	Listener l = new ListenerImpl();
	s.doAsync();
	}
	private class ListenerImpl implements Listener{
	public void onValueChanged(int i){
	//how to test this value?
	}
	}
	}

view raw TestSample.java hosted with ❤ by GitHub

We can't test the value inside the callback. Infact, an async call runs usually in worker thread. When the thread has done some computation, it calls the callback. The simplest case is when the callback is run in the same worker thread.

But still, we need to find a way to block the main thread, otherwise the test class will simply don't wait before the callback is called! Remember that the method testDoSync() is called in the main thread.

We can use a semaphore, and make the test method wait until the callback is delivered. Then we can easily test the return value. The Semaphore class has some interesting properties: first, we can use it to put a thread in wait; the acquire() method stops the thread until a resource is available. As we have created the Semaphore with 0 resources available, this will cause the next call to acquire() to stop the thread.
But what if there is the unlikely case that the listener, returns before the acquire() call is made? No worries, as the signal() will simply increment the number of resources available and so the acquire() method will not nlock but will return straight away. Yay, this is for sure a better way to handle threads synchronization that the usual pattern wait-notify!
This is the code that covers this case:

	public class TestSample extends AndroidTestCase{
	private int mFinalValue;
	private static final int EXPECTED_VALUE = 10;
	public void testDoAsync(){
	SampleClass s = new SampleClass();
	Listener l = new ListenerImpl();
	Semaphore semaphore = new Semaphore(0);
	s.doAsync();
	semaphore.acquire();
	assertEquals(mFinalValue, EXPECTED_VALUE);
	}
	private class ListenerImpl implements Listener{
	public void onValueChanged(int i){
	mFinalValue = i;
	semaphore.release();
	}
	}
	}

view raw TestSample2.java hosted with ❤ by GitHub

And now, the worst case. Let's imagine that the code run by the worker thread do some stuff, and then it posts the results of its work in the calling thread (for instance through a handler). Then, onValueChanged() will never be called. Why? It is because we needed to stop the main thread. The main thread is a looper thread: normally a thread do some stuff and then it dies. Instead, a thread with a looper processes events by looping continuously. Another thread can post events on it: the events are put in the thread queue and they are processed one at time. If we block the main thread, the event posted by the worker thread will NEVER get processed.
How to handle this case?
We still need to block the main thread. But we need to launch the callback from a secondary thread with the looper.
We will use a facility offered by android: HandlerThread.

	public class TestSample extends AndroidTestCase{
	private int mFinalValue;
	private static final int EXPECTED_VALUE = 10;
	private final HandlerThread mHandlerThread;
	private SampleClass mInstance;
	public void testDoAsync(){
	mInstance = new SampleClass();
	Listener l = new ListenerImpl();
	mHandlerThread = new MyHandler("handlerThread");
	Semaphore semaphore = new Semaphore(0);
	mHandlerThread.start();
	semaphore.acquire();
	mHandlerThread.quit();
	assertEquals(mFinalValue, EXPECTED_VALUE);
	}
	private class MyHandler extends HandlerThread{
	public void run() {
	mInstance.doAsync();
	}
	}
	private class ListenerImpl implements Listener{
	public void onValueChanged(int i){
	mFinalValue = i;
	semaphore.release();
	}
	}
	}

view raw TestSample3.java hosted with ❤ by GitHub

It will create a thread with looper for us; then the callback will be called in the secondary thread looper that is not blocked, and from that thread we can release the semaphore of the main thread.
Finally, remember to quit() the thread handler (that will quit the embedded looper too and will cause the death of that thread).

Dynamic resize of views and offscreen view size calculation in LinearLayout

The layout is usually handled by a set of xml files, where we specify how the components of our view group are displayed.
It should be the preferred way of generating and composing the views. It is possible to merge layouts, to inflate custom views etc.
There are some occasions, though, where the xml syntax and attributes are not powerful enough.
For example, we can have a vertical linear layout where, at some point, we inflate a custom view. We don't know how big (and, above all), tall is this view at compile time. The problem is, all or some views below it can disappear because our "big" view takes all available space.

A solution might be to wrap the views in a relative layout. All good, all fine, in that way we can specify that the big view must be below a child, and above another. Then we align the first view to the top, and the last to the bottom.

But the problem is that the height of the relative layout can't be wrapped!
As stated also in the documentation (which should have read before spending a couple of hours in adapting the layout :P)

Note that you cannot have a circular dependency between the size of the RelativeLayout and the position of its children. For example, you cannot have a RelativeLayout whose height is set to WRAP_CONTENT and a child set to ALIGN_PARENT_BOTTOM.

The only way is adjusting the layout at runtime: we must calculate the height of the big view  and if its bottom point is at the end of the layout and there are still views to draw, then we need to calculate their value and resize it accordingly.

A problem is that we can't get simply the height of the offscreen views! Since they are offscreen, Android will give us 0 as the height.

What we can do, is using the class called View.MeasureSpec and calculate the view size like this:

	private Pair<Integer,Integer> measureButton(){
	int widthMeasureSpec = View.MeasureSpec.makeMeasureSpec(ViewGroup.LayoutParams.WRAP_CONTENT, View.MeasureSpec.EXACTLY);
	int heightMeasureSpec = View.MeasureSpec.makeMeasureSpec(ViewGroup.LayoutParams.WRAP_CONTENT, View.MeasureSpec.EXACTLY);
	mButton.measure(widthMeasureSpec, heightMeasureSpec);
	int h = mButton.getMeasuredHeight();
	int w = mButton.getMeasuredWidth();
	Log.d(TAG, "height of button is :"+h+", width is :"+w);
	return new Pair<Integer, Integer>(w,h);
	}

view raw MeasureButton.java hosted with ❤ by GitHub

Then, we need to find a way to adjust the size of the big view; again, we can't do that in onCreate() or other similar callbacks, as the view is not rendered yet and we will get 0 as height of the view.
We could override the View.onMeasure() method but as it gets called multiple times by the framework, it is not very reliable.
Best thing is adding a ViewTreeObserver and do all the calculations in its callback:

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	//... init code ...
	ViewTreeObserver vto = mRootView.getViewTreeObserver();
	vto.addOnGlobalLayoutListener(new OnGlobalLayoutListenerImpl());
	}
	private void resizeBigView(){
	int indexOfBigView = mRootView.indexOfChild(mBigView);
	int totalNumberOFChildren = mRootView.getChildCount();
	int heightOfButton = measureRequiredHeight(mRootView, indexOfBigView + 1, totalNumberOFChildren);
	int bigViewOriginalHeight = mBigView.getHeight();
	int bigViewBottom = mBigView.getBottom();
	int rootViewHeight = mRootView.getHeight();
	int pixelsToRemove = 0;
	//if big view covers the button (even partially!)
	if(bigViewBottom > rootViewHeight - heightOfButton) {
	pixelsToRemove = bigViewBottom - (rootViewHeight - heightOfButton);
	Log.d(TAG, "pixels to remove: "+pixelsToRemove);
	}
	//setup view with the same height as before but changing height from match_parent to precise value
	LinearLayout.LayoutParams params = (LinearLayout.LayoutParams)mBigView.getLayoutParams();
	params.height = bigViewOriginalHeight - pixelsToRemove;
	mBigView.setLayoutParams(params);
	}
	//.. in our listener:
	public void onGlobalLayout() {
	resizeBigView();
	if (android.os.Build.VERSION.SDK_INT < 16) // Use old, deprecated method
	mRootView.getViewTreeObserver().removeGlobalOnLayoutListener(this);
	else // Use new method
	mRootView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
	}

view raw resize.java hosted with ❤ by GitHub

The code of this example is available here:
https://github.com/nalitzis/TestDynamicViews