由FocusChange引发的问题手札

这次碰见了Fragment.replace后发生的focus改变问题。

这个问题是用户用蓝牙键盘的Enter键点击了某个tabContent的内容，该内容由ListFragment来展现，切换的方式是ft.replace。所以发生了显示异常问题（显示的不是所点item对应的内容，而是tab0的内容）。

Fragment fg = AListFragment.getNewInstance(subList, mListMode, mHeaderMode, key, mPlaylistId);
FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.replace(android.R.id.tabcontent, fg, Integer.toString(subList));
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
ft.addToBackStack(Integer.toString(subList));
ft.commit();

FragmentTransaction的replace最终会引起 removeFragment，而removeFragment就会进而removeFocus。

onTabChanged: tabId= 131073
java.lang.RuntimeException
at com.samsung.musicplus.contents.extra.MusicSelectListTabActivity.onTabChanged(MusicSelectListTabActivity.java:236)
at android.widget.TabHost.invokeOnTabChangeListener(TabHost.java:462)
at android.widget.TabHost.setCurrentTab(TabHost.java:442)
at android.widget.TabHost$2.onTabSelectionChanged(TabHost.java:194)
at android.widget.TabWidget.onFocusChange(TabWidget.java:683)
at android.view.View.onFocusChanged(View.java:6278)
at android.widget.TextView.onFocusChanged(TextView.java:9559)
at android.view.View.handleFocusGainInternal(View.java:6004)
at android.view.View.requestFocusNoSearch(View.java:9077)
at android.view.View.requestFocus(View.java:9056)
at android.widget.HorizontalScrollView.onRequestFocusInDescendants(HorizontalScrollView.java:2056)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)
at android.view.View.requestFocus(View.java:9023)
at android.view.View.requestFocus(View.java:9002)
at android.view.View.rootViewRequestFocus(View.java:6177)
at android.view.ViewGroup.removeViewInternal(ViewGroup.java:4968)
at android.view.ViewGroup.removeViewInternal(ViewGroup.java:4928)
at android.view.ViewGroup.removeView(ViewGroup.java:4859)
at android.app.FragmentManagerImpl.moveToState(FragmentManager.java:1084)
at android.app.FragmentManagerImpl.removeFragment(FragmentManager.java:1275)
at android.app.BackStackRecord.run(BackStackRecord.java:744)
at android.app.FragmentManagerImpl.execPendingActions(FragmentManager.java:1557)
at android.app.FragmentManagerImpl$1.run(FragmentManager.java:488)
at android.os.Handler.handleCallback(Handler.java:739)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:148)
at android.app.ActivityThread.main(ActivityThread.java:7331)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1230)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:1120)

下面我们针对Stack来细看代码流程：

从Fragment的removeFragment开始看吧。

public void removeFragment(Fragment fragment, int transition, int transitionStyle) {
if (DEBUG) Log.v(TAG, "remove: " + fragment + " nesting=" + fragment.mBackStackNesting);
final boolean inactive = !fragment.isInBackStack();
if (!fragment.mDetached || inactive) {
if (false) {
// Would be nice to catch a bad remove here, but we need
// time to test this to make sure we aren't crashes cases
// where it is not a problem.
if (!mAdded.contains(fragment)) {
throw new IllegalStateException("Fragment not added: " + fragment);
}
}
if (mAdded != null) {
mAdded.remove(fragment);
}
if (fragment.mHasMenu && fragment.mMenuVisible) {
mNeedMenuInvalidate = true;
}
fragment.mAdded = false;
fragment.mRemoving = true;
moveToState(fragment, inactive ? Fragment.INITIALIZING : Fragment.CREATED,
transition, transitionStyle, false);
}
}

一直走到 moveToState中的 Fragment.ACTIVITY_CREATED，这里的switch case全然不用break和return，很奇怪

