public final boolean requestFocus() {
        /*调用requestFoscus()的一个重载。View.FOCUS_DOWN表示焦点的寻找方向。
        当本控件是一个ViewGroup时将会从左上角开始沿着这个方向查找可以获取焦点的子控件。
        不过在本例只讨论控件是一个View时的情况，此时该参数并无任何效果*/
        return requestFocus(View.FOCUS_DOWN);
    }
    
    public final boolean requestFocus (int direction) {
        /*继续调用另外一个重载，新的重载中增加了一个Rect作为参数。此Rect表示了上一个焦点控件的区域。
        它表示从哪个位置开始沿着direction所指定的方向查找焦点控件。
        仅当本控件是ViewGroup时此参数才有意义*/
        return requestFocus(direction, null);
    }
    
    public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
        /*requestFocus()的这一重载便是View和Viewgroup分道扬镳的地方。 requestFocusNoSearch()方法的意义就是无须查找，直接使本控件获取焦点*/
        return requestFocusNoSearch(direction, previouslyFocusedRect);
    }
    
    private boolean requestFocusNoSearch(int direction, Rect previouslyFocusedRect) {
        //首先检查一下此控件是否符合拥有焦点的条件
        
        //①首先，此控件必须是Focuaable的。可以通过View.setFocusable()方法设置控件是否focusable
        if ((mViewFlags & FOCUSABLE_MASK) !=FOCUSABLE || (mViewFlags & VISIBILITY_MASK) != VISIBLE) {
            return false;
        }
        
        //②再者，如果系统目前处于触摸模式，则要求此控件必须可以在触摸模式下拥有焦点
        if (isInTouchMode() && (FOCUSABLE_IN_TOUCH_MODE != (mViewFlags & FOCUSABLE_IN_TOUCH_MODE))) {
            return false;
        }
        
        //③最后，如果任一父控件的DescendantFocusability取值为FOCUS_BLOCK_DESCENDANTS时，阻止此控件获取焦点。
        hasAncestorThatBlocksDescendantFocus()会沿着控件树一路回溯到整个控件树的根控件并逐一检查DescendantFocusability特性的取值*/
        if (hasAncestorThatBlocksDescendantFocus()) {
            return false;
        }
        
        //④最后调用handleFocusGainlnternal()使此控件获得焦点
        handleFocusGainlnternal(direction, previouslyFocusedRect);
        
        return true;
    }

private boolean hasAncestorThatBlocksDescendantFocus() {
    final boolean focusableInTouchMode = isFocusableInTouchMode();
    ViewParent ancestor = mParent;
    while (ancestor instanceof ViewGroup) {
        final ViewGroup vgAncestor = (ViewGroup) ancestor;
        if (vgAncestor.getDescendantFocusability() == ViewGroup.FOCUS_BLOCK_DESCENDANTS
                || (!focusableInTouchMode && vgAncestor.shouldBlockFocusForTouchscreen())) {
            return true;
        } else {
            ancestor = vgAncestor.getParent();
        }
    }
    return false;
}

    void handleFocusGainlnternal(int direction, Rect previouslyFocusedRect) {
        if((mPrivateFlags & PFLAG_FOCUSED) == 0) {
            //①把PFLAG_FOCUSED标记加入mPrivateFlags中。这便表示此控件已经拥有焦点了
            mPrivateFlags |= PFLAG_FOCUSED;
            
            /*②将这一变化通知其父控件。这一操作的主要目的是保证控件树中只有一个控件拥有焦点，并且在ViewRootImpl中触发一次“遍历”以便对控件树进行重绘*/
            if (mParent != null) {
                mParent.requestChildFocus(this, this);
            }
            
            /*③通知对此控件焦点变化感兴趣的监听者。在这个方法中，View.onFocusLose()、OnFocusChangeListener.onFocusChange()都会被调用。
            另外，控件焦点决定了输入法的输入对象，因此InputMethodManager的focusIn()和focusOut()也会在这里被调用以更新输入法的状态*/
            onFocusChanged (true, direction, previouslyFocusedRect);
            
            //④更新控件的Drawable状态。这将使得控件在随后的绘制中得以高亮显示
            refreshDrawableState();
            ...
        }
    }

    public void requestChildFocus(View child, View focused) {
        //①如果上一个焦点控件就是这个ViewGroup，则通过调用View.unFocus()将PLFAG_FOCUSED标记移除，以释放焦点
        super.unFocus();
        
        if (mFocused != child) {
            /*②如果上一个焦点控件在这个ViewGroup所表示的控件树之中，即mFocused不为null，则调用mFocused.unFocus()以释放焦点*/
            if (mFocused != null) {
                mFocused.unFocus()；
            }
            
            /*3.设置mFocused成员为child。注意child参数不一定是实际拥有焦点的控件。而是此ViewGroup的直接子控件，同时它是实际拥有焦点的控件的父控件*/
            mFocused = child;
        }
        
        if (mParent != null) {
            //4.将这一操作继续向控件树的根部回溯。注意child参数是此ViewGroup，而不是实际拥有焦点的focused
            mParent.requestChildFocus(this, focused);
        }
    }

