Gallery平滑移动

本文主要是介绍Gallery平滑移动，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

看了些网上的方法弄了下平滑移动的效果，虽说最后是实现了，实现后发现也不是我想要的效果，对于我幸苦写过的代码先存放在这上面了

package com.layout;

import android.content.Context;
import android.graphics.Camera;
import android.graphics.Matrix;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.Transformation;
import android.widget.Gallery;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Scroller;

public class GalleryFlow extends Gallery{

   private Camera mCamera = new Camera();
    private int mMaxRotationAngle = 60;
    private int mMaxZoom = -300;
    private int mCoveflowCenter;

    //test
    private Scroller mScroller;
    private int mTouchSlop;
    private int mMinimumVelocitx;
    private int mMaximumVelocitx;
    private VelocityTracker mVelocityTracker;
    private float mLastMotionX;
    private boolean mIsInEdge = false;
    private Context context;

    public GalleryFlow(Context context) {
        super(context);
        this.context = context;
        this.setStaticTransformationsEnabled(true);
    }
    public GalleryFlow(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.setStaticTransformationsEnabled(true);
        this.context = context;
        init(context);
    }

    public void init(Context context) {
        mScroller = new Scroller(context);
        setFocusable(true);
        setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
        setWillNotDraw(false);
        final ViewConfiguration configuration = ViewConfiguration.get(context);
        mTouchSlop = configuration.getScaledTouchSlop();
        mMinimumVelocitx = configuration.getScaledMinimumFlingVelocity();
        mMaximumVelocitx = configuration.getScaledMaximumFlingVelocity();
    }

    public void fling(int velocityX) {
            if (getChildCount() > 0) {
                    mScroller.fling(getScrollX(), getScrollY(), velocityX, 0, 0, 20, 0,
                                    0);
                    final boolean movingDown = velocityX > 0;
                    awakenScrollBars(mScroller.getDuration());
                    invalidate();
            }
    }

    private void obtainVelocityTracker(MotionEvent event) {
            if (mVelocityTracker == null) {
                    mVelocityTracker = VelocityTracker.obtain();
            }
            mVelocityTracker.addMovement(event);
    }

