gallery3d/ui/PositionController.java

/*
 * 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.
 */

package com.android.gallery3d.ui;

import android.content.Context;
import android.graphics.Rect;
import android.util.Log;
import android.widget.OverScroller;

import com.android.gallery3d.common.Utils;
import com.android.gallery3d.util.GalleryUtils;
import com.android.gallery3d.util.RangeArray;
import com.android.gallery3d.util.RangeIntArray;
import com.android.gallery3d.ui.PhotoView.Size;

class PositionController {
    private static final String TAG = "PositionController";

    public static final int IMAGE_AT_LEFT_EDGE = 1;
    public static final int IMAGE_AT_RIGHT_EDGE = 2;
    public static final int IMAGE_AT_TOP_EDGE = 4;
    public static final int IMAGE_AT_BOTTOM_EDGE = 8;

    public static final int CAPTURE_ANIMATION_TIME = 700;
    public static final int SNAPBACK_ANIMATION_TIME = 600;

    // Special values for animation time.
    private static final long NO_ANIMATION = -1;
    private static final long LAST_ANIMATION = -2;

    private static final int ANIM_KIND_NONE = -1;
    private static final int ANIM_KIND_SCROLL = 0;
    private static final int ANIM_KIND_SCALE = 1;
    private static final int ANIM_KIND_SNAPBACK = 2;
    private static final int ANIM_KIND_SLIDE = 3;
    private static final int ANIM_KIND_ZOOM = 4;
    private static final int ANIM_KIND_OPENING = 5;
    private static final int ANIM_KIND_FLING = 6;
    private static final int ANIM_KIND_FLING_X = 7;
    private static final int ANIM_KIND_DELETE = 8;
    private static final int ANIM_KIND_CAPTURE = 9;

    // Animation time in milliseconds. The order must match ANIM_KIND_* above.
    //
    // The values for ANIM_KIND_FLING_X does't matter because we use
    // mFilmScroller.isFinished() to decide when to stop. We set it to 0 so it's
    // faster for Animatable.advanceAnimation() to calculate the progress
    // (always 1).
    private static final int ANIM_TIME[] = {
        0,    // ANIM_KIND_SCROLL
        0,    // ANIM_KIND_SCALE
        SNAPBACK_ANIMATION_TIME,  // ANIM_KIND_SNAPBACK
        400,  // ANIM_KIND_SLIDE
        300,  // ANIM_KIND_ZOOM
        400,  // ANIM_KIND_OPENING
        0,    // ANIM_KIND_FLING (the duration is calculated dynamically)
        0,    // ANIM_KIND_FLING_X (see the comment above)
        0,    // ANIM_KIND_DELETE (the duration is calculated dynamically)
        CAPTURE_ANIMATION_TIME,  // ANIM_KIND_CAPTURE
    };

    // We try to scale up the image to fill the screen. But in order not to
    // scale too much for small icons, we limit the max up-scaling factor here.
    private static final float SCALE_LIMIT = 4;

    // For user's gestures, we give a temporary extra scaling range which goes
    // above or below the usual scaling limits.
    private static final float SCALE_MIN_EXTRA = 0.7f;
    private static final float SCALE_MAX_EXTRA = 1.4f;

    // Setting this true makes the extra scaling range permanent (until this is
    // set to false again).
    private boolean mExtraScalingRange = false;

    // Film Mode v.s. Page Mode: in film mode we show smaller pictures.
    private boolean mFilmMode = false;

    // These are the limits for width / height of the picture in film mode.
    private static final float FILM_MODE_PORTRAIT_HEIGHT = 0.48f;
    private static final float FILM_MODE_PORTRAIT_WIDTH = 0.7f;
    private static final float FILM_MODE_LANDSCAPE_HEIGHT = 0.7f;
    private static final float FILM_MODE_LANDSCAPE_WIDTH = 0.7f;

    // In addition to the focused box (index == 0). We also keep information
    // about this many boxes on each side.
    private static final int BOX_MAX = PhotoView.SCREEN_NAIL_MAX;
    private static final int[] CENTER_OUT_INDEX = new int[2 * BOX_MAX + 1];

    private static final int IMAGE_GAP = GalleryUtils.dpToPixel(16);
    private static final int HORIZONTAL_SLACK = GalleryUtils.dpToPixel(12);

    // These are constants for the delete gesture.
    private static final int DEFAULT_DELETE_ANIMATION_DURATION = 200; // ms
    private static final int MAX_DELETE_ANIMATION_DURATION = 400; // ms

    private Listener mListener;
    private volatile Rect mOpenAnimationRect;

    // Use a large enough value, so we won't see the gray shadow in the beginning.
    private int mViewW = 1200;
    private int mViewH = 1200;

    // A scaling gesture is in progress.
    private boolean mInScale;
    // The focus point of the scaling gesture, relative to the center of the
    // picture in bitmap pixels.
    private float mFocusX, mFocusY;

    // whether there is a previous/next picture.
    private boolean mHasPrev, mHasNext;

    // This is used by the fling animation (page mode).
    private FlingScroller mPageScroller;

    // This is used by the fling animation (film mode).
    private OverScroller mFilmScroller;

    // The bound of the stable region that the focused box can stay, see the
    // comments above calculateStableBound() for details.
    private int mBoundLeft, mBoundRight, mBoundTop, mBoundBottom;

    // Constrained frame is a rectangle that the focused box should fit into if
    // it is constrained. It has two effects:
    //
    // (1) In page mode, if the focused box is constrained, scaling for the
    // focused box is adjusted to fit into the constrained frame, instead of the
    // whole view.
    //
    // (2) In page mode, if the focused box is constrained, the mPlatform's
    // default center (mDefaultX/Y) is moved to the center of the constrained
    // frame, instead of the view center.
    //
    private Rect mConstrainedFrame = new Rect();

    // Whether the focused box is constrained.
    //
    // Our current program's first call to moveBox() sets constrained = true, so
    // we set the initial value of this variable to true, and we will not see
    // see unwanted transition animation.
    private boolean mConstrained = true;

    //
    //  ___________________________________________________________
    // |   _____       _____       _____       _____       _____   |
    // |  |     |     |     |     |     |     |     |     |     |  |
    // |  | Box |     | Box |     | Box*|     | Box |     | Box |  |
    // |  |_____|.....|_____|.....|_____|.....|_____|.....|_____|  |
    // |          Gap         Gap         Gap         Gap          |
    // |___________________________________________________________|
    //
    //                       <--  Platform  -->
    //
    // The focused box (Box*) centers at mPlatform's (mCurrentX, mCurrentY)

    private Platform mPlatform = new Platform();
    private RangeArray<Box> mBoxes = new RangeArray<Box>(-BOX_MAX, BOX_MAX);
    // The gap at the right of a Box i is at index i. The gap at the left of a
    // Box i is at index i - 1.
    private RangeArray<Gap> mGaps = new RangeArray<Gap>(-BOX_MAX, BOX_MAX - 1);
    private FilmRatio mFilmRatio = new FilmRatio();

    // These are only used during moveBox().
    private RangeArray<Box> mTempBoxes = new RangeArray<Box>(-BOX_MAX, BOX_MAX);
    private RangeArray<Gap> mTempGaps =
        new RangeArray<Gap>(-BOX_MAX, BOX_MAX - 1);

    // The output of the PositionController. Available through getPosition().
    private RangeArray<Rect> mRects = new RangeArray<Rect>(-BOX_MAX, BOX_MAX);

    // The direction of a new picture should appear. New pictures pop from top
    // if this value is true, or from bottom if this value is false.
    boolean mPopFromTop;

    public interface Listener {
        void invalidate();
        boolean isHoldingDown();
        boolean isHoldingDelete();

        // EdgeView
        void onPull(int offset, int direction);
        void onRelease();
        void onAbsorb(int velocity, int direction);
    }

