画廊中列表视图的 Coverflow 动画

Question

我正在实现一个包含一系列垂直滚动列表视图的画廊。我已经搜索了类似的实现，我在这里指定了封面流小部件：http://www.inter-fuser.com/2010/01/android-coverflow-widget.html 但它只处理转换为位图的图像，以便在自定义图库视图中进行缩放和旋转。由于我的实现需要垂直滚动列表视图，我需要一些帮助。

我可以重复使用此代码用我的列表视图替换图像吗？或者有没有适合我要求的定制画廊。任何帮助将不胜感激。

附上 Safari 书签页面供参考。我想要这样的视图，我应该能够将每一列滚动为垂直滚动的列表视图和水平滚动的画廊。

Answer 1

看看我的回答

应该在你的活动包中添加三个类

1 CoverAbsSpinner.java

2 CoverAdapterView.java

3 CoverFlow

从您的活动中调用这些课程。从activity调用CoverFlow的方式

import java.io.FileInputStream;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuffXfermode;
import android.graphics.Bitmap.Config;
import android.graphics.PorterDuff.Mode;
import android.graphics.Shader.TileMode;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;

public class CoverFlowActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        CoverFlow coverFlow;
        coverFlow = new CoverFlow(this);

        coverFlow.setAdapter(new ImageAdapter(this));

        ImageAdapter coverImageAdapter =  new ImageAdapter(this);

        coverImageAdapter.createReflectedImages();

        coverFlow.setAdapter(coverImageAdapter);

        coverFlow.setSpacing(-15);
        coverFlow.setSelection(8, true);


        setContentView(coverFlow);

        //Use this if you want to use XML layout file
        //setContentView(R.layout.main);
        //coverFlow =  (CoverFlow) findViewById(R.id.coverflow);


    }

    public class ImageAdapter extends BaseAdapter {
        int mGalleryItemBackground;
        private Context mContext;

        private FileInputStream fis;

        private Integer[] mImageIds = {
                R.drawable.a,
                R.drawable.b,
                R.drawable.c,
                R.drawable.d,
                R.drawable.e,
                R.drawable.a,
                R.drawable.b,
                R.drawable.c,
                R.drawable.d
        };

        private ImageView[] mImages;

        public ImageAdapter(Context c) {
            mContext = c;
            mImages = new ImageView[mImageIds.length];
        }
        public boolean createReflectedImages() {
                //The gap we want between the reflection and the original image
                final int reflectionGap = 4;


                int index = 0;
                for (int imageId : mImageIds) {
                    Bitmap originalImage = BitmapFactory.decodeResource(getResources(), 
                            imageId);
                    int width = originalImage.getWidth();
                    int height = originalImage.getHeight();


                    //This will not scale but will flip on the Y axis
                    Matrix matrix = new Matrix();
                    matrix.preScale(1, -1);

                    //Create a Bitmap with the flip matrix applied to it.
                    //We only want the bottom half of the image
                    Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0, height/2, width, height/2, matrix, false);


                    //Create a new bitmap with same width but taller to fit reflection
                    Bitmap bitmapWithReflection = Bitmap.createBitmap(width 
                      , (height + height/2), Config.ARGB_8888);

                   //Create a new Canvas with the bitmap that's big enough for
                   //the image plus gap plus reflection
                   Canvas canvas = new Canvas(bitmapWithReflection);
                   //Draw in the original image
                   canvas.drawBitmap(originalImage, 0, 0, null);
                   //Draw in the gap
                   Paint deafaultPaint = new Paint();
                   canvas.drawRect(0, height, width, height + reflectionGap, deafaultPaint);
                   //Draw in the reflection
                   canvas.drawBitmap(reflectionImage,0, height + reflectionGap, null);

                   //Create a shader that is a linear gradient that covers the reflection
                   Paint paint = new Paint(); 
                   LinearGradient shader = new LinearGradient(0, originalImage.getHeight(), 0, 
                     bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff, 
                     TileMode.CLAMP); 
                   //Set the paint to use this shader (linear gradient)
                   paint.setShader(shader); 
                   //Set the Transfer mode to be porter duff and destination in
                   paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN)); 
                   //Draw a rectangle using the paint with our linear gradient
                   canvas.drawRect(0, height, width, 
                     bitmapWithReflection.getHeight() + reflectionGap, paint); 

                   ImageView imageView = new ImageView(mContext);
                   imageView.setImageBitmap(bitmapWithReflection);
                   imageView.setLayoutParams(new CoverFlow.LayoutParams(120, 180));
                   imageView.setScaleType(ScaleType.MATRIX);
                   mImages[index++] = imageView;

                }
                return true;
        }

        public int getCount() {
            return mImageIds.length;
        }

        public Object getItem(int position) {
            return position;
        }

        public long getItemId(int position) {
            return position;
        }

        public View getView(int position, View convertView, ViewGroup parent) {

            //Use this code if you want to load from resources
            //ImageView i = new ImageView(mContext);
            //i.setImageResource(mImageIds[position]);
            //i.setLayoutParams(new CoverFlow.LayoutParams(130, 130));
            //i.setScaleType(ImageView.ScaleType.MATRIX);           
            //return i;

            return mImages[position];
        }
         /** Returns the size (0.0f to 1.0f) of the views 
         * depending on the 'offset' to the center. */ 
         public float getScale(boolean focused, int offset) { 
           /* Formula: 1 / (2 ^ offset) */ 
             return Math.max(0, 1.0f / (float)Math.pow(2, Math.abs(offset))); 
         } 

    }

}

输出就像