    private void releaseVelocityTracker() {
            if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
            }
    }

   @Override
   public boolean onTouchEvent(MotionEvent event) {
       // TODO Auto-generated method stub
       if (event.getAction() == MotionEvent.ACTION_DOWN
               && event.getEdgeFlags() != 0) {
           return false;
       }

       obtainVelocityTracker(event);

       final int action = event.getAction();
       final float x = event.getX();
       final float y = event.getY();

       switch (action) {
       case MotionEvent.ACTION_DOWN:
           if (!mScroller.isFinished()) {
               mScroller.abortAnimation();
           }
           mLastMotionX = x;
           break;

       case MotionEvent.ACTION_MOVE:
           final int deltaX = (int) (mLastMotionX - x);
           mLastMotionX = x;
           if (deltaX < 0) {
               if (getScrollX() > 0) {
//                   scrollBy(0,deltaX);
                   scrollBy(deltaX,0);
               }
       }else if(deltaX > 0) {
               int childTotalWidth = 0;
               int width = 0;
               if(getChildAt(0) != null){
                   width = getChildAt(0).getWidth();
               }
               for (int i = 0; i < getChildCount(); i++) {
                   childTotalWidth += this.getChildAt(i).getWidth();
               }
               mIsInEdge = getScrollX() <= childTotalWidth - 20;//width
               if (mIsInEdge) {
//                   scrollBy(0, deltaX);
                   scrollBy(deltaX, 0);
               }
           }
           break;

       case MotionEvent.ACTION_UP:
           final VelocityTracker velocityTracker = mVelocityTracker;
           velocityTracker.computeCurrentVelocity(1000, mMaximumVelocitx);
           int initialVelocity = (int) velocityTracker.getYVelocity();

           if ((Math.abs(initialVelocity) > mMinimumVelocitx)
                   && getChildCount() > 0) {
               fling(-initialVelocity);
           }

           releaseVelocityTracker();
           break;
       }

       return true;

   }

    public void computeScroll() {
            if (mScroller.computeScrollOffset()) {
                    int scrollX = getScrollX();
                    int scrollY = getScrollY();
                    int oldX = scrollX;
                    int oldY = scrollY;
                    int x = mScroller.getCurrX();
                    int y = mScroller.getCurrY();
                    scrollX = x ;
                    scrollX = scrollX + 10;
                    scrollY = y;
//                    scrollY = scrollY + 10;
                    scrollTo(scrollX, scrollY);
                    postInvalidate();
            }
    }
   @Override
   public int getChildCount() {
       // TODO Auto-generated method stub
       return super.getChildCount();
   }


    public int getMaxRotationAngle() {
        return mMaxRotationAngle;
    }
    public void setMaxRotationAngle(int maxRotationAngle) {
        mMaxRotationAngle = maxRotationAngle;
    }
    public int getMaxZoom() {
        return mMaxZoom;
    }
    public void setMaxZoom(int maxZoom) {
        mMaxZoom = maxZoom;
    }
    private int getCenterOfCoverflow() {
        return (getWidth() - getPaddingLeft() - getPaddingRight()) / 2
                        + getPaddingLeft();
    }
    private static int getCenterOfView(View view) {
        System.out.println("view left :"+view.getLeft());
        System.out.println("view width :"+view.getWidth());
        return view.getLeft() + view.getWidth() / 2;

    }

    @Override
    protected boolean getChildStaticTransformation(View child, Transformation t) {
       /*/
       final int childCenter = getCenterOfView(child);
         final int childWidth = child.getWidth();
         int rotationAngle = 0;

         t.clear();
         t.setTransformationType(Transformation.TYPE_MATRIX);

         if (childCenter == mCoveflowCenter) {
                 transformImageBitmap((LinearLayout) child, t, 0);
         } else {
                 rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
                 if (Math.abs(rotationAngle) > mMaxRotationAngle) {
                         rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle
                                         : mMaxRotationAngle;
                 }
                 transformImageBitmap((LinearLayout) child, t, rotationAngle);
         }
         //*/
        return true;
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        mCoveflowCenter = getCenterOfCoverflow();
        super.onSizeChanged(w, h, oldw, oldh);
    }

    private void transformImageBitmap(LinearLayout child, Transformation t,
                    int rotationAngle) {
        mCamera.save();
        final Matrix imageMatrix = t.getMatrix();
        final int imageHeight = child.getLayoutParams().height;
        final int imageWidth = child.getLayoutParams().width;

        final int rotation = Math.abs(rotationAngle);

        mCamera.translate(0.0f, 0.0f, 100.0f);
        if (rotation < mMaxRotationAngle) {
            float zoomAmount = (float) (mMaxZoom + (rotation * 1));//1.5
            mCamera.translate(0.0f, 0.0f, 0);
        }
        mCamera.rotateY(rotationAngle);
        mCamera.getMatrix(imageMatrix);
        imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));
        imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));
        mCamera.restore();


    }

}

另外一种

@SuppressWarnings("deprecation")
public void onJumpPage(int id) {

cur = gally.getSelectedItemPosition();

MotionEvent e1 = MotionEvent.obtain(
SystemClock.uptimeMillis(),
SystemClock.uptimeMillis()+30,
MotionEvent.ACTION_DOWN,
(float)screenWidth-30,//89.333336f,
(float)screenHeight-30,//265.33334f,
0);

MotionEvent e2 = MotionEvent.obtain(
SystemClock.uptimeMillis(),
SystemClock.uptimeMillis()+30,
MotionEvent.ACTION_UP,
(float)screenWidth-30,//300.0f,
(float)screenHeight-30,//screenHeight/2 - 100,//238.00003f,
0);

if(id < cur){
gally.onFling(e1, e2, screenWidth,
0);
LogWrapper.i("tempvalue","rightMove");
}else if(id > cur){
gally.onFling(e1, e2, -screenWidth,
0);
LogWrapper.i("tempvalue","leftMove");
}
//*/
gally.setSelection(id);