Android探索更新UI的方法（二）-更新UI的方式

前言

  前一章我们讲了更新UI的时机，即Android是在哪一刻才更新UI的，了解Android更新UI的源码流程有助于我们了解其本质，在开发过程中出错也能更快的定位。当然看源码也要不求甚解，不要一头砸进去，毫无头绪，只需顺着一条主线，适可而止。像UI怎么显示到屏幕上的，实际App进程是把显示操作发给System_Server进程的WindowManagerService线程，让它去显示，中间通过Binder线程实现进程间交互。

Android更新UI的几种方式

  我们知道Android中有以下几种更新UI的方式，我们探讨的都是在非UI线程更新，下同。

        1、Handler sendMessage() or post();
        2、Activity runOnUiThread();
        3、View post()
        4、AsyncTask
        5、View其他相关用法

Handler

  handler是最常用的，也是Android中最基本的方法，Android中所有的异步更新UI的本质都是用Handler。那么我们看一下sendMessage和post有什么区别

public final boolean sendMessage(Message msg)
{
        return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
}

发现最后调用的是sendMessageAtTime，这个方法里面吧Message加入到MessageQueue里面

public final boolean post(Runnable r)
{
       return  sendMessageDelayed(getPostMessage(r), 0);
}

private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
}

其实就是把Runnable包装成一个Message，即把Message的callback设置成Runnable，之后就会在主线程回调Runnable的run方法。就这么简单实现了UI的更新。

runOnUiThread()

  runOnUiThread()是Activity的方法

// we must have a handler before the FragmentController is constructed
final Handler mHandler = new Handler();

/**
     * Runs the specified action on the UI thread. If the current thread is the UI
     * thread, then the action is executed immediately. If the current thread is
     * not the UI thread, the action is posted to the event queue of the UI thread.
     *
     * @param action the action to run on the UI thread
     */
    @Override
    public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

  如果是在主线程调用该方法，则跟没调用一样的，都是立即更新UI，调用Runnable的run方法；
  如果实在子线程调用该方法，则通过handler.post()把它放进消息队列。所以这个方法的本质很简单，主线程立即更新，子线程通过handler放进MessageQueue
  注意mHandler是Activity里面的handler,mUiThread实在Activity的attach方法中赋值的，这个方法是由ActivityThread经过一系列方法调用的，所以这个是主线程。

View post()

Android还提供这个View.post()方法来供我们更新UI，这个方法在View.java里面

/**
     * <p>Causes the Runnable to be added to the message queue.
     * The runnable will be run on the user interface thread.</p>
     *
     * @param action The Runnable that will be executed.
     *
     * @return Returns true if the Runnable was successfully placed in to the
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     *
     * @see #postDelayed
     * @see #removeCallbacks
     */
    public boolean post(Runnable action) {
        final AttachInfo attachInfo = mAttachInfo;
        if (attachInfo != null) {
            return attachInfo.mHandler.post(action);
        }

        // Postpone the runnable until we know on which thread it needs to run.
        // Assume that the runnable will be successfully placed after attach.
        getRunQueue().post(action);
        return true;
    }

  从注释可以知道，当attachInfo为空时，即这时候UI还没创建好，是吧Runnable添加到队列中；当attachInfo不为空时，它是把Runnable投递到主线程的消息队列，这里用的handler是mAttachInfo的handler，我们看一下它是在哪，什么时候创建的。

    AttachInfo mAttachInfo;
/**
     * Queue of pending runnables. Used to postpone calls to post() until this
     * view is attached and has a handler.
     */
    private HandlerActionQueue mRunQueue;

/**
     * @param info the {@link android.view.View.AttachInfo} to associated with
     *        this view
     */
    void dispatchAttachedToWindow(AttachInfo info, int visibility) {
        mAttachInfo = info;
        .....
        // Transfer all pending runnables.
        if (mRunQueue != null) {
            mRunQueue.executeActions(info.mHandler);
            mRunQueue = null;
        }
    }

dispatchAttachedToWindow()是在ViewRootImpl中调用的

ViewRootImpl.java

private void performTraversals() {
        // cache mView since it is used so much below...
        final View host = mView;
        .....
        if (mFirst) {
                host.dispatchAttachedToWindow(mAttachInfo, 0);
        }
        // Execute enqueued actions on every traversal in case a detached view enqueued an action
        getRunQueue().executeActions(mAttachInfo.mHandler);
        .....
}