@Override
public void requestChildFocus(View child, View focused) {
    if (DEBUG_INPUT_RESIZE) {
        Log.v(mTag, "Request child focus: focus now " + focused);
    }
    checkThread();
    scheduleTraversals();
}

    void unFocus() {
        if (mFocused == null) {
            /*如果mFocused为空，则表示此ViewGroup位于mFocused单向链表的尾端，即此ViewGroup是焦点的实际拥有者，因此调用View.unFocus()使此ViewGroup放弃焦点*/
            super.unFocus();
        } else {
            //否则将unFocus()传递给链表的下一个控件
            mFocused.unFocus();
            
            //最后将mFocused设置为null
            mFocused = null;
        }
    }

void unFocus() {
    if ((mPrivateFlags & PFLAG_FOCUSED) != 0) {
        mPrivateFlags &= ~PFLAG_FOCUSED;

        onFocusChanged(false, 0, null);
        refreshDrawableState();

        if (AccessibilityManager.getInstance(mContext).isEnabled()) {
            notifyAccessibilityStateChanged();
        }
    }
}

    public boolean requestFocus (int direction, Rect previouslyFocusedRect) {
        //①首先获取ViewGroup的DescendantFocusability将性的取值
        int descendantFocusability = getDescendantFocusability();
        
        //根据不同的DescendantFocusability特性，requestFocus()会产生不同的效果
        switch (descendantFocusability) {
            case FOCUS_BLOCK_DESCENDANTS:
                /*②FOCUS_BLOCK_DESCENDANTS: ViewGroup将会阻止所有子控件获取焦点，于是调用 view.requestFocus()尝试自己获取焦点*/
                return super.requestFocus(direction, previouslyFocusedRect);
                
            case FOCUS_BEFORE_DESCENDANTS: {
                /*③FOCUS_BEFORE_DESCENDANTS: viewGroup将有优先于子控件获取焦点的权利。因此会首
                先调用View.requestFocus()尝试自己获取焦点，倘若自己不满足获取焦点的条件则通过调用onRequestFocusInDescendants()方法将获取焦点的请求转发给子控件*/
                final boolean took = super.requestFocus(direction, previouslyFocusedRect);                
                return took ? took : onRequestFocusInDescendants(direction, previouslyFocusedRect);
            }
            
            case FOCUS_AFTER_DESCENDANTS: {
                /*④FOCUS_AFTER_DESCENDANTS:子控件将有优先于此ViewGroup获取焦点的权利。因此会首
                先调用onRequestFocusInDescendants()尝试将获取焦点的请求转发给子控件。倘若所有子控件都无法获取焦点，再调用View.requestFocus()尝试自己获取焦点*/
                final boolean took = onRequestFocusInDescendants(direction, previouslyFocusedRect);
                return took ? took : super.requestFocus(direction, previouslyFocusedRect);
            }
            
            default：
            ...//抛出异常
        }
    }

    protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
        /*此方法的目的是按照direction参数所措述的方向在子控件列表中依次尝试使其获取焦点，这里direction
        所描述的方向并不是控件在屏幕上的位置，而是它们在mChildren列表中的位置因此direction仅有 按照索引递增(FOCUS_FORWARD)或递减两种方向可选*/
        int index, increment, end, count = mChildrenCount;
        
        if (direction & FOCUS_FORWARD)  != 0) {
            index = 0; increment = 1; end = count;
        } else {
            index = count - 1; increment = -1; end = -1;
        }
        
        final View[] children = mChildren;
        for (int i = index; i != end; i += increment) {
            View child = children[i];
            //首先子控件必须是可见的
            if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
            
                //调用子控件的requestFocus()，如果子控件获取了焦点，则停止继续查找
                if (child.requestFocus(direction, previouslyFocusedRect)) {
                    return true;
                }
            }
        }
        return false;
    }

