Android Gallery(超豪华胜优酷,自动无限循环播放+3D+阴影,有图有真相)

Android Gallery(超豪华胜优酷,自动无限循环播放+3D+阴影,有图有真相)

---------------------------------------DetialGallery.java

package gongzibai.co.cc;

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

public class DetialGallery extends
  Gallery {
 private Camera mCamera = new Camera();// 相机类
 private int mMaxRotationAngle = 60;// 最大转动角度
 private int mMaxZoom = -380;// //最大缩放值
 private int mCoveflowCenter;// 半径值
 private boolean mAlphaMode = true;
 private boolean mCircleMode = false;

 

 public DetialGallery(
   Context context,
   AttributeSet attrs) {
  super(context, attrs);
  // TODO Auto-generated constructor stub
 }

 public int getMaxRotationAngle() {
  return mMaxRotationAngle;
 }

 public void setMaxRotationAngle(
   int maxRotationAngle) {
  mMaxRotationAngle = maxRotationAngle;
 }

 public boolean getAlphaMode() {
  return mAlphaMode;
 }

 public void setAlphaMode(
   boolean isAlpha) {
  mAlphaMode = isAlpha;
 }
 
 public boolean getCircleMode() {
        return mCircleMode;
    }

    public void setCircleMode(boolean isCircle) {
        mCircleMode = isCircle;
    }

 

 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;
 }

 // 控制gallery中每个图片的旋转(重写的gallery中方法)
 protected boolean getChildStaticTransformation(
   View child, Transformation t) {
  // 取得当前子view的半径值
  final int childCenter = getCenterOfView(child);
  System.out
    .println("childCenter："
      + childCenter);
  final int childWidth = child
    .getWidth();
  // 旋转角度
  int rotationAngle = 0;
  // 重置转换状态
  t.clear();
  // 设置转换类型
  t.setTransformationType(Transformation.TYPE_MATRIX);
  // 如果图片位于中心位置不需要进行旋转
  if (childCenter == mCoveflowCenter) {
   transformImageBitmap(
     (ImageView) child,
     t, 0);
  } else {
   // 根据图片在gallery中的位置来计算图片的旋转角度
   rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
   System.out
     .println("rotationAngle:"
       + rotationAngle);
   // 如果旋转角度绝对值大于最大旋转角度返回（-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);
  if (rotation <= mMaxRotationAngle) {
   float zoomAmount = (float) (mMaxZoom + (rotation * 1.5));
   mCamera.translate(0.0f,
     0.0f, zoomAmount);
   if (mCircleMode) {
    if (rotation < 40)
     mCamera.translate(
       0.0f, 155,
       0.0f);
    else
     mCamera.translate(
       0.0f,
       (255 - rotation * 2.5f),
       0.0f);
   }
   if (mAlphaMode) {
    ((ImageView) (child))
      .setAlpha((int) (255 - rotation * 2.5));
   }
  }

  // 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);
  // if (mAlphaMode) {
  // ((ImageView) (child))
  // .setAlpha((int) (255 - rotation * 2.5));
  // }
  //
  // }
  // 在Y轴上旋转，对应图片竖向向里翻转。
  // 如果在X轴上旋转，则对应图片横向向里翻转。
  mCamera.rotateY(rotationAngle);
  mCamera.getMatrix(imageMatrix);
  imageMatrix.preTranslate(
    -(imageWidth / 2),
    -(imageHeight / 2));
  imageMatrix.postTranslate(
    (imageWidth / 2),
    (imageHeight / 2));
  mCamera.restore();
 }

 @Override
 public boolean onFling(
   MotionEvent e1,
   MotionEvent e2,
   float velocityX,
   float velocityY) {
  // TODO Auto-generated method stub
  return false;
 }
}

 

 

-----------------------------------Gallery1Activity

package gongzibai.co.cc;

import android.app.Activity;
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.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
import android.widget.Toast;

public class Gallery1Activity extends
  Activity {
 Integer[] imgResId = {
   R.drawable.icon,
   R.drawable.icon2,
   R.drawable.icon3,
   R.drawable.icon,
   R.drawable.icon2,
   R.drawable.icon3,

 };
 public static final int CHANGE_BANNER = 1;
 private int cur_index = 0;

 /** Called when the activity is first created. */
 @Override
 public void onCreate(
   Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);

  final DetialGallery gallery = (DetialGallery) findViewById(R.id.widget1);
  ImageAdapter imageAdapter = new ImageAdapter(
    Gallery1Activity.this,
    imgResId);
  imageAdapter
    .createReflectedImages();// 创建倒影效果
  gallery.setFadingEdgeLength(0);

  gallery.setAdapter(imageAdapter);
  gallery.setSelection(1);

  final Handler handler = new Handler() {
   public void handleMessage(
     Message msg) {

    switch (msg.what) {

    case CHANGE_BANNER:

     gallery.onKeyDown(
       KeyEvent.KEYCODE_DPAD_RIGHT,
       null);

     break;

    default:

     break;

    }

   };
  };
  new Thread(new Runnable() {

   public void run() {

    while (true) {

     handler.sendEmptyMessage(CHANGE_BANNER);

     try {

      Thread.sleep(3000);

     } catch (InterruptedException e) {

      e.printStackTrace();

     }

    }

   }

  }

  ).start();

  gallery.setOnItemSelectedListener(new OnItemSelectedListener() {

   @Override
   public void onItemSelected(
     AdapterView<?> arg0,
     View arg1,
     int arg2, long arg3) {
    // TODO Auto-generated method stub
    Toast.makeText(
      Gallery1Activity.this,
      "这是第" + arg2
        + "张图片",
      2).show();
   }

   @Override
   public void onNothingSelected(
     AdapterView<?> arg0) {
    // TODO Auto-generated method stub

   }
  });

 }

 class ImageAdapter extends
   BaseAdapter {
  int mGalleryItemBackground;
  private Context mContext;
  private Integer[] mImageIds;
  private ImageView[] mImages;

  public ImageAdapter(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 / 3,
        width,
        height / 3,
        matrix,
        false);

    // 创建一个宽度不变，高度为原图+倒影图高度的位图
    Bitmap bitmapWithReflection = Bitmap
      .createBitmap(
        width,
        (height + height / 2),
        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.MIRROR);
    // 设置阴影
    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 DetialGallery.LayoutParams(
        170,
        300));
    imageView
      .setScaleType(ScaleType.FIT_XY);
//    imageView.setAlpha(80);
    mImages[index++] = imageView;
   }
   return true;
  }

  @SuppressWarnings("unused")
  private Resources getResources() {
   return null;
  }

  public int getCount() {
   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) {
   return mImages[position
     % imgResId.length];
  }

  public float getScale(
    boolean focused,
    int offset) {
   return Math
     .max(0,
       1.0f / (float) Math
         .pow(2,
           Math.abs(offset)));
  }
 }
}

 

 

 

-----------------------.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/widget32"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <gongzibai.co.cc.DetialGallery
        android:id="@+id/widget1"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:spacing="5dp"
         />

</LinearLayout>

 

 作者：gongzibai