3d循环倒影gallery组件

最新推荐文章于 2019-06-11 16:16:24 发布

xiaoxiandroid

最新推荐文章于 2019-06-11 16:16:24 发布

阅读量390

点赞数

分类专栏：带归档

带归档专栏收录该内容

62 篇文章 0 订阅

订阅专栏

最近在学习Gallery组件，想实现一个3d效果，能循环拖动，从前人那总结的代码。
现有一个BUG还望高手能解答，在AndroidManifest.xml中当sdk版本在4.0以上时如android:targetSdkVersion="18" 会出现如下图现象，即居中图片回旋转

而在sdk2.0版本如android:targetSdkVersion="8"时则正常显示

是否android版本对gallery进行了修改？？求指点怎么在高版本中正常实现这个效果
代码如下

自定义gallery,实现3d效果

 
    
    
   package com.example.instructions.view;
 
import android.content.Context;
import android.graphics.Camera;
import android.graphics.Matrix;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.Transformation;
import android.widget.Gallery;
import android.widget.ImageView;
 
 
public class FlowGallery extends Gallery {
 
    private Camera mCamera = new Camera();// 相机类
    private int mMaxRotationAngle = 60;// 最大转动角度
    private int mMaxZoom = -300;// //最大缩放值
    private int mCoveflowCenter;// 半径值d(
 
    public FlowGallery(Context context) {
        super(context);
        // 支持转换 ,执行getChildStaticTransformation方法
        this.setStaticTransformationsEnabled(true);
    }
 
    public FlowGallery(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.setStaticTransformationsEnabled(true);
    }
 
    public FlowGallery(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        this.setStaticTransformationsEnabled(true);
    }
 
    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) {
        return view.getLeft() + view.getWidth() / 2;
    }
 
    // 控制gallery中每个图片的旋转(重写的gallery中方法)
    protected boolean getChildStaticTransformation(View child, Transformation t) {
        // 取得当前子view的半径值
        final int childCenter = getCenterOfView(child);
        final int childWidth = child.getWidth();
        // 旋转角度
        int rotationAngle = 0;
        // 重置转换状态
        t.clear();
        // 设置转换类型
        t.setTransformationType(Transformation.TYPE_BOTH);
        // 如果图片位于中心位置不需要进行旋转
        if (childCenter == mCoveflowCenter) {
            transformImageBitmap((ImageView) child, t, 0);
        } else {
            // 根据图片在gallery中的位置来计算图片的旋转角度
            rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
            // 如果旋转角度绝对值大于最大旋转角度返回(-mMaxRotationAngle或mMaxRotationAngle;)
            if (Math.abs(rotationAngle) > mMaxRotationAngle) {
                rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle
                        : mMaxRotationAngle;
            }
            transformImageBitmap((ImageView) child, t, rotationAngle);
        }
        return true;
    }
 
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        mCoveflowCenter = getCenterOfCoverflow();
        super.onSizeChanged(w, h, oldw, oldh);
    }
 
    private void transformImageBitmap(ImageView 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);
        // 在Z轴上正向移动camera的视角,实际效果为放大图片.
        // 如果在Y轴上移动,则图片上下移动;X轴上对应图片左右移动.
        mCamera.translate(0.0f, 0.0f, 100.0f);
        // As the angle of the view gets less, zoom in
        if (rotation < mMaxRotationAngle) {
            float zoomAmount = (float) (mMaxZoom + (rotation * 1.5));
            mCamera.translate(0.0f, 0.0f, zoomAmount);
        }
        // 在Y轴上旋转,对应图片竖向向里翻转.
        // 如果在X轴上旋转,则对应图片横向向里翻转.
        mCamera.rotateY(rotationAngle);
        mCamera.getMatrix(imageMatrix);
        imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));
        imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));
        mCamera.restore();
    }
} 
   
 
   
 
  

在adapter中实现倒影效果

 
    
    
   package com.example.instructions.adapter;
 
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
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.Shader.TileMode;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
 
import com.example.instructions.view.FlowGallery;
 
public class Adapter_Gallery extends BaseAdapter {
    private Context mContext;
    private Integer[] mImageIds;
    private ImageView[] mImages;
 
    public Adapter_Gallery(Context c, Integer[] ImageIds) {
        mContext = c;
        mImageIds = ImageIds;
        mImages = new ImageView[mImageIds.length];
    }
 
