[Android]Android焦點流程代碼分析

以下內容為原創，歡迎轉載，轉載請註明

通過View的View::focusSearch進行焦點搜索對應方向上的下一個可以獲取焦點的View：

public View focusSearch(@FocusRealDirection int direction) {
if (mParent != null) {
return mParent.focusSearch(this, direction);
} else {
return null;
}
}

不斷地調用父控制項來進行搜索，focusSearch有兩個實現：ViewGroup和RecyclerView，先看ViewGroup：

@Override
public View focusSearch(View focused, int direction) {
if (isRootNamespace) {
// root namespace means we should consider ourselves the top of the
// tree for focus searching; otherwise we could be focus searching
// into other tabs. see LocalActivityManager and TabHost for more info
return FocusFinder.getInstance.findNextFocus(this, focused, direction);
} else if (mParent != null) {
return mParent.focusSearch(focused, direction);
}
return null;
}

如果是最頂層，則直接調用FocusFinder::findNextFocus方法進行搜索；否則調用父控制項的focusSearch。FocusFinder::findNextFocus如下：

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;
root.addFocusables(focusables, direction);
if (!focusables.isEmpty) {
next = findNextFocus(root, focused, focusedRect, direction, focusables);
}
} finally {
focusables.clear;
}
return next;
}

上面的root參數代表的是最頂層的view。

首先，通過嘗試通過findNextUserSpecifiedFocus來查找下一個「指定的」可獲得焦點的View，這個指定是開發者通過SDK自帶的setNextFocusLeftId等方法進行手動設置的。如果查找到指定的下一個可獲得焦點的View，則返回該View；否則，執行View::addFocusables方法，通過這個最頂層的View去拿到所有直接或間接的Focusable的子View，並添加到ArrayList<View> focusables中。

View::addFolcusables方法中有4種實現：

第一種是View中默認實現：

public void addFocusables(ArrayList<View> views, @FocusDirection int direction,
@FocusableMode int focusableMode) {
if (views == null) {
return;
}
if (!isFocusable) {
return;
}
if ((focusableMode & FOCUSABLES_TOUCH_MODE) == FOCUSABLES_TOUCH_MODE
&& !isFocusableInTouchMode) {
return;
}
views.add(this);
}

如果自己是focusable的話，直接把自己添加進去。

第二種是ViewGroup實現：

@Override
public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
final int focusableCount = views.size;

// we add ourselves (if focusable) in all cases except for when we are
// FOCUS_AFTER_DESCENDANTS and there are some descendants focusable. this is
// to avoid the focus search finding layouts when a more precise search
// among the focusable children would be more interesting.
if ((descendantFocusability != FOCUS_AFTER_DESCENDANTS
// No focusable descendants
|| (focusableCount == views.size)) &&
(isFocusableInTouchMode || !shouldBlockFocusForTouchscreen)) {
super.addFocusables(views, direction, focusableMode);
}
}

先會處理自身ViewGroup與它後代的關係(descendantFocusability)，前面提到過，可能的幾種情況：

• FOCUS_BEFORE_DESCENDANTS

  : ViewGroup本身先對焦點進行處理，如果沒有處理則分發給child View進行處理

• FOCUS_AFTER_DESCENDANTS

  : 先分發給Child View進行處理，如果所有的Child View都沒有處理，則自己再處理

• FOCUS_BLOCK_DESCENDANTS

  : ViewGroup本身進行處理，不管是否處理成功，都不會分發給ChildView進行處理

所以，以上：

1. 如果不是FOCUS_BLOCK_DESCENDANTS，則首先檢查blockForTouchscreen並重置掉focusableMode，然後遍歷所有的子View，調用child::addFocusables。
2. 如果不是FOCUS_AFTER_DESCENDANTS或者沒有focusable的子View時自己處理，所以把自己加入到views中。

第三種是ViewPager實現：

@Override
public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
final int focusableCount = views.size;

