完美解决关于禁止ViewPager预加载的相关问题

package com.plumcot.usb.view; 
/* 
* Copyright (C) 2011 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. 
*/ 
import android.content.Context; 
import android.database.DataSetObserver; 
import android.graphics.Canvas; 
import android.graphics.Rect; 
import android.graphics.drawable.Drawable; 
import android.os.Parcel; 
import android.os.Parcelable; 
import android.os.SystemClock; 
import android.support.v4.os.ParcelableCompat; 
import android.support.v4.os.ParcelableCompatCreatorCallbacks; 
import android.support.v4.view.KeyEventCompat; 
import android.support.v4.view.MotionEventCompat; 
import android.support.v4.view.PagerAdapter; 
import android.support.v4.view.VelocityTrackerCompat; 
import android.support.v4.view.ViewCompat; 
import android.support.v4.view.ViewConfigurationCompat; 
import android.support.v4.widget.EdgeEffectCompat; 
import android.util.AttributeSet; 
import android.util.Log; 
import android.view.FocusFinder; 
import android.view.KeyEvent; 
import android.view.MotionEvent; 
import android.view.SoundEffectConstants; 
import android.view.VelocityTracker; 
import android.view.View; 
import android.view.ViewConfiguration; 
import android.view.ViewGroup; 
import android.view.ViewParent; 
import android.view.accessibility.AccessibilityEvent; 
import android.view.animation.Interpolator; 
import android.widget.Scroller; 
import java.util.ArrayList; 
import java.util.Collections; 
import java.util.Comparator; 
/** 
* Layout manager that allows the user to flip left and right 
* through pages of data. You supply an implementation of a 
* {@link android.support.v4.view.PagerAdapter} to generate the pages that the view shows. 
* 
* <p Note this class is currently under early design and 
* development. The API will likely change in later updates of 
* the compatibility library, requiring changes to the source code 
* of apps when they are compiled against the newer version.</p  
*/ 
public class NoPreloadViewPager extends ViewGroup { 
private static final String TAG = "<span style="font-family:Arial, Helvetica, sans-serif;" NoPreLoadViewPager</span "; 
private static final boolean DEBUG = false; 
private static final boolean USE_CACHE = false; 
private static final int DEFAULT_OFFSCREEN_PAGES = 0;//默认是1 
private static final int MAX_SETTLE_DURATION = 600; // ms 
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 displayed page. 
private int mRestoredCurItem = -1; 
private Parcelable mRestoredAdapterState = null; 
private ClassLoader mRestoredClassLoader = null; 
private Scroller mScroller; 
private PagerObserver mObserver; 
private int mPageMargin; 
private Drawable mMarginDrawable; 
private int mChildWidthMeasureSpec; 
private int mChildHeightMeasureSpec; 
private boolean mInLayout; 
private boolean mScrollingCacheEnabled; 
private boolean mPopulatePending; 
private boolean mScrolling; 
private int mOffscreenPageLimit = DEFAULT_OFFSCREEN_PAGES; 
private boolean mIsBeingDragged; 
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 used to retain consistency during 
* drags/flings if multiple pointers are used. 
*/ 
private int mActivePointerId = INVALID_POINTER; 
/** 
* Sentinel value for no current active pointer. 
* Used by {@link #mActivePointerId}. 
*/ 
private static final int INVALID_POINTER = -1; 
/** 
* Determines speed during touch scrolling 
*/ 
private VelocityTracker mVelocityTracker; 
private int mMinimumVelocity; 
private int mMaximumVelocity; 
private float mBaseLineFlingVelocity; 
private float mFlingVelocityInfluence; 
private boolean mFakeDragging; 
private long mFakeDragBeginTime; 
private EdgeEffectCompat mLeftEdge; 
private EdgeEffectCompat mRightEdge; 
private boolean mFirstLayout = true; 
private OnPageChangeListener mOnPageChangeListener; 
/** 
* Indicates that the pager is in an idle, settled 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 dragged 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 mScrollState = SCROLL_STATE_IDLE; 
/** 
* Callback interface for responding to changing state of the selected page. 
*/ 
public interface OnPageChangeListener { 
/** 
* This method will be invoked when the current page is scrolled, either as part 
* of a programmatically initiated smooth scroll or a user initiated touch scroll. 
* 
* @param position Position index of the first page currently being displayed. 
*         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 onPageScrolled(int position, float positionOffset, int positionOffsetPixels); 
/** 
* This method will be invoked when a new page becomes selected. Animation is not 
* necessarily complete. 
* 
* @param position Position index of the new selected page. 
*/ 
public void onPageSelected(int position); 
/** 
* Called 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 stopped/idle. 
* 
* @param state The new scroll state. 
* @see android.support.v4.view.ViewPager#SCROLL_STATE_IDLE 
* @see android.support.v4.view.ViewPager#SCROLL_STATE_DRAGGING 
* @see android.support.v4.view.ViewPager#SCROLL_STATE_SETTLING 
*/ 
public void onPageScrollStateChanged(int state); 
} 
/** 
* Simple implementation of the {@link android.support.v4.view.LazyViewPager.OnPageChangeListener} interface with stub 
* implementations of each method. Extend this if you do not intend to override 
* every method of {@link android.support.v4.view.LazyViewPager.OnPageChangeListener}. 
*/ 
public static class SimpleOnPageChangeListener implements OnPageChangeListener { 
@Override 
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 
// This space for rent 
} 
@Override 
public void onPageSelected(int position) { 
// This space for rent 
} 
@Override 
public void onPageScrollStateChanged(int state) { 
// This space for rent 
} 
} 
public NoPreloadViewPager(Context context) { 
super(context); 
initViewPager(); 
} 
public NoPreloadViewPager(Context context, AttributeSet attrs) { 
super(context, attrs); 
initViewPager(); 
} 
void initViewPager() { 
setWillNotDraw(false); 
setDescendantFocusability(FOCUS_AFTER_DESCENDANTS); 
setFocusable(true); 
final Context context = getContext(); 
mScroller = new Scroller(context, sInterpolator); 
final ViewConfiguration configuration = ViewConfiguration.get(context); 
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration); 
mMinimumVelocity = configuration.getScaledMinimumFlingVelocity(); 
mMaximumVelocity = configuration.getScaledMaximumFlingVelocity(); 
mLeftEdge = new EdgeEffectCompat(context); 
mRightEdge = new EdgeEffectCompat(context); 
float density = context.getResources().getDisplayMetrics().density; 
mBaseLineFlingVelocity = 2500.0f * density; 
mFlingVelocityInfluence = 0.4f; 
} 
private void setScrollState(int newState) { 
if (mScrollState == newState) { 
return; 
} 
mScrollState = newState; 
if (mOnPageChangeListener != null) { 
mOnPageChangeListener.onPageScrollStateChanged(newState); 
} 
} 
public void setAdapter(PagerAdapter adapter) { 
if (mAdapter != null) { 
//      mAdapter.unregisterDataSetObserver(mObserver); 
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(); 
removeAllViews(); 
mCurItem = 0; 
scrollTo(0, 0); 
} 
mAdapter = adapter; 
if (mAdapter != null) { 
if (mObserver == null) { 
mObserver = new PagerObserver(); 
} 
//      mAdapter.registerDataSetObserver(mObserver); 
mPopulatePending = false; 
if (mRestoredCurItem  = 0) { 
mAdapter.restoreState(mRestoredAdapterState, mRestoredClassLoader); 
setCurrentItemInternal(mRestoredCurItem, false, true); 
mRestoredCurItem = -1; 
mRestoredAdapterState = null; 
mRestoredClassLoader = null; 
} else { 
populate(); 
} 
} 
} 
public PagerAdapter getAdapter() { 
return mAdapter; 
} 
/** 
* Set the currently selected page. If the ViewPager has already been through its first 
* layout there will be a smooth animated transition between the current item and the 
* specified item. 
* 
* @param item Item index to select 
*/ 
public void setCurrentItem(int item) { 
mPopulatePending = false; 
setCurrentItemInternal(item, !mFirstLayout, false); 
} 
/** 
* Set the currently selected page. 
* 
* @param item Item index to select 
* @param smoothScroll True to smoothly scroll to the new item, false to transition immediately 
*/ 
public void setCurrentItem(int item, boolean smoothScroll) { 
mPopulatePending = false; 
setCurrentItemInternal(item, smoothScroll, false); 
} 
public int getCurrentItem() { 
return mCurItem; 
} 
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) { 
setCurrentItemInternal(item, smoothScroll, always, 0); 
} 
void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) { 
if (mAdapter == null || mAdapter.getCount() <= 0) { 
setScrollingCacheEnabled(false); 
return; 
} 
if (!always && mCurItem == item && mItems.size() != 0) { 
setScrollingCacheEnabled(false); 
return; 
} 
if (item < 0) { 
item = 0; 
} else if (item  = mAdapter.getCount()) { 
item = mAdapter.getCount() - 1; 
} 
final int pageLimit = mOffscreenPageLimit; 
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 dispatchSelected = mCurItem != item; 
mCurItem = item; 
populate(); 
final int destX = (getWidth() + mPageMargin) * item; 
if (smoothScroll) { 
smoothScrollTo(destX, 0, velocity); 
if (dispatchSelected && mOnPageChangeListener != null) { 
mOnPageChangeListener.onPageSelected(item); 
} 
} else { 
if (dispatchSelected && mOnPageChangeListener != null) { 
mOnPageChangeListener.onPageSelected(item); 
} 
completeScroll(); 
scrollTo(destX, 0); 
} 
} 
public void setOnPageChangeListener(OnPageChangeListener listener) { 
mOnPageChangeListener = listener; 
} 
/** 
* Returns the number of pages that will be retained 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 #setOffscreenPageLimit(int) 
*/ 
public int getOffscreenPageLimit() { 
return mOffscreenPageLimit; 
} 
/** 
* Set the number of pages that should be retained to either side of the 
* current page in the view hierarchy in an idle state. Pages beyond this 
* limit will be recreated from the adapter when needed. 
* 
* <p This is offered as an optimization. If you know in advance the number 
* of pages you will need to support or have lazy-loading mechanisms in place 
* on your pages, tweaking this setting can have benefits in perceived 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 created 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 setOffscreenPageLimit(int limit) { 
if (limit < DEFAULT_OFFSCREEN_PAGES) { 
Log.w(TAG, "Requested offscreen page limit " + limit + " too small; defaulting to " + 
DEFAULT_OFFSCREEN_PAGES); 
limit = DEFAULT_OFFSCREEN_PAGES; 
} 
if (limit != mOffscreenPageLimit) { 
mOffscreenPageLimit = limit; 
populate(); 
} 
} 
/** 
* Set the margin between pages. 
* 
* @param marginPixels Distance between adjacent pages in pixels 
* @see #getPageMargin() 
* @see #setPageMarginDrawable(android.graphics.drawable.Drawable) 
* @see #setPageMarginDrawable(int) 
*/ 
public void setPageMargin(int marginPixels) { 
final int oldMargin = mPageMargin; 
mPageMargin = marginPixels; 
final int width = getWidth(); 
recomputeScrollPosition(width, width, marginPixels, oldMargin); 
requestLayout(); 
} 
/** 
* Return the margin between pages. 
* 
* @return The size of the margin in pixels 
*/ 
public int getPageMargin() { 
return mPageMargin; 
} 
/** 
* Set a drawable that will be used to fill the margin between pages. 
* 
* @param d Drawable to display between pages 
*/ 
public void setPageMarginDrawable(Drawable d) { 
mMarginDrawable = d; 
if (d != null) refreshDrawableState(); 
setWillNotDraw(d == null); 
invalidate(); 
} 
/** 
* Set a drawable that will be used to fill the margin between pages. 
* 
* @param resId Resource ID of a drawable to display between pages 
*/ 
public void setPageMarginDrawable(int resId) { 
setPageMarginDrawable(getContext().getResources().getDrawable(resId)); 
} 
@Override 
protected boolean verifyDrawable(Drawable who) { 
return super.verifyDrawable(who) || who == mMarginDrawable; 
} 
@Override 
protected void drawableStateChanged() { 
super.drawableStateChanged(); 
final Drawable d = mMarginDrawable; 
if (d != null && d.isStateful()) { 
d.setState(getDrawableState()); 
} 
} 
// We want the duration of the page snap animation to be influenced by the distance that 
// the screen has to travel, however, we don't want this duration to be effected 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 android.view.View#scrollBy}, but scroll smoothly instead of immediately. 
* 
* @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 smoothScrollTo(int x, int y) { 
smoothScrollTo(x, y, 0); 
} 
/** 
* Like {@link android.view.View#scrollBy}, but scroll smoothly instead of immediately. 
* 
* @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 associated with a fling, if applicable. (0 otherwise) 
*/ 
void smoothScrollTo(int x, int y, int velocity) { 
if (getChildCount() == 0) { 
// Nothing to do. 
setScrollingCacheEnabled(false); 
return; 
} 
int sx = getScrollX(); 
int sy = getScrollY(); 
int dx = x - sx; 
int dy = y - sy; 
if (dx == 0 && dy == 0) { 
completeScroll(); 
setScrollState(SCROLL_STATE_IDLE); 
return; 
} 
setScrollingCacheEnabled(true); 
mScrolling = true; 
setScrollState(SCROLL_STATE_SETTLING); 
final float pageDelta = (float) Math.abs(dx) / (getWidth() + mPageMargin); 
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); 
mScroller.startScroll(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 dataSetChanged() { 
// This method only gets called if our observer is attached, so mAdapter is non-null. 
boolean needPopulate = 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_UNCHANGED) { 
continue; 
} 
if (newPos == PagerAdapter.POSITION_NONE) { 
mItems.remove(i); 
i--; 
mAdapter.destroyItem(this, ii.position, ii.object); 
needPopulate = 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 changed position. Follow it. 
newCurrItem = newPos; 
} 
ii.position = newPos; 
needPopulate = true; 
} 
} 
Collections.sort(mItems, COMPARATOR); 
if (newCurrItem  = 0) { 
// TODO This currently causes a jump. 
setCurrentItemInternal(newCurrItem, false, true); 
needPopulate = true; 
} 
if (needPopulate) { 
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 finished 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 attached to a window. This is to 
// avoid trying to populate before we have restored our view hierarchy 
// state and conflicting with what is restored. 
if (getWindowToken() == null) { 
return; 
} 
mAdapter.startUpdate(this); 
final int pageLimit = mOffscreenPageLimit; 
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 need 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 currentFocused = findFocus(); 
ItemInfo ii = currentFocused != null ? infoForAnyChild(currentFocused) : 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 SavedState extends BaseSavedState { 
int position; 
Parcelable adapterState; 
ClassLoader loader; 
public SavedState(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 "FragmentPager.SavedState{" 
+ Integer.toHexString(System.identityHashCode(this)) 
+ " position=" + position + "}"; 
} 
public static final Creator<SavedState  CREATOR 
= ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState () { 
@Override 
public SavedState createFromParcel(Parcel in, ClassLoader loader) { 
return new SavedState(in, loader); 
} 
@Override 
public SavedState[] newArray(int size) { 
return new SavedState[size]; 
} 
}); 
SavedState(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(); 
SavedState ss = new SavedState(superState); 
ss.position = mCurItem; 
if (mAdapter != null) { 
ss.adapterState = mAdapter.saveState(); 
} 
return ss; 
} 
@Override 
public void onRestoreInstanceState(Parcelable state) { 
if (!(state instanceof SavedState)) { 
super.onRestoreInstanceState(state); 
return; 
} 
SavedState ss = (SavedState)state; 
super.onRestoreInstanceState(ss.getSuperState()); 
if (mAdapter != null) { 
mAdapter.restoreState(ss.adapterState, ss.loader); 
setCurrentItemInternal(ss.position, false, true); 
} else { 
mRestoredCurItem = ss.position; 
mRestoredAdapterState = ss.adapterState; 
mRestoredClassLoader = ss.loader; 
} 
} 
@Override 
public void addView(View child, int index, LayoutParams params) { 
if (mInLayout) { 
addViewInLayout(child, index, params); 
child.measure(mChildWidthMeasureSpec, mChildHeightMeasureSpec); 
} else { 
super.addView(child, index, params); 
} 
if (USE_CACHE) { 
if (child.getVisibility() != GONE) { 
child.setDrawingCacheEnabled(mScrollingCacheEnabled); 
} else { 
child.setDrawingCacheEnabled(false); 
} 
} 
} 
ItemInfo infoForChild(View child) { 
for (int i=0; i<mItems.size(); i++) { 
ItemInfo ii = mItems.get(i); 
if (mAdapter.isViewFromObject(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 
protected void onAttachedToWindow() { 
super.onAttachedToWindow(); 
mFirstLayout = true; 
} 
@Override 
protected 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. 
setMeasuredDimension(getDefaultSize(0, widthMeasureSpec), 
getDefaultSize(0, heightMeasureSpec)); 
// Children are just made to fill our space. 
mChildWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() - 
getPaddingLeft() - getPaddingRight(), MeasureSpec.EXACTLY); 
mChildHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() - 
getPaddingTop() - getPaddingBottom(), MeasureSpec.EXACTLY); 
// Make sure we have created all fragments that we need to have shown. 
mInLayout = true; 
populate(); 
mInLayout = false; 
// Make sure all children have been properly measured. 
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 
protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
super.onSizeChanged(w, h, oldw, oldh); 
// Make sure scroll position is set correctly. 
if (w != oldw) { 
recomputeScrollPosition(w, oldw, mPageMargin, mPageMargin); 
} 
} 
private void recomputeScrollPosition(int width, int oldWidth, int margin, int oldMargin) { 
final int widthWithMargin = width + margin; 
if (oldWidth   0) { 
final int oldScrollPos = getScrollX(); 
final int oldwwm = oldWidth + oldMargin; 
final int oldScrollItem = oldScrollPos / oldwwm; 
final float scrollOffset = (float) (oldScrollPos % oldwwm) / oldwwm; 
final int scrollPos = (int) ((oldScrollItem + scrollOffset) * widthWithMargin); 
scrollTo(scrollPos, getScrollY()); 
if (!mScroller.isFinished()) { 
// We now return to your regularly scheduled scroll, already in progress. 
final int newDuration = mScroller.getDuration() - mScroller.timePassed(); 
mScroller.startScroll(scrollPos, 0, mCurItem * widthWithMargin, 0, newDuration); 
} 
} else { 
int scrollPos = mCurItem * widthWithMargin; 
if (scrollPos != getScrollX()) { 
completeScroll(); 
scrollTo(scrollPos, getScrollY()); 
} 
} 
} 
@Override 
protected void onLayout(boolean changed, 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 + mPageMargin) * ii.position; 
int childLeft = getPaddingLeft() + loff; 
int childTop = getPaddingTop(); 
if (DEBUG) Log.v(TAG, "Positioning #" + i + " " + child + " f=" + ii.object 
+ ":" + childLeft + "," + childTop + " " + child.getMeasuredWidth() 
+ "x" + child.getMeasuredHeight()); 
child.layout(childLeft, childTop, 
childLeft + child.getMeasuredWidth(), 
childTop + child.getMeasuredHeight()); 
} 
} 
mFirstLayout = false; 
} 
@Override 
public void computeScroll() { 
if (DEBUG) Log.i(TAG, "computeScroll: finished=" + mScroller.isFinished()); 
if (!mScroller.isFinished()) { 
if (mScroller.computeScrollOffset()) { 
if (DEBUG) Log.i(TAG, "computeScroll: still scrolling"); 
int oldX = getScrollX(); 
int oldY = getScrollY(); 
int x = mScroller.getCurrX(); 
int y = mScroller.getCurrY(); 
if (oldX != x || oldY != y) { 
scrollTo(x, y); 
} 
if (mOnPageChangeListener != null) { 
final int widthWithMargin = getWidth() + mPageMargin; 
final int position = x / widthWithMargin; 
final int offsetPixels = x % widthWithMargin; 
final float offset = (float) offsetPixels / widthWithMargin; 
mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels); 
} 
// Keep on drawing until the animation has finished. 
invalidate(); 
return; 
} 
} 
// Done with scroll, clean up state. 
completeScroll(); 
} 
private void completeScroll() { 
boolean needPopulate = mScrolling; 
if (needPopulate) { 
// Done with scroll, no longer want to cache view drawing. 
setScrollingCacheEnabled(false); 
mScroller.abortAnimation(); 
int oldX = getScrollX(); 
int oldY = getScrollY(); 
int x = mScroller.getCurrX(); 
int y = mScroller.getCurrY(); 
if (oldX != x || oldY != y) { 
scrollTo(x, y); 
} 
setScrollState(SCROLL_STATE_IDLE); 
} 
mPopulatePending = false; 
mScrolling = false; 
for (int i=0; i<mItems.size(); i++) { 
ItemInfo ii = mItems.get(i); 
if (ii.scrolling) { 
needPopulate = true; 
ii.scrolling = false; 
} 
} 
if (needPopulate) { 
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 called 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!"); 
mIsBeingDragged = false; 
mIsUnableToDrag = false; 
mActivePointerId = INVALID_POINTER; 
return false; 
} 
// Nothing more to do here if we have decided whether or not we 
// are dragging. 
if (action != MotionEvent.ACTION_DOWN) { 
if (mIsBeingDragged) { 
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: { 
/* 
* mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 
* whether the user has moved 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 = getScrollX(); 
final boolean atEdge = (dx   0 && scrollX == 0) || (dx < 0 && mAdapter != null && 
scrollX  = (mAdapter.getCount() - 1) * getWidth() - 1); 
if (DEBUG) Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff); 
if (canScroll(this, false, (int) dx, (int) x, (int) y)) { 
// Nested view has scrollable area under this point. Let it be handled there. 
mInitialMotionX = mLastMotionX = x; 
mLastMotionY = y; 
return false; 
} 
if (xDiff   mTouchSlop && xDiff   yDiff) { 
if (DEBUG) Log.v(TAG, "Starting drag!"); 
mIsBeingDragged = true; 
setScrollState(SCROLL_STATE_DRAGGING); 
mLastMotionX = x; 
setScrollingCacheEnabled(true); 
} else { 
if (yDiff   mTouchSlop) { 
// The finger has moved enough in the vertical 
// direction to be counted 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 (mScrollState == SCROLL_STATE_SETTLING) { 
// Let the user 'catch' the pager as it animates. 
mIsBeingDragged = true; 
mIsUnableToDrag = false; 
setScrollState(SCROLL_STATE_DRAGGING); 
} else { 
completeScroll(); 
mIsBeingDragged = false; 
mIsUnableToDrag = false; 
} 
if (DEBUG) Log.v(TAG, "Down at " + mLastMotionX + "," + mLastMotionY 
+ " mIsBeingDragged=" + mIsBeingDragged 
+ "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 mIsBeingDragged; 
} 
@Override 
public boolean onTouchEvent(MotionEvent ev) { 
if (mFakeDragging) { 
// 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.getEdgeFlags() != 0) { 
// Don't handle edge touches immediately -- 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 needsInvalidate = false; 
switch (action & MotionEventCompat.ACTION_MASK) { 
case MotionEvent.ACTION_DOWN: { 
/* 
* If being flinged and user touches, stop the fling. isFinished 
* will be false if being flinged. 
*/ 
completeScroll(); 
// Remember where the motion event started 
mLastMotionX = mInitialMotionX = ev.getX(); 
mActivePointerId = MotionEventCompat.getPointerId(ev, 0); 
break; 
} 
case MotionEvent.ACTION_MOVE: 
if (!mIsBeingDragged) { 
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, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff); 
if (xDiff   mTouchSlop && xDiff   yDiff) { 
if (DEBUG) Log.v(TAG, "Starting drag!"); 
mIsBeingDragged = true; 
mLastMotionX = x; 
setScrollState(SCROLL_STATE_DRAGGING); 
setScrollingCacheEnabled(true); 
} 
} 
if (mIsBeingDragged) { 
// 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 oldScrollX = getScrollX(); 
float scrollX = oldScrollX + deltaX; 
final int width = getWidth(); 
final int widthWithMargin = width + mPageMargin; 
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; 
needsInvalidate = mLeftEdge.onPull(over / width); 
} 
scrollX = leftBound; 
} else if (scrollX   rightBound) { 
if (rightBound == lastItemIndex * widthWithMargin) { 
float over = scrollX - rightBound; 
needsInvalidate = mRightEdge.onPull(over / width); 
} 
scrollX = rightBound; 
} 
// Don't lose the rounded component 
mLastMotionX += scrollX - (int) scrollX; 
scrollTo((int) scrollX, getScrollY()); 
if (mOnPageChangeListener != null) { 
final int position = (int) scrollX / widthWithMargin; 
final int positionOffsetPixels = (int) scrollX % widthWithMargin; 
final float positionOffset = (float) positionOffsetPixels / widthWithMargin; 
mOnPageChangeListener.onPageScrolled(position, positionOffset, 
positionOffsetPixels); 
} 
} 
break; 
case MotionEvent.ACTION_UP: 
if (mIsBeingDragged) { 
final VelocityTracker velocityTracker = mVelocityTracker; 
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); 
int initialVelocity = (int) VelocityTrackerCompat.getXVelocity( 
velocityTracker, mActivePointerId); 
mPopulatePending = true; 
final int widthWithMargin = getWidth() + mPageMargin; 
final int scrollX = getScrollX(); 
final int currentPage = scrollX / widthWithMargin; 
int nextPage = initialVelocity   0 ? currentPage : currentPage + 1; 
setCurrentItemInternal(nextPage, true, true, initialVelocity); 
mActivePointerId = INVALID_POINTER; 
endDrag(); 
needsInvalidate = mLeftEdge.onRelease() | mRightEdge.onRelease(); 
} 
break; 
case MotionEvent.ACTION_CANCEL: 
if (mIsBeingDragged) { 
setCurrentItemInternal(mCurItem, true, true); 
mActivePointerId = INVALID_POINTER; 
endDrag(); 
needsInvalidate = mLeftEdge.onRelease() | mRightEdge.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 (needsInvalidate) { 
invalidate(); 
} 
return true; 
} 
@Override 
public void draw(Canvas canvas) { 
super.draw(canvas); 
boolean needsInvalidate = false; 
final int overScrollMode = ViewCompat.getOverScrollMode(this); 
if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS || 
(overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS && 
mAdapter != null && mAdapter.getCount()   1)) { 
if (!mLeftEdge.isFinished()) { 
final int restoreCount = canvas.save(); 
final int height = getHeight() - getPaddingTop() - getPaddingBottom(); 
canvas.rotate(270); 
canvas.translate(-height + getPaddingTop(), 0); 
mLeftEdge.setSize(height, getWidth()); 
needsInvalidate |= mLeftEdge.draw(canvas); 
canvas.restoreToCount(restoreCount); 
} 
if (!mRightEdge.isFinished()) { 
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 + mPageMargin) + mPageMargin); 
mRightEdge.setSize(height, width); 
needsInvalidate |= mRightEdge.draw(canvas); 
canvas.restoreToCount(restoreCount); 
} 
} else { 
mLeftEdge.finish(); 
mRightEdge.finish(); 
} 
if (needsInvalidate) { 
// Keep animating 
invalidate(); 
} 
} 
@Override 
protected void onDraw(Canvas canvas) { 
super.onDraw(canvas); 
// Draw the margin drawable if needed. 
if (mPageMargin   0 && mMarginDrawable != null) { 
final int scrollX = getScrollX(); 
final int width = getWidth(); 
final int offset = scrollX % (width + mPageMargin); 
if (offset != 0) { 
// Pages fit completely when settled; we only need to draw when in between 
final int left = scrollX - offset + width; 
mMarginDrawable.setBounds(left, 0, left + mPageMargin, 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 #fakeDragBy(float)} to simulate the actual drag motion. Call 
* {@link #endFakeDrag()} 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 started. 
* 
* @see #fakeDragBy(float) 
* @see #endFakeDrag() 
*/ 
public boolean beginFakeDrag() { 
if (mIsBeingDragged) { 
return false; 
} 
mFakeDragging = true; 
setScrollState(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(); 
mFakeDragBeginTime = time; 
return true; 
} 
/** 
* End a fake drag of the pager. 
* 
* @see #beginFakeDrag() 
* @see #fakeDragBy(float) 
*/ 
public void endFakeDrag() { 
if (!mFakeDragging) { 
throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first."); 
} 
final VelocityTracker velocityTracker = mVelocityTracker; 
velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); 
int initialVelocity = (int)VelocityTrackerCompat.getYVelocity( 
velocityTracker, mActivePointerId); 
mPopulatePending = true; 
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(); 
mFakeDragging = false; 
} 
/** 
* Fake drag by an offset in pixels. You must have called {@link #beginFakeDrag()} first. 
* 
* @param xOffset Offset in pixels to drag by. 
* @see #beginFakeDrag() 
* @see #endFakeDrag() 
*/ 
public void fakeDragBy(float xOffset) { 
if (!mFakeDragging) { 
throw new IllegalStateException("No fake drag in progress. Call beginFakeDrag first."); 
} 
mLastMotionX += xOffset; 
float scrollX = getScrollX() - xOffset; 
final int width = getWidth(); 
final int widthWithMargin = width + mPageMargin; 
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 rounded component 
mLastMotionX += scrollX - (int) scrollX; 
scrollTo((int) scrollX, getScrollY()); 
if (mOnPageChangeListener != null) { 
final int position = (int) scrollX / widthWithMargin; 
final int positionOffsetPixels = (int) scrollX % widthWithMargin; 
final float positionOffset = (float) positionOffsetPixels / widthWithMargin; 
mOnPageChangeListener.onPageScrolled(position, positionOffset, 
positionOffsetPixels); 
} 
// Synthesize an event for the VelocityTracker. 
final long time = SystemClock.uptimeMillis(); 
final MotionEvent ev = MotionEvent.obtain(mFakeDragBeginTime, 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 #beginFakeDrag() 
* @see #fakeDragBy(float) 
* @see #endFakeDrag() 
*/ 
public boolean isFakeDragging() { 
return mFakeDragging; 
} 
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() { 
mIsBeingDragged = false; 
mIsUnableToDrag = false; 
if (mVelocityTracker != null) { 
mVelocityTracker.recycle(); 
mVelocityTracker = null; 
} 
} 
private void setScrollingCacheEnabled(boolean enabled) { 
if (mScrollingCacheEnabled != enabled) { 
mScrollingCacheEnabled = enabled; 
if (USE_CACHE) { 
final int size = getChildCount(); 
for (int i = 0; i < size; ++i) { 
final View child = getChildAt(i); 
if (child.getVisibility() != GONE) { 
child.setDrawingCacheEnabled(enabled); 
} 
} 
} 
} 
} 
/** 
* 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 passed should itself be checked 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. 
*/ 
protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) { 
if (v instanceof ViewGroup) { 
final ViewGroup group = (ViewGroup) v; 
final int scrollX = v.getScrollX(); 
final int scrollY = v.getScrollY(); 
final int count = group.getChildCount(); 
// Count backwards - let topmost views consume scroll distance first. 
for (int i = count - 1; i  = 0; i--) { 
// TODO: Add versioned support here for transformed views. 
// This will not work for transformed 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() && 
canScroll(child, true, dx, x + scrollX - child.getLeft(), 
y + scrollY - child.getTop())) { 
return true; 
} 
} 
} 
return checkV && ViewCompat.canScrollHorizontally(v, -dx); 
} 
@Override 
public boolean dispatchKeyEvent(KeyEvent event) { 
// Let the focused 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 dispatched to 
* it by the view hierarchy. 
* 
* @param event The key event to execute. 
* @return Return true if the event was handled, else false. 
*/ 
public boolean executeKeyEvent(KeyEvent event) { 
boolean handled = false; 
if (event.getAction() == KeyEvent.ACTION_DOWN) { 
switch (event.getKeyCode()) { 
case KeyEvent.KEYCODE_DPAD_LEFT: 
handled = arrowScroll(FOCUS_LEFT); 
break; 
case KeyEvent.KEYCODE_DPAD_RIGHT: 
handled = arrowScroll(FOCUS_RIGHT); 
break; 
case KeyEvent.KEYCODE_TAB: 
if (KeyEventCompat.hasNoModifiers(event)) { 
handled = arrowScroll(FOCUS_FORWARD); 
} else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) { 
handled = arrowScroll(FOCUS_BACKWARD); 
} 
break; 
} 
} 
return handled; 
} 
public boolean arrowScroll(int direction) { 
View currentFocused = findFocus(); 
if (currentFocused == this) currentFocused = null; 
boolean handled = false; 
View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, 
direction); 
if (nextFocused != null && nextFocused != currentFocused) { 
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 (currentFocused != null && nextFocused.getLeft()  = currentFocused.getLeft()) { 
handled = pageLeft(); 
} else { 
handled = nextFocused.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 (currentFocused != null && nextFocused.getLeft() <= currentFocused.getLeft()) { 
handled = pageRight(); 
} else { 
handled = nextFocused.requestFocus(); 
} 
} 
} else if (direction == FOCUS_LEFT || direction == FOCUS_BACKWARD) { 
// Trying to move left and nothing there; try to page. 
handled = pageLeft(); 
} else if (direction == FOCUS_RIGHT || direction == FOCUS_FORWARD) { 
// Trying to move right and nothing there; try to page. 
handled = pageRight(); 
} 
if (handled) { 
playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction)); 
} 
return handled; 
} 
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 need to do the same thing View does. 
if (!isFocusable()) { 
return; 
} 
if ((focusableMode & FOCUSABLES_TOUCH_MODE) == FOCUSABLES_TOUCH_MODE && 
isInTouchMode() && !isFocusableInTouchMode()) { 
return; 
} 
if (views != null) { 
views.add(this); 
} 
} 
} 
/** 
* 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 
protected boolean onRequestFocusInDescendants(int direction, 
Rect previouslyFocusedRect) { 
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, previouslyFocusedRect)) { 
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; 
} 
private class PagerObserver extends DataSetObserver { 
@Override 
public void onChanged() { 
dataSetChanged(); 
} 
@Override 
public void onInvalidated() { 
dataSetChanged(); 
} 
} 
}