998 lines
38 KiB
Java
998 lines
38 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2007 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
|
|
* you may not use this file except in compliance with the License.
|
||
|
|
* You may obtain a copy of the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
|
|
* See the License for the specific language governing permissions and
|
||
|
|
* limitations under the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package android.view;
|
||
|
|
|
||
|
|
import android.annotation.NonNull;
|
||
|
|
import android.annotation.Nullable;
|
||
|
|
import android.annotation.TestApi;
|
||
|
|
import android.content.pm.PackageManager;
|
||
|
|
import android.graphics.Rect;
|
||
|
|
import android.util.ArrayMap;
|
||
|
|
import android.util.ArraySet;
|
||
|
|
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.Collections;
|
||
|
|
import java.util.Comparator;
|
||
|
|
import java.util.HashMap;
|
||
|
|
import java.util.List;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The algorithm used for finding the next focusable view in a given direction
|
||
|
|
* from a view that currently has focus.
|
||
|
|
*/
|
||
|
|
public class FocusFinder {
|
||
|
|
|
||
|
|
private static final ThreadLocal<FocusFinder> tlFocusFinder =
|
||
|
|
new ThreadLocal<FocusFinder>() {
|
||
|
|
@Override
|
||
|
|
protected FocusFinder initialValue() {
|
||
|
|
return new FocusFinder();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Get the focus finder for this thread.
|
||
|
|
*/
|
||
|
|
public static FocusFinder getInstance() {
|
||
|
|
return tlFocusFinder.get();
|
||
|
|
}
|
||
|
|
|
||
|
|
final Rect mFocusedRect = new Rect();
|
||
|
|
final Rect mOtherRect = new Rect();
|
||
|
|
final Rect mBestCandidateRect = new Rect();
|
||
|
|
private final UserSpecifiedFocusComparator mUserSpecifiedFocusComparator =
|
||
|
|
new UserSpecifiedFocusComparator((r, v) -> isValidId(v.getNextFocusForwardId())
|
||
|
|
? v.findUserSetNextFocus(r, View.FOCUS_FORWARD) : null);
|
||
|
|
private final UserSpecifiedFocusComparator mUserSpecifiedClusterComparator =
|
||
|
|
new UserSpecifiedFocusComparator((r, v) -> isValidId(v.getNextClusterForwardId())
|
||
|
|
? v.findUserSetNextKeyboardNavigationCluster(r, View.FOCUS_FORWARD) : null);
|
||
|
|
private final FocusSorter mFocusSorter = new FocusSorter();
|
||
|
|
|
||
|
|
private final ArrayList<View> mTempList = new ArrayList<View>();
|
||
|
|
|
||
|
|
// enforce thread local access
|
||
|
|
private FocusFinder() {}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the next view to take focus in root's descendants, starting from the view
|
||
|
|
* that currently is focused.
|
||
|
|
* @param root Contains focused. Cannot be null.
|
||
|
|
* @param focused Has focus now.
|
||
|
|
* @param direction Direction to look.
|
||
|
|
* @return The next focusable view, or null if none exists.
|
||
|
|
*/
|
||
|
|
public final View findNextFocus(ViewGroup root, View focused, int direction) {
|
||
|
|
return findNextFocus(root, focused, null, direction);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the next view to take focus in root's descendants, searching from
|
||
|
|
* a particular rectangle in root's coordinates.
|
||
|
|
* @param root Contains focusedRect. Cannot be null.
|
||
|
|
* @param focusedRect The starting point of the search.
|
||
|
|
* @param direction Direction to look.
|
||
|
|
* @return The next focusable view, or null if none exists.
|
||
|
|
*/
|
||
|
|
public View findNextFocusFromRect(ViewGroup root, Rect focusedRect, int direction) {
|
||
|
|
mFocusedRect.set(focusedRect);
|
||
|
|
return findNextFocus(root, null, mFocusedRect, direction);
|
||
|
|
}
|
||
|
|
|
||
|
|
private View findNextFocus(ViewGroup root, View focused, Rect focusedRect, int direction) {
|
||
|
|
View next = null;
|
||
|
|
ViewGroup effectiveRoot = getEffectiveRoot(root, focused);
|
||
|
|
if (focused != null) {
|
||
|
|
next = findNextUserSpecifiedFocus(effectiveRoot, focused, direction);
|
||
|
|
}
|
||
|
|
if (next != null) {
|
||
|
|
return next;
|
||
|
|
}
|
||
|
|
ArrayList<View> focusables = mTempList;
|
||
|
|
try {
|
||
|
|
focusables.clear();
|
||
|
|
effectiveRoot.addFocusables(focusables, direction);
|
||
|
|
if (!focusables.isEmpty()) {
|
||
|
|
next = findNextFocus(effectiveRoot, focused, focusedRect, direction, focusables);
|
||
|
|
}
|
||
|
|
} finally {
|
||
|
|
focusables.clear();
|
||
|
|
}
|
||
|
|
return next;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns the "effective" root of a view. The "effective" root is the closest ancestor
|
||
|
|
* within-which focus should cycle.
|
||
|
|
* <p>
|
||
|
|
* For example: normal focus navigation would stay within a ViewGroup marked as
|
||
|
|
* touchscreenBlocksFocus and keyboardNavigationCluster until a cluster-jump out.
|
||
|
|
* @return the "effective" root of {@param focused}
|
||
|
|
*/
|
||
|
|
private ViewGroup getEffectiveRoot(ViewGroup root, View focused) {
|
||
|
|
if (focused == null || focused == root) {
|
||
|
|
return root;
|
||
|
|
}
|
||
|
|
ViewGroup effective = null;
|
||
|
|
ViewParent nextParent = focused.getParent();
|
||
|
|
while (nextParent instanceof ViewGroup) {
|
||
|
|
if (nextParent == root) {
|
||
|
|
return effective != null ? effective : root;
|
||
|
|
}
|
||
|
|
ViewGroup vg = (ViewGroup) nextParent;
|
||
|
|
if (vg.getTouchscreenBlocksFocus()
|
||
|
|
&& focused.getContext().getPackageManager().hasSystemFeature(
|
||
|
|
PackageManager.FEATURE_TOUCHSCREEN)
|
||
|
|
&& vg.isKeyboardNavigationCluster()) {
|
||
|
|
// Don't stop and return here because the cluster could be nested and we only
|
||
|
|
// care about the top-most one.
|
||
|
|
effective = vg;
|
||
|
|
}
|
||
|
|
nextParent = nextParent.getParent();
|
||
|
|
}
|
||
|
|
return root;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the root of the next keyboard navigation cluster after the current one.
|
||
|
|
* @param root The view tree to look inside. Cannot be null
|
||
|
|
* @param currentCluster The starting point of the search. Null means the default cluster
|
||
|
|
* @param direction Direction to look
|
||
|
|
* @return The next cluster, or null if none exists
|
||
|
|
*/
|
||
|
|
public View findNextKeyboardNavigationCluster(
|
||
|
|
@NonNull View root,
|
||
|
|
@Nullable View currentCluster,
|
||
|
|
@View.FocusDirection int direction) {
|
||
|
|
View next = null;
|
||
|
|
if (currentCluster != null) {
|
||
|
|
next = findNextUserSpecifiedKeyboardNavigationCluster(root, currentCluster, direction);
|
||
|
|
if (next != null) {
|
||
|
|
return next;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
final ArrayList<View> clusters = mTempList;
|
||
|
|
try {
|
||
|
|
clusters.clear();
|
||
|
|
root.addKeyboardNavigationClusters(clusters, direction);
|
||
|
|
if (!clusters.isEmpty()) {
|
||
|
|
next = findNextKeyboardNavigationCluster(
|
||
|
|
root, currentCluster, clusters, direction);
|
||
|
|
}
|
||
|
|
} finally {
|
||
|
|
clusters.clear();
|
||
|
|
}
|
||
|
|
return next;
|
||
|
|
}
|
||
|
|
|
||
|
|
private View findNextUserSpecifiedKeyboardNavigationCluster(View root, View currentCluster,
|
||
|
|
int direction) {
|
||
|
|
View userSetNextCluster =
|
||
|
|
currentCluster.findUserSetNextKeyboardNavigationCluster(root, direction);
|
||
|
|
if (userSetNextCluster != null && userSetNextCluster.hasFocusable()) {
|
||
|
|
return userSetNextCluster;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
private View findNextUserSpecifiedFocus(ViewGroup root, View focused, int direction) {
|
||
|
|
// check for user specified next focus
|
||
|
|
View userSetNextFocus = focused.findUserSetNextFocus(root, direction);
|
||
|
|
View cycleCheck = userSetNextFocus;
|
||
|
|
boolean cycleStep = true; // we want the first toggle to yield false
|
||
|
|
while (userSetNextFocus != null) {
|
||
|
|
if (userSetNextFocus.isFocusable()
|
||
|
|
&& userSetNextFocus.getVisibility() == View.VISIBLE
|
||
|
|
&& (!userSetNextFocus.isInTouchMode()
|
||
|
|
|| userSetNextFocus.isFocusableInTouchMode())) {
|
||
|
|
return userSetNextFocus;
|
||
|
|
}
|
||
|
|
userSetNextFocus = userSetNextFocus.findUserSetNextFocus(root, direction);
|
||
|
|
if (cycleStep = !cycleStep) {
|
||
|
|
cycleCheck = cycleCheck.findUserSetNextFocus(root, direction);
|
||
|
|
if (cycleCheck == userSetNextFocus) {
|
||
|
|
// found a cycle, user-specified focus forms a loop and none of the views
|
||
|
|
// are currently focusable.
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
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;
|
||
|
|
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
setFocusBottomRight(root, focusedRect);
|
||
|
|
break;
|
||
|
|
case View.FOCUS_BACKWARD:
|
||
|
|
if (root.isLayoutRtl()) {
|
||
|
|
setFocusTopLeft(root, focusedRect);
|
||
|
|
} else {
|
||
|
|
setFocusBottomRight(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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private View findNextKeyboardNavigationCluster(
|
||
|
|
View root,
|
||
|
|
View currentCluster,
|
||
|
|
List<View> clusters,
|
||
|
|
@View.FocusDirection int direction) {
|
||
|
|
try {
|
||
|
|
// Note: This sort is stable.
|
||
|
|
mUserSpecifiedClusterComparator.setFocusables(clusters, root);
|
||
|
|
Collections.sort(clusters, mUserSpecifiedClusterComparator);
|
||
|
|
} finally {
|
||
|
|
mUserSpecifiedClusterComparator.recycle();
|
||
|
|
}
|
||
|
|
final int count = clusters.size();
|
||
|
|
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_FORWARD:
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return getNextKeyboardNavigationCluster(root, currentCluster, clusters, count);
|
||
|
|
case View.FOCUS_BACKWARD:
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
return getPreviousKeyboardNavigationCluster(root, currentCluster, clusters, count);
|
||
|
|
default:
|
||
|
|
throw new IllegalArgumentException("Unknown direction: " + direction);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private View findNextFocusInRelativeDirection(ArrayList<View> focusables, ViewGroup root,
|
||
|
|
View focused, Rect focusedRect, int direction) {
|
||
|
|
try {
|
||
|
|
// Note: This sort is stable.
|
||
|
|
mUserSpecifiedFocusComparator.setFocusables(focusables, root);
|
||
|
|
Collections.sort(focusables, mUserSpecifiedFocusComparator);
|
||
|
|
} finally {
|
||
|
|
mUserSpecifiedFocusComparator.recycle();
|
||
|
|
}
|
||
|
|
|
||
|
|
final int count = focusables.size();
|
||
|
|
if (count < 2) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
View next = null;
|
||
|
|
final boolean[] looped = new boolean[1];
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_FORWARD:
|
||
|
|
next = getNextFocusable(focused, focusables, count, looped);
|
||
|
|
break;
|
||
|
|
case View.FOCUS_BACKWARD:
|
||
|
|
next = getPreviousFocusable(focused, focusables, count, looped);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
if (root != null && root.mAttachInfo != null && root == root.getRootView()) {
|
||
|
|
root.mAttachInfo.mNextFocusLooped = looped[0];
|
||
|
|
}
|
||
|
|
return next != null ? next : focusables.get(count - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void setFocusBottomRight(ViewGroup root, Rect focusedRect) {
|
||
|
|
final int rootBottom = root.getScrollY() + root.getHeight();
|
||
|
|
final int rootRight = root.getScrollX() + root.getWidth();
|
||
|
|
focusedRect.set(rootRight, rootBottom, rootRight, rootBottom);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void setFocusTopLeft(ViewGroup root, Rect focusedRect) {
|
||
|
|
final int rootTop = root.getScrollY();
|
||
|
|
final int rootLeft = root.getScrollX();
|
||
|
|
focusedRect.set(rootLeft, rootTop, rootLeft, rootTop);
|
||
|
|
}
|
||
|
|
|
||
|
|
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));
|
||
|
|
}
|
||
|
|
|
||
|
|
View closest = null;
|
||
|
|
|
||
|
|
int numFocusables = focusables.size();
|
||
|
|
for (int i = 0; i < numFocusables; i++) {
|
||
|
|
View focusable = focusables.get(i);
|
||
|
|
|
||
|
|
// only interested in other non-root views
|
||
|
|
if (focusable == focused || focusable == root) continue;
|
||
|
|
|
||
|
|
// get focus bounds of other view in same coordinate system
|
||
|
|
focusable.getFocusedRect(mOtherRect);
|
||
|
|
root.offsetDescendantRectToMyCoords(focusable, mOtherRect);
|
||
|
|
|
||
|
|
if (isBetterCandidate(direction, focusedRect, mOtherRect, mBestCandidateRect)) {
|
||
|
|
mBestCandidateRect.set(mOtherRect);
|
||
|
|
closest = focusable;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return closest;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static View getNextFocusable(View focused, ArrayList<View> focusables, int count,
|
||
|
|
boolean[] outLooped) {
|
||
|
|
if (count < 2) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (focused != null) {
|
||
|
|
int position = focusables.lastIndexOf(focused);
|
||
|
|
if (position >= 0 && position + 1 < count) {
|
||
|
|
return focusables.get(position + 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
outLooped[0] = true;
|
||
|
|
return focusables.get(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static View getPreviousFocusable(View focused, ArrayList<View> focusables, int count,
|
||
|
|
boolean[] outLooped) {
|
||
|
|
if (count < 2) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (focused != null) {
|
||
|
|
int position = focusables.indexOf(focused);
|
||
|
|
if (position > 0) {
|
||
|
|
return focusables.get(position - 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
outLooped[0] = true;
|
||
|
|
return focusables.get(count - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static View getNextKeyboardNavigationCluster(
|
||
|
|
View root,
|
||
|
|
View currentCluster,
|
||
|
|
List<View> clusters,
|
||
|
|
int count) {
|
||
|
|
if (currentCluster == null) {
|
||
|
|
// The current cluster is the default one.
|
||
|
|
// The next cluster after the default one is the first one.
|
||
|
|
// Note that the caller guarantees that 'clusters' is not empty.
|
||
|
|
return clusters.get(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
final int position = clusters.lastIndexOf(currentCluster);
|
||
|
|
if (position >= 0 && position + 1 < count) {
|
||
|
|
// Return the next non-default cluster if we can find it.
|
||
|
|
return clusters.get(position + 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// The current cluster is the last one. The next one is the default one, i.e. the
|
||
|
|
// root.
|
||
|
|
return root;
|
||
|
|
}
|
||
|
|
|
||
|
|
private static View getPreviousKeyboardNavigationCluster(
|
||
|
|
View root,
|
||
|
|
View currentCluster,
|
||
|
|
List<View> clusters,
|
||
|
|
int count) {
|
||
|
|
if (currentCluster == null) {
|
||
|
|
// The current cluster is the default one.
|
||
|
|
// The previous cluster before the default one is the last one.
|
||
|
|
// Note that the caller guarantees that 'clusters' is not empty.
|
||
|
|
return clusters.get(count - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
final int position = clusters.indexOf(currentCluster);
|
||
|
|
if (position > 0) {
|
||
|
|
// Return the previous non-default cluster if we can find it.
|
||
|
|
return clusters.get(position - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// The current cluster is the first one. The previous one is the default one, i.e.
|
||
|
|
// the root.
|
||
|
|
return root;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Is rect1 a better candidate than rect2 for a focus search in a particular
|
||
|
|
* direction from a source rect? This is the core routine that determines
|
||
|
|
* the order of focus searching.
|
||
|
|
* @param direction the direction (up, down, left, right)
|
||
|
|
* @param source The source we are searching from
|
||
|
|
* @param rect1 The candidate rectangle
|
||
|
|
* @param rect2 The current best candidate.
|
||
|
|
* @return Whether the candidate is the new best.
|
||
|
|
*/
|
||
|
|
boolean isBetterCandidate(int direction, Rect source, Rect rect1, Rect rect2) {
|
||
|
|
|
||
|
|
// to be a better candidate, need to at least be a candidate in the first
|
||
|
|
// place :)
|
||
|
|
if (!isCandidate(source, rect1, direction)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// we know that rect1 is a candidate.. if rect2 is not a candidate,
|
||
|
|
// rect1 is better
|
||
|
|
if (!isCandidate(source, rect2, direction)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if rect1 is better by beam, it wins
|
||
|
|
if (beamBeats(direction, source, rect1, rect2)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if rect2 is better, then rect1 cant' be :)
|
||
|
|
if (beamBeats(direction, source, rect2, rect1)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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)));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* One rectangle may be another candidate than another by virtue of being
|
||
|
|
* exclusively in the beam of the source rect.
|
||
|
|
* @return Whether rect1 is a better candidate than rect2 by virtue of it being in src's
|
||
|
|
* beam
|
||
|
|
*/
|
||
|
|
boolean beamBeats(int direction, Rect source, Rect rect1, Rect rect2) {
|
||
|
|
final boolean rect1InSrcBeam = beamsOverlap(direction, source, rect1);
|
||
|
|
final boolean rect2InSrcBeam = beamsOverlap(direction, source, rect2);
|
||
|
|
|
||
|
|
// if rect1 isn't exclusively in the src beam, it doesn't win
|
||
|
|
if (rect2InSrcBeam || !rect1InSrcBeam) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// we know rect1 is in the beam, and rect2 is not
|
||
|
|
|
||
|
|
// if rect1 is to the direction of, and rect2 is not, rect1 wins.
|
||
|
|
// for example, for direction left, if rect1 is to the left of the source
|
||
|
|
// and rect2 is below, then we always prefer the in beam rect1, since rect2
|
||
|
|
// could be reached by going down.
|
||
|
|
if (!isToDirectionOf(direction, source, rect2)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// for horizontal directions, being exclusively in beam always wins
|
||
|
|
if ((direction == View.FOCUS_LEFT || direction == View.FOCUS_RIGHT)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Fudge-factor opportunity: how to calculate distance given major and minor
|
||
|
|
* axis distances. Warning: this fudge factor is finely tuned, be sure to
|
||
|
|
* run all focus tests if you dare tweak it.
|
||
|
|
*/
|
||
|
|
long getWeightedDistanceFor(long majorAxisDistance, long minorAxisDistance) {
|
||
|
|
return 13 * majorAxisDistance * majorAxisDistance
|
||
|
|
+ minorAxisDistance * minorAxisDistance;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Is destRect a candidate for the next focus given the direction? This
|
||
|
|
* checks whether the dest is at least partially to the direction of (e.g left of)
|
||
|
|
* from source.
|
||
|
|
*
|
||
|
|
* Includes an edge case for an empty rect (which is used in some cases when
|
||
|
|
* searching from a point on the screen).
|
||
|
|
*/
|
||
|
|
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}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Do the "beams" w.r.t the given direction's axis of rect1 and rect2 overlap?
|
||
|
|
* @param direction the direction (up, down, left, right)
|
||
|
|
* @param rect1 The first rectangle
|
||
|
|
* @param rect2 The second rectangle
|
||
|
|
* @return whether the beams overlap
|
||
|
|
*/
|
||
|
|
boolean beamsOverlap(int direction, Rect rect1, Rect rect2) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return (rect2.bottom > rect1.top) && (rect2.top < rect1.bottom);
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
return (rect2.right > rect1.left) && (rect2.left < rect1.right);
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* e.g for left, is 'to left of'
|
||
|
|
*/
|
||
|
|
boolean isToDirectionOf(int direction, Rect src, Rect dest) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
return src.left >= dest.right;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return src.right <= dest.left;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
return src.top >= dest.bottom;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
return src.bottom <= dest.top;
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return The distance from the edge furthest in the given direction
|
||
|
|
* of source to the edge nearest in the given direction of dest. If the
|
||
|
|
* dest is not in the direction from source, return 0.
|
||
|
|
*/
|
||
|
|
static int majorAxisDistance(int direction, Rect source, Rect dest) {
|
||
|
|
return Math.max(0, majorAxisDistanceRaw(direction, source, dest));
|
||
|
|
}
|
||
|
|
|
||
|
|
static int majorAxisDistanceRaw(int direction, Rect source, Rect dest) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
return source.left - dest.right;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return dest.left - source.right;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
return source.top - dest.bottom;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
return dest.top - source.bottom;
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return The distance along the major axis w.r.t the direction from the
|
||
|
|
* edge of source to the far edge of dest. If the
|
||
|
|
* dest is not in the direction from source, return 1 (to break ties with
|
||
|
|
* {@link #majorAxisDistance}).
|
||
|
|
*/
|
||
|
|
static int majorAxisDistanceToFarEdge(int direction, Rect source, Rect dest) {
|
||
|
|
return Math.max(1, majorAxisDistanceToFarEdgeRaw(direction, source, dest));
|
||
|
|
}
|
||
|
|
|
||
|
|
static int majorAxisDistanceToFarEdgeRaw(int direction, Rect source, Rect dest) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
return source.left - dest.left;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return dest.right - source.right;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
return source.top - dest.top;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
return dest.bottom - source.bottom;
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the distance on the minor axis w.r.t the direction to the nearest
|
||
|
|
* edge of the destination rectangle.
|
||
|
|
* @param direction the direction (up, down, left, right)
|
||
|
|
* @param source The source rect.
|
||
|
|
* @param dest The destination rect.
|
||
|
|
* @return The distance.
|
||
|
|
*/
|
||
|
|
static int minorAxisDistance(int direction, Rect source, Rect dest) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
// the distance between the center verticals
|
||
|
|
return Math.abs(
|
||
|
|
((source.top + source.height() / 2) -
|
||
|
|
((dest.top + dest.height() / 2))));
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
// the distance between the center horizontals
|
||
|
|
return Math.abs(
|
||
|
|
((source.left + source.width() / 2) -
|
||
|
|
((dest.left + dest.width() / 2))));
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Find the nearest touchable view to the specified view.
|
||
|
|
*
|
||
|
|
* @param root The root of the tree in which to search
|
||
|
|
* @param x X coordinate from which to start the search
|
||
|
|
* @param y Y coordinate from which to start the search
|
||
|
|
* @param direction Direction to look
|
||
|
|
* @param deltas Offset from the <x, y> to the edge of the nearest view. Note that this array
|
||
|
|
* may already be populated with values.
|
||
|
|
* @return The nearest touchable view, or null if none exists.
|
||
|
|
*/
|
||
|
|
public View findNearestTouchable(ViewGroup root, int x, int y, int direction, int[] deltas) {
|
||
|
|
ArrayList<View> touchables = root.getTouchables();
|
||
|
|
int minDistance = Integer.MAX_VALUE;
|
||
|
|
View closest = null;
|
||
|
|
|
||
|
|
int numTouchables = touchables.size();
|
||
|
|
|
||
|
|
int edgeSlop = ViewConfiguration.get(root.mContext).getScaledEdgeSlop();
|
||
|
|
|
||
|
|
Rect closestBounds = new Rect();
|
||
|
|
Rect touchableBounds = mOtherRect;
|
||
|
|
|
||
|
|
for (int i = 0; i < numTouchables; i++) {
|
||
|
|
View touchable = touchables.get(i);
|
||
|
|
|
||
|
|
// get visible bounds of other view in same coordinate system
|
||
|
|
touchable.getDrawingRect(touchableBounds);
|
||
|
|
|
||
|
|
root.offsetRectBetweenParentAndChild(touchable, touchableBounds, true, true);
|
||
|
|
|
||
|
|
if (!isTouchCandidate(x, y, touchableBounds, direction)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
int distance = Integer.MAX_VALUE;
|
||
|
|
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
distance = x - touchableBounds.right + 1;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
distance = touchableBounds.left;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
distance = y - touchableBounds.bottom + 1;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
distance = touchableBounds.top;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (distance < edgeSlop) {
|
||
|
|
// Give preference to innermost views
|
||
|
|
if (closest == null ||
|
||
|
|
closestBounds.contains(touchableBounds) ||
|
||
|
|
(!touchableBounds.contains(closestBounds) && distance < minDistance)) {
|
||
|
|
minDistance = distance;
|
||
|
|
closest = touchable;
|
||
|
|
closestBounds.set(touchableBounds);
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
deltas[0] = -distance;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
deltas[0] = distance;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
deltas[1] = -distance;
|
||
|
|
break;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
deltas[1] = distance;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return closest;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Is destRect a candidate for the next touch given the direction?
|
||
|
|
*/
|
||
|
|
private boolean isTouchCandidate(int x, int y, Rect destRect, int direction) {
|
||
|
|
switch (direction) {
|
||
|
|
case View.FOCUS_LEFT:
|
||
|
|
return destRect.left <= x && destRect.top <= y && y <= destRect.bottom;
|
||
|
|
case View.FOCUS_RIGHT:
|
||
|
|
return destRect.left >= x && destRect.top <= y && y <= destRect.bottom;
|
||
|
|
case View.FOCUS_UP:
|
||
|
|
return destRect.top <= y && destRect.left <= x && x <= destRect.right;
|
||
|
|
case View.FOCUS_DOWN:
|
||
|
|
return destRect.top >= y && destRect.left <= x && x <= destRect.right;
|
||
|
|
}
|
||
|
|
throw new IllegalArgumentException("direction must be one of "
|
||
|
|
+ "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT}.");
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final boolean isValidId(final int id) {
|
||
|
|
return id != 0 && id != View.NO_ID;
|
||
|
|
}
|
||
|
|
|
||
|
|
static final class FocusSorter {
|
||
|
|
private ArrayList<Rect> mRectPool = new ArrayList<>();
|
||
|
|
private int mLastPoolRect;
|
||
|
|
private int mRtlMult;
|
||
|
|
private HashMap<View, Rect> mRectByView = null;
|
||
|
|
|
||
|
|
private Comparator<View> mTopsComparator = (first, second) -> {
|
||
|
|
if (first == second) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
Rect firstRect = mRectByView.get(first);
|
||
|
|
Rect secondRect = mRectByView.get(second);
|
||
|
|
|
||
|
|
int result = firstRect.top - secondRect.top;
|
||
|
|
if (result == 0) {
|
||
|
|
return firstRect.bottom - secondRect.bottom;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
};
|
||
|
|
|
||
|
|
private Comparator<View> mSidesComparator = (first, second) -> {
|
||
|
|
if (first == second) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
Rect firstRect = mRectByView.get(first);
|
||
|
|
Rect secondRect = mRectByView.get(second);
|
||
|
|
|
||
|
|
int result = firstRect.left - secondRect.left;
|
||
|
|
if (result == 0) {
|
||
|
|
return firstRect.right - secondRect.right;
|
||
|
|
}
|
||
|
|
return mRtlMult * result;
|
||
|
|
};
|
||
|
|
|
||
|
|
public void sort(View[] views, int start, int end, ViewGroup root, boolean isRtl) {
|
||
|
|
int count = end - start;
|
||
|
|
if (count < 2) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (mRectByView == null) {
|
||
|
|
mRectByView = new HashMap<>();
|
||
|
|
}
|
||
|
|
mRtlMult = isRtl ? -1 : 1;
|
||
|
|
for (int i = mRectPool.size(); i < count; ++i) {
|
||
|
|
mRectPool.add(new Rect());
|
||
|
|
}
|
||
|
|
for (int i = start; i < end; ++i) {
|
||
|
|
Rect next = mRectPool.get(mLastPoolRect++);
|
||
|
|
views[i].getDrawingRect(next);
|
||
|
|
root.offsetDescendantRectToMyCoords(views[i], next);
|
||
|
|
mRectByView.put(views[i], next);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sort top-to-bottom
|
||
|
|
Arrays.sort(views, start, count, mTopsComparator);
|
||
|
|
// Sweep top-to-bottom to identify rows
|
||
|
|
int sweepBottom = mRectByView.get(views[start]).bottom;
|
||
|
|
int rowStart = start;
|
||
|
|
int sweepIdx = start + 1;
|
||
|
|
for (; sweepIdx < end; ++sweepIdx) {
|
||
|
|
Rect currRect = mRectByView.get(views[sweepIdx]);
|
||
|
|
if (currRect.top >= sweepBottom) {
|
||
|
|
// Next view is on a new row, sort the row we've just finished left-to-right.
|
||
|
|
if ((sweepIdx - rowStart) > 1) {
|
||
|
|
Arrays.sort(views, rowStart, sweepIdx, mSidesComparator);
|
||
|
|
}
|
||
|
|
sweepBottom = currRect.bottom;
|
||
|
|
rowStart = sweepIdx;
|
||
|
|
} else {
|
||
|
|
// Next view vertically overlaps, we need to extend our "row height"
|
||
|
|
sweepBottom = Math.max(sweepBottom, currRect.bottom);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Sort whatever's left (final row) left-to-right
|
||
|
|
if ((sweepIdx - rowStart) > 1) {
|
||
|
|
Arrays.sort(views, rowStart, sweepIdx, mSidesComparator);
|
||
|
|
}
|
||
|
|
|
||
|
|
mLastPoolRect = 0;
|
||
|
|
mRectByView.clear();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Public for testing.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@TestApi
|
||
|
|
public static void sort(View[] views, int start, int end, ViewGroup root, boolean isRtl) {
|
||
|
|
getInstance().mFocusSorter.sort(views, start, end, root, isRtl);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sorts views according to any explicitly-specified focus-chains. If there are no explicitly
|
||
|
|
* specified focus chains (eg. no nextFocusForward attributes defined), this should be a no-op.
|
||
|
|
*/
|
||
|
|
private static final class UserSpecifiedFocusComparator implements Comparator<View> {
|
||
|
|
private final ArrayMap<View, View> mNextFoci = new ArrayMap<>();
|
||
|
|
private final ArraySet<View> mIsConnectedTo = new ArraySet<>();
|
||
|
|
private final ArrayMap<View, View> mHeadsOfChains = new ArrayMap<View, View>();
|
||
|
|
private final ArrayMap<View, Integer> mOriginalOrdinal = new ArrayMap<>();
|
||
|
|
private final NextFocusGetter mNextFocusGetter;
|
||
|
|
private View mRoot;
|
||
|
|
|
||
|
|
public interface NextFocusGetter {
|
||
|
|
View get(View root, View view);
|
||
|
|
}
|
||
|
|
|
||
|
|
UserSpecifiedFocusComparator(NextFocusGetter nextFocusGetter) {
|
||
|
|
mNextFocusGetter = nextFocusGetter;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void recycle() {
|
||
|
|
mRoot = null;
|
||
|
|
mHeadsOfChains.clear();
|
||
|
|
mIsConnectedTo.clear();
|
||
|
|
mOriginalOrdinal.clear();
|
||
|
|
mNextFoci.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
public void setFocusables(List<View> focusables, View root) {
|
||
|
|
mRoot = root;
|
||
|
|
for (int i = 0; i < focusables.size(); ++i) {
|
||
|
|
mOriginalOrdinal.put(focusables.get(i), i);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = focusables.size() - 1; i >= 0; i--) {
|
||
|
|
final View view = focusables.get(i);
|
||
|
|
final View next = mNextFocusGetter.get(mRoot, view);
|
||
|
|
if (next != null && mOriginalOrdinal.containsKey(next)) {
|
||
|
|
mNextFoci.put(view, next);
|
||
|
|
mIsConnectedTo.add(next);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = focusables.size() - 1; i >= 0; i--) {
|
||
|
|
final View view = focusables.get(i);
|
||
|
|
final View next = mNextFoci.get(view);
|
||
|
|
if (next != null && !mIsConnectedTo.contains(view)) {
|
||
|
|
setHeadOfChain(view);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void setHeadOfChain(View head) {
|
||
|
|
for (View view = head; view != null; view = mNextFoci.get(view)) {
|
||
|
|
final View otherHead = mHeadsOfChains.get(view);
|
||
|
|
if (otherHead != null) {
|
||
|
|
if (otherHead == head) {
|
||
|
|
return; // This view has already had its head set properly
|
||
|
|
}
|
||
|
|
// A hydra -- multi-headed focus chain (e.g. A->C and B->C)
|
||
|
|
// Use the one we've already chosen instead and reset this chain.
|
||
|
|
view = head;
|
||
|
|
head = otherHead;
|
||
|
|
}
|
||
|
|
mHeadsOfChains.put(view, head);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public int compare(View first, View second) {
|
||
|
|
if (first == second) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// Order between views within a chain is immaterial -- next/previous is
|
||
|
|
// within a chain is handled elsewhere.
|
||
|
|
View firstHead = mHeadsOfChains.get(first);
|
||
|
|
View secondHead = mHeadsOfChains.get(second);
|
||
|
|
if (firstHead == secondHead && firstHead != null) {
|
||
|
|
if (first == firstHead) {
|
||
|
|
return -1; // first is the head, it should be first
|
||
|
|
} else if (second == firstHead) {
|
||
|
|
return 1; // second is the head, it should be first
|
||
|
|
} else if (mNextFoci.get(first) != null) {
|
||
|
|
return -1; // first is not the end of the chain
|
||
|
|
} else {
|
||
|
|
return 1; // first is end of chain
|
||
|
|
}
|
||
|
|
}
|
||
|
|
boolean involvesChain = false;
|
||
|
|
if (firstHead != null) {
|
||
|
|
first = firstHead;
|
||
|
|
involvesChain = true;
|
||
|
|
}
|
||
|
|
if (secondHead != null) {
|
||
|
|
second = secondHead;
|
||
|
|
involvesChain = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (involvesChain) {
|
||
|
|
// keep original order between chains
|
||
|
|
return mOriginalOrdinal.get(first) < mOriginalOrdinal.get(second) ? -1 : 1;
|
||
|
|
} else {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|