mView是在setView()中赋值的

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
            }
       }
}

而setView是WindowManagerGlobal中调用的，关于WMS等的源码分析我们之后再讲，这里只需要重点关注View的mRunQueue，也就是在Activity启动的流程中，会把post的Runnable放到mRunQueue这个队列里，当view显示到屏幕上，会调用ViewRootImpl的performTraversals()，然后调用View的dispatchAttachedToWindow，然后执行mRunQueue里面的任务。
  总结：当view没创建好时，先把任务添加到队列中，不会执行；只有当view创建完毕，显示到屏幕上时，才回去调用任务队列里面的任务，所以我们在onCreate(),onStart()等生命周期里面post的任务不会立即执行，有兴趣的童鞋可以去试一下。
  接下来我们重点关注mRunQueue这个HandlerActionQueue

/**
 * Class used to enqueue pending work from Views when no Handler is attached.
 *
 * @hide Exposed for test framework only.
 */
public class HandlerActionQueue {
    private HandlerAction[] mActions;
    private int mCount;

    public void post(Runnable action) {
        postDelayed(action, 0);
    }

    public void postDelayed(Runnable action, long delayMillis) {
        final HandlerAction handlerAction = new HandlerAction(action, delayMillis);

        synchronized (this) {
            if (mActions == null) {
                mActions = new HandlerAction[4];
            }
            mActions = GrowingArrayUtils.append(mActions, mCount, handlerAction);
            mCount++;
        }
    }

    public void removeCallbacks(Runnable action) {
        synchronized (this) {
            final int count = mCount;
            int j = 0;

            final HandlerAction[] actions = mActions;
            for (int i = 0; i < count; i++) {
                if (actions[i].matches(action)) {
                    // Remove this action by overwriting it within
                    // this loop or nulling it out later.
                    continue;
                }

                if (j != i) {
                    // At least one previous entry was removed, so
                    // this one needs to move to the "new" list.
                    actions[j] = actions[i];
                }

                j++;
            }

            // The "new" list only has j entries.
            mCount = j;

            // Null out any remaining entries.
            for (; j < count; j++) {
                actions[j] = null;
            }
        }
    }

    public void executeActions(Handler handler) {
        synchronized (this) {
            final HandlerAction[] actions = mActions;
            for (int i = 0, count = mCount; i < count; i++) {
                final HandlerAction handlerAction = actions[i];
                handler.postDelayed(handlerAction.action, handlerAction.delay);
            }

            mActions = null;
            mCount = 0;
        }
    }

    public int size() {
        return mCount;
    }

    public Runnable getRunnable(int index) {
        if (index >= mCount) {
            throw new IndexOutOfBoundsException();
        }
        return mActions[index].action;
    }

    public long getDelay(int index) {
        if (index >= mCount) {
            throw new IndexOutOfBoundsException();
        }
        return mActions[index].delay;
    }

    private static class HandlerAction {
        final Runnable action;
        final long delay;

        public HandlerAction(Runnable action, long delay) {
            this.action = action;
            this.delay = delay;
        }

        public boolean matches(Runnable otherAction) {
            return otherAction == null && action == null
                    || action != null && action.equals(otherAction);
        }
    }
}

它里面有个内部类HandlerAction，封装了Runnable，HandlerAction[]保存了任务，初始容量大小为4。可以看到post()方法就是把Runnable放进handlerAction数组里面，并没有执行，真正的执行在dispatchAttachedToWindow方法中

if (mRunQueue != null) {
            mRunQueue.executeActions(info.mHandler);
            mRunQueue = null;
}

public void executeActions(Handler handler) {
        synchronized (this) {
            final HandlerAction[] actions = mActions;
            for (int i = 0, count = mCount; i < count; i++) {
                final HandlerAction handlerAction = actions[i];
                handler.postDelayed(handlerAction.action, handlerAction.delay);
            }

            mActions = null;
            mCount = 0;
        }
}

执行就是遍历HandlerAction数组，依次执行，这里的handler是AttachInfo的handler，它是ViewRootImpl中的ViewRootHandler，它也是继承Handler的。执行完毕后清空HandlerAction数组。

view post 时序图

AsyncTask

AsyncTask的原理其实也是用Handler更新UI的，它内部有一个InternalHandler sHandler；

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