void moveToState(Fragment f, int newState, int transit, int transitionStyle,
boolean keepActive) {
if (f.mState < newState) {
switch (f.mState) {
case Fragment.INITIALIZING:
case Fragment.CREATED:
case Fragment.ACTIVITY_CREATED:
case Fragment.STOPPED:
case Fragment.STARTED:
}
} else if (f.mState > newState) {
switch (f.mState) {
case Fragment.RESUMED:
case Fragment.STARTED:
case Fragment.STOPPED:
case Fragment.ACTIVITY_CREATED:
if (newState < Fragment.ACTIVITY_CREATED) {
if (DEBUG) Log.v(TAG, "movefrom ACTIVITY_CREATED: " + f);
if (f.mView != null) {
// Need to save the current view state if not
// done already.
if (mHost.onShouldSaveFragmentState(f) && f.mSavedViewState == null) {
saveFragmentViewState(f);
}
}
f.performDestroyView();
if (f.mView != null && f.mContainer != null) {
Animator anim = null;
if (mCurState > Fragment.INITIALIZING && !mDestroyed) {
anim = loadAnimator(f, transit, false,
transitionStyle);
}
if (anim != null) {
final ViewGroup container = f.mContainer;
final View view = f.mView;
final Fragment fragment = f;
container.startViewTransition(view);
f.mAnimatingAway = anim;
f.mStateAfterAnimating = newState;
anim.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator anim) {
container.endViewTransition(view);
if (fragment.mAnimatingAway != null) {
fragment.mAnimatingAway = null;
moveToState(fragment, fragment.mStateAfterAnimating,
0, 0, false);
}
}
});
4000
anim.setTarget(f.mView);
setHWLayerAnimListenerIfAlpha(f.mView, anim);
anim.start();

}
f.mContainer.removeView(f.mView);  //1084
}
f.mContainer = null;
f.mView = null;
}
case Fragment.CREATED:
}
}
f.mState = newState;
}

进入ViewGroup removeView

public void removeView(View view) {
if (removeViewInternal(view)) {
requestLayout();
invalidate(true);
}
}

private boolean removeViewInternal(View view) {
final int index = indexOfChild(view);
if (index >= 0) {
removeViewInternal(index, view);  //4928
return true;
}
return false;
}

private void removeViewInternal(int index, View view) {

if (mTransition != null) {
mTransition.removeChild(this, view);
}

boolean clearChildFocus = false;
if (view == mFocused) {
view.unFocus(null);
clearChildFocus = true;
}

view.clearAccessibilityFocus();

cancelTouchTarget(view);
cancelHoverTarget(view);

if (view.getAnimation() != null ||
(mTransitioningViews != null && mTransitioningViews.contains(view))) {
addDisappearingView(view);
} else if (view.mAttachInfo != null) {
view.dispatchDetachedFromWindow();
}

if (view.hasTransientState()) {
childHasTransientStateChanged(view, false);
}

needGlobalAttributesUpdate(false);

removeFromArray(index);

if (clearChildFocus) {
clearChildFocus(view);
if (!rootViewRequestFocus()) {   //4968
notifyGlobalFocusCleared(this);
}
}

dispatchViewRemoved(view);

if (view.getVisibility() != View.GONE) {
notifySubtreeAccessibilityStateChangedIfNeeded();
}

int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();
for (int i = 0; i < transientCount; ++i) {
final int oldIndex = mTransientIndices.get(i);
if (index < oldIndex) {
mTransientIndices.set(i, oldIndex - 1);
}
}
}

ViewGroup继承自View，实现了ViewParent, ViewManager接口，这里是进入View的rootViewRequestFocus

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

requestFocus的注释还是很值得看的

