Fix race condition caused by delayed hiding of previous state.

The fix for #1 (race condition) also introduces a second race condition
when `setState()` is called a second time before the 1st call's previous
state view was hidden by the `Runnable`.  For example:

    msv.setState(ContentState.LOADING); // (1)
    msv.setState(ContentState.CONTENT); // (2)

This is the simplest way to reproduce the problem.  The default state is
`ContentState.CONTENT`. The (1) call shows the `LOADING` view and posts
a runnable that intends to hide the `CONTENT` view.  Then the (2) call
does the opposite:  shows the `CONTENT` view and posts a runnable
to hide the `LOADING` view.  The (2) show happens before the (1)
runnable has a chance to hide the `CONTENT` view, so when the runnable
finally does get run, it hides the `CONTENT` view, superceding the work
done by the (2) call.

This change converts the `postRunnable()` behavior into an inner
`Handler` subclass that will take a `ContentState` obj that is meant
to be hidden.  That way when `setState()` is called, we can remove any
pending messages that are meant to hide the state that is currently
requested to be shown.  If however, you are switching states to a different
state, then the pending hide will still be executed properly, such as:

    msv.setState(ContentState.LOADING);
    msv.setState(ContentState.GENERAL_ERROR);
    // will still hide CONTENT *and* will hide LOADING

This manifests easily when you set up your view to have an initial state
of `LOADING` in `onViewCreated()`, and in `onViewStateRestored()`, you
set the state back to `CONTENT`.

Author: Joe Hansche

library/src/com/meetme/android/multistateview/MultiStateView.java

@@ -2,10 +2,12 @@
 
 import android.content.Context;
 import android.content.res.TypedArray;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.AttributeSet;
-import android.util.Log;
 import android.util.SparseArray;
 import android.view.View;
 import android.widget.FrameLayout;
@@ -23,15 +25,14 @@ public class MultiStateView extends FrameLayout {
     private View mNetworkErrorView;
     private View mGeneralErrorView;
     private OnClickListener mTapToRetryClickListener;
+    private MultiStateHandler mHandler;
 
     public MultiStateView(Context context) {
-        super(context);
-        parseAttrs(context, null);
+        this(context, null);
     }
 
     public MultiStateView(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        parseAttrs(context, attrs);
+        this(context, attrs, 0);
     }
 
     public MultiStateView(Context context, AttributeSet attrs, int defStyle) {
@@ -175,15 +176,10 @@ public void setState(final ContentState state) {
 
         final ContentState previousState = mViewState.state;
 
+        // Remove any previously pending hide events for the to-be-shown state
+        mHandler.removeMessages(MultiStateHandler.MESSAGE_HIDE_PREVIOUS, state);
         // Only change visibility after other UI tasks have been performed
-        this.post(new Runnable() {
-            @Override
-            public void run() {
-                Log.v("DALLAS", "Attempting to change state from " + previousState);
-                // Hide the current state
-                getStateView(previousState).setVisibility(View.GONE);
-            }
-        });
+        mHandler.sendMessage(mHandler.obtainMessage(MultiStateHandler.MESSAGE_HIDE_PREVIOUS, previousState));
 
         mViewState.state = state;
 
@@ -363,6 +359,19 @@ private void setViewState(MultiStateViewData state) {
         setCustomErrorString(state.customErrorString);
     }
 
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mHandler = new MultiStateHandler(getHandler().getLooper());
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        mHandler.removeMessages(MultiStateHandler.MESSAGE_HIDE_PREVIOUS);
+        mHandler = null;
+        super.onDetachedFromWindow();
+    }
+
     @Override
     public void addView(View child) {
         if (!isViewInternal(child)) {
@@ -538,4 +547,33 @@ public MultiStateViewData[] newArray(int size) {
             }
         };
     }
+
+    /**
+     * Handler used to hide the previous state when switching to a new state
+     *
+     * @author jhansche
+     */
+    private class MultiStateHandler extends Handler {
+        public static final int MESSAGE_HIDE_PREVIOUS = 0;
+
+        @SuppressWarnings("unused")
+        public MultiStateHandler() {
+            super();
+        }
+
+        public MultiStateHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case MESSAGE_HIDE_PREVIOUS:
+                    ContentState previousState = (ContentState) msg.obj;
+                    View previousView = getStateView(previousState);
+                    if (previousView != null) previousView.setVisibility(View.GONE);
+                    break;
+            }
+        }
+    }
 }