Improvements to ListFragment.

Now deals correctly with a content view containing just a list,
and adds a lot more built-in functionality: ability to show
custom text for an empty list, and indeterminant progress while
populating the list.

In addition, reworks transaction committing to be more aggressive
about committing the transactions as the containing activity
moves between its states (rather than waiting for the activity's
handler to process the transaction message whenever that may
finally happen).  And fixed a bug with saving/restoring state of
transaction replace operations.

Change-Id: I9617a0c4f248b50a61b319910323639b6de24f73

1 files changed, 61 insertions, 2 deletions

diff --git a/core/java/android/app/FragmentManager.java b/core/java/android/app/FragmentManager.java
index c0ab0b5..b8eeb09 100644
--- a/core/java/android/app/FragmentManager.java
+++ b/core/java/android/app/FragmentManager.java
@@ -77,6 +77,10 @@ public class FragmentManager {
     static final boolean DEBUG = true;
     static final String TAG = "FragmentManager";
     
+    ArrayList<Runnable> mPendingActions;
+    Runnable[] mTmpActions;
+    boolean mExecutingActions;
+    
     ArrayList<Fragment> mActive;
     ArrayList<Fragment> mAdded;
     ArrayList<Integer> mAvailIndices;
@@ -91,6 +95,13 @@ public class FragmentManager {
     Bundle mStateBundle = null;
     SparseArray<Parcelable> mStateArray = null;
     
+    Runnable mExecCommit = new Runnable() {
+        @Override
+        public void run() {
+            execPendingActions();
+        }
+    };
+    
     Animation loadAnimation(Fragment fragment, int transit, boolean enter,
             int transitionStyle) {
         Animation animObj = fragment.onCreateAnimation(transitionStyle, enter,
@@ -486,6 +497,52 @@ public class FragmentManager {
         return null;
     }
     
+    public void enqueueAction(Runnable action) {
+        synchronized (this) {
+            if (mPendingActions == null) {
+                mPendingActions = new ArrayList<Runnable>();
+            }
+            mPendingActions.add(action);
+            if (mPendingActions.size() == 1) {
+                mActivity.mHandler.removeCallbacks(mExecCommit);
+                mActivity.mHandler.post(mExecCommit);
+            }
+        }
+    }
+    
+    /**
+     * Only call from main thread!
+     */
+    public void execPendingActions() {
+        if (mExecutingActions) {
+            throw new IllegalStateException("Recursive entry to execPendingActions");
+        }
+        
+        while (true) {
+            int numActions;
+            
+            synchronized (this) {
+                if (mPendingActions == null || mPendingActions.size() == 0) {
+                    return;
+                }
+                
+                numActions = mPendingActions.size();
+                if (mTmpActions == null || mTmpActions.length < numActions) {
+                    mTmpActions = new Runnable[numActions];
+                }
+                mPendingActions.toArray(mTmpActions);
+                mPendingActions.clear();
+                mActivity.mHandler.removeCallbacks(mExecCommit);
+            }
+            
+            mExecutingActions = true;
+            for (int i=0; i<numActions; i++) {
+                mTmpActions[i].run();
+            }
+            mExecutingActions = false;
+        }
+    }
+    
     public void addBackStackState(BackStackEntry state) {
         if (mBackStack == null) {
             mBackStack = new ArrayList<BackStackEntry>();
@@ -503,8 +560,9 @@ public class FragmentManager {
                 return false;
             }
             final BackStackEntry bss = mBackStack.remove(last);
-            handler.post(new Runnable() {
+            enqueueAction(new Runnable() {
                 public void run() {
+                    if (DEBUG) Log.v(TAG, "Popping back stack state: " + bss);
                     bss.popFromBackStack();
                     moveToState(mCurState, reverseTransit(bss.getTransition()),
                             bss.getTransitionStyle(), true);
@@ -526,9 +584,10 @@ public class FragmentManager {
             for (int i=mBackStack.size()-1; i>index; i--) {
                 states.add(mBackStack.remove(i));
             }
-            handler.post(new Runnable() {
+            enqueueAction(new Runnable() {
                 public void run() {
                     for (int i=0; i<states.size(); i++) {
+                        if (DEBUG) Log.v(TAG, "Popping back stack state: " + states.get(i));
                         states.get(i).popFromBackStack();
                     }
                     moveToState(mCurState, true);