• 0

  • 491

从 Android 开发到读懂源码 第01期:requestFocus 源码分析

Mellon

大家好

1星期前

各位好,从今天开始,将带来几期关于 Android 源码解析的文章,感谢你的阅读,也可以关注公众号,欢迎加群一起和大佬互相交流学习。

这节内容我们先从 requestFocus 入手:
在开发过程中,我们需要某个控件 View 进行聚焦,一般会主动调用该控件的 requestFocus 方法。(本文基于 API 27 源码进行分析)
<View.java>
public final boolean requestFocus() {    // 默认使用 FOCUS_DOWN 进行聚焦    
    return requestFocus(View.FOCUS_DOWN);
}
复制代码
我们从源码中可以看到,requestFocus 接着会走到 requestFocusNoSearch 方法中,看方法名就能理解,因为我们是直接 requestFocus,意图就是指定某个 View 获得焦点,所以不需要走寻焦机制:
<View.java>
private boolean requestFocusNoSearch(int direction, Rect previouslyFocusedRect) {
    // need to be focusable    
    // 如果该 view 设置的 focusable = false,直接返回    
    if ((mViewFlags & FOCUSABLE) != FOCUSABLE
            || (mViewFlags & VISIBILITY_MASK) != VISIBLE) {
        return false;
    }
    // need to be focusable in touch mode if in touch mode
    // 触摸模式下
    if (isInTouchMode() &&
        (FOCUSABLE_IN_TOUCH_MODE != (mViewFlags & FOCUSABLE_IN_TOUCH_MODE))) {
           return false;// 如果该 view 设置的 focusableInTouchMode = false,直接返回
    }
    // need to not have any parents blocking us
    if (hasAncestorThatBlocksDescendantFocus()) {
        return false;// 如果 parent 中设置了 FOCUS_BLOCK_DESCENDANTS,直接返回
    }
    handleFocusGainInternal(direction, previouslyFocusedRect);
    return true;// 聚焦成功
}
复制代码

1 requestFocusNoSearch

方法 requestFocusNoSearch 的大致功能如下:
  • 首先第一步会判断当前 View 的 focusable 状态,如果是 false,说明该 View并不能获取焦点,也就没有必要再往下走了。
  • 接着会判断是否触摸模式,在触摸模式下,如果 focusableInTouchMode 是 false 的话,也说明该 View 通过触摸并不能获取焦点,也没必要往下走了。
  • 继续看下面一个判断 hasAncestorThatBlocksDescendantFocus() 方法:
<View.java>
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;
}
复制代码

2 hasAncestorThatBlocksDescendantFocus

再来看下 hasAncestorThatBlocksDescendantFocus,这个方法也就是遍历 parent 父 View 查找是否有设置 FOCUS_BLOCK_DESCENDANTS,如果设置了,说明父 View 把焦点传递给拦截了,并不希望自己获得焦点,因此该方法会返回 true。回到 requestFocusNoSearch 中,也就直接 return 不往下走了。
经过一系列的条件判断,如果可聚焦,并且父 View 未拦截焦点,最终会走到核心方法 handleFocusGainInternal 中:
<View.java>
void handleFocusGainInternal(@FocusRealDirection int direction, Rect previouslyFocusedRect) {
    if (DBG) {
        System.out.println(this + " requestFocus()");
    }
    if ((mPrivateFlags & PFLAG_FOCUSED) == 0) {
        mPrivateFlags |= PFLAG_FOCUSED;// 更新标记位(isFocused判断依据)
        // 当前状态下的焦点
        View oldFocus = (mAttachInfo != null) ? getRootView().findFocus() : null;
        if (mParent != null) {
            mParent.requestChildFocus(this, this);// 清除当前焦点,将 mFocus 变量更新值为当前期望聚焦的 view
            updateFocusedInCluster(oldFocus, direction);// android 高版本新增的方法,此方法和键盘相关,在此不作重点关注
        }
        if (mAttachInfo != null) {
            // 通知 ViewTreeObserver 焦点变化
            mAttachInfo.mTreeObserver.dispatchOnGlobalFocusChange(oldFocus, this);
        }
        onFocusChanged(true, direction, previouslyFocusedRect);// 通知焦点变化回调
        refreshDrawableState();// 当前 view 聚焦,刷新 drawable 状态
    }
}
复制代码