// we add ourselves (if focusable) in all cases except for when we are
// FOCUS_AFTER_DESCENDANTS and there are some descendants focusable. this is
// to avoid the focus search finding layouts when a more precise search
// among the focusable children would be more interesting.
if (descendantFocusability != FOCUS_AFTER_DESCENDANTS
|| (focusableCount == views.size)) { // No focusable descendants
// Note that we can"t call the superclass here, because it will
// add all views in. So we need to do the same thing View does.
if (!isFocusable) {
return;
}
if ((focusableMode & FOCUSABLES_TOUCH_MODE) == FOCUSABLES_TOUCH_MODE
&& isInTouchMode && !isFocusableInTouchMode) {
return;
}
if (views != null) {
views.add(this);
}
}
}

與ViewGroup基本一致，在descendantFocusability不是FOCUS_BLOCK_DESCENDANTS時，遍歷子View時判斷view是否屬於當前的page，如果是才加進去。如果不是FOCUS_AFTER_DESCENDANTS或者沒有focusable的子View時自己處理，所以把自己加入到views中。

第四種是RecyclerView實現：

@Override
public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
if (mLayout == null || !mLayout.onAddFocusables(this, views, direction, focusableMode)) {
super.addFocusables(views, direction, focusableMode);
}
}

通過LayoutManager::onAddFocusables來進行管理，如果返回false，則直接調用父類ViewGroup的方法，看下LayoutManager::onAddFocusables的實現：

public boolean onAddFocusables(RecyclerView recyclerView, ArrayList<View> views,
int direction, int focusableMode) {
return false;
}

直接返回false，並且沒有看到相關的LayoutManager對該方法的重寫，所以，這裡應該是直接調用了父類ViewGroup的方法。

addFocusables方法完畢，回到FocusFinder::findNextFocus方法中通過root.addFocusables(focusables, direction);加入所有可獲取焦點的View之後，在非空的情況下調用如下代碼：

next = findNextFocus(root, focused, focusedRect, direction, focusables);

所以重點是FocusFinder::findNextFocus方法的實現：