/**
* Call this to try to give focus to a specific view or to one of its
* descendants.
*
* A view will not actually take focus if it is not focusable ({@link #isFocusable} returns
* false), or if it is focusable and it is not focusable in touch mode
* ({@link #isFocusableInTouchMode}) while the device is in touch mode.
*
* See also {@link #focusSearch(int)}, which is what you call to say that you
* have focus, and you want your parent to look for the next one.
*
* This is equivalent to calling {@link #requestFocus(int, Rect)} with arguments
* {@link #FOCUS_DOWN} and <code>null</code>.
*
* @return Whether this view or one of its descendants actually took focus.
*/
public final boolean requestFocus() {
return requestFocus(View.FOCUS_DOWN);
}
public final boolean requestFocus(int direction) {
return requestFocus(direction, null);
}
/**
* Call this to try to give focus to a specific view or to one of its descendants
* and give it hints about the direction and a specific rectangle that the focus
* is coming from.  The rectangle can help give larger views a finer grained hint
* about where focus is coming from, and therefore, where to show selection, or
* forward focus change internally.
*
* A view will not actually take focus if it is not focusable ({@link #isFocusable} returns
* false), or if it is focusable and it is not focusable in touch mode
* ({@link #isFocusableInTouchMode}) while the device is in touch mode.
*
* A View will not take focus if it is not visible.
*
* A View will not take focus if one of its parents has
* {@link android.view.ViewGroup#getDescendantFocusability()} equal to
* {@link ViewGroup#FOCUS_BLOCK_DESCENDANTS}.
*
* See also {@link #focusSearch(int)}, which is what you call to say that you
* have focus, and you want your parent to look for the next one.
*
* You may wish to override this method if your custom {@link View} has an internal
* {@link View} that it wishes to forward the request to.
*
* @param direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
* @param previouslyFocusedRect The rectangle (in this View's coordinate system)
*        to give a finer grained hint about where focus is coming from.  May be null
*        if there is no hint.
* @return Whether this view or one of its descendants actually took focus.
*/
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
return requestFocusNoSearch(direction, previouslyFocusedRect);
}

我一直以为马上调用的还是View的requestFocus(int direction, Rect previouslyFocusedRect)，然而它调用的却是ViewGroup的。这是因为Java是一门面向对象语言，当子类对象调用的方法在子类中被复写时，那么应该调用的是子类的对象，也就是说，马上调用的是

at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)

/**
* {@inheritDoc}
*
* Looks for a view to give focus to respecting the setting specified by
* {@link #getDescendantFocusability()}.
*
* Uses {@link #onRequestFocusInDescendants(int, android.graphics.Rect)} to
* find focus within the children of this group when appropriate.
*
* @see #FOCUS_BEFORE_DESCENDANTS
* @see #FOCUS_AFTER_DESCENDANTS
* @see #FOCUS_BLOCK_DESCENDANTS
* @see #onRequestFocusInDescendants(int, android.graphics.Rect)
*/
@Override
public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
if (DBG) {
System.out.println(this + " ViewGroup.requestFocus direction="
+ direction);
}
int descendantFocusability = getDescendantFocusability();

switch (descendantFocusability) {
case FOCUS_BLOCK_DESCENDANTS:
return super.requestFocus(direction, previouslyFocusedRect);
case FOCUS_BEFORE_DESCENDANTS: {
final boolean took = super.requestFocus(direction, previouslyFocusedRect);
return took ? took :    //3054
onRequestFocusInDescendants(direction, previouslyFocusedRect);
}
case FOCUS_AFTER_DESCENDANTS: {
final boolean took = onRequestFocusInDescendants(direction, previouslyFocusedRect);   // 3057
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);
}
}

/**
* Gets the descendant focusability of this view group.  The descendant
* focusability defines the relationship between this view group and its
* descendants when looking for a view to take focus in
* {@link #requestFocus(int, android.graphics.Rect)}.
*
* @return one of {@link #FOCUS_BEFORE_DESCENDANTS}, {@link #FOCUS_AFTER_DESCENDANTS},
*   {@link #FOCUS_BLOCK_DESCENDANTS}.
*/
@ViewDebug.ExportedProperty(category = "focus", mapping = {
@ViewDebug.IntToString(from = FOCUS_BEFORE_DESCENDANTS, to = "FOCUS_BEFORE_DESCENDANTS"),
@ViewDebug.IntToString(from = FOCUS_AFTER_DESCENDANTS, to = "FOCUS_AFTER_DESCENDANTS"),
@ViewDebug.IntToString(from = FOCUS_BLOCK_DESCENDANTS, to = "FOCUS_BLOCK_DESCENDANTS")
})
public int getDescendantFocusability() {
return mGroupFlags & FLAG_MASK_FOCUSABILITY;
}