3 handleFocusGainInternal

而对于 handleFocusGainInternal 这个方法,首先会更新当前 View 的标记位 mPrivateFlags 记录自己的 isFocused 状态,接着通过 rootView 查找到当前的焦点赋值给 oldFocus,然后调用 parent 的 requestChildFocus 方法告知 parent 自己当前聚焦啦。
<ViewGroup.java>
@Override
public void requestChildFocus(View child, View focused) {
    if (DBG) {
        System.out.println(this + " requestChildFocus()");
    }
    // 再次判断是否设置了 FOCUS_BLOCK_DESCENDANTS
    if (getDescendantFocusability() == FOCUS_BLOCK_DESCENDANTS) {
        return;
    }
    // Unfocus us, if necessary
    super.unFocus(focused);
    // We had a previous notion of who had focus. Clear it.
    if (mFocused != child) {
        if (mFocused != null) {
            mFocused.unFocus(focused);
        }
        mFocused = child;
    }
    if (mParent != null) {
        mParent.requestChildFocus(this, focused);
    }
}
复制代码

4 requestChildFocus

在 requestChildFocus 这个方法里,focused 这个参数其实没用到(unFocus 作为形参传入,其实里面也根本没用到该参数),在上面第一次调用时传入的都是 this,这个 focused 实际上就是直接的焦点,child 在第一次调用时也是直接焦点,child == focused,但是通过 mParent.requestChildFocus(this, focused);后,child 这个参数就变成了直接焦点的父 View,一层一层往上进行调用以此类推,这里要重点区分下两个参数含义。下面是官方对该参数的注释:
<ViewParent.java>
    /**
     * Called when a child of this parent wants focus
     *
     * @param child The child of this ViewParent that wants focus. This view
     *        will contain the focused view. It is not necessarily the view that
     *        actually has focus.
     * @param focused The view that is a descendant of child that actually has
     *        focus
     */
    public void requestChildFocus(View child, View focused);
复制代码
在每个 ViewGroup 中都有一个 mFocus 变量,该变量的作用就是保存着当前 ViewGroup 下的焦点,并非直接焦点。(官方对这个变量含义的注释:The view contained within this ViewGroup that has or contains focus.)接着回到这个 requestChildFocus(View child, View focused)方法接着往下看,具体逻辑是:
  • 再次判断是否设置了 FOCUS_BLOCK_DESCENDANTS,如果拦截则不继续往下走。
  • 一般情况下,当前焦点 mFocused 都和我们期望聚焦的 view 并非同一个,则进入分支调用 mFocused.unFocus(focused)
<View.java>
void unFocus(View focused) {
    if (DBG) {
        System.out.println(this + " unFocus()");
    }
    clearFocusInternal(focused, false, false);
}
// 最终调用这个方法
void clearFocusInternal(View focused, boolean propagate, boolean refocus) {
    // 其实没用到focused这个参数
    if ((mPrivateFlags & PFLAG_FOCUSED) != 0) {
        mPrivateFlags &= ~PFLAG_FOCUSED;
        if (propagate && mParent != null) {
            mParent.clearChildFocus(this);// 通知 parent 清除自己(当前的焦点)的 mFocus 值,因为焦点已经不在该 View 树节点下
        }
        onFocusChanged(false, 0, null);// 回调焦点状态变更的通知
        refreshDrawableState();// 刷新失去焦点后的 drawable 状态
        if (propagate && (!refocus || !rootViewRequestFocus())) {
            notifyGlobalFocusCleared(this);
        }
    }
}
复制代码

