Android源码-ViewPager取消预加载

package com.bodybuilding.waycube.viewpagertest;

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.widget.Scroller;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/**
 * Created by Administrator on 2017/9/12.
 */
import android.view.animation.Interpolator;

    /**
     * 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 MyViewPager extends ViewGroup {
        private static final String TAG = "myViewPager";
        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 MyViewPager(Context context) {
            super(context);
            initViewPager();
        }

        public MyViewPager(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();
            }
        }
}