private static final int FLAG_MASK_FOCUSABILITY = 0x60000;

/**
* This view will get focus before any of its descendants.
*/
public static final int FOCUS_BEFORE_DESCENDANTS = 0x20000;

/**
* This view will get focus only if none of its descendants want it.
*/
public static final int FOCUS_AFTER_DESCENDANTS = 0x40000;

/**
* This view will block any of its descendants from getting focus, even
* if they are focusable.
*/
public static final int FOCUS_BLOCK_DESCENDANTS = 0x60000;

ViewDebug的注解是用在显示于Hierarchy View中的，咱们继续看，为什么这个里面走的是FOCUS_AFTER_DESCENDANTS,呃，mGroupFlags我们还是暂时保留吧，不过从initViewGroup()中来看setDescendantFocusability(FOCUS_BEFORE_DESCENDANTS)默认是FOCUS_BEFORE_DESCENDANTS。

at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3057)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)
at android.view.ViewGroup.requestFocus(ViewGroup.java:3054)
at android.view.ViewGroup.onRequestFocusInDescendants(ViewGroup.java:3098)

后面是一个递归找焦点的过程。

/**
* Look for a descendant to call {@link View#requestFocus} on.
* Called by {@link ViewGroup#requestFocus(int, android.graphics.Rect)}
* when it wants to request focus within its children.  Override this to
* customize how your {@link ViewGroup} requests focus within its children.
* @param direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT
* @param previouslyFocusedRect The rectangle (in this View's coordinate system)
*        to give a finer grained hint about where focus is coming from.  May be null
*        if there is no hint.
* @return Whether focus was taken.
*/
@SuppressWarnings({"ConstantConditions"})
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;
for (int i = index; i != end; i += increment) {
View child = children[i];
if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
if (child.requestFocus(direction, previouslyFocusedRect)) {
return true;
}
}
}
return false;
}

public static final int FOCUS_FORWARD = 0x00000002;

根据direction来决定index从0还是从count-1开始。

咱们看log的时候requestFocus有时候是3054行，有时候是3057行，其差别在于FOCUS_AFTER_DESCENDANTS和FOCUS_BEFORE_DESCENDANTS。就这么递归直到HorizontalScrollView.java

at android.view.View.onFocusChanged(View.java:6278)
at android.widget.TextView.onFocusChanged(TextView.java:9559)
at android.view.View.handleFocusGainInternal(View.java:6004)
at android.view.View.requestFocusNoSearch(View.java:9077)
at android.view.View.requestFocus(View.java:9056)
at android.widget.HorizontalScrollView.onRequestFocusInDescendants(HorizontalScrollView.java:2056)

/**
* When looking for focus in children of a scroll view, need to be a little
* more careful not to give focus to something that is scrolled off screen.
*
* This is more expensive than the default {@link android.view.ViewGroup}
* implementation, otherwise this behavior might have been made the default.
*/
@Override
protected boolean onRequestFocusInDescendants(int direction,
Rect previouslyFocusedRect) {

// convert from forward / backward notation to up / down / left / right
// (ugh).
if (direction == View.FOCUS_FORWARD) {
direction = View.FOCUS_RIGHT;
} else if (direction == View.FOCUS_BACKWARD) {
direction = View.FOCUS_LEFT;
}

final View nextFocus = previouslyFocusedRect == null ?
FocusFinder.getInstance().findNextFocus(this, null, direction) :
FocusFinder.getInstance().findNextFocusFromRect(this,
previouslyFocusedRect, direction);

if (nextFocus == null) {
return false;
}

if (isOffScreen(nextFocus)) {
return false;
}

return nextFocus.requestFocus(direction, previouslyFocusedRect);  // 2056
}

这里走回View(nextFocus)的requestFocus，也就是requestFocusNoSearch。