注意它初始化Handler用的是主线程的Looper，sHandler = new InternalHandler(Looper.getMainLooper());关于AsyncTask的工作原理之后会讲到。

View其他相关用法

ViewTreeObserver

  在开发中，通常有这样一种需求，我们需要获取View的宽高等信息，要获取这些信息必须等View完成measure后才能获取，可以用上面我们将的View的post获取，也可以用ViewTreeObserver设置监听来获取

        final ViewTreeObserver observer = surfaceView.getViewTreeObserver();
        ViewTreeObserver.OnGlobalLayoutListener layoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                if (observer.isAlive()) {
                    observer.removeGlobalOnLayoutListener(this);
                    //获取宽高 
                }
            }
        };
        observer.addOnGlobalLayoutListener(layoutListener);

它会在View的layout发生变化时调用，注意可能会多次调用，用过一次后最好移除监听，否则回调会多次执行，拿它是什么时候回调的呢，我们要再一次进入ViewRootImpl的performTravels()方法

ViewTreeObserver.java

public final void dispatchOnGlobalLayout() {
        final CopyOnWriteArray<OnGlobalLayoutListener> listeners = mOnGlobalLayoutListeners;
        if (listeners != null && listeners.size() > 0) {
            CopyOnWriteArray.Access<OnGlobalLayoutListener> access = listeners.start();
            try {
                int count = access.size();
                for (int i = 0; i < count; i++) {
                    access.get(i).onGlobalLayout();
                }
            } finally {
                listeners.end();
            }
        }
}

ViewRootImpl.java

private void performTraversals() {
        .....
        performMeasure();
        .....
        performLayout();

        if (triggerGlobalLayoutListener) {
            mAttachInfo.mRecomputeGlobalAttributes = false;
            mAttachInfo.mTreeObserver.dispatchOnGlobalLayout();
        }
        .....
        performDraw();
        .....
}

当View完成测量，布局后，如果设置了监听，则回调。所以这也能正确的获取宽高。

MessageQueue.IdleHandler

在上一节中，我们提到过MessageQueue中有个有趣的接口叫IdleHandler

private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
private IdleHandler[] mPendingIdleHandlers;
/**
     * Callback interface for discovering when a thread is going to block
     * waiting for more messages.
     */
    public static interface IdleHandler {
        /**
         * Called when the message queue has run out of messages and will now
         * wait for more.  Return true to keep your idle handler active, false
         * to have it removed.  This may be called if there are still messages
         * pending in the queue, but they are all scheduled to be dispatched
         * after the current time.
         */
        boolean queueIdle();
    }

public void addIdleHandler(@NonNull IdleHandler handler) {
        if (handler == null) {
            throw new NullPointerException("Can't add a null IdleHandler");
        }
        synchronized (this) {
            mIdleHandlers.add(handler);
        }
}

public void removeIdleHandler(@NonNull IdleHandler handler) {
        synchronized (this) {
            mIdleHandlers.remove(handler);
        }
}

Message next() {
        .....
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        for (;;) {
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler

                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            // Reset the idle handler count to 0 so we do not run them again.
            pendingIdleHandlerCount = 0;
        .....
}

通过官方解释我们可以了解这个接口的作用：当消息队列中没有消息时，会回调该接口，前提是你设置了监听。它的返回值：返回false，那么就会移除它，返回true就会在下次message处理完了的时候继续回调。

那么这个接口到底有什么用呢，其实也可以用来获取View的宽高，在View初始化，Activity启动的时候，MessageQueue的有许多的消息，我们可以从ViewRootImpl的ViewRootHandler里面可以看出。当MessageQueue为空时，表示View真正的完成了measue，layout，draw等操作，这是我们就可以去执行一些获取view属性的操作或者做一些耗时操作，这时就不会影响UI的显示了，特别是进入App主页，经常需要向服务器请求大量的数据来更新UI，如果子线程过多，又设置了过高的优先级，就会抢占调度UI线程，导致卡顿，所以这个接口就很有用了。那么怎么具体使用呢？

         //MessageQueue queue = Looper.getMainLooper().getQueue();
        MessageQueue queue = Looper.myQueue();
        queue.addIdleHandler(new MessageQueue.IdleHandler() {
            @Override
            public boolean queueIdle() {
                Log.d("Activity","idleHandler");
                return false;
            }
        });