@Override
public void clearFocus() {
    if (DBG) {
        System.out.println(this + " clearFocus()");
    }
    if (mFocused == null) {
        super.clearFocus();
    } else {
        View focused = mFocused;
        mFocused = null;
        focused.clearFocus();
    }
}

public void clearFocus() {
    if (DBG) {
        System.out.println(this + " clearFocus()");
    }

    clearFocusInternal(null, true, true);
}

void clearFocusInternal(View focused, boolean propagate, boolean refocus) {
    if ((mPrivateFlags & PFLAG_FOCUSED) != 0) {
        mPrivateFlags &= ~PFLAG_FOCUSED;

        if (propagate && mParent != null) {
            mParent.clearChildFocus(this);
        }

        onFocusChanged(false, 0, null);
        refreshDrawableState();

        if (propagate && (!refocus || !rootViewRequestFocus())) {
            notifyGlobalFocusCleared(this);
        }
    }
}

boolean rootViewRequestFocus() {
    final View root = getRootView();
    return root != null && root.requestFocus();
}

@Override
public void clearChildFocus(View child) {
    if (DBG) {
        System.out.println(this + " clearChildFocus()");
    }

    mFocused = null;
    if (mParent != null) {
        mParent.clearChildFocus(this);
    }
}

@Override
public void clearChildFocus(View child) {
    if (DEBUG_INPUT_RESIZE) {
        Log.v(mTag, "Clearing child focus");
    }
    checkThread();
    scheduleTraversals();
}

    public View focusSearch(int direction) {
        if (mParent != null) {
            //查找工作会交给父控件完成
            return mParent.focusSearch(this, direction);
        } else {
            /*如果控件没有父控件就直接返回null，毕竟一个控件没有添加到控件树中查找下一个焦点是没有
            意义的*/
            return null;
        }
    }

    public View focusSearch(View focused, int direction) {
        if (isRootNamespace()) {
            /*①如果isRootNamespace()返回true，则表示这是一个根控件。此时ViewGroup拥有整个控件
            树，因此它是负责焦点查找的最合适的人选。它使用了FocusFinder工具类进行焦点查找*/
            return FocusFinder.getlnstance().findNextFocus(this, focused, direction);
        } else if (mParent != null) {
            //②如果这不是根控件，则继续向控件树的根部回溯
            return mParent.focusSearch(focused, direction);
        }
        return null;
    }

    public final View findNextFocus(ViewGroup root, View focused, int direction) {
        return findNextFocus(root, focused, null, direction) ;
    }

    private View findNextFocus(ViewGroup root, View focused, Rect focusedRect, int direction) {
        View next = null;
        
        //①首先将尝试依照开发者的设置选择下一个拥有焦点的控件
        if (focused != null) {
            next = findNextUserSpecifiedFocus(root, focused, direction);
        }

        if (next != null) {
            return next;
        }

        /*②内置算法。倘若开发者没有为当前的焦点控件设置下一个拥有焦点的控件，将会使用控件系统内置的算法进行下一个焦点的查找*/
        ArrayList<View> focusables = mTempList;
        try{
            focusables.clear()；
            //③将控件树中所有可以获取焦点的控件存储到focusables列表中。后续的将会在这个列表中进行查找
            root.addFocusables(focusables, direction);
            if (!focusables.isEmpty()) {
                //④调用findNextFocus()的另一个重载完成查找
                next = findNextFocus(root, focused, focusedRect, direction, focusables);
            }
        } finally {
            focusables.clear()；
        }
        return next;
    }

    private View findNextFocus(ViewGroup root, View focused, Rect focusedRect, int direction, ArrayList<View> focusables) {
        //①首先需要确定查找的起始位置
        if (focused != null) {
            ...
            /*当focused不为null时，起始位置即focused所在的位置。View.getFocusedRect()所返回
            的并不是控件的mLeft、mTop、mRight、mBottom。因为Scroll的存在它们并不能反映控件的
            真实位置。View.getFocusedRect()会将Scroll所产生的偏移考虑在内，但是Tranformation(如
            setScaledX()等设置）并没有计算在内，因此它们并不会影响焦点查找的结果*/
            focused.getFocusedRect(focusedRect);
            
            /* View.getFocusedRect()所返回的结果基于View本身的坐标系。为了使得控件之间的位置可以
            比较，必须将其转换到根控件所在的多坐标系中*/
            root.offsetDescendantRectToMyCoords(focused, focusedRect);
        } else {
            if (focusedRect == null) {
                /*当focusedRect为null时，表示查找在指定方向上的第一个可以获取焦点的控件。
                此时会以根控件的某个角所在位置作为起始位置。例如对Left和Up两个方向来说，起始位置会被
                设置为根控件的右下角这个点，而对Right和Bottom来说，起始位置将会是根控件的左上角*/
                ...
            }
        }
        //接下来便会根据不同的方向选择不同的查找算法
        switch (direction) {
            case View.FOCUS_FORWARD:
            case View.FOCUS_BACKWARD:
                /*②对FOCUS_FORWARD/BACKWARD 来说将会选择相对位置进行查找。这种查找与控件位置无关，
                它会选择focusables列表中索引近邻focused的控件作为查找结果*/
                // 首先会把focusables列表按照内置的排序算法进行排序，排序算法是按照控件焦点区域上左下右的优先级进行递增排序的，
                // 先获取当前focused在focusables中的index，然后根据查找方向在列表中获取下一个或上一个能获取焦点的view即可
                return findNextFocusInRelativeDirection(focusables, root, focused, focusedRect,    direction)；
                
            case View.FOCUS_UP:
            case View.FOCUS_DOWN:
            case View.FOCUS_LEFT:
            case View.FOCUS_RIGHT:
                //③对于UP、DOWN、LEFT、Right 4个方向会根据控件的实际位置进行查找
                return findNextFocusInAbsoluteDirection(focusables, root, focused, focusedRect, direction);
            
            default：
                throw new IllegalArgumentException("Unknown direction: " + direction);
        }
    }

    View findNextFocusInAbsoluteDirection(ArrayList<View> focusables, ViewGroup root, View focused, 
                                                Rect focusedRect, int direction) {
        //①首先确定第一个最佳候选控件的位置。focusedRect即查找的起始位置
        mBestCandidateRect.set(focusedRect);
        ...
        //closest表示在指定的方向上距离起始位置最接近的一个控件
        View closest = null;
        
        int numFocusables = focusables.size();
        
        //遍历focusables列表进行查找
        for (int i = 0; i < numFocusables; i++) {
            View focusable = focusables.get(i);
            
            /*既然是查找下一个焦点控件，那么已经拥有焦点的控件自然不能算作候选者。另外根控件也不能作
            为候选对象*/
            if (focusable == focused || focusable == root) continue;
            
            /*②与获取起始位置一样，获取候选控件的位置。将其位置转换到根控件的坐标系中，以便能够与起始位置进行比较*/
            focusable.getFocusedRect(mOtherRect);
            root.offsetDescendantRectToMyCoords(focusable, mOtherRect);
            
            /*③通过ieBetterCandidate()方法比较现有的mBestCandidateRect与候选控件的位置。倘若
            候选控件的位置更佳，则设置候选控件为closest，设置候选控件的位置为mBesetCandidateRect。
            如此往复，当所有候选控件都经过比较之后，closest便是最后的查找结果。*/
            if (isBetterCandidate(direction, focusedRect, mOtherRect, mBestCandidateRect)) {
                mBestCandidateRect.set(mOtherRect);
                closest = focusable;
            }
        }
        //返回closest作为下一个焦点控件
        return closest;
    }

    public void onInputEvent(InputEvent event) {
        //通过enqueueInputEvent将输入事件入队，注意第四个参数为true
        enqueueInputEvent (event, this, 0, true);
    }

    void enqueueInputEvent(InputEvent event, InputEventReceiver receiver, 
                                int flags, boolean processImmediately) {
        /*①将InputEvent对应的InputEventReceiver封装为一个QueuedInputEvent。
            QueuedInputEvent将是输入事件在ViewRootImpl中的存在形式*/
        QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);
        
        /*②将新建的QueuedInputEvent追加到mFirstPendingInputEvent所表示的一个单向链表的尾部。
            ViewRootImpl将会沿着链表从头至尾地逐个处理输入事件*/
        QueuedInputEvent last = mFirstPendingInputEvent;
        
        if (last == null) {
            mFirstPendingInputEvent = q;
        } else {
            while(last.mNext != null) {
                last = last.mNext;
            }
            last.mNext = q;
        }
        
        if (processImmediately) {
            //③倘若第四个参数为true，则直接在当前线程中开始对输入事件的处理工作
            doProcessInputEvents();
        } else {
            //④否则将处理事件的请求发送给主线程的Handler，随后进行处理
            scheduleProcessInputEvents();
        }
    }

    void  doProcessInputEvents() {
        // 遍历整个输入事件队列，逐个处理这些事件
        // 判断mCurrentInputEvent是否为null的原因是，如果最后没有调用finishInputEvent()就不会再收到新的输入事件，
        // 也就是说当调用finishInputEvent()里会在从MessageQueue中取出一个输入事件，再次回调用onInputEvent()，
        // 而此时还没有执行到mCurrentInputEvent=null，所以加入这个判断就不会发生递归调用的错误。
        while (mCurrentInputEvent == null && mFirstPendingInputEvent != null) {
            QueuedInputEvent q = mFirstPendingInputEvent;
            mFirstPendingInputEvent = q.mNext;
            q.mNext = null;
            
            //①正在处理的输入事件会被保存为mCurrentInputEvent
            mCurrentInputEvent = q;
            
            //②deliverInputEvent()方法将会完成单个事件的整个处理流程
            deliverInputEvent(q);
        }
    }

    private void deliverInputEvent(QueuedInputEvent q) {
        try{
            if (q.mEvent instanceof KeyEvent) {
                //处理按键事件
                deliverKeyEvent(q);
            }else{
                final int source = q.mEvent.getSource();
                if  ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
                    //处理触摸事件
                    deliverPointerEvent(q);
                } else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
                    //处理轨迹球事件
                    deliverTrackballEvent(q);
                }else{
                    //处理其他Motion事件，如悬浮(HOVER)、游戏手柄等
                    deliverGenericMotionEvent(q);
                }
            }
        } finally {...}
    }

    private void finishInputEvent(QueuedInputEvent q, boolean handled) {
        /*倘若被完成的输入事件不是mCurrentInputEvent，则抛出异常。 ViewRootImpl不允许事件的嵌套处理*/
        if (q != mCurrentInputEvent) {
            throw new IllegalStateException("finished input event out of order");
        }

        //①回收输入事件并向InputDispatcher发送反馈
        if (q.mReceiver != null) {
            /*如果rnReceiver不为null，表示这是一个来自InputDispatcher的事件，需要向InputDispatcher 发送反馈。事件实例的回收由InputEventReceiver托管完成．*/
            q.mReceiver.finishInputEvent(q.mEvent, handled);
        } else {
            /*如果mReceiver为null，表示这是ViewRootImpl自行创建的事件，此时只要将事件实例回收即可。 不需要惊动InputDispatcher*/
            q.mEvent.recycleIfNeededAfterDispatch();
        }

        /*②回收不再有效的QueuedInputEvent实例。被回收的实例会组成一个以mQueuedInputEventPool为
            头部的单向链表中。下次使用obtainQueuedInputEvent()时可以复用这个实例*/
        recycleQueuedInputEvent(q);

        // 设置mCurrentInputEvent为null
        mCurrentInputEvent = null;

        //如果队列中有了新的输入事件，则重新启动输入事件的派发
        if (mFirstPendingInputEvent != null) {
            scheduleProcessInputEvents();
        }
    }

    void scheduleConsumeBatchedInput() {
        if (!mConsumeBatchedInputScheduled) {
            mConsumeBatchedInputScheduled = true;
            mChoreographer.postCallback(Choreographer.CALLBACK_INPUT, mConsumedBatchedInputRunnable, null);
        }
    }

    void doConsumeBatchedInput(long frameTimeNanos) {
        if (mConsumeBatchedInputScheduled) {
            mConsumeBatchedInputScheduled = false;
            if (mInputEventReceiver != null) {
Consumes all pending batched input events.
Must be called on the same Looper thread to which the receiver is attached.
This method forces all batched input events to be delivered immediately.
                mInputEventReceiver.consumeBatchedInputEvents(frameTimeNanos);
            }
            doProcessInputEvents();
        }
    }

    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
            mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            
            scheduleConsumeBatchedInput();
        }
    }

    final class WindowInputEventReceiver extends InputEventReceiver {
        public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {
            super(inputChannel, looper);
        }

        @Override
        public void onInputEvent(InputEvent event) {
            enqueueInputEvent(event, this, 0, true);
        }


Called when a batched input event is pending. 
The batched input event will continue to accumulate additional movement samples(收集额外的运动样本) until the recipient(接受者) calls consumeBatchedInputEvents 
 or an event is received that ends the batch and causes it to be consumed immediately (such as a pointer up event).
        @Override
        public void onBatchedInputEventPending() {
            scheduleConsumeBatchedInput();
        }

        @Override
        public void dispose() {
            unscheduleConsumeBatchedInput();
            super.dispose();
        }
    }