    static {
        // Initialize the CENTER_OUT_INDEX array.
        // The array maps 0, 1, 2, 3, 4, ..., 2 * BOX_MAX
        // to 0, 1, -1, 2, -2, ..., BOX_MAX, -BOX_MAX
        for (int i = 0; i < CENTER_OUT_INDEX.length; i++) {
            int j = (i + 1) / 2;
            if ((i & 1) == 0) j = -j;
            CENTER_OUT_INDEX[i] = j;
        }
    }

    public PositionController(Context context, Listener listener) {
        mListener = listener;
        mPageScroller = new FlingScroller();
        mFilmScroller = new OverScroller(context,
                null /* default interpolator */, 0, 0, false /* no flywheel */);

        // Initialize the areas.
        initPlatform();
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            mBoxes.put(i, new Box());
            initBox(i);
            mRects.put(i, new Rect());
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            mGaps.put(i, new Gap());
            initGap(i);
        }
    }

    public void setOpenAnimationRect(Rect r) {
        mOpenAnimationRect = r;
    }

    public void setViewSize(int viewW, int viewH) {
        if (viewW == mViewW && viewH == mViewH) return;

        boolean wasMinimal = isAtMinimalScale();

        mViewW = viewW;
        mViewH = viewH;
        initPlatform();

        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            setBoxSize(i, viewW, viewH, true);
        }

        updateScaleAndGapLimit();

        // If the focused box was at minimal scale, we try to make it the
        // minimal scale under the new view size.
        if (wasMinimal) {
            Box b = mBoxes.get(0);
            b.mCurrentScale = b.mScaleMin;
        }

        // If we have the opening animation, do it. Otherwise go directly to the
        // right position.
        if (!startOpeningAnimationIfNeeded()) {
            skipToFinalPosition();
        }
    }

    public void setConstrainedFrame(Rect cFrame) {
        if (mConstrainedFrame.equals(cFrame)) return;
        mConstrainedFrame.set(cFrame);
        mPlatform.updateDefaultXY();
        updateScaleAndGapLimit();
        snapAndRedraw();
    }

    public void forceImageSize(int index, Size s) {
        if (s.width == 0 || s.height == 0) return;
        Box b = mBoxes.get(index);
        b.mImageW = s.width;
        b.mImageH = s.height;
        return;
    }

    public void setImageSize(int index, Size s, Rect cFrame) {
        if (s.width == 0 || s.height == 0) return;

        boolean needUpdate = false;
        if (cFrame != null && !mConstrainedFrame.equals(cFrame)) {
            mConstrainedFrame.set(cFrame);
            mPlatform.updateDefaultXY();
            needUpdate = true;
        }
        needUpdate |= setBoxSize(index, s.width, s.height, false);

        if (!needUpdate) return;
        updateScaleAndGapLimit();
        snapAndRedraw();
    }

    // Returns false if the box size doesn't change.
    private boolean setBoxSize(int i, int width, int height, boolean isViewSize) {
        Box b = mBoxes.get(i);
        boolean wasViewSize = b.mUseViewSize;

        // If we already have an image size, we don't want to use the view size.
        if (!wasViewSize && isViewSize) return false;

        b.mUseViewSize = isViewSize;

        if (width == b.mImageW && height == b.mImageH) {
            return false;
        }

        // The ratio of the old size and the new size.
        //
        // If the aspect ratio changes, we don't know if it is because one side
        // grows or the other side shrinks. Currently we just assume the view
        // angle of the longer side doesn't change (so the aspect ratio change
        // is because the view angle of the shorter side changes). This matches
        // what camera preview does.
        float ratio = (width > height)
                ? (float) b.mImageW / width
                : (float) b.mImageH / height;

        b.mImageW = width;
        b.mImageH = height;

        // If this is the first time we receive an image size, we change the
        // scale directly. Otherwise adjust the scales by a ratio, and snapback
        // will animate the scale into the min/max bounds if necessary.
        if (wasViewSize && !isViewSize) {
            b.mCurrentScale = getMinimalScale(b);
            b.mAnimationStartTime = NO_ANIMATION;
        } else {
            b.mCurrentScale *= ratio;
            b.mFromScale *= ratio;
            b.mToScale *= ratio;
        }

        if (i == 0) {
            mFocusX /= ratio;
            mFocusY /= ratio;
        }

        return true;
    }

    private boolean startOpeningAnimationIfNeeded() {
        if (mOpenAnimationRect == null) return false;
        Box b = mBoxes.get(0);
        if (b.mUseViewSize) return false;

        // Start animation from the saved rectangle if we have one.
        Rect r = mOpenAnimationRect;
        mOpenAnimationRect = null;

        mPlatform.mCurrentX = r.centerX() - mViewW / 2;
        b.mCurrentY = r.centerY() - mViewH / 2;
        b.mCurrentScale = Math.max(r.width() / (float) b.mImageW,
                r.height() / (float) b.mImageH);
        startAnimation(mPlatform.mDefaultX, 0, b.mScaleMin,
                ANIM_KIND_OPENING);

        // Animate from large gaps for neighbor boxes to avoid them
        // shown on the screen during opening animation.
        for (int i = -1; i < 1; i++) {
            Gap g = mGaps.get(i);
            g.mCurrentGap = mViewW;
            g.doAnimation(g.mDefaultSize, ANIM_KIND_OPENING);
        }

        return true;
    }

    public void setFilmMode(boolean enabled) {
        if (enabled == mFilmMode) return;
        mFilmMode = enabled;

        mPlatform.updateDefaultXY();
        updateScaleAndGapLimit();
        stopAnimation();
        snapAndRedraw();
    }

    public void setExtraScalingRange(boolean enabled) {
        if (mExtraScalingRange == enabled) return;
        mExtraScalingRange = enabled;
        if (!enabled) {
            snapAndRedraw();
        }
    }

    // This should be called whenever the scale range of boxes or the default
    // gap size may change. Currently this can happen due to change of view
    // size, image size, mFilmMode, mConstrained, and mConstrainedFrame.
    private void updateScaleAndGapLimit() {
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            Box b = mBoxes.get(i);
            b.mScaleMin = getMinimalScale(b);
            b.mScaleMax = getMaximalScale(b);
        }

        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            Gap g = mGaps.get(i);
            g.mDefaultSize = getDefaultGapSize(i);
        }
    }

    // Returns the default gap size according the the size of the boxes around
    // the gap and the current mode.
    private int getDefaultGapSize(int i) {
        if (mFilmMode) return IMAGE_GAP;
        Box a = mBoxes.get(i);
        Box b = mBoxes.get(i + 1);
        return IMAGE_GAP + Math.max(gapToSide(a), gapToSide(b));
    }

    // Here is how we layout the boxes in the page mode.
    //
    //   previous             current             next
    //  ___________       ________________     __________
    // |  _______  |     |   __________   |   |  ______  |
    // | |       | |     |  |   right->|  |   | |      | |
    // | |       |<-------->|<--left   |  |   | |      | |
    // | |_______| |  |  |  |__________|  |   | |______| |
    // |___________|  |  |________________|   |__________|
    //                |  <--> gapToSide()
    //                |
    // IMAGE_GAP + MAX(gapToSide(previous), gapToSide(current))
    private int gapToSide(Box b) {
        return (int) ((mViewW - getMinimalScale(b) * b.mImageW) / 2 + 0.5f);
    }

    // Stop all animations at where they are now.
    public void stopAnimation() {
        mPlatform.mAnimationStartTime = NO_ANIMATION;
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            mBoxes.get(i).mAnimationStartTime = NO_ANIMATION;
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            mGaps.get(i).mAnimationStartTime = NO_ANIMATION;
        }
    }

    public void skipAnimation() {
        if (mPlatform.mAnimationStartTime != NO_ANIMATION) {
            mPlatform.mCurrentX = mPlatform.mToX;
            mPlatform.mCurrentY = mPlatform.mToY;
            mPlatform.mAnimationStartTime = NO_ANIMATION;
        }
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            Box b = mBoxes.get(i);
            if (b.mAnimationStartTime == NO_ANIMATION) continue;
            b.mCurrentY = b.mToY;
            b.mCurrentScale = b.mToScale;
            b.mAnimationStartTime = NO_ANIMATION;
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            Gap g = mGaps.get(i);
            if (g.mAnimationStartTime == NO_ANIMATION) continue;
            g.mCurrentGap = g.mToGap;
            g.mAnimationStartTime = NO_ANIMATION;
        }
        redraw();
    }

    public void snapback() {
        snapAndRedraw();
    }

    public void skipToFinalPosition() {
        stopAnimation();
        snapAndRedraw();
        skipAnimation();
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Start an animations for the focused box
    ////////////////////////////////////////////////////////////////////////////

    public void zoomIn(float tapX, float tapY, float targetScale) {
        tapX -= mViewW / 2;
        tapY -= mViewH / 2;
        Box b = mBoxes.get(0);

        // Convert the tap position to distance to center in bitmap coordinates
        float tempX = (tapX - mPlatform.mCurrentX) / b.mCurrentScale;
        float tempY = (tapY - b.mCurrentY) / b.mCurrentScale;

        int x = (int) (-tempX * targetScale + 0.5f);
        int y = (int) (-tempY * targetScale + 0.5f);

        calculateStableBound(targetScale);
        int targetX = Utils.clamp(x, mBoundLeft, mBoundRight);
        int targetY = Utils.clamp(y, mBoundTop, mBoundBottom);
        targetScale = Utils.clamp(targetScale, b.mScaleMin, b.mScaleMax);

        startAnimation(targetX, targetY, targetScale, ANIM_KIND_ZOOM);
    }

    public void resetToFullView() {
        Box b = mBoxes.get(0);
        startAnimation(mPlatform.mDefaultX, 0, b.mScaleMin, ANIM_KIND_ZOOM);
    }

    public void beginScale(float focusX, float focusY) {
        focusX -= mViewW / 2;
        focusY -= mViewH / 2;
        Box b = mBoxes.get(0);
        Platform p = mPlatform;
        mInScale = true;
        mFocusX = (int) ((focusX - p.mCurrentX) / b.mCurrentScale + 0.5f);
        mFocusY = (int) ((focusY - b.mCurrentY) / b.mCurrentScale + 0.5f);
    }

    // Scales the image by the given factor.
    // Returns an out-of-range indicator:
    //   1 if the intended scale is too large for the stable range.
    //   0 if the intended scale is in the stable range.
    //  -1 if the intended scale is too small for the stable range.
    public int scaleBy(float s, float focusX, float focusY) {
        focusX -= mViewW / 2;
        focusY -= mViewH / 2;
        Box b = mBoxes.get(0);
        Platform p = mPlatform;

        // We want to keep the focus point (on the bitmap) the same as when we
        // begin the scale gesture, that is,
        //
        // (focusX' - currentX') / scale' = (focusX - currentX) / scale
        //
        s = b.clampScale(s * getTargetScale(b));
        int x = mFilmMode ? p.mCurrentX : (int) (focusX - s * mFocusX + 0.5f);
        int y = mFilmMode ? b.mCurrentY : (int) (focusY - s * mFocusY + 0.5f);
        startAnimation(x, y, s, ANIM_KIND_SCALE);
        if (s < b.mScaleMin) return -1;
        if (s > b.mScaleMax) return 1;
        return 0;
    }

    public void endScale() {
        mInScale = false;
        snapAndRedraw();
    }

    // Slide the focused box to the center of the view.
    public void startHorizontalSlide() {
        Box b = mBoxes.get(0);
        startAnimation(mPlatform.mDefaultX, 0, b.mScaleMin, ANIM_KIND_SLIDE);
    }

    // Slide the focused box to the center of the view with the capture
    // animation. In addition to the sliding, the animation will also scale the
    // the focused box, the specified neighbor box, and the gap between the
    // two. The specified offset should be 1 or -1.
    public void startCaptureAnimationSlide(int offset) {
        Box b = mBoxes.get(0);
        Box n = mBoxes.get(offset);  // the neighbor box
        Gap g = mGaps.get(offset);  // the gap between the two boxes

        mPlatform.doAnimation(mPlatform.mDefaultX, mPlatform.mDefaultY,
                ANIM_KIND_CAPTURE);
        b.doAnimation(0, b.mScaleMin, ANIM_KIND_CAPTURE);
        n.doAnimation(0, n.mScaleMin, ANIM_KIND_CAPTURE);
        g.doAnimation(g.mDefaultSize, ANIM_KIND_CAPTURE);
        redraw();
    }

    // Only allow scrolling when we are not currently in an animation or we
    // are in some animation with can be interrupted.
    private boolean canScroll() {
        Box b = mBoxes.get(0);
        if (b.mAnimationStartTime == NO_ANIMATION) return true;
        switch (b.mAnimationKind) {
            case ANIM_KIND_SCROLL:
            case ANIM_KIND_FLING:
            case ANIM_KIND_FLING_X:
                return true;
        }
        return false;
    }

    public void scrollPage(int dx, int dy) {
        if (!canScroll()) return;

        Box b = mBoxes.get(0);
        Platform p = mPlatform;

        calculateStableBound(b.mCurrentScale);

        int x = p.mCurrentX + dx;
        int y = b.mCurrentY + dy;

        // Vertical direction: If we have space to move in the vertical
        // direction, we show the edge effect when scrolling reaches the edge.
        if (mBoundTop != mBoundBottom) {
            if (y < mBoundTop) {
                mListener.onPull(mBoundTop - y, EdgeView.BOTTOM);
            } else if (y > mBoundBottom) {
                mListener.onPull(y - mBoundBottom, EdgeView.TOP);
            }
        }

        y = Utils.clamp(y, mBoundTop, mBoundBottom);

        // Horizontal direction: we show the edge effect when the scrolling
        // tries to go left of the first image or go right of the last image.
        if (!mHasPrev && x > mBoundRight) {
            int pixels = x - mBoundRight;
            mListener.onPull(pixels, EdgeView.LEFT);
            x = mBoundRight;
        } else if (!mHasNext && x < mBoundLeft) {
            int pixels = mBoundLeft - x;
            mListener.onPull(pixels, EdgeView.RIGHT);
            x = mBoundLeft;
        }

        startAnimation(x, y, b.mCurrentScale, ANIM_KIND_SCROLL);
    }

    public void scrollFilmX(int dx) {
        if (!canScroll()) return;

        Box b = mBoxes.get(0);
        Platform p = mPlatform;

        // Only allow scrolling when we are not currently in an animation or we
        // are in some animation with can be interrupted.
        if (b.mAnimationStartTime != NO_ANIMATION) {
            switch (b.mAnimationKind) {
                case ANIM_KIND_SCROLL:
                case ANIM_KIND_FLING:
                case ANIM_KIND_FLING_X:
                    break;
                default:
                    return;
            }
        }

        int x = p.mCurrentX + dx;

        // Horizontal direction: we show the edge effect when the scrolling
        // tries to go left of the first image or go right of the last image.
        x -= mPlatform.mDefaultX;
        if (!mHasPrev && x > 0) {
            mListener.onPull(x, EdgeView.LEFT);
            x = 0;
        } else if (!mHasNext && x < 0) {
            mListener.onPull(-x, EdgeView.RIGHT);
            x = 0;
        }
        x += mPlatform.mDefaultX;
        startAnimation(x, b.mCurrentY, b.mCurrentScale, ANIM_KIND_SCROLL);
    }

    public void scrollFilmY(int boxIndex, int dy) {
        if (!canScroll()) return;

        Box b = mBoxes.get(boxIndex);
        int y = b.mCurrentY + dy;
        b.doAnimation(y, b.mCurrentScale, ANIM_KIND_SCROLL);
        redraw();
    }

    public boolean flingPage(int velocityX, int velocityY) {
        Box b = mBoxes.get(0);
        Platform p = mPlatform;

        // We only want to do fling when the picture is zoomed-in.
        if (viewWiderThanScaledImage(b.mCurrentScale) &&
            viewTallerThanScaledImage(b.mCurrentScale)) {
            return false;
        }

        // We only allow flinging in the directions where it won't go over the
        // picture.
        int edges = getImageAtEdges();
        if ((velocityX > 0 && (edges & IMAGE_AT_LEFT_EDGE) != 0) ||
            (velocityX < 0 && (edges & IMAGE_AT_RIGHT_EDGE) != 0)) {
            velocityX = 0;
        }
        if ((velocityY > 0 && (edges & IMAGE_AT_TOP_EDGE) != 0) ||
            (velocityY < 0 && (edges & IMAGE_AT_BOTTOM_EDGE) != 0)) {
            velocityY = 0;
        }

        if (velocityX == 0 && velocityY == 0) return false;

        mPageScroller.fling(p.mCurrentX, b.mCurrentY, velocityX, velocityY,
                mBoundLeft, mBoundRight, mBoundTop, mBoundBottom);
        int targetX = mPageScroller.getFinalX();
        int targetY = mPageScroller.getFinalY();
        ANIM_TIME[ANIM_KIND_FLING] = mPageScroller.getDuration();
        return startAnimation(targetX, targetY, b.mCurrentScale, ANIM_KIND_FLING);
    }

    public boolean flingFilmX(int velocityX) {
        if (velocityX == 0) return false;

        Box b = mBoxes.get(0);
        Platform p = mPlatform;

        // If we are already at the edge, don't start the fling.
        int defaultX = p.mDefaultX;
        if ((!mHasPrev && p.mCurrentX >= defaultX)
                || (!mHasNext && p.mCurrentX <= defaultX)) {
            return false;
        }

        mFilmScroller.fling(p.mCurrentX, 0, velocityX, 0,
                Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0);
        int targetX = mFilmScroller.getFinalX();
        return startAnimation(
                targetX, b.mCurrentY, b.mCurrentScale, ANIM_KIND_FLING_X);
    }

    // Moves the specified box out of screen. If velocityY is 0, a default
    // velocity is used. Returns the time for the duration, or -1 if we cannot
    // not do the animation.
    public int flingFilmY(int boxIndex, int velocityY) {
        Box b = mBoxes.get(boxIndex);

        // Calculate targetY
        int h = heightOf(b);
        int targetY;
        int FUZZY = 3;  // TODO: figure out why this is needed.
        if (velocityY < 0 || (velocityY == 0 && b.mCurrentY <= 0)) {
            targetY = -mViewH / 2 - (h + 1) / 2 - FUZZY;
        } else {
            targetY = (mViewH + 1) / 2 + h / 2 + FUZZY;
        }

        // Calculate duration
        int duration;
        if (velocityY != 0) {
            duration = (int) (Math.abs(targetY - b.mCurrentY) * 1000f
                    / Math.abs(velocityY));
            duration = Math.min(MAX_DELETE_ANIMATION_DURATION, duration);
        } else {
            duration = DEFAULT_DELETE_ANIMATION_DURATION;
        }

        // Start animation
        ANIM_TIME[ANIM_KIND_DELETE] = duration;
        if (b.doAnimation(targetY, b.mCurrentScale, ANIM_KIND_DELETE)) {
            redraw();
            return duration;
        }
        return -1;
    }

    // Returns the index of the box which contains the given point (x, y)
    // Returns Integer.MAX_VALUE if there is no hit. There may be more than
    // one box contains the given point, and we want to give priority to the
    // one closer to the focused index (0).
    public int hitTest(int x, int y) {
        for (int i = 0; i < 2 * BOX_MAX + 1; i++) {
            int j = CENTER_OUT_INDEX[i];
            Rect r = mRects.get(j);
            if (r.contains(x, y)) {
                return j;
            }
        }

        return Integer.MAX_VALUE;
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Redraw
    //
    //  If a method changes box positions directly, redraw()
    //  should be called.
    //
    //  If a method may also cause a snapback to happen, snapAndRedraw() should
    //  be called.
    //
    //  If a method starts an animation to change the position of focused box,
    //  startAnimation() should be called.
    //
    //  If time advances to change the box position, advanceAnimation() should
    //  be called.
    ////////////////////////////////////////////////////////////////////////////
    private void redraw() {
        layoutAndSetPosition();
        mListener.invalidate();
    }

    private void snapAndRedraw() {
        mPlatform.startSnapback();
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            mBoxes.get(i).startSnapback();
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            mGaps.get(i).startSnapback();
        }
        mFilmRatio.startSnapback();
        redraw();
    }

    private boolean startAnimation(int targetX, int targetY, float targetScale,
            int kind) {
        boolean changed = false;
        changed |= mPlatform.doAnimation(targetX, mPlatform.mDefaultY, kind);
        changed |= mBoxes.get(0).doAnimation(targetY, targetScale, kind);
        if (changed) redraw();
        return changed;
    }

    public void advanceAnimation() {
        boolean changed = false;
        changed |= mPlatform.advanceAnimation();
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            changed |= mBoxes.get(i).advanceAnimation();
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            changed |= mGaps.get(i).advanceAnimation();
        }
        changed |= mFilmRatio.advanceAnimation();
        if (changed) redraw();
    }

    public boolean inOpeningAnimation() {
        return (mPlatform.mAnimationKind == ANIM_KIND_OPENING &&
                mPlatform.mAnimationStartTime != NO_ANIMATION) ||
               (mBoxes.get(0).mAnimationKind == ANIM_KIND_OPENING &&
                mBoxes.get(0).mAnimationStartTime != NO_ANIMATION);
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Layout
    ////////////////////////////////////////////////////////////////////////////

    // Returns the display width of this box.
    private int widthOf(Box b) {
        return (int) (b.mImageW * b.mCurrentScale + 0.5f);
    }

    // Returns the display height of this box.
    private int heightOf(Box b) {
        return (int) (b.mImageH * b.mCurrentScale + 0.5f);
    }

    // Returns the display width of this box, using the given scale.
    private int widthOf(Box b, float scale) {
        return (int) (b.mImageW * scale + 0.5f);
    }

    // Returns the display height of this box, using the given scale.
    private int heightOf(Box b, float scale) {
        return (int) (b.mImageH * scale + 0.5f);
    }

    // Convert the information in mPlatform and mBoxes to mRects, so the user
    // can get the position of each box by getPosition().
    //
    // Note we go from center-out because each box's X coordinate
    // is relative to its anchor box (except the focused box).
    private void layoutAndSetPosition() {
        for (int i = 0; i < 2 * BOX_MAX + 1; i++) {
            convertBoxToRect(CENTER_OUT_INDEX[i]);
        }
        //dumpState();
    }

    private void dumpState() {
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            Log.d(TAG, "Gap " + i + ": " + mGaps.get(i).mCurrentGap);
        }

        for (int i = 0; i < 2 * BOX_MAX + 1; i++) {
            dumpRect(CENTER_OUT_INDEX[i]);
        }

        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            for (int j = i + 1; j <= BOX_MAX; j++) {
                if (Rect.intersects(mRects.get(i), mRects.get(j))) {
                    Log.d(TAG, "rect " + i + " and rect " + j + "intersects!");
                }
            }
        }
    }

    private void dumpRect(int i) {
        StringBuilder sb = new StringBuilder();
        Rect r = mRects.get(i);
        sb.append("Rect " + i + ":");
        sb.append("(");
        sb.append(r.centerX());
        sb.append(",");
        sb.append(r.centerY());
        sb.append(") [");
        sb.append(r.width());
        sb.append("x");
        sb.append(r.height());
        sb.append("]");
        Log.d(TAG, sb.toString());
    }

    private void convertBoxToRect(int i) {
        Box b = mBoxes.get(i);
        Rect r = mRects.get(i);
        int y = b.mCurrentY + mPlatform.mCurrentY + mViewH / 2;
        int w = widthOf(b);
        int h = heightOf(b);
        if (i == 0) {
            int x = mPlatform.mCurrentX + mViewW / 2;
            r.left = x - w / 2;
            r.right = r.left + w;
        } else if (i > 0) {
            Rect a = mRects.get(i - 1);
            Gap g = mGaps.get(i - 1);
            r.left = a.right + g.mCurrentGap;
            r.right = r.left + w;
        } else {  // i < 0
            Rect a = mRects.get(i + 1);
            Gap g = mGaps.get(i);
            r.right = a.left - g.mCurrentGap;
            r.left = r.right - w;
        }
        r.top = y - h / 2;
        r.bottom = r.top + h;
    }

    // Returns the position of a box.
    public Rect getPosition(int index) {
        return mRects.get(index);
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Box management
    ////////////////////////////////////////////////////////////////////////////

    // Initialize the platform to be at the view center.
    private void initPlatform() {
        mPlatform.updateDefaultXY();
        mPlatform.mCurrentX = mPlatform.mDefaultX;
        mPlatform.mCurrentY = mPlatform.mDefaultY;
        mPlatform.mAnimationStartTime = NO_ANIMATION;
    }

    // Initialize a box to have the size of the view.
    private void initBox(int index) {
        Box b = mBoxes.get(index);
        b.mImageW = mViewW;
        b.mImageH = mViewH;
        b.mUseViewSize = true;
        b.mScaleMin = getMinimalScale(b);
        b.mScaleMax = getMaximalScale(b);
        b.mCurrentY = 0;
        b.mCurrentScale = b.mScaleMin;
        b.mAnimationStartTime = NO_ANIMATION;
        b.mAnimationKind = ANIM_KIND_NONE;
    }

    // Initialize a box to a given size.
    private void initBox(int index, Size size) {
        if (size.width == 0 || size.height == 0) {
            initBox(index);
            return;
        }
        Box b = mBoxes.get(index);
        b.mImageW = size.width;
        b.mImageH = size.height;
        b.mUseViewSize = false;
        b.mScaleMin = getMinimalScale(b);
        b.mScaleMax = getMaximalScale(b);
        b.mCurrentY = 0;
        b.mCurrentScale = b.mScaleMin;
        b.mAnimationStartTime = NO_ANIMATION;
        b.mAnimationKind = ANIM_KIND_NONE;
    }

    // Initialize a gap. This can only be called after the boxes around the gap
    // has been initialized.
    private void initGap(int index) {
        Gap g = mGaps.get(index);
        g.mDefaultSize = getDefaultGapSize(index);
        g.mCurrentGap = g.mDefaultSize;
        g.mAnimationStartTime = NO_ANIMATION;
    }

    private void initGap(int index, int size) {
        Gap g = mGaps.get(index);
        g.mDefaultSize = getDefaultGapSize(index);
        g.mCurrentGap = size;
        g.mAnimationStartTime = NO_ANIMATION;
    }

    private void debugMoveBox(int fromIndex[]) {
        StringBuilder s = new StringBuilder("moveBox:");
        for (int i = 0; i < fromIndex.length; i++) {
            int j = fromIndex[i];
            if (j == Integer.MAX_VALUE) {
                s.append(" N");
            } else {
                s.append(" ");
                s.append(fromIndex[i]);
            }
        }
        Log.d(TAG, s.toString());
    }

    // Move the boxes: it may indicate focus change, box deleted, box appearing,
    // box reordered, etc.
    //
    // Each element in the fromIndex array indicates where each box was in the
    // old array. If the value is Integer.MAX_VALUE (pictured as N below), it
    // means the box is new.
    //
    // For example:
    // N N N N N N N -- all new boxes
    // -3 -2 -1 0 1 2 3 -- nothing changed
    // -2 -1 0 1 2 3 N -- focus goes to the next box
    // N -3 -2 -1 0 1 2 -- focus goes to the previous box
    // -3 -2 -1 1 2 3 N -- the focused box was deleted.
    //
    // hasPrev/hasNext indicates if there are previous/next boxes for the
    // focused box. constrained indicates whether the focused box should be put
    // into the constrained frame.
    public void moveBox(int fromIndex[], boolean hasPrev, boolean hasNext,
            boolean constrained, Size[] sizes) {
        //debugMoveBox(fromIndex);
        mHasPrev = hasPrev;
        mHasNext = hasNext;

        RangeIntArray from = new RangeIntArray(fromIndex, -BOX_MAX, BOX_MAX);

        // 1. Get the absolute X coordinates for the boxes.
        layoutAndSetPosition();
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            Box b = mBoxes.get(i);
            Rect r = mRects.get(i);
            b.mAbsoluteX = r.centerX() - mViewW / 2;
        }

        // 2. copy boxes and gaps to temporary storage.
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            mTempBoxes.put(i, mBoxes.get(i));
            mBoxes.put(i, null);
        }
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            mTempGaps.put(i, mGaps.get(i));
            mGaps.put(i, null);
        }

        // 3. move back boxes that are used in the new array.
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            int j = from.get(i);
            if (j == Integer.MAX_VALUE) continue;
            mBoxes.put(i, mTempBoxes.get(j));
            mTempBoxes.put(j, null);
        }

        // 4. move back gaps if both boxes around it are kept together.
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            int j = from.get(i);
            if (j == Integer.MAX_VALUE) continue;
            int k = from.get(i + 1);
            if (k == Integer.MAX_VALUE) continue;
            if (j + 1 == k) {
                mGaps.put(i, mTempGaps.get(j));
                mTempGaps.put(j, null);
            }
        }

        // 5. recycle the boxes that are not used in the new array.
        int k = -BOX_MAX;
        for (int i = -BOX_MAX; i <= BOX_MAX; i++) {
            if (mBoxes.get(i) != null) continue;
            while (mTempBoxes.get(k) == null) {
                k++;
            }
            mBoxes.put(i, mTempBoxes.get(k++));
            initBox(i, sizes[i + BOX_MAX]);
        }

        // 6. Now give the recycled box a reasonable absolute X position.
        //
        // First try to find the first and the last box which the absolute X
        // position is known.
        int first, last;
        for (first = -BOX_MAX; first <= BOX_MAX; first++) {
            if (from.get(first) != Integer.MAX_VALUE) break;
        }
        for (last = BOX_MAX; last >= -BOX_MAX; last--) {
            if (from.get(last) != Integer.MAX_VALUE) break;
        }
        // If there is no box has known X position at all, make the focused one
        // as known.
        if (first > BOX_MAX) {
            mBoxes.get(0).mAbsoluteX = mPlatform.mCurrentX;
            first = last = 0;
        }
        // Now for those boxes between first and last, assign their position to
        // align to the previous box or the next box with known position. For
        // the boxes before first or after last, we will use a new default gap
        // size below.

        // Align to the previous box
        for (int i = Math.max(0, first + 1); i < last; i++) {
            if (from.get(i) != Integer.MAX_VALUE) continue;
            Box a = mBoxes.get(i - 1);
            Box b = mBoxes.get(i);
            int wa = widthOf(a);
            int wb = widthOf(b);
            b.mAbsoluteX = a.mAbsoluteX + (wa - wa / 2) + wb / 2
                    + getDefaultGapSize(i);
            if (mPopFromTop) {
                b.mCurrentY = -(mViewH / 2 + heightOf(b) / 2);
            } else {
                b.mCurrentY = (mViewH / 2 + heightOf(b) / 2);
            }
        }

        // Align to the next box
        for (int i = Math.min(-1, last - 1); i > first; i--) {
            if (from.get(i) != Integer.MAX_VALUE) continue;
            Box a = mBoxes.get(i + 1);
            Box b = mBoxes.get(i);
            int wa = widthOf(a);
            int wb = widthOf(b);
            b.mAbsoluteX = a.mAbsoluteX - wa / 2 - (wb - wb / 2)
                    - getDefaultGapSize(i);
            if (mPopFromTop) {
                b.mCurrentY = -(mViewH / 2 + heightOf(b) / 2);
            } else {
                b.mCurrentY = (mViewH / 2 + heightOf(b) / 2);
            }
        }

        // 7. recycle the gaps that are not used in the new array.
        k = -BOX_MAX;
        for (int i = -BOX_MAX; i < BOX_MAX; i++) {
            if (mGaps.get(i) != null) continue;
            while (mTempGaps.get(k) == null) {
                k++;
            }
            mGaps.put(i, mTempGaps.get(k++));
            Box a = mBoxes.get(i);
            Box b = mBoxes.get(i + 1);
            int wa = widthOf(a);
            int wb = widthOf(b);
            if (i >= first && i < last) {
                int g = b.mAbsoluteX - a.mAbsoluteX - wb / 2 - (wa - wa / 2);
                initGap(i, g);
            } else {
                initGap(i);
            }
        }

        // 8. calculate the new absolute X coordinates for those box before
        // first or after last.
        for (int i = first - 1; i >= -BOX_MAX; i--) {
            Box a = mBoxes.get(i + 1);
            Box b = mBoxes.get(i);
            int wa = widthOf(a);
            int wb = widthOf(b);
            Gap g = mGaps.get(i);
            b.mAbsoluteX = a.mAbsoluteX - wa / 2 - (wb - wb / 2) - g.mCurrentGap;
        }

        for (int i = last + 1; i <= BOX_MAX; i++) {
            Box a = mBoxes.get(i - 1);
            Box b = mBoxes.get(i);
            int wa = widthOf(a);
            int wb = widthOf(b);
            Gap g = mGaps.get(i - 1);
            b.mAbsoluteX = a.mAbsoluteX + (wa - wa / 2) + wb / 2 + g.mCurrentGap;
        }

        // 9. offset the Platform position
        int dx = mBoxes.get(0).mAbsoluteX - mPlatform.mCurrentX;
        mPlatform.mCurrentX += dx;
        mPlatform.mFromX += dx;
        mPlatform.mToX += dx;
        mPlatform.mFlingOffset += dx;

        if (mConstrained != constrained) {
            mConstrained = constrained;
            mPlatform.updateDefaultXY();
            updateScaleAndGapLimit();
        }

        snapAndRedraw();
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Public utilities
    ////////////////////////////////////////////////////////////////////////////

    public boolean isAtMinimalScale() {
        Box b = mBoxes.get(0);
        return isAlmostEqual(b.mCurrentScale, b.mScaleMin);
    }

    public boolean isCenter() {
        Box b = mBoxes.get(0);
        return mPlatform.mCurrentX == mPlatform.mDefaultX
            && b.mCurrentY == 0;
    }

    public int getImageWidth() {
        Box b = mBoxes.get(0);
        return b.mImageW;
    }

    public int getImageHeight() {
        Box b = mBoxes.get(0);
        return b.mImageH;
    }

    public float getImageScale() {
        Box b = mBoxes.get(0);
        return b.mCurrentScale;
    }

    public int getImageAtEdges() {
        Box b = mBoxes.get(0);
        Platform p = mPlatform;
        calculateStableBound(b.mCurrentScale);
        int edges = 0;
        if (p.mCurrentX <= mBoundLeft) {
            edges |= IMAGE_AT_RIGHT_EDGE;
        }
        if (p.mCurrentX >= mBoundRight) {
            edges |= IMAGE_AT_LEFT_EDGE;
        }
        if (b.mCurrentY <= mBoundTop) {
            edges |= IMAGE_AT_BOTTOM_EDGE;
        }
        if (b.mCurrentY >= mBoundBottom) {
            edges |= IMAGE_AT_TOP_EDGE;
        }
        return edges;
    }

    public boolean isScrolling() {
        return mPlatform.mAnimationStartTime != NO_ANIMATION
                && mPlatform.mCurrentX != mPlatform.mToX;
    }

    public void stopScrolling() {
        if (mPlatform.mAnimationStartTime == NO_ANIMATION) return;
        if (mFilmMode) mFilmScroller.forceFinished(true);
        mPlatform.mFromX = mPlatform.mToX = mPlatform.mCurrentX;
    }

    public float getFilmRatio() {
        return mFilmRatio.mCurrentRatio;
    }

    public void setPopFromTop(boolean top) {
        mPopFromTop = top;
    }

    public boolean hasDeletingBox() {
        for(int i = -BOX_MAX; i <= BOX_MAX; i++) {
            if (mBoxes.get(i).mAnimationKind == ANIM_KIND_DELETE) {
                return true;
            }
        }
        return false;
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Private utilities
    ////////////////////////////////////////////////////////////////////////////

    private float getMinimalScale(Box b) {
        float wFactor = 1.0f;
        float hFactor = 1.0f;
        int viewW, viewH;

        if (!mFilmMode && mConstrained && !mConstrainedFrame.isEmpty()
                && b == mBoxes.get(0)) {
            viewW = mConstrainedFrame.width();
            viewH = mConstrainedFrame.height();
        } else {
            viewW = mViewW;
            viewH = mViewH;
        }

        if (mFilmMode) {
            if (mViewH > mViewW) {  // portrait
                wFactor = FILM_MODE_PORTRAIT_WIDTH;
                hFactor = FILM_MODE_PORTRAIT_HEIGHT;
            } else {  // landscape
                wFactor = FILM_MODE_LANDSCAPE_WIDTH;
                hFactor = FILM_MODE_LANDSCAPE_HEIGHT;
            }
        }

        float s = Math.min(wFactor * viewW / b.mImageW,
                hFactor * viewH / b.mImageH);
        return Math.min(SCALE_LIMIT, s);
    }

    private float getMaximalScale(Box b) {
        if (mFilmMode) return getMinimalScale(b);
        if (mConstrained && !mConstrainedFrame.isEmpty()) return getMinimalScale(b);
        return SCALE_LIMIT;
    }

    private static boolean isAlmostEqual(float a, float b) {
        float diff = a - b;
        return (diff < 0 ? -diff : diff) < 0.02f;
    }

    // Calculates the stable region of mPlatform.mCurrentX and
    // mBoxes.get(0).mCurrentY, where "stable" means
    //
    // (1) If the dimension of scaled image >= view dimension, we will not
    // see black region outside the image (at that dimension).
    // (2) If the dimension of scaled image < view dimension, we will center
    // the scaled image.
    //
    // We might temporarily go out of this stable during user interaction,
    // but will "snap back" after user stops interaction.
    //
    // The results are stored in mBound{Left/Right/Top/Bottom}.
    //
    // An extra parameter "horizontalSlack" (which has the value of 0 usually)
    // is used to extend the stable region by some pixels on each side
    // horizontally.
    private void calculateStableBound(float scale, int horizontalSlack) {
        Box b = mBoxes.get(0);

        // The width and height of the box in number of view pixels
        int w = widthOf(b, scale);
        int h = heightOf(b, scale);

        // When the edge of the view is aligned with the edge of the box
        mBoundLeft = (mViewW + 1) / 2 - (w + 1) / 2 - horizontalSlack;
        mBoundRight = w / 2 - mViewW / 2 + horizontalSlack;
        mBoundTop = (mViewH + 1) / 2 - (h + 1) / 2;
        mBoundBottom = h / 2 - mViewH / 2;

        // If the scaled height is smaller than the view height,
        // force it to be in the center.
        if (viewTallerThanScaledImage(scale)) {
            mBoundTop = mBoundBottom = 0;
        }

        // Same for width
        if (viewWiderThanScaledImage(scale)) {
            mBoundLeft = mBoundRight = mPlatform.mDefaultX;
        }
    }

    private void calculateStableBound(float scale) {
        calculateStableBound(scale, 0);
    }

    private boolean viewTallerThanScaledImage(float scale) {
        return mViewH >= heightOf(mBoxes.get(0), scale);
    }

    private boolean viewWiderThanScaledImage(float scale) {
        return mViewW >= widthOf(mBoxes.get(0), scale);
    }

    private float getTargetScale(Box b) {
        return b.mAnimationStartTime == NO_ANIMATION
                ? b.mCurrentScale : b.mToScale;
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Animatable: an thing which can do animation.
    ////////////////////////////////////////////////////////////////////////////
    private abstract static class Animatable {
        public long mAnimationStartTime;
        public int mAnimationKind;
        public int mAnimationDuration;

        // This should be overridden in subclass to change the animation values
        // give the progress value in [0, 1].
        protected abstract boolean interpolate(float progress);
        public abstract boolean startSnapback();

        // Returns true if the animation values changes, so things need to be
        // redrawn.
        public boolean advanceAnimation() {
            if (mAnimationStartTime == NO_ANIMATION) {
                return false;
            }
            if (mAnimationStartTime == LAST_ANIMATION) {
                mAnimationStartTime = NO_ANIMATION;
                return startSnapback();
            }

            float progress;
            if (mAnimationDuration == 0) {
                progress = 1;
            } else {
                long now = AnimationTime.get();
                progress =
                    (float) (now - mAnimationStartTime) / mAnimationDuration;
            }

            if (progress >= 1) {
                progress = 1;
            } else {
                progress = applyInterpolationCurve(mAnimationKind, progress);
            }

            boolean done = interpolate(progress);

            if (done) {
                mAnimationStartTime = LAST_ANIMATION;
            }

            return true;
        }

        private static float applyInterpolationCurve(int kind, float progress) {
            float f = 1 - progress;
            switch (kind) {
                case ANIM_KIND_SCROLL:
                case ANIM_KIND_FLING:
                case ANIM_KIND_FLING_X:
                case ANIM_KIND_DELETE:
                case ANIM_KIND_CAPTURE:
                    progress = 1 - f;  // linear
                    break;
                case ANIM_KIND_SCALE:
                    progress = 1 - f * f;  // quadratic
                    break;
                case ANIM_KIND_OPENING:
                    progress = 1 - f * f * f;  // x^3
                    break;
                case ANIM_KIND_SNAPBACK:
                case ANIM_KIND_ZOOM:
                case ANIM_KIND_SLIDE:
                    progress = 1 - f * f * f * f * f; // x^5
                    break;
            }
            return progress;
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Platform: captures the global X/Y movement.
    ////////////////////////////////////////////////////////////////////////////
    private class Platform extends Animatable {
        public int mCurrentX, mFromX, mToX, mDefaultX;
        public int mCurrentY, mFromY, mToY, mDefaultY;
        public int mFlingOffset;

        @Override
        public boolean startSnapback() {
            if (mAnimationStartTime != NO_ANIMATION) return false;
            if (mAnimationKind == ANIM_KIND_SCROLL
                    && mListener.isHoldingDown()) return false;
            if (mInScale) return false;

            Box b = mBoxes.get(0);
            float scaleMin = mExtraScalingRange ?
                b.mScaleMin * SCALE_MIN_EXTRA : b.mScaleMin;
            float scaleMax = mExtraScalingRange ?
                b.mScaleMax * SCALE_MAX_EXTRA : b.mScaleMax;
            float scale = Utils.clamp(b.mCurrentScale, scaleMin, scaleMax);
            int x = mCurrentX;
            int y = mDefaultY;
            if (mFilmMode) {
                int defaultX = mDefaultX;
                if (!mHasNext) x = Math.max(x, defaultX);
                if (!mHasPrev) x = Math.min(x, defaultX);
            } else {
                calculateStableBound(scale, HORIZONTAL_SLACK);
                // If the picture is zoomed-in, we want to keep the focus point
                // stay in the same position on screen, so we need to adjust
                // target mCurrentX (which is the center of the focused
                // box). The position of the focus point on screen (relative the
                // the center of the view) is:
                //
                // mCurrentX + scale * mFocusX = mCurrentX' + scale' * mFocusX
                // => mCurrentX' = mCurrentX + (scale - scale') * mFocusX
                //
                if (!viewWiderThanScaledImage(scale)) {
                    float scaleDiff = b.mCurrentScale - scale;
                    x += (int) (mFocusX * scaleDiff + 0.5f);
                }
                x = Utils.clamp(x, mBoundLeft, mBoundRight);
            }
            if (mCurrentX != x || mCurrentY != y) {
                return doAnimation(x, y, ANIM_KIND_SNAPBACK);
            }
            return false;
        }

        // The updateDefaultXY() should be called whenever these variables
        // changes: (1) mConstrained (2) mConstrainedFrame (3) mViewW/H (4)
        // mFilmMode
        public void updateDefaultXY() {
            // We don't check mFilmMode and return 0 for mDefaultX. Because
            // otherwise if we decide to leave film mode because we are
            // centered, we will immediately back into film mode because we find
            // we are not centered.
            if (mConstrained && !mConstrainedFrame.isEmpty()) {
                mDefaultX = mConstrainedFrame.centerX() - mViewW / 2;
                mDefaultY = mFilmMode ? 0 :
                        mConstrainedFrame.centerY() - mViewH / 2;
            } else {
                mDefaultX = 0;
                mDefaultY = 0;
            }
        }

        // Starts an animation for the platform.
        private boolean doAnimation(int targetX, int targetY, int kind) {
            if (mCurrentX == targetX && mCurrentY == targetY) return false;
            mAnimationKind = kind;
            mFromX = mCurrentX;
            mFromY = mCurrentY;
            mToX = targetX;
            mToY = targetY;
            mAnimationStartTime = AnimationTime.startTime();
            mAnimationDuration = ANIM_TIME[kind];
            mFlingOffset = 0;
            advanceAnimation();
            return true;
        }

        @Override
        protected boolean interpolate(float progress) {
            if (mAnimationKind == ANIM_KIND_FLING) {
                return interpolateFlingPage(progress);
            } else if (mAnimationKind == ANIM_KIND_FLING_X) {
                return interpolateFlingFilm(progress);
            } else {
                return interpolateLinear(progress);
            }
        }

        private boolean interpolateFlingFilm(float progress) {
            mFilmScroller.computeScrollOffset();
            mCurrentX = mFilmScroller.getCurrX() + mFlingOffset;

            int dir = EdgeView.INVALID_DIRECTION;
            if (mCurrentX < mDefaultX) {
                if (!mHasNext) {
                    dir = EdgeView.RIGHT;
                }
            } else if (mCurrentX > mDefaultX) {
                if (!mHasPrev) {
                    dir = EdgeView.LEFT;
                }
            }
            if (dir != EdgeView.INVALID_DIRECTION) {
                int v = (int) (mFilmScroller.getCurrVelocity() + 0.5f);
                mListener.onAbsorb(v, dir);
                mFilmScroller.forceFinished(true);
                mCurrentX = mDefaultX;
            }
            return mFilmScroller.isFinished();
        }

        private boolean interpolateFlingPage(float progress) {
            mPageScroller.computeScrollOffset(progress);
            Box b = mBoxes.get(0);
            calculateStableBound(b.mCurrentScale);

            int oldX = mCurrentX;
            mCurrentX = mPageScroller.getCurrX();

            // Check if we hit the edges; show edge effects if we do.
            if (oldX > mBoundLeft && mCurrentX == mBoundLeft) {
                int v = (int) (-mPageScroller.getCurrVelocityX() + 0.5f);
                mListener.onAbsorb(v, EdgeView.RIGHT);
            } else if (oldX < mBoundRight && mCurrentX == mBoundRight) {
                int v = (int) (mPageScroller.getCurrVelocityX() + 0.5f);
                mListener.onAbsorb(v, EdgeView.LEFT);
            }

            return progress >= 1;
        }

        private boolean interpolateLinear(float progress) {
            // Other animations
            if (progress >= 1) {
                mCurrentX = mToX;
                mCurrentY = mToY;
                return true;
            } else {
                if (mAnimationKind == ANIM_KIND_CAPTURE) {
                    progress = CaptureAnimation.calculateSlide(progress);
                }
                mCurrentX = (int) (mFromX + progress * (mToX - mFromX));
                mCurrentY = (int) (mFromY + progress * (mToY - mFromY));
                if (mAnimationKind == ANIM_KIND_CAPTURE) {
                    return false;
                } else {
                    return (mCurrentX == mToX && mCurrentY == mToY);
                }
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Box: represents a rectangular area which shows a picture.
    ////////////////////////////////////////////////////////////////////////////
    private class Box extends Animatable {
        // Size of the bitmap
        public int mImageW, mImageH;

        // This is true if we assume the image size is the same as view size
        // until we know the actual size of image. This is also used to
        // determine if there is an image ready to show.
        public boolean mUseViewSize;

        // The minimum and maximum scale we allow for this box.
        public float mScaleMin, mScaleMax;

        // The X/Y value indicates where the center of the box is on the view
        // coordinate. We always keep the mCurrent{X,Y,Scale} sync with the
        // actual values used currently. Note that the X values are implicitly
        // defined by Platform and Gaps.
        public int mCurrentY, mFromY, mToY;
        public float mCurrentScale, mFromScale, mToScale;

        // The absolute X coordinate of the center of the box. This is only used
        // during moveBox().
        public int mAbsoluteX;

        @Override
        public boolean startSnapback() {
            if (mAnimationStartTime != NO_ANIMATION) return false;
            if (mAnimationKind == ANIM_KIND_SCROLL
                    && mListener.isHoldingDown()) return false;
            if (mAnimationKind == ANIM_KIND_DELETE
                    && mListener.isHoldingDelete()) return false;
            if (mInScale && this == mBoxes.get(0)) return false;

            int y = mCurrentY;
            float scale;

            if (this == mBoxes.get(0)) {
                float scaleMin = mExtraScalingRange ?
                    mScaleMin * SCALE_MIN_EXTRA : mScaleMin;
                float scaleMax = mExtraScalingRange ?
                    mScaleMax * SCALE_MAX_EXTRA : mScaleMax;
                scale = Utils.clamp(mCurrentScale, scaleMin, scaleMax);
                if (mFilmMode) {
                    y = 0;
                } else {
                    calculateStableBound(scale, HORIZONTAL_SLACK);
                    // If the picture is zoomed-in, we want to keep the focus
                    // point stay in the same position on screen. See the
                    // comment in Platform.startSnapback for details.
                    if (!viewTallerThanScaledImage(scale)) {
                        float scaleDiff = mCurrentScale - scale;
                        y += (int) (mFocusY * scaleDiff + 0.5f);
                    }
                    y = Utils.clamp(y, mBoundTop, mBoundBottom);
                }
            } else {
                y = 0;
                scale = mScaleMin;
            }

            if (mCurrentY != y || mCurrentScale != scale) {
                return doAnimation(y, scale, ANIM_KIND_SNAPBACK);
            }
            return false;
        }

        private boolean doAnimation(int targetY, float targetScale, int kind) {
            targetScale = clampScale(targetScale);

            if (mCurrentY == targetY && mCurrentScale == targetScale
                    && kind != ANIM_KIND_CAPTURE) {
                return false;
            }

            // Now starts an animation for the box.
            mAnimationKind = kind;
            mFromY = mCurrentY;
            mFromScale = mCurrentScale;
            mToY = targetY;
            mToScale = targetScale;
            mAnimationStartTime = AnimationTime.startTime();
            mAnimationDuration = ANIM_TIME[kind];
            advanceAnimation();
            return true;
        }

        // Clamps the input scale to the range that doAnimation() can reach.
        public float clampScale(float s) {
            return Utils.clamp(s,
                    SCALE_MIN_EXTRA * mScaleMin,
                    SCALE_MAX_EXTRA * mScaleMax);
        }

        @Override
        protected boolean interpolate(float progress) {
            if (mAnimationKind == ANIM_KIND_FLING) {
                return interpolateFlingPage(progress);
            } else {
                return interpolateLinear(progress);
            }
        }

        private boolean interpolateFlingPage(float progress) {
            mPageScroller.computeScrollOffset(progress);
            calculateStableBound(mCurrentScale);

            int oldY = mCurrentY;
            mCurrentY = mPageScroller.getCurrY();

            // Check if we hit the edges; show edge effects if we do.
            if (oldY > mBoundTop && mCurrentY == mBoundTop) {
                int v = (int) (-mPageScroller.getCurrVelocityY() + 0.5f);
                mListener.onAbsorb(v, EdgeView.BOTTOM);
            } else if (oldY < mBoundBottom && mCurrentY == mBoundBottom) {
                int v = (int) (mPageScroller.getCurrVelocityY() + 0.5f);
                mListener.onAbsorb(v, EdgeView.TOP);
            }

            return progress >= 1;
        }

        private boolean interpolateLinear(float progress) {
            if (progress >= 1) {
                mCurrentY = mToY;
                mCurrentScale = mToScale;
                return true;
            } else {
                mCurrentY = (int) (mFromY + progress * (mToY - mFromY));
                mCurrentScale = mFromScale + progress * (mToScale - mFromScale);
                if (mAnimationKind == ANIM_KIND_CAPTURE) {
                    float f = CaptureAnimation.calculateScale(progress);
                    mCurrentScale *= f;
                    return false;
                } else {
                    return (mCurrentY == mToY && mCurrentScale == mToScale);
                }
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //  Gap: represents a rectangular area which is between two boxes.
    ////////////////////////////////////////////////////////////////////////////
    private class Gap extends Animatable {
        // The default gap size between two boxes. The value may vary for
        // different image size of the boxes and for different modes (page or
        // film).
        public int mDefaultSize;

        // The gap size between the two boxes.
        public int mCurrentGap, mFromGap, mToGap;

        @Override
        public boolean startSnapback() {
            if (mAnimationStartTime != NO_ANIMATION) return false;
            return doAnimation(mDefaultSize, ANIM_KIND_SNAPBACK);
        }

        // Starts an animation for a gap.
        public boolean doAnimation(int targetSize, int kind) {
            if (mCurrentGap == targetSize && kind != ANIM_KIND_CAPTURE) {
                return false;
            }
            mAnimationKind = kind;
            mFromGap = mCurrentGap;
            mToGap = targetSize;
            mAnimationStartTime = AnimationTime.startTime();
            mAnimationDuration = ANIM_TIME[mAnimationKind];
            advanceAnimation();
            return true;
        }

        @Override
        protected boolean interpolate(float progress) {
            if (progress >= 1) {
                mCurrentGap = mToGap;
                return true;
            } else {
                mCurrentGap = (int) (mFromGap + progress * (mToGap - mFromGap));
                if (mAnimationKind == ANIM_KIND_CAPTURE) {
                    float f = CaptureAnimation.calculateScale(progress);
                    mCurrentGap = (int) (mCurrentGap * f);
                    return false;
                } else {
                    return (mCurrentGap == mToGap);
                }
            }
        }
    }

    ////////////////////////////////////////////////////////////////////////////
    //  FilmRatio: represents the progress of film mode change.
    ////////////////////////////////////////////////////////////////////////////
    private class FilmRatio extends Animatable {
        // The film ratio: 1 means switching to film mode is complete, 0 means
        // switching to page mode is complete.
        public float mCurrentRatio, mFromRatio, mToRatio;

        @Override
        public boolean startSnapback() {
            float target = mFilmMode ? 1f : 0f;
            if (target == mToRatio) return false;
            return doAnimation(target, ANIM_KIND_SNAPBACK);
        }

        // Starts an animation for the film ratio.
        private boolean doAnimation(float targetRatio, int kind) {
            mAnimationKind = kind;
            mFromRatio = mCurrentRatio;
            mToRatio = targetRatio;
            mAnimationStartTime = AnimationTime.startTime();
            mAnimationDuration = ANIM_TIME[mAnimationKind];
            advanceAnimation();
            return true;
        }

        @Override
        protected boolean interpolate(float progress) {
            if (progress >= 1) {
                mCurrentRatio = mToRatio;
                return true;
            } else {
                mCurrentRatio = mFromRatio + progress * (mToRatio - mFromRatio);
                return (mCurrentRatio == mToRatio);
            }
        }
    }
}