private boolean requestFocusNoSearch(int direction, Rect previouslyFocusedRect) {
// need to be focusable
if ((mViewFlags & FOCUSABLE_MASK) != 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;
}

// need to not have any parents blocking us
if (hasAncestorThatBlocksDescendantFocus()) {
return false;
}

handleFocusGainInternal(direction, previouslyFocusedRect);  //9077
return true;
}

/**
* Give this view focus. This will cause
* {@link #onFocusChanged(boolean, int, android.graphics.Rect)} to be called.
*
* Note: this does not check whether this {@link View} should get focus, it just
* gives it focus no matter what.  It should only be called internally by framework
* code that knows what it is doing, namely {@link #requestFocus(int, Rect)}.
*
* @param direction values are {@link View#FOCUS_UP}, {@link View#FOCUS_DOWN},
*        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT}. This is the direction which
*        focus moved when requestFocus() is called. It may not always
*        apply, in which case use the default View.FOCUS_DOWN.
* @param previouslyFocusedRect The rectangle of the view that had focus
*        prior in this View's coordinate system.
*/
void handleFocusGainInternal(@FocusRealDirection int direction, Rect previouslyFocusedRect) {
if (DBG) {
System.out.println(this + " requestFocus()");
}

if ((mPrivateFlags & PFLAG_FOCUSED) == 0) {
mPrivateFlags |= PFLAG_FOCUSED;

View oldFocus = (mAttachInfo != null) ? getRootView().findFocus() : null;

if (mParent != null) {
mParent.requestChildFocus(this, this);
}

if (mAttachInfo != null) {
mAttachInfo.mTreeObserver.dispatchOnGlobalFocusChange(oldFocus, this);
}

onFocusChanged(true, direction, previouslyFocusedRect);   // 6004
refreshDrawableState();
}
}

先是TextView的onFocusChange

@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mTemporaryDetach) {
// If we are temporarily in the detach state, then do nothing.
super.onFocusChanged(focused, direction, previouslyFocusedRect);
return;
}

if (mEditor != null) mEditor.onFocusChanged(focused, direction);

if (focused) {
if (mText instanceof Spannable) {
Spannable sp = (Spannable) mText;
MetaKeyKeyListener.resetMetaState(sp);
}
}

startStopMarquee(focused);

if (mTransformation != null) {
mTransformation.onFocusChanged(this, mText, focused, direction, previouslyFocusedRect);
}

super.onFocusChanged(focused, direction, previouslyFocusedRect);  //9559
}

调了
bfc6
父类View的onFocusChanged

/**
* Called by the view system when the focus state of this view changes.
* When the focus change event is caused by directional navigation, direction
* and previouslyFocusedRect provide insight into where the focus is coming from.
* When overriding, be sure to call up through to the super class so that
* the standard focus handling will occur.
*
* @param gainFocus True if the View has focus; false otherwise.
* @param direction The direction focus has moved when requestFocus()
*                  is called to give this view focus. Values are
*                  {@link #FOCUS_UP}, {@link #FOCUS_DOWN}, {@link #FOCUS_LEFT},
*                  {@link #FOCUS_RIGHT}, {@link #FOCUS_FORWARD}, or {@link #FOCUS_BACKWARD}.
*                  It may not always apply, in which case use the default.
* @param previouslyFocusedRect The rectangle, in this view's coordinate
*        system, of the previously focused view.  If applicable, this will be
*        passed in as finer grained information about where the focus is coming
*        from (in addition to direction).  Will be <code>null</code> otherwise.
*/
@CallSuper
protected void onFocusChanged(boolean gainFocus, @FocusDirection int direction,
@Nullable Rect previouslyFocusedRect) {
if (gainFocus) {
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
} else {
notifyViewAccessibilityStateChangedIfNeeded(
AccessibilityEvent.CONTENT_CHANGE_TYPE_UNDEFINED);
}

InputMethodManager imm = InputMethodManager.peekInstance();
if (!gainFocus) {
if (isPressed()) {
setPressed(false);
}
if (imm != null && mAttachInfo != null
&& mAttachInfo.mHasWindowFocus) {
imm.focusOut(this);
}
onFocusLost();
} else if (imm != null && mAttachInfo != null
&& mAttachInfo.mHasWindowFocus) {
imm.focusIn(this);
}

invalidate(true);
ListenerInfo li = mListenerInfo;
if (li != null && li.mOnFocusChangeListener != null) {
li.mOnFocusChangeListener.onFocusChange(this, gainFocus);   // 6278
}

if (mAttachInfo != null) {
mAttachInfo.mKeyDispatchState.reset(this);
}
}