    /*
     * 创建倒影效果
     * 
     * @return
     */
    public boolean createReflectedImages() {
        // //倒影图和原图之间的距离
        final int reflectionGap = 4;
        int index = 0;
        for (int imageId : mImageIds) {
            // //返回原图解码之后的bitmap对象
            Bitmap originalImage = BitmapFactory.decodeResource(
                    mContext.getResources(), imageId);
            int width = originalImage.getWidth();
            int height = originalImage.getHeight();
            // 创建矩阵对象
            Matrix matrix = new Matrix();
            // //指定一个角度以0,0为坐标进行旋转
            // // matrix.setRotate(30);
            // //指定矩阵(x轴不变,y轴相反)
            matrix.preScale(1, -1);
            // //将矩阵应用到该原图之中,返回一个宽度不变,高度为原图1/2的倒影位图
            Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,
                    height / 2, width, height / 2, matrix, false);
            // //创建一个宽度不变,高度为原图+倒影图高度的位图
            Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
                    (height + height / 3), Config.ARGB_8888);
            // //将上面创建的位图初始化到画布
            Canvas canvas = new Canvas(bitmapWithReflection);// 绘制倒影图（原图 + 间距 + 倒影）
            canvas.drawBitmap(originalImage, 0, 0, null);    // 绘制原图
            Paint deafaultPaint = new Paint();
            deafaultPaint.setAntiAlias(false);
            canvas.drawRect(0, height, width, height + reflectionGap,deafaultPaint);// 绘制原图与倒影的间距
            canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);// 绘制倒影图
            Paint paint = new Paint();
            paint.setAntiAlias(false);
            /*
             * 参数一：为渐变起初点坐标x位置, 参数二：为y轴位置, 参数三和四：分辨对应渐变终点, 最后参数为平铺方式,
             * 这里设置为镜像Gradient是基于Shader类,所以我们通过Paint的setShader方法来设置这个渐变
             */
            LinearGradient shader = new LinearGradient(0,
                    originalImage.getHeight(), 0,
                    bitmapWithReflection.getHeight() + reflectionGap,
                    0x70ffffff, 0x00ffffff, TileMode.CLAMP);
            // 设置阴影
            paint.setShader(shader);
            paint.setXfermode(new PorterDuffXfermode(
                    android.graphics.PorterDuff.Mode.DST_IN));
            // 用已经定义好的画笔构建一个矩形阴影渐变效果
            canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
                    + reflectionGap, paint);
            // 创建一个ImageView用来显示已经画好的bitmapWithReflection
            ImageView imageView = new ImageView(mContext);
            imageView.setImageBitmap(bitmapWithReflection);
            // 设置imageView大小 ,也就是最终显示的图片大小
            // imageView.setLayoutParams(new GalleryFlow.LayoutParams(300,
            // 400));
            imageView.setLayoutParams(new FlowGallery.LayoutParams(300, 550));
            imageView.setScaleType(ScaleType.FIT_XY);
            // imageView.setScaleType(ScaleType.MATRIX);
            mImages[index++] = imageView;
        }
        return true;
    }
 
    public int getCount() {
        // return mImageIds.length;
        return Integer.MAX_VALUE;
    }
 
    public Object getItem(int position) {
        return position;
    }
 
    public long getItemId(int position) {
        return position;
    }
 
    public View getView(int position, View convertView, ViewGroup parent) {
        position = position % mImages.length;
        // MyGellaryActivity.mMyView.setSeletion(position%3);
        return mImages[position];
    }
 
    public float getScale(boolean focused, int offset) {
        return Math.max(0, 1.0f / (float) Math.pow(2, Math.abs(offset)));
    }
} 
   
 
   
 
  

Activity调用

public class Activity_Gallery extends Activity {
//    private static FlowIndicator mMyView;
    private FlowGallery galleryFlow;
    private Adapter_Gallery adapter;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
         
        requestWindowFeature(Window.FEATURE_NO_TITLE); 
//        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN ,  
//                      WindowManager.LayoutParams.FLAG_FULLSCREEN);                 //全屏
        this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_BEHIND);
         
        setContentView(R.layout.activity_gallery);
        Integer[] images = { R.drawable.homeimage1, R.drawable.homeimage2,
                R.drawable.homeimage3,R.drawable.homeimage1, R.drawable.homeimage2,
                R.drawable.homeimage3,};
        adapter = new Adapter_Gallery(this, images);
        adapter.createReflectedImages();                                        // 创建倒影效果
         
        galleryFlow = (FlowGallery) this.findViewById(R.id.Gallery01);
//        mMyView = (FlowIndicator) this.findViewById(R.id.myView);
//        mMyView.setCount(3);
//        mMyView.setSeletion(0);
        galleryFlow.setFadingEdgeLength(0);
        galleryFlow.setAdapter(adapter);
        galleryFlow.setSelection(3000);
         
        galleryFlow.setOnItemSelectedListener(new OnItemSelectedListener() {
 
            @Override
            public void onItemSelected(AdapterView<?> arg0, View arg1,
                    int arg2, long arg3) {
                // TODO Auto-generated method stub
//                mMyView.setSeletion(arg2%3);
            }
 
            @Override
            public void onNothingSelected(AdapterView<?> arg0) {
                // TODO Auto-generated method stub
 
            }
        });
        galleryFlow.setOnItemClickListener(new OnItemClickListener() {            // 设置点击事件监听
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                //Toast.makeText(Main.this, "img " + (position%6) + " selected", Toast.LENGTH_SHORT).show();
                if(position%3 == 1){
//                    Intent intent = new Intent(Activity_Gallery.this, //Activity_UserManual.class);
//                    startActivity(intent);
                }
            }
        });
         
         
    }
}