private View findNextFocus(ViewGroup root, View focused, Rect focusedRect,
int direction, ArrayList<View> focusables) {
if (focused != null) {
if (focusedRect == null) {
focusedRect = mFocusedRect;
}
// fill in interesting rect from focused
focused.getFocusedRect(focusedRect);
root.offsetDescendantRectToMyCoords(focused, focusedRect);
} else {
if (focusedRect == null) {
focusedRect = mFocusedRect;
// make up a rect at top left or bottom right of root
switch (direction) {
case View.FOCUS_RIGHT:
case View.FOCUS_DOWN:
setFocusTopLeft(root, focusedRect);
break;
case View.FOCUS_FORWARD:
if (root.isLayoutRtl) {
setFocusBottomRight(root, focusedRect);
} else {
setFocusTopLeft(root, focusedRect);
}
break;

switch (direction) {
case View.FOCUS_FORWARD:
case View.FOCUS_BACKWARD:
return findNextFocusInRelativeDirection(focusables, root, focused, focusedRect,
direction);
case View.FOCUS_UP:
case View.FOCUS_DOWN:
case View.FOCUS_LEFT:
case View.FOCUS_RIGHT:
return findNextFocusInAbsoluteDirection(focusables, root, focused,
focusedRect, direction);
default:
throw new IllegalArgumentException("Unknown direction: " + direction);
}
}

• 如果focused不是null，說明當前獲取到焦點的View存在，則獲得繪製焦點的Rect到focusedRect，然後根據rootView遍歷所有ParentView從子View糾正坐標到根View坐標。
• 如果focused是null，則說明當前沒有View獲取到焦點，則把focusedRect根據不同的direction重置為「一點」。

最後根據direction調用FocusFinder::findNextFocusInAbsoluteDirection方法進行對比查找「下一個」View。

View findNextFocusInAbsoluteDirection(ArrayList<View> focusables, ViewGroup root, View focused,
Rect focusedRect, int direction) {
// initialize the best candidate to something impossible
// (so the first plausible view will become the best choice)
mBestCandidateRect.set(focusedRect);
switch(direction) {
case View.FOCUS_LEFT:
mBestCandidateRect.offset(focusedRect.width + 1, 0);
break;
case View.FOCUS_RIGHT:
mBestCandidateRect.offset(-(focusedRect.width + 1), 0);
break;
case View.FOCUS_UP:
mBestCandidateRect.offset(0, focusedRect.height + 1);
break;
case View.FOCUS_DOWN:
mBestCandidateRect.offset(0, -(focusedRect.height + 1));
}

if (isBetterCandidate(direction, focusedRect, mOtherRect, mBestCandidateRect)) {
mBestCandidateRect.set(mOtherRect);
closest = focusable;
}
}
return closest;
}

首先把最優選擇mBestCandidateRect設置為focusedRect，根據方向做1像素的偏移便於對比。遍歷所有剛剛查詢出來的focusables，拿到每一個的focusedRect區域並進行轉換，然後通過FocusFinder::isBetterCandidate方法進行對比，然後拿到更好的，遍歷完成後就是最優選擇。接下來看下FocusFinder::isBetterCandidate方法來了解下是怎麼做對比的：

下面代碼意思是：以source這個rect來說，作為對應derection上下一個focus view，rect1是否比rect2更優？

boolean isBetterCandidate(int direction, Rect source, Rect rect1, Rect rect2) {

// otherwise, do fudge-tastic comparison of the major and minor axis
return (getWeightedDistanceFor(
majorAxisDistance(direction, source, rect1),
minorAxisDistance(direction, source, rect1))
< getWeightedDistanceFor(
majorAxisDistance(direction, source, rect2),
minorAxisDistance(direction, source, rect2)));
}

首先確定rect1是否isCandidate？isCandidate做的邏輯簡單來說就是確定rect是否滿足給定的derection作為下一個focus view這個條件，它的判斷依據如下：

boolean isCandidate(Rect srcRect, Rect destRect, int direction) {
switch (direction) {
case View.FOCUS_LEFT:
return (srcRect.right > destRect.right || srcRect.left >= destRect.right)
&& srcRect.left > destRect.left;
case View.FOCUS_RIGHT:
return (srcRect.left < destRect.left || srcRect.right <= destRect.left)
&& srcRect.right < destRect.right;
case View.FOCUS_UP:
return (srcRect.bottom > destRect.bottom || srcRect.top >= destRect.bottom)
&& srcRect.top > destRect.top;
case View.FOCUS_DOWN:
return (srcRect.top < destRect.top || srcRect.bottom <= destRect.top)
&& srcRect.bottom < destRect.bottom;
}
throw new IllegalArgumentException("direction must be one of "
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
}

代碼比較簡單。再回到 FocusFinder::isBetterCandidate的代碼邏輯：

• 如果rect1不滿足基本條件，則肯定返回false（基本的條件都不滿足）
• 如果rect2不滿足基本條件，則返回true，認為rect1更優
• 如果都滿足基本條件的情況下，通過FocusFinder::beamBeats方法來判斷哪種更優

接下來看下FocusFinder::beamBeats的實現：

boolean beamBeats(int direction, Rect source, Rect rect1, Rect rect2) {
final boolean rect1InSrcBeam = beamsOverlap(direction, source, rect1);
final boolean rect2InSrcBeam = beamsOverlap(direction, source, rect2);

// for vertical directions, beams only beat up to a point:
// now, as long as rect2 isn"t completely closer, rect1 wins
// e.g for direction down, completely closer means for rect2"s top
// edge to be closer to the source"s top edge than rect1"s bottom edge.
return (majorAxisDistance(direction, source, rect1)
< majorAxisDistanceToFarEdge(direction, source, rect2));
}

首先通過beamsOverlap方法來判斷兩個rect與source是否重疊等等。注意的是，在水平情況下，如果rect1重疊，則就是最優解（為什麼？比較奇怪），最後如果是豎直情況，通過FocusFinder::majorAxisDistance方法來判斷哪個離source最近。如果還是比較不出，則通過getWeightedDistanceFor方法來通過「主要距離」和「次要距離」做一個綜合的比較。

繼續 focusSearch代碼的分析，剛剛只跟了ViewGroup，還有一個實現是RecyclerView的實現：

@Override
public View focusSearch(View focused, int direction) {
View result = mLayout.onInterceptFocusSearch(focused, direction);
if (result != null) {
return result;
}
// ...
}

首先通過onInterceptFocusSearch進行攔截，如果返回具體的focus View，則直接返回；否則繼續往下；onInterceptFocusSearch實現如下：

public View onInterceptFocusSearch(View focused, int direction) {
return null;
}

默認為空實現，返回null，也沒有其它的子類進行重寫，所以暫時不管這個處理，繼續看focusSearch：

@Override
public View focusSearch(View focused, int direction) {
View result = mLayout.onInterceptFocusSearch(focused, direction);
if (result != null) {
return result;
}
final boolean canRunFocusFailure = mAdapter != null && mLayout != null
&& !isComputingLayout && !mLayoutFrozen;

final FocusFinder ff = FocusFinder.getInstance;
if (canRunFocusFailure
&& (direction == View.FOCUS_FORWARD || direction == View.FOCUS_BACKWARD)) {
// convert direction to absolute direction and see if we have a view there and if not
// tell LayoutManager to add if it can.
boolean needsFocusFailureLayout = false;
if (mLayout.canScrollVertically) {
final int absDir =
direction == View.FOCUS_FORWARD ? View.FOCUS_DOWN : View.FOCUS_UP;
final View found = ff.findNextFocus(this, focused, absDir);
needsFocusFailureLayout = found == null;
if (FORCE_ABS_FOCUS_SEARCH_DIRECTION) {
// Workaround for broken FOCUS_BACKWARD in API 15 and older devices.
direction = absDir;
}
}
if (!needsFocusFailureLayout && mLayout.canScrollHorizontally) {
boolean rtl = mLayout.getLayoutDirection == ViewCompat.LAYOUT_DIRECTION_RTL;
final int absDir = (direction == View.FOCUS_FORWARD) ^ rtl
? View.FOCUS_RIGHT : View.FOCUS_LEFT;
final View found = ff.findNextFocus(this, focused, absDir);
needsFocusFailureLayout = found == null;
if (FORCE_ABS_FOCUS_SEARCH_DIRECTION) {
// Workaround for broken FOCUS_BACKWARD in API 15 and older devices.
direction = absDir;
}
}
if (needsFocusFailureLayout) {
consumePendingUpdateOperations;
final View focusedItemView = findContainingItemView(focused);
if (focusedItemView == null) {
// panic, focused view is not a child anymore, cannot call super.
return null;
}
eatRequestLayout;
mLayout.onFocusSearchFailed(focused, direction, mRecycler, mState);
resumeRequestLayout(false);
}
result = ff.findNextFocus(this, focused, direction);
} else {
result = ff.findNextFocus(this, focused, direction);
if (result == null && canRunFocusFailure) {
consumePendingUpdateOperations;
final View focusedItemView = findContainingItemView(focused);
if (focusedItemView == null) {
// panic, focused view is not a child anymore, cannot call super.
return null;
}
eatRequestLayout;
result = mLayout.onFocusSearchFailed(focused, direction, mRecycler, mState);
resumeRequestLayout(false);
}
}
if (result != null && !result.hasFocusable) {
if (getFocusedChild == null) {
// Scrolling to this unfocusable view is not meaningful since there is no currently
// focused view which RV needs to keep visible.
return super.focusSearch(focused, direction);
}
// If the next view returned by onFocusSearchFailed in layout manager has no focusable
// views, we still scroll to that view in order to make it visible on the screen.
// If it"s focusable, framework already calls RV"s requestChildFocus which handles
// bringing this newly focused item onto the screen.
requestChildOnScreen(result, null);
return focused;
}
return isPreferredNextFocus(focused, result, direction)
? result : super.focusSearch(focused, direction);
}

我們暫時只考慮direction為left，top，right，down的情況，則進入最外面if的else分支：

public View focusSearch(View focused, int direction) {
// ...
result = ff.findNextFocus(this, focused, direction);
if (result == null && canRunFocusFailure) {
consumePendingUpdateOperations;
final View focusedItemView = findContainingItemView(focused);
if (focusedItemView == null) {
// panic, focused view is not a child anymore, cannot call super.
return null;
}
eatRequestLayout;
result = mLayout.onFocusSearchFailed(focused, direction, mRecycler, mState);
resumeRequestLayout(false);
}
// ...
}

首先通過FocusFinder::findNextFocus方法來獲取下一個應該獲得焦點的View，這裡獲取的結果與FocusFinder::findNextFocus邏輯一致。

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！