5 clearFocusInternal

最后再来聊聊 clearFocusInternal,这个方法是 mFocus 进行调用的,也就是对当前的焦点所在的 View 进行清除焦点状态处理,主要做了下面几件事:
  • 通知 parent 调用 clearChildFocus 将 mFocus 变量置 null,因为焦点已经不在该 View 树节点下。
  • 回调自身的焦点状态变更的通知,我们通常所设置的 setOnFocusChangeListener 的监听就是在这里面进行触发回调的。
  • 由于第 1 步中清除了自己的焦点状态,失焦之后自然需要刷新视图状态,这里会调用 refreshDrawableState 进行 drawableState 的刷新,也就是我们通常在 xml 中设置的 selector 状态属性。
**注意一点**:
这里面的 focused 参数其实根本没用到,但是这个 focused 才是真正最直接的焦点。
清除了当前焦点之后,回到 parent 的 requestChildFocus 中,将我们期望聚焦的 child 赋值给 mFocused,前面说过这个 mFocus 变量就是保存着当前的焦点,走到这步,我们调用 View.requestFocus 已经成功将焦点从 oldFocus 转移到 newFocus 上了。
<ViewGroup.java>
ViewGroup.requestChildFocus
...
// We had a previous notion of who had focus. Clear it.
if (mFocused != child) {
    if (mFocused != null) {
        mFocused.unFocus(focused);
    }
    mFocused = child;
}
if (mParent != null) {
    mParent.requestChildFocus(this, focused);
}
...
复制代码
接下去还会再次通过 parent 一层一层的告诉父 View,当前焦点在我这。也就是说某一个子 View 如果聚焦了,它会将自己赋值给 parent 的 mFocus 变量,这样下次查找焦点,就可以通过顶层的 parent 一级一级通过 mFocus 变量进行 findFocus 查找到最下层的直接焦点。这里展开一下 findFocus 方法就很明白了:
<ViewGroup.java>
@Override
public View findFocus() {
    if (DBG) {
        System.out.println("Find focus in " + this + ": flags="
                + isFocused() + ", child=" + mFocused);
    }
    // 如果当前 isFocused 了,说明我自己已经是焦点了,直接返回自己
    if (isFocused()) {
        return this;
    }
    // mFocus 不为 null,说明焦点在这个 mFocus 的 View 树下
    if (mFocused != null) {
        return mFocused.findFocus();
    }
    return null;
}

<View.java>
public View findFocus() {
    // 当遍历到直接子 View 之后就是根据标志位进行判断
    return (mPrivateFlags & PFLAG_FOCUSED) != 0 ? this : null;}
复制代码
举个例子:A 包含 B,B 包含 C,A 和 B 都是 ViewGroup,C 是直接 View,A 的 mFocus是 B,B 的 mFocus 是 C,注意一点,这里面只是说 mFocus != null,并不是说 A 和 B 的 isFocused 也是 true 的,要区别开 hasFocus 和 isFocused。这里一层层的往上走,最终会走到 ViewRootImpl 的 requestChildFocus 进行 UI 重绘。
<ViewGroup.java>
public boolean hasFocus() {
    return (mPrivateFlags & PFLAG_FOCUSED) != 0 || mFocused != null;
}

