实现 图片的放大，缩小，左右屏幕滑动 。
直接贴代码吧。。
public class
ViewPager extends
ViewGroup {
private static final String TAG = "
ViewPager";
private static final boolean DEBUG = false;
private static final boolean USE_CACHE = false;
private static final int DEFAULT_OFFSCREEN_
PAGES = 1;
private static final int MAX_SETTLE_DURATION = 600; // ms
private static final int
PAGER_NEXT_MARGIN_DP = 40;
static class ItemInfo {
Object object;
int position;
boolean
scrolling;
}
private static final Comparator<ItemInfo> COMPARATOR = new Comparator<ItemInfo>() {
@Override
public int compare(ItemInfo lhs, ItemInfo rhs) {
return lhs.position - rhs.position;
}
};
private static final Interpolator sInterpolator = new Interpolator() {
public float getInterpolation(float t) {
// _o(t) = t * t * ((tension + 1) * t + tension)
// o(t) = _o(t - 1) + 1
t -= 1.0f;
return t * t * t + 1.0f;
}
};
private final ArrayList<ItemInfo> mItems = new ArrayList<ItemInfo>();
private
PagerAdapter mAdapter;
private int mCurItem; // Index of currently display
ed page.
private int mRestor
edCurItem = -1;
private Parcelable mRestor
edAdapterState = null;
private ClassLoader mRestor
edClassLoader = null;
private
Scroller m
Scroller;
private
PagerAdapter.DataSetObserver mObserver;
private int m
PageMargin;
private Drawable mMarginDrawable;
private int mChildWidthMeasureSpec;
private int mChildHeightMeasureSpec;
private boolean mInLayout;
private boolean m
ScrollingCacheEnabl
ed;
private boolean mPopulatePending;
private boolean m
Scrolling;
private int mOffscreen
PageLimit = DEFAULT_OFFSCREEN_
PAGES;
private boolean mIsBeingDragg
ed;
private boolean mIsUnableToDrag;
private int mTouchSlop;
private float mInitialMotionX;
/**
* Position of the last motion event.
*/
private float mLastMotionX;
private float mLastMotionY;
/**
* ID of the active pointer. This is us
ed to retain consistency during
* drags/flings if multiple pointers are us
ed.
*/
private int mActivePointerId = INVALID_POINTER;
/**
* Sentinel value for no current active pointer. Us
ed by
* {@link #mActivePointerId}.
*/
private static final int INVALID_POINTER = -1;
/**
* Determines spe
ed during touch
scrolling
*/
private VelocityTracker mVelocityTracker;
private int mMinimumVelocity;
private int mMaximumVelocity;
private float mBaseLineFlingVelocity;
private float mFlingVelocityInfluence;
private int m
PagerNextMarginPixels;
private boolean mFak
eDragging;
private long mFak
eDragBeginTime;
private
EdgeEffectCompat mLeft
Edge;
private
EdgeEffectCompat mRight
Edge;
private boolean mFirstLayout = true;
private On
PageChangeListener mOn
PageChangeListener;
/**
* Indicates that the
pager is in an idle, settl
ed state. The current
page
* is fully in
view and no animation is in progress.
*/
public static final int
SCROLL_STATE_IDLE = 0;
/**
* Indicates that the
pager is currently being dragg
ed by the user.
*/
public static final int
SCROLL_STATE_DRAGGING = 1;
/**
* Indicates that the
pager is in the process of settling to a final
* position.
*/
public static final int
SCROLL_STATE_SETTLING = 2;
private int m
ScrollState =
SCROLL_STATE_IDLE;
/**
* Callback interface for responding to changing state of the select
ed page.
*/
public interface On
PageChangeListener {
/**
* This method will be invok
ed when the current
page is
scrolled, either
* as part of a programmatically initiat
ed smooth
scroll or a user
* initiat
ed touch
scroll.
*
* @param position
* Position index of the first
page currently being
* display
ed.
Page position+1 will be visible if
* positionOffset is nonzero.
* @param positionOffset
* Value from [0, 1) indicating the offset from the
page at
* position.
* @param positionOffsetPixels
* Value in pixels indicating the offset from position.
*/
public void on
PageScrolled(int position, float positionOffset,
int positionOffsetPixels);
/**
* This method will be invok
ed when a new
page becomes select
ed.
* Animation is not necessarily complete.
*
* @param position
* Position index of the new select
ed page.
*/
public void on
PageSelect
ed(int position, int prePosition);
/**
* Call
ed when the
scroll state changes. Useful for discovering when the
* user begins dragging, when the
pager is automatically settling to the
* current
page, or when it is fully stopp
ed/idle.
*
* @param state
* The new
scroll state.
* @see
ViewPager#
SCROLL_STATE_IDLE
* @see
ViewPager#
SCROLL_STATE_DRAGGING
* @see
ViewPager#
SCROLL_STATE_SETTLING
*/
public void on
PageScrollStateChang
ed(int state);
}
/**
* Simple implementation of the {@link On
PageChangeListener} interface with
* stub implementations of each method. Extend this if you do not intend to
* override every method of {@link On
PageChangeListener}.
*/
public static class SimpleOn
PageChangeListener implements
On
PageChangeListener {
@Override
public void on
PageScrolled(int position, float positionOffset,
int positionOffsetPixels) {
// This space for rent
}
@Override
public void on
PageSelect
ed(int position, int prePosition) {
// This space for rent
}
@Override
public void on
PageScrollStateChang
ed(int state) {
// This space for rent
}
}
public
ViewPager(Context context) {
super(context);
init
ViewPager();
}
public
ViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
init
ViewPager();
}
void init
ViewPager() {
setWillNotDraw(false);
setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
setFocusable(true);
final Context context = getContext();
m
Scroller = new
Scroller(context, sInterpolator);
final
ViewConfiguration configuration =
ViewConfiguration.get(context);
mTouchSlop =
ViewConfigurationCompat
.getScal
edPagingTouchSlop(configuration);
mMinimumVelocity = configuration.getScal
edMinimumFlingVelocity();
mMaximumVelocity = configuration.getScal
edMaximumFlingVelocity();
mLeft
Edge = new
EdgeEffectCompat(context);
mRight
Edge = new
EdgeEffectCompat(context);
float density = context.getResources().getDisplayMetrics().density;
mBaseLineFlingVelocity = 2500.0f * density;
mFlingVelocityInfluence = 0.4f;
final float scale = getResources().getDisplayMetrics().density;
m
PagerNextMarginPixels = (int) (
PAGER_NEXT_MARGIN_DP * scale + 0.5f);
}
private void set
ScrollState(int newState) {
if (m
ScrollState == newState) {
return;
}
m
ScrollState = newState;
if (mOn
PageChangeListener != null) {
mOn
PageChangeListener.on
PageScrollStateChang
ed(newState);
}
}
public void setAdapter(
PagerAdapter adapter) {
if (mAdapter != null) {
mAdapter.setDataSetObserver(null);
mAdapter.startUpdate(this);
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
mAdapter.destroyItem(this, ii.position, ii.object);
}
mAdapter.finishUpdate(this);
mItems.clear();
removeAll
Views();
mCurItem = 0;
scrollTo(0, 0);
}
mAdapter = adapter;
if (mAdapter != null) {
if (mObserver == null) {
mObserver = new DataSetObserver();
}
mAdapter.setDataSetObserver(mObserver);
mPopulatePending = false;
if (mRestor
edCurItem >= 0) {
mAdapter.restoreState(mRestor
edAdapterState,
mRestor
edClassLoader);
setCurrentItemInternal(mRestor
edCurItem, false, true);
mRestor
edCurItem = -1;
mRestor
edAdapterState = null;
mRestor
edClassLoader = null;
} else {
populate();
}
}
}
public
PagerAdapter getAdapter() {
return mAdapter;
}
/**
* Set the currently select
ed page. If the
ViewPager has already been
* through its first layout there will be a smooth animat
ed transition
* between the current item and the specifi
ed item.
*
* @param item
* Item index to select
*/
public void setCurrentItem(int item) {
mPopulatePending = false;
setCurrentItemInternal(item, !mFirstLayout, false);
}
/**
* Set the currently select
ed page.
*
* @param item
* Item index to select
* @param smooth
Scroll
* True to smoothly
scroll to the new item, false to transition
* imm
ediately
*/
public void setCurrentItem(int item, boolean smooth
Scroll) {
mPopulatePending = false;
setCurrentItemInternal(item, smooth
Scroll, false);
}
public int getCurrentItem() {
return mCurItem;
}
void setCurrentItemInternal(int item, boolean smooth
Scroll, boolean always) {
setCurrentItemInternal(item, smooth
Scroll, always, 0);
}
void setCurrentItemInternal(int item, boolean smooth
Scroll, boolean always,
int velocity) {
int preItem = mCurItem;
if (mAdapter == null || mAdapter.getCount() <= 0) {
set
ScrollingCacheEnabl
ed(false);
return;
}
if (!always && mCurItem == item && mItems.size() != 0) {
set
ScrollingCacheEnabl
ed(false);
return;
}
if (item < 0) {
item = 0;
} else if (item >= mAdapter.getCount()) {
item = mAdapter.getCount() - 1;
}
final int
pageLimit = mOffscreen
PageLimit;
if (item > (mCurItem +
pageLimit) || item < (mCurItem -
pageLimit)) {
// We are doing a jump by more than one
page. To avoid
// glitches, we want to keep all current
pages in the
view
// until the
scroll ends.
for (int i = 0; i < mItems.size(); i++) {
mItems.get(i).
scrolling = true;
}
}
final boolean dispatchSelect
ed = mCurItem != item;
mCurItem = item;
populate();
final int destX = (getWidth() + m
PageMargin) * item;
if (smooth
Scroll) {
smooth
ScrollTo(destX, 0, velocity);
if (dispatchSelect
ed && mOn
PageChangeListener != null) {
mOn
PageChangeListener.on
PageSelect
ed(item, preItem);
}
} else {
if (dispatchSelect
ed && mOn
PageChangeListener != null) {
mOn
PageChangeListener.on
PageSelect
ed(item, preItem);
}
complete
Scroll();
scrollTo(destX, 0);
}
}
public void setOn
PageChangeListener(On
PageChangeListener listener) {
mOn
PageChangeListener = listener;
}
/**
* Returns the number of
pages that will be retain
ed to either side of the
* current
page in the
view hierarchy in an idle state. Defaults to 1.
*
* @return How many
pages will be kept offscreen on either side
* @see #setOffscreen
PageLimit(int)
*/
public int getOffscreen
PageLimit() {
return mOffscreen
PageLimit;
}
/**
* Set the number of
pages that should be retain
ed to either side of the
* current
page in the
view hierarchy in an idle state.
Pages beyond this
* limit will be recreat
ed from the adapter when ne
eded.
*
* <p>
* This is offer
ed as an optimization. If you know in advance the number of
*
pages you will ne
ed to support or have lazy-loading mechanisms in place
* on your
pages, tweaking this setting can have benefits in perceiv
ed
* smoothness of paging animations and interaction. If you have a small
* number of
pages (3-4) that you can keep active all at once, less time
* will be spent in layout for newly creat
ed view subtrees as the user
pages
* back and forth.
* </p>
*
* <p>
* You should keep this limit low, especially if your
pages have complex
* layouts. This setting defaults to 1.
* </p>
*
* @param limit
* How many
pages will be kept offscreen in an idle state.
*/
public void setOffscreen
PageLimit(int limit) {
if (limit < DEFAULT_OFFSCREEN_
PAGES) {
Log.w(TAG, "Request
ed offscreen
page limit " + limit
+ " too small; defaulting to " + DEFAULT_OFFSCREEN_
PAGES);
limit = DEFAULT_OFFSCREEN_
PAGES;
}
if (limit != mOffscreen
PageLimit) {
mOffscreen
PageLimit = limit;
populate();
}
}
/**
* Set the margin between
pages.
*
* @param marginPixels
* Distance between adjacent
pages in pixels
* @see #get
PageMargin()
* @see #set
PageMarginDrawable(Drawable)
* @see #set
PageMarginDrawable(int)
*/
public void set
PageMargin(int marginPixels) {
final int oldMargin = m
PageMargin;
m
PageMargin = marginPixels;
final int width = getWidth();
recompute
ScrollPosition(width, width, marginPixels, oldMargin);
requestLayout();
}
/**
* Return the margin between
pages.
*
* @return The size of the margin in pixels
*/
public int get
PageMargin() {
return m
PageMargin;
}
/**
* Set a drawable that will be us
ed to fill the margin between
pages.
*
* @param d
* Drawable to display between
pages
*/
public void set
PageMarginDrawable(Drawable d) {
mMarginDrawable = d;
if (d != null)
refreshDrawableState();
setWillNotDraw(d == null);
invalidate();
}
/**
* Set a drawable that will be us
ed to fill the margin between
pages.
*
* @param resId
* Resource ID of a drawable to display between
pages
*/
public void set
PageMarginDrawable(int resId) {
set
PageMarginDrawable(getContext().getResources().getDrawable(resId));
}
@Override
protect
ed boolean verifyDrawable(Drawable who) {
return super.verifyDrawable(who) || who == mMarginDrawable;
}
@Override
protect
ed void drawableStateChang
ed() {
super.drawableStateChang
ed();
final Drawable d = mMarginDrawable;
if (d != null && d.isStateful()) {
d.setState(getDrawableState());
}
}
// We want the duration of the
page snap animation to be influenc
ed by the
// distance that
// the screen has to travel, however, we don't want this duration to be
// effect
ed in a
// purely linear fashion. Instead, we use this method to moderate the effect
// that the distance
// of travel has on the overall snap duration.
float distanceInfluenceForSnapDuration(float f) {
f -= 0.5f; // center the values about 0.
f *= 0.3f * Math.PI / 2.0f;
return (float) Math.sin(f);
}
/**
* Like {@link
View#
scrollBy}, but
scroll smoothly instead of imm
ediately.
*
* @param x
* the number of pixels to
scroll by on the X axis
* @param y
* the number of pixels to
scroll by on the Y axis
*/
void smooth
ScrollTo(int x, int y) {
smooth
ScrollTo(x, y, 0);
}
/**
* Like {@link
View#
scrollBy}, but
scroll smoothly instead of imm
ediately.
*
* @param x
* the number of pixels to
scroll by on the X axis
* @param y
* the number of pixels to
scroll by on the Y axis
* @param velocity
* the velocity associat
ed with a fling, if applicable. (0
* otherwise)
*/
void smooth
ScrollTo(int x, int y, int velocity) {
if (getChildCount() == 0) {
// Nothing to do.
set
ScrollingCacheEnabl
ed(false);
return;
}
int sx = get
ScrollX();
int sy = get
ScrollY();
int dx = x - sx;
int dy = y - sy;
if (dx == 0 && dy == 0) {
complete
Scroll();
set
ScrollState(
SCROLL_STATE_IDLE);
return;
}
set
ScrollingCacheEnabl
ed(true);
m
Scrolling = true;
set
ScrollState(
SCROLL_STATE_SETTLING);
final float
pageDelta = (float) Math.abs(dx)
/ (getWidth() + m
PageMargin);
int duration = (int) (
pageDelta * 100);
velocity = Math.abs(velocity);
if (velocity > 0) {
duration += (duration / (velocity / mBaseLineFlingVelocity))
* mFlingVelocityInfluence;
} else {
duration += 100;
}
duration = Math.min(duration, MAX_SETTLE_DURATION);
m
Scroller.start
Scroll(sx, sy, dx, dy, duration);
invalidate();
}
void addNewItem(int position, int index) {
ItemInfo ii = new ItemInfo();
ii.position = position;
ii.object = mAdapter.instantiateItem(this, position);
if (index < 0) {
mItems.add(ii);
} else {
mItems.add(index, ii);
}
}
void dataSetChang
ed() {
// This method only gets call
ed if our observer is attach
ed, so mAdapter
// is non-null.
boolean ne
edPopulate = mItems.size() < 3
&& mItems.size() < mAdapter.getCount();
int newCurrItem = -1;
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos ==
PagerAdapter.POSITION_UNCHANG
ED) {
continue;
}
if (newPos ==
PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
mAdapter.destroyItem(this, ii.position, ii.object);
ne
edPopulate = true;
if (mCurItem == ii.position) {
// Keep the current item in the valid range
newCurrItem = Math.max(0,
Math.min(mCurItem, mAdapter.getCount() - 1));
}
continue;
}
if (ii.position != newPos) {
if (ii.position == mCurItem) {
// Our current item chang
ed position. Follow it.
newCurrItem = newPos;
}
ii.position = newPos;
ne
edPopulate = true;
}
}
Collections.sort(mItems, COMPARATOR);
if (newCurrItem >= 0) {
// TODO This currently causes a jump.
setCurrentItemInternal(newCurrItem, false, true);
ne
edPopulate = true;
}
if (ne
edPopulate) {
populate();
requestLayout();
}
}
void populate() {
if (mAdapter == null) {
return;
}
// Bail now if we are waiting to populate. This is to hold off
// on creating
views from the time the user releases their finger to
// fling to a new position until we have finish
ed the
scroll to
// that position, avoiding glitches from happening at that point.
if (mPopulatePending) {
if (DEBUG)
Log.i(TAG, "populate is pending, skipping for now...");
return;
}
// Also, don't populate until we are attach
ed to a window. This is to
// avoid trying to populate before we have restor
ed our
view hierarchy
// state and conflicting with what is restor
ed.
if (getWindowToken() == null) {
return;
}
mAdapter.startUpdate(this);
final int
pageLimit = mOffscreen
PageLimit;
final int startPos = Math.max(0, mCurItem -
pageLimit);
final int N = mAdapter.getCount();
final int endPos = Math.min(N - 1, mCurItem +
pageLimit);
if (DEBUG)
Log.v(TAG, "populating: startPos=" + startPos + " endPos=" + endPos);
// Add and remove
pages in the existing list.
int lastPos = -1;
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if ((ii.position < startPos || ii.position > endPos)
&& !ii.
scrolling) {
if (DEBUG)
Log.i(TAG, "removing: " + ii.position + " @ " + i);
mItems.remove(i);
i--;
mAdapter.destroyItem(this, ii.position, ii.object);
} else if (lastPos < endPos && ii.position > startPos) {
// The next item is outside of our range, but we have a gap
// between it and the last item where we want to have a
page
// shown. Fill in the gap.
lastPos++;
if (lastPos < startPos) {
lastPos = startPos;
}
while (lastPos <= endPos && lastPos < ii.position) {
if (DEBUG)
Log.i(TAG, "inserting: " + lastPos + " @ " + i);
addNewItem(lastPos, i);
lastPos++;
i++;
}
}
lastPos = ii.position;
}
// Add any new
pages we ne
ed at the end.
lastPos = mItems.size() > 0 ? mItems.get(mItems.size() - 1).position
: -1;
if (lastPos < endPos) {
lastPos++;
lastPos = lastPos > startPos ? lastPos : startPos;
while (lastPos <= endPos) {
if (DEBUG)
Log.i(TAG, "appending: " + lastPos);
addNewItem(lastPos, -1);
lastPos++;
}
}
if (DEBUG) {
Log.i(TAG, "Current
page list:");
for (int i = 0; i < mItems.size(); i++) {
Log.i(TAG, "#" + i + ":
page " + mItems.get(i).position);
}
}
ItemInfo curItem = null;
for (int i = 0; i < mItems.size(); i++) {
if (mItems.get(i).position == mCurItem) {
curItem = mItems.get(i);
break;
}
}
mAdapter.setPrimaryItem(this, mCurItem,
curItem != null ? curItem.object : null);
mAdapter.finishUpdate(this);
if (hasFocus()) {
View currentFocus
ed = findFocus();
ItemInfo ii = currentFocus
ed != null ? infoForAnyChild(currentFocus
ed)
: null;
if (ii == null || ii.position != mCurItem) {
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
if (child.requestFocus(FOCUS_FORWARD)) {
break;
}
}
}
}
}
}
public static class Sav
edState extends BaseSav
edState {
int position;
Parcelable adapterState;
ClassLoader loader;
public Sav
edState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(position);
out.writeParcelable(adapterState, flags);
}
@Override
public String toString() {
return "Fragment
Pager.Sav
edState{"
+ Integer.toHexString(System.identityHashCode(this))
+ " position=" + position + "}";
}
public static final Parcelable.Creator<Sav
edState> CREATOR = ParcelableCompat
.newCreator(new ParcelableCompatCreatorCallbacks<Sav
edState>() {
@Override
public Sav
edState createFromParcel(Parcel in,
ClassLoader loader) {
return new Sav
edState(in, loader);
}
@Override
public Sav
edState[] newArray(int size) {
return new Sav
edState[size];
}
});
Sav
edState(Parcel in, ClassLoader loader) {
super(in);
if (loader == null) {
loader = getClass().getClassLoader();
}
position = in.readInt();
adapterState = in.readParcelable(loader);
this.loader = loader;
}
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
Sav
edState ss = new Sav
edState(superState);
ss.position = mCurItem;
if (mAdapter != null) {
ss.adapterState = mAdapter.saveState();
}
return ss;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof Sav
edState)) {
super.onRestoreInstanceState(state);
return;
}
Sav
edState ss = (Sav
edState) state;
super.onRestoreInstanceState(ss.getSuperState());
if (mAdapter != null) {
mAdapter.restoreState(ss.adapterState, ss.loader);
setCurrentItemInternal(ss.position, false, true);
} else {
mRestor
edCurItem = ss.position;
mRestor
edAdapterState = ss.adapterState;
mRestor
edClassLoader = ss.loader;
}
}
@Override
public void add
View(
View child, int index, LayoutParams params) {
if (mInLayout) {
add
ViewInLayout(child, index, params);
child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
} else {
super.add
View(child, index, params);
}
if (USE_CACHE) {
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabl
ed(m
ScrollingCacheEnabl
ed);
} else {
child.setDrawingCacheEnabl
ed(false);
}
}
}
ItemInfo infoForChild(
View child) {
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (mAdapter.is
ViewFromObject(child, ii.object)) {
return ii;
}
}
return null;
}
ItemInfo infoForAnyChild(
View child) {
ViewParent parent;
while ((parent = child.getParent()) != this) {
if (parent == null || !(parent instanceof
View)) {
return null;
}
child = (
View) parent;
}
return infoForChild(child);
}
@Override
protect
ed void onAttach
edToWindow() {
super.onAttach
edToWindow();
mFirstLayout = true;
}
@Override
protect
ed void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// For simple implementation, or internal size is always 0.
// We depend on the container to specify the layout size of
// our
view. We can't really know what it is since we will be
// adding and removing different arbitrary
views and do not
// want the layout to change as this happens.
setMeasur
edDimension(getDefaultSize(0, widthMeasureSpec),
getDefaultSize(0, heightMeasureSpec));
// Children are just made to fill our space.
mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasur
edWidth()
- getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY);
mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
getMeasur
edHeight() - getPaddingTop() - getPaddingBottom(),
MeasureSpec.EXACTLY);
// Make sure we have creat
ed all fragments that we ne
ed to have shown.
mInLayout = true;
populate();
mInLayout = false;
// Make sure all children have been properly measur
ed.
final int size = getChildCount();
for (int i = 0; i < size; ++i) {
final
View child = getChildAt(i);
if (child.getVisibility() != GONE) {
if (DEBUG)
Log.v(TAG, "Measuring #" + i + " " + child + ": "
+ mChildWidthMeasureSpec);
child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec);
}
}
}
@Override
protect
ed void onSizeChang
ed(int w, int h, int oldw, int oldh) {
super.onSizeChang
ed(w, h, oldw, oldh);
// Make sure
scroll position is set correctly.
if (w != oldw) {
recompute
ScrollPosition(w, oldw, m
PageMargin, m
PageMargin);
}
}
private void recompute
ScrollPosition(int width, int oldWidth, int margin,
int oldMargin) {
final int widthWithMargin = width + margin;
if (oldWidth > 0) {
final int old
ScrollPos = get
ScrollX();
final int oldwwm = oldWidth + oldMargin;
final int old
ScrollItem = old
ScrollPos / oldwwm;
final float
scrollOffset = (float) (old
ScrollPos % oldwwm) / oldwwm;
final int
scrollPos = (int) ((old
ScrollItem +
scrollOffset) * widthWithMargin);
scrollTo(
scrollPos, get
ScrollY());
if (!m
Scroller.isFinish
ed()) {
// We now return to your regularly sch
edul
ed scroll, already in
// progress.
final int newDuration = m
Scroller.getDuration()
- m
Scroller.timePass
ed();
m
Scroller.start
Scroll(
scrollPos, 0, mCurItem * widthWithMargin,
0, newDuration);
}
} else {
int
scrollPos = mCurItem * widthWithMargin;
if (
scrollPos != get
ScrollX()) {
complete
Scroll();
scrollTo(
scrollPos, get
ScrollY());
}
}
}
@Override
protect
ed void onLayout(boolean chang
ed, int l, int t, int r, int b) {
mInLayout = true;
populate();
mInLayout = false;
final int count = getChildCount();
final int width = r - l;
for (int i = 0; i < count; i++) {
View child = getChildAt(i);
ItemInfo ii;
if (child.getVisibility() != GONE
&& (ii = infoForChild(child)) != null) {
int loff = (width + m
PageMargin) * ii.position;
int childLeft = getPaddingLeft() + loff;
int childTop = getPaddingTop();
if (DEBUG)
Log.v(TAG,
"Positioning #" + i + " " + child + " f="
+ ii.object + ":" + childLeft + ","
+ childTop + " " + child.getMeasur
edWidth()
+ "x" + child.getMeasur
edHeight());
child.layout(childLeft, childTop,
childLeft + child.getMeasur
edWidth(),
childTop + child.getMeasur
edHeight());
}
}
mFirstLayout = false;
}
@Override
public void compute
Scroll() {
if (DEBUG)
Log.i(TAG, "compute
Scroll: finish
ed=" + m
Scroller.isFinish
ed());
if (!m
Scroller.isFinish
ed()) {
if (m
Scroller.compute
ScrollOffset()) {
if (DEBUG)
Log.i(TAG, "compute
Scroll: still
scrolling");
int oldX = get
ScrollX();
int oldY = get
ScrollY();
int x = m
Scroller.getCurrX();
int y = m
Scroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
}
if (mOn
PageChangeListener != null) {
final int widthWithMargin = getWidth() + m
PageMargin;
final int position = x / widthWithMargin;
final int offsetPixels = x % widthWithMargin;
final float offset = (float) offsetPixels / widthWithMargin;
mOn
PageChangeListener.on
PageScrolled(position, offset,
offsetPixels);
}
// Keep on drawing until the animation has finish
ed.
invalidate();
return;
}
}
// Done with
scroll, clean up state.
complete
Scroll();
}
private void complete
Scroll() {
boolean ne
edPopulate = m
Scrolling;
if (ne
edPopulate) {
// Done with
scroll, no longer want to cache
view drawing.
set
ScrollingCacheEnabl
ed(false);
m
Scroller.abortAnimation();
int oldX = get
ScrollX();
int oldY = get
ScrollY();
int x = m
Scroller.getCurrX();
int y = m
Scroller.getCurrY();
if (oldX != x || oldY != y) {
scrollTo(x, y);
}
set
ScrollState(
SCROLL_STATE_IDLE);
}
mPopulatePending = false;
m
Scrolling = false;
for (int i = 0; i < mItems.size(); i++) {
ItemInfo ii = mItems.get(i);
if (ii.
scrolling) {
ne
edPopulate = true;
ii.
scrolling = false;
}
}
if (ne
edPopulate) {
populate();
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
/*
* This method JUST determines whether we want to intercept the motion.
* If we return true, onMotionEvent will be call
ed and we do the actual
*
scrolling there.
*/
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
// Always take care of the touch gesture being complete.
if (action == MotionEvent.ACTION_CANCEL
|| action == MotionEvent.ACTION_UP) {
// Release the drag.
if (DEBUG)
Log.v(TAG, "Intercept done!");
mIsBeingDragg
ed = false;
mIsUnableToDrag = false;
mActivePointerId = INVALID_POINTER;
return false;
}
// Nothing more to do here if we have decid
ed whether or not we
// are dragging.
if (action != MotionEvent.ACTION_DOWN) {
if (mIsBeingDragg
ed) {
if (DEBUG)
Log.v(TAG, "Intercept returning true!");
return true;
}
if (mIsUnableToDrag) {
if (DEBUG)
Log.v(TAG, "Intercept returning false!");
return false;
}
}
switch (action) {
case MotionEvent.ACTION_MOVE: {
/*
* mIsBeingDragg
ed == false, otherwise the shortcut would have
* caught it. Check whether the user has mov
ed far enough from his
* original down touch.
*/
/*
* Locally do absolute value. mLastMotionY is set to the y value of
* the down event.
*/
final int activePointerId = mActivePointerId;
if (activePointerId == INVALID_POINTER) {
// If we don't have a valid id, the touch down wasn't on
// content.
break;
}
final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
activePointerId);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float dx = x - mLastMotionX;
final float xDiff = Math.abs(dx);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float yDiff = Math.abs(y - mLastMotionY);
final int
scrollX = get
ScrollX();
final boolean at
Edge = (dx > 0 &&
scrollX == 0)
|| (dx < 0 && mAdapter != null &&
scrollX >= (mAdapter
.getCount() - 1) * getWidth() - 1);
if (DEBUG)
Log.v(TAG, "Mov
ed x to " + x + "," + y + " diff=" + xDiff + ","
+ yDiff);
if (can
Scroll(this, false, (int) dx, (int) x, (int) y)) {
// Nest
ed view has
scrollable area under this point. Let it be
// handl
ed there.
mInitialMotionX = mLastMotionX = x;
mLastMotionY = y;
return false;
}
if (xDiff > mTouchSlop && xDiff > yDiff) {
if (DEBUG)
Log.v(TAG, "Starting drag!");
mIsBeingDragg
ed = true;
set
ScrollState(
SCROLL_STATE_DRAGGING);
mLastMotionX = x;
set
ScrollingCacheEnabl
ed(true);
} else {
if (yDiff > mTouchSlop) {
// The finger has mov
ed enough in the vertical
// direction to be count
ed as a drag... abort
// any attempt to drag horizontally, to work correctly
// with children that have
scrolling containers.
if (DEBUG)
Log.v(TAG, "Starting unable to drag!");
mIsUnableToDrag = true;
}
}
break;
}
case MotionEvent.ACTION_DOWN: {
/*
* Remember location of down touch. ACTION_DOWN always refers to
* pointer index 0.
*/
mLastMotionX = mInitialMotionX = ev.getX();
mLastMotionY = ev.getY();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
if (m
ScrollState ==
SCROLL_STATE_SETTLING) {
// Let the user 'catch' the
pager as it animates.
mIsBeingDragg
ed = true;
mIsUnableToDrag = false;
set
ScrollState(
SCROLL_STATE_DRAGGING);
} else {
complete
Scroll();
mIsBeingDragg
ed = false;
mIsUnableToDrag = false;
}
if (DEBUG)
Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY
+ " mIsBeingDragg
ed=" + mIsBeingDragg
ed
+ "mIsUnableToDrag=" + mIsUnableToDrag);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
break;
}
/*
* The only time we want to intercept motion events is if we are in the
* drag mode.
*/
return mIsBeingDragg
ed;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
if (mFak
eDragging) {
// A fake drag is in progress already, ignore this real one
// but still eat the touch events.
// (It is likely that the user is multi-touching the screen.)
return true;
}
if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.get
EdgeFlags() != 0) {
// Don't handle
edge touches imm
ediately -- they may actually belong
// to one of our
// descendants.
return false;
}
if (mAdapter == null || mAdapter.getCount() == 0) {
// Nothing to present or
scroll; nothing to touch.
return false;
}
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
}
mVelocityTracker.addMovement(ev);
final int action = ev.getAction();
boolean ne
edsInvalidate = false;
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
/*
* If being fling
ed and user touches, stop the fling. isFinish
ed
* will be false if being fling
ed.
*/
complete
Scroll();
// Remember where the motion event start
ed
mLastMotionX = mInitialMotionX = ev.getX();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
break;
}
case MotionEvent.ACTION_MOVE:
if (!mIsBeingDragg
ed) {
final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
mActivePointerId);
final float x = MotionEventCompat.getX(ev, pointerIndex);
final float xDiff = Math.abs(x - mLastMotionX);
final float y = MotionEventCompat.getY(ev, pointerIndex);
final float yDiff = Math.abs(y - mLastMotionY);
if (DEBUG)
Log.v(TAG, "Mov
ed x to " + x + "," + y + " diff=" + xDiff
+ "," + yDiff);
if (xDiff > mTouchSlop && xDiff > yDiff) {
if (DEBUG)
Log.v(TAG, "Starting drag!");
mIsBeingDragg
ed = true;
mLastMotionX = x;
set
ScrollState(
SCROLL_STATE_DRAGGING);
set
ScrollingCacheEnabl
ed(true);
}
}
if (mIsBeingDragg
ed) {
//
Scroll to follow the motion event
final int activePointerIndex = MotionEventCompat
.findPointerIndex(ev, mActivePointerId);
final float x = MotionEventCompat.getX(ev, activePointerIndex);
final float deltaX = mLastMotionX - x;
mLastMotionX = x;
float old
ScrollX = get
ScrollX();
float
scrollX = old
ScrollX + deltaX;
final int width = getWidth();
final int widthWithMargin = width + m
PageMargin;
final int lastItemIndex = mAdapter.getCount() - 1;
final float leftBound = Math.max(0, (mCurItem - 1)
* widthWithMargin);
final float rightBound = Math.min(mCurItem + 1, lastItemIndex)
* widthWithMargin;
if (
scrollX < leftBound) {
if (leftBound == 0) {
float over = -
scrollX;
ne
edsInvalidate = mLeft
Edge.onPull(over / width);
}
scrollX = leftBound;
} else if (
scrollX > rightBound) {
if (rightBound == lastItemIndex * widthWithMargin) {
float over =
scrollX - rightBound;
ne
edsInvalidate = mRight
Edge.onPull(over / width);
}
scrollX = rightBound;
}
// Don't lose the round
ed component
mLastMotionX +=
scrollX - (int)
scrollX;
scrollTo((int)
scrollX, get
ScrollY());
if (mOn
PageChangeListener != null) {
final int position = (int)
scrollX / widthWithMargin;
final int positionOffsetPixels = (int)
scrollX
% widthWithMargin;
final float positionOffset = (float) positionOffsetPixels
/ widthWithMargin;
mOn
PageChangeListener.on
PageScrolled(position,
positionOffset, positionOffsetPixels);
}
}
break;
case MotionEvent.ACTION_UP:
if (mIsBeingDragg
ed) {
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
velocityTracker, mActivePointerId);
mPopulatePending = true;
final int widthWithMargin = getWidth() + m
PageMargin;
final int
scrollX = get
ScrollX();
// 澧炲姞杈硅窛鍒ゆ柇
int current
Page =
scrollX / widthWithMargin;
int left
PageScorll =
scrollX % widthWithMargin;
int next
Page = current
Page;
float chargeVelocity = initialVelocity;
if (chargeVelocity > 0) {
// 鍚戝彸
if (widthWithMargin - left
PageScorll > m
PagerNextMarginPixels) {
next
Page = current
Page;
} else {
next
Page = current
Page + 1;
}
} else {
// 鍚戝乏
if (left
PageScorll > m
PagerNextMarginPixels) {
next
Page = current
Page + 1;
} else {
next
Page = current
Page;
}
}
// next
Page = chargeVelocity > 0 ? current
Page
// : current
Page + 1;
// Log.d(TAG, "initialVelocity:" + initialVelocity
// + ", current
Page: " + (
scrollX / widthWithMargin)
// + ", widthWithMargin: " + widthWithMargin
// + ",
scrollX: " +
scrollX + ", chargeVelocity: "
// + chargeVelocity + ", next
Page: " + next
Page);
setCurrentItemInternal(next
Page, true, true, initialVelocity);
mActivePointerId = INVALID_POINTER;
endDrag();
ne
edsInvalidate = mLeft
Edge.onRelease()
| mRight
Edge.onRelease();
}
break;
case MotionEvent.ACTION_CANCEL:
if (mIsBeingDragg
ed) {
setCurrentItemInternal(mCurItem, true, true);
mActivePointerId = INVALID_POINTER;
endDrag();
ne
edsInvalidate = mLeft
Edge.onRelease()
| mRight
Edge.onRelease();
}
break;
case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
final float x = MotionEventCompat.getX(ev, index);
mLastMotionX = x;
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
onSecondaryPointerUp(ev);
mLastMotionX = MotionEventCompat.getX(ev,
MotionEventCompat.findPointerIndex(ev, mActivePointerId));
break;
}
if (ne
edsInvalidate) {
invalidate();
}
return true;
}
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
boolean ne
edsInvalidate = false;
final int over
ScrollMode =
ViewCompat.getOver
ScrollMode(this);
if (over
ScrollMode ==
ViewCompat.OVER_
SCROLL_ALWAYS
|| (over
ScrollMode ==
ViewCompat.OVER_
SCROLL_IF_CONTENT_
SCROLLS
&& mAdapter != null && mAdapter.getCount() > 1)) {
if (!mLeft
Edge.isFinish
ed()) {
final int restoreCount = canvas.save();
final int height = getHeight() - getPaddingTop()
- getPaddingBottom();
canvas.rotate(270);
canvas.translate(-height + getPaddingTop(), 0);
mLeft
Edge.setSize(height, getWidth());
ne
edsInvalidate |= mLeft
Edge.draw(canvas);
canvas.restoreToCount(restoreCount);
}
if (!mRight
Edge.isFinish
ed()) {
final int restoreCount = canvas.save();
final int width = getWidth();
final int height = getHeight() - getPaddingTop()
- getPaddingBottom();
final int itemCount = mAdapter != null ? mAdapter.getCount()
: 1;
canvas.rotate(90);
canvas.translate(-getPaddingTop(), -itemCount
* (width + m
PageMargin) + m
PageMargin);
mRight
Edge.setSize(height, width);
ne
edsInvalidate |= mRight
Edge.draw(canvas);
canvas.restoreToCount(restoreCount);
}
} else {
mLeft
Edge.finish();
mRight
Edge.finish();
}
if (ne
edsInvalidate) {
// Keep animating
invalidate();
}
}
@Override
protect
ed void onDraw(Canvas canvas) {
super.onDraw(canvas);
// Draw the margin drawable if ne
eded.
if (m
PageMargin > 0 && mMarginDrawable != null) {
final int
scrollX = get
ScrollX();
final int width = getWidth();
final int offset =
scrollX % (width + m
PageMargin);
if (offset != 0) {
//
Pages fit completely when settl
ed; we only ne
ed to draw when
// in between
final int left =
scrollX - offset + width;
mMarginDrawable.setBounds(left, 0, left + m
PageMargin,
getHeight());
mMarginDrawable.draw(canvas);
}
}
}
/**
* Start a fake drag of the
pager.
*
* <p>
* A fake drag can be useful if you want to synchronize the motion of the
*
ViewPager with the touch
scrolling of another
view, while still letting
* the
ViewPager control the snapping motion and fling behavior. (e.g.
* parallax-
scrolling tabs.) Call {@link #fak
eDragBy(float)} to simulate the
* actual drag motion. Call {@link #endFak
eDrag()} to complete the fake drag
* and fling as necessary.
*
* <p>
* During a fake drag the
ViewPager will ignore all touch events. If a real
* drag is already in progress, this method will return false.
*
* @return true if the fake drag began successfully, false if it could not
* be start
ed.
*
* @see #fak
eDragBy(float)
* @see #endFak
eDrag()
*/
public boolean beginFak
eDrag() {
if (mIsBeingDragg
ed) {
return false;
}
mFak
eDragging = true;
set
ScrollState(
SCROLL_STATE_DRAGGING);
mInitialMotionX = mLastMotionX = 0;
if (mVelocityTracker == null) {
mVelocityTracker = VelocityTracker.obtain();
} else {
mVelocityTracker.clear();
}
final long time = SystemClock.uptimeMillis();
final MotionEvent ev = MotionEvent.obtain(time, time,
MotionEvent.ACTION_DOWN, 0, 0, 0);
mVelocityTracker.addMovement(ev);
ev.recycle();
mFak
eDragBeginTime = time;
return true;
}
/**
* End a fake drag of the
pager.
*
* @see #beginFak
eDrag()
* @see #fak
eDragBy(float)
*/
public void endFak
eDrag() {
Log.d(TAG, "endFak
eDrag");
if (!mFak
eDragging) {
throw new IllegalStateException(
"No fake drag in progress. Call beginFak
eDrag first.");
}
final VelocityTracker velocityTracker = mVelocityTracker;
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(
velocityTracker, mActivePointerId);
mPopulatePending = true;
Log.d(TAG,
"initialVelocity: " + initialVelocity
+ ", Math.abs(mInitialMotionX - mLastMotionX): "
+ Math.abs(mInitialMotionX - mLastMotionX));
if ((Math.abs(initialVelocity) > mMinimumVelocity)
|| Math.abs(mInitialMotionX - mLastMotionX) >= (getWidth() / 3)) {
if (mLastMotionX > mInitialMotionX) {
setCurrentItemInternal(mCurItem - 1, true, true);
} else {
setCurrentItemInternal(mCurItem + 1, true, true);
}
} else {
setCurrentItemInternal(mCurItem, true, true);
}
endDrag();
mFak
eDragging = false;
}
/**
* Fake drag by an offset in pixels. You must have call
ed
* {@link #beginFak
eDrag()} first.
*
* @param xOffset
* Offset in pixels to drag by.
* @see #beginFak
eDrag()
* @see #endFak
eDrag()
*/
public void fak
eDragBy(float xOffset) {
if (!mFak
eDragging) {
throw new IllegalStateException(
"No fake drag in progress. Call beginFak
eDrag first.");
}
mLastMotionX += xOffset;
float
scrollX = get
ScrollX() - xOffset;
final int width = getWidth();
final int widthWithMargin = width + m
PageMargin;
final float leftBound = Math.max(0, (mCurItem - 1) * widthWithMargin);
final float rightBound = Math
.min(mCurItem + 1, mAdapter.getCount() - 1) * widthWithMargin;
if (
scrollX < leftBound) {
scrollX = leftBound;
} else if (
scrollX > rightBound) {
scrollX = rightBound;
}
// Don't lose the round
ed component
mLastMotionX +=
scrollX - (int)
scrollX;
scrollTo((int)
scrollX, get
ScrollY());
if (mOn
PageChangeListener != null) {
final int position = (int)
scrollX / widthWithMargin;
final int positionOffsetPixels = (int)
scrollX % widthWithMargin;
final float positionOffset = (float) positionOffsetPixels
/ widthWithMargin;
mOn
PageChangeListener.on
PageScrolled(position, positionOffset,
positionOffsetPixels);
}
// Synthesize an event for the VelocityTracker.
final long time = SystemClock.uptimeMillis();
final MotionEvent ev = MotionEvent.obtain(mFak
eDragBeginTime, time,
MotionEvent.ACTION_MOVE, mLastMotionX, 0, 0);
mVelocityTracker.addMovement(ev);
ev.recycle();
}
/**
* Returns true if a fake drag is in progress.
*
* @return true if currently in a fake drag, false otherwise.
*
* @see #beginFak
eDrag()
* @see #fak
eDragBy(float)
* @see #endFak
eDrag()
*/
public boolean isFak
eDragging() {
return mFak
eDragging;
}
private void onSecondaryPointerUp(MotionEvent ev) {
final int pointerIndex = MotionEventCompat.getActionIndex(ev);
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
if (pointerId == mActivePointerId) {
// This was our active pointer going up. Choose a new
// active pointer and adjust accordingly.
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
mActivePointerId = MotionEventCompat.getPointerId(ev,
newPointerIndex);
if (mVelocityTracker != null) {
mVelocityTracker.clear();
}
}
}
private void endDrag() {
mIsBeingDragg
ed = false;
mIsUnableToDrag = false;
if (mVelocityTracker != null) {
mVelocityTracker.recycle();
mVelocityTracker = null;
}
}
private void set
ScrollingCacheEnabl
ed(boolean enabl
ed) {
if (m
ScrollingCacheEnabl
ed != enabl
ed) {
m
ScrollingCacheEnabl
ed = enabl
ed;
if (USE_CACHE) {
final int size = getChildCount();
for (int i = 0; i < size; ++i) {
final
View child = getChildAt(i);
if (child.getVisibility() != GONE) {
child.setDrawingCacheEnabl
ed(enabl
ed);
}
}
}
}
}
/**
* Tests
scrollability within child
views of v given a delta of dx.
*
* @param v
*
View to test for horizontal
scrollability
* @param checkV
* Whether the
view v pass
ed should itself be check
ed for
*
scrollability (true), or just its children (false).
* @param dx
* Delta
scrolled in pixels
* @param x
* X coordinate of the active touch point
* @param y
* Y coordinate of the active touch point
* @return true if child
views of v can be
scrolled by delta of dx.
*/
protect
ed boolean can
Scroll(
View v, boolean checkV, int dx, int x, int y) {
if (v instanceof
ViewGroup) {
final
ViewGroup group = (
ViewGroup) v;
final int
scrollX = v.get
ScrollX();
final int
scrollY = v.get
ScrollY();
final int count = group.getChildCount();
// Count backwards - let topmost
views consume
scroll distance
// first.
for (int i = count - 1; i >= 0; i--) {
// TODO: Add version
ed support here for transform
ed views.
// This will not work for transform
ed views in Honeycomb+
final
View child = group.getChildAt(i);
if (x +
scrollX >= child.getLeft()
&& x +
scrollX < child.getRight()
&& y +
scrollY >= child.getTop()
&& y +
scrollY < child.getBottom()
&& can
Scroll(child, true, dx,
x +
scrollX - child.getLeft(), y +
scrollY
- child.getTop())) {
return true;
}
}
}
return checkV &&
ViewCompat.can
ScrollHorizontally(v, -dx);
}
@Override
public boolean dispatchKeyEvent(KeyEvent event) {
// Let the focus
ed view and/or our descendants get the key first
return super.dispatchKeyEvent(event) || executeKeyEvent(event);
}
/**
* You can call this function yourself to have the
scroll view perform
*
scrolling from a key event, just as if the event had been dispatch
ed to
* it by the
view hierarchy.
*
* @param event
* The key event to execute.
* @return Return true if the event was handl
ed, else false.
*/
public boolean executeKeyEvent(KeyEvent event) {
boolean handl
ed = false;
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (event.getKeyCode()) {
case KeyEvent.KEYCODE_DPAD_LEFT:
handl
ed = arrow
Scroll(FOCUS_LEFT);
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
handl
ed = arrow
Scroll(FOCUS_RIGHT);
break;
case KeyEvent.KEYCODE_TAB:
if (KeyEventCompat.hasNoModifiers(event)) {
handl
ed = arrow
Scroll(FOCUS_FORWARD);
} else if (KeyEventCompat.hasModifiers(event,
KeyEvent.META_SHIFT_ON)) {
handl
ed = arrow
Scroll(FOCUS_BACKWARD);
}
break;
}
}
return handl
ed;
}
public boolean arrow
Scroll(int direction) {
View currentFocus
ed = findFocus();
if (currentFocus
ed == this)
currentFocus
ed = null;
boolean handl
ed = false;
View nextFocus
ed = FocusFinder.getInstance().findNextFocus(this,
currentFocus
ed, direction);
if (nextFocus
ed != null && nextFocus
ed != currentFocus
ed) {
if (direction ==
View.FOCUS_LEFT) {
// If there is nothing to the left, or this is causing us to
// jump to the right, then what we really want to do is
page
// left.
if (currentFocus
ed != null
&& nextFocus
ed.getLeft() >= currentFocus
ed.getLeft()) {
handl
ed =
pageLeft();
} else {
handl
ed = nextFocus
ed.requestFocus();
}
} else if (direction ==
View.FOCUS_RIGHT) {
// If there is nothing to the right, or this is causing us to
// jump to the left, then what we really want to do is
page
// right.
if (currentFocus
ed != null
&& nextFocus
ed.getLeft() <= currentFocus
ed.getLeft()) {
handl
ed =
pageRight();
} else {
handl
ed = nextFocus
ed.requestFocus();
}
}
} else if (direction == FOCUS_LEFT || direction == FOCUS_BACKWARD) {
// Trying to move left and nothing there; try to
page.
handl
ed =
pageLeft();
} else if (direction == FOCUS_RIGHT || direction == FOCUS_FORWARD) {
// Trying to move right and nothing there; try to
page.
handl
ed =
pageRight();
}
if (handl
ed) {
playSoundEffect(SoundEffectConstants
.getContantForFocusDirection(direction));
}
return handl
ed;
}
boolean
pageLeft() {
if (mCurItem > 0) {
setCurrentItem(mCurItem - 1, true);
return true;
}
return false;
}
boolean
pageRight() {
if (mAdapter != null && mCurItem < (mAdapter.getCount() - 1)) {
setCurrentItem(mCurItem + 1, true);
return true;
}
return false;
}
/**
* We only want the current
page that is being shown to be focusable.
*/
@Override
public void addFocusables(ArrayList<
View>
views, int direction,
int focusableMode) {
final int focusableCount =
views.size();
final int descendantFocusability = getDescendantFocusability();
if (descendantFocusability != FOCUS_BLOCK_DESCENDANTS) {
for (int i = 0; i < getChildCount(); i++) {
final
View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
child.addFocusables(
views, direction, focusableMode);
}
}
}
}
// 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())) {
// Note that we can't call the superclass here, because it will
// add all
views in. So we ne
ed 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);
}
}
}
/**
* We only want the current
page that is being shown to be touchable.
*/
@Override
public void addTouchables(ArrayList<
View>
views) {
// Note that we don't call super.addTouchables(), which means that
// we don't call
View.addTouchables(). This is okay because a
ViewPager
// is itself not touchable.
for (int i = 0; i < getChildCount(); i++) {
final
View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
child.addTouchables(
views);
}
}
}
}
/**
* We only want the current
page that is being shown to be focusable.
*/
@Override
protect
ed boolean onRequestFocusInDescendants(int direction,
Rect previouslyFocus
edRect) {
int index;
int increment;
int end;
int count = getChildCount();
if ((direction & FOCUS_FORWARD) != 0) {
index = 0;
increment = 1;
end = count;
} else {
index = count - 1;
increment = -1;
end = -1;
}
for (int i = index; i != end; i += increment) {
View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem) {
if (child.requestFocus(direction, previouslyFocus
edRect)) {
return true;
}
}
}
}
return false;
}
@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
//
ViewPagers should only report accessibility info for the current
//
page,
// otherwise things get very confusing.
// TODO: Should this note something about the paging container?
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final
View child = getChildAt(i);
if (child.getVisibility() == VISIBLE) {
final ItemInfo ii = infoForChild(child);
if (ii != null && ii.position == mCurItem
&& child.dispatchPopulateAccessibilityEvent(event)) {
return true;
}
}
}
return false;
}
760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