我们看到log里会打出focusIn 和focusOut的信息，其实就是这里调用的IMM的方法。然后是通知onFocusChangeListener的监听者。而TabWidget就是其中一个。

at com.samsung.musicplus.contents.extra.MusicSelectListTabActivity.onTabChanged(MusicSelectListTabActivity.java:236)
at android.widget.TabHost.invokeOnTabChangeListener(TabHost.java:462)
at android.widget.TabHost.setCurrentTab(TabHost.java:442)
at android.widget.TabHost$2.onTabSelectionChanged(TabHost.java:194)
at android.widget.TabWidget.onFocusChange(TabWidget.java:683)

TabWidget在onFocusChange里面干了比较重要的事setCurrentTab，也就是这个问题发生的主要原因。在挨个询问焦点的过程中setCurrentTab为0了,所以回调onTabSelectionChanged。

/** {@inheritDoc} */
public void onFocusChange(View v, boolean hasFocus) {
if (v == this && hasFocus && getTabCount() > 0 && mSelectedTab != -1) {
getChildTabViewAt(mSelectedTab).requestFocus();
return;
}
if (hasFocus) {
int i = 0;
int numTabs = getTabCount();
while (i < numTabs) {
if (getChildTabViewAt(i) == v) {
setCurrentTab(i);
mSelectionChangedListener.onTabSelectionChanged(i, false);  //683
if (isShown()) {
// a tab is focused so send an event to announce the tab widget state
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
}
break;
}
i++;
}
}
}

TabHost onTabSelectionChanged

mTabWidget.setTabSelectionListener(new TabWidget.OnTabSelectionChanged() {
public void onTabSelectionChanged(int tabIndex, boolean clicked) {
setCurrentTab(tabIndex);  //442
if (clicked) {
mTabContent.requestFocus(View.FOCUS_FORWARD);
}
}
});

setCurrentTab中会调用invokeOnTabChangeListener，最终反馈到Activity

public void setCurrentTab(int index) {
if (index < 0 || index >= mTabSpecs.size()) {
return;
}

if (index == mCurrentTab) {
return;
}

// notify old tab content
if (mCurrentTab != -1) {
mTabSpecs.get(mCurrentTab).mContentStrategy.tabClosed();
}

mCurrentTab = index;
final TabHost.TabSpec spec = mTabSpecs.get(index);

// Call the tab widget's focusCurrentTab(), instead of just
// selecting the tab.
mTabWidget.focusCurrentTab(mCurrentTab);

// tab content
mCurrentView = spec.mContentStrategy.getContentView();

if (mCurrentView.getParent() == null) {
mTabContent
.addView(
mCurrentView,
new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT));
}

if (!mTabWidget.hasFocus()) {
// if the tab widget didn't take focus (likely because we're in touch mode)
// give the current tab content view a shot
mCurrentView.requestFocus();
}

//mTabContent.requestFocus(View.FOCUS_FORWARD);
invokeOnTabChangeListener();
}

private void invokeOnTabChangeListener() {
if (mOnTabChangeListener != null) {
/* { EAF */
if (IS_ELASTIC_ENABLED && InjectionManager.getInstance() != null) {
InjectionManager.getInstance().dispatchTabHostEvent(getCurrentView().getContext(),getCurrentTabTag());
}
/* EAF } */
mOnTabChangeListener.onTabChanged(getCurrentTabTag());
}
}

最后的解决方案是在ListFragment中加了callback，当tab列表中的一项被点击的时候（onListItemClick）去回调其onFocusChange通知监听者（TabActivity）这个时候短暂地将tab设为focusable false,避开这个获取焦点环节。