<ViewRootImpl.java>
@Overridepublic void requestChildFocus(View child, View focused) {
    if (DEBUG_INPUT_RESIZE) {
        Log.v(mTag, "Request child focus: focus now " + focused);
    }
    checkThread();
    scheduleTraversals();// UI 重绘
}
复制代码
回到上面,handleFocusGainInternal 中的 mPrivateFlags |= PFLAG_FOCUSED;这里修改了标记位,实际上 isFocused 就是通过这个标记位进行判断的。
<View.java>
@ViewDebug.ExportedProperty(category = "focus")
public boolean isFocused() {
    return (mPrivateFlags & PFLAG_FOCUSED) != 0;
}
复制代码
至此,View.requestFocus 的调用流程结束,焦点已经从之前的 oldFocus 转移到新的 newFocus 上了。接下来,我们继续分析下 ViewGroup.requestFocus 方法:
<ViewGroup.java>
@Override
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
    if (DBG) {
        System.out.println(this + " ViewGroup.requestFocus direction="
                + direction);
    }
    int descendantFocusability = getDescendantFocusability();
    // 主要还是看 ViewGroup 设置的焦点拦截模式
    switch (descendantFocusability) {
        case FOCUS_BLOCK_DESCENDANTS:// 拦截掉了焦点,直接调用 super 的逻辑在自己中 requestFocus
            return super.requestFocus(direction, previouslyFocusedRect);
        case FOCUS_BEFORE_DESCENDANTS: {// 首先调用 super 的逻辑在自己中 requestFocus,如果自己请求焦点失败再遍历子 View 进行 requestFocus
            final boolean took = super.requestFocus(direction, previouslyFocusedRect);
            return took ? took : onRequestFocusInDescendants(direction, previouslyFocusedRect);
        }
        case FOCUS_AFTER_DESCENDANTS: {// 与 FOCUS_BEFORE_DESCENDANTS 相反,先遍历子 View 进行 requestFocus,如果子 View 都请求焦点失败后再调用 super 的逻辑在自己中 requestFocus
            final boolean took = onRequestFocusInDescendants(direction, previouslyFocusedRect);
            return took ? took : super.requestFocus(direction, previouslyFocusedRect);
        }
        default:
            throw new IllegalStateException("descendant focusability must be "
                    + "one of FOCUS_BEFORE_DESCENDANTS, FOCUS_AFTER_DESCENDANTS, FOCUS_BLOCK_DESCENDANTS "
                    + "but is " + descendantFocusability);
    }
}
复制代码
这里面的逻辑还是很清晰的,主要判断依据就是焦点拦截模式 descendantFocusability:
  • FOCUS_BLOCK_DESCENDANTS:自身拦截掉焦点,直接对自己进行 requestFocus 调用去请求焦点;
  • FOCUS_BEFORE_DESCENDANTS:自身优先子 View 获得焦点,先对自己进行 requestFocus 调用去请求焦点,如果失败再遍历子 View 让子 View 进行聚焦;
  • FOCUS_AFTER_DESCENDANTS:先遍历子 View 让子 View 进行聚焦,如果子 View 都没有聚焦,则再对自己进行 requestFocus 调用去请求焦点。
下面我们看下 onRequestFocusInDescendants 里做了些什么:
<ViewGroup.java>
protected boolean onRequestFocusInDescendants(int direction,
        Rect previouslyFocusedRect) {
    int index;
    int increment;
    int end;
    int 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;// mChildren 数组中保存了所有的 childView
    for (int i = index; i != end; i += increment) {
        View child = children[i];
        if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {// 遍历子 View,并且 View 可见
            if (child.requestFocus(direction, previouslyFocusedRect)) {// 该子 View 请求焦点
                return true;// 请求焦点成功,直接返回
            }
        }
    }
    return false;
}
复制代码
onRequestFocusInDescendants 主要功能就是遍历该 ViewGroup 下所有子 View,然后对可见的子 View 调用 requestFocus,如果请求焦点成功,则直接返回 true,至此,ViewGroup.requestFocus 也处理完毕了。

欢迎加入 Android 交流社群

群内不定期邀请一些身边的 Android 大牛

交流分享,解答工作中遇到的的问题

分享工作经验、面试技巧等!

也欢迎各位大牛投稿,内容可以是数据库、开发、运维、产品、运营等!

悦专栏 LIKECOLUMN

在这里,学好编程

做更优秀的 IT人!

免责声明:文章版权归原作者所有,其内容与观点不代表Unitimes立场,亦不构成任何投资意见或建议。

android

491

相关文章推荐

未登录头像

暂无评论