Android Gallery3D效果 教程 案例 代码

1.扩展Gallery：
public class GalleryFlow extends Gallery {
private Camera mCamera = new Camera（）；//相机类
private int mMaxRotationAngle = 60；//最大转动角度
private int mMaxZoom = -300；最大缩放值
private int mCoveflowCenter；//半径值
public GalleryFlow（Context context） {
super（context）；
//支持转换 ，执行getChildStaticTransformation方法
this.setStaticTransformationsEnabled（true）；
}
public GalleryFlow（Context context， AttributeSet attrs） {
super（context， attrs）；
this.setStaticTransformationsEnabled（true）；
}
public GalleryFlow（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） {
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）；
// 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（）；
}
}

public 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/2， width， height/2， 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 GalleryFlow.LayoutParams（300， 400））；
//imageView.setScaleType（ScaleType.MATRIX）；
mImages[index++] = imageView；
}
return true；
}
@SuppressWarnings（"unused"）
private Resources getResources（） {
return null；
}
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） {
return mImages[position]；
}
public float getScale（boolean focused， int offset） {
return Math.max（0， 1.0f / （float） Math.pow（2， Math.abs（offset）））；
}
}

　public class Gallery3DActivity extends Activity {
public void onCreate（Bundle savedInstanceState） {
super.onCreate（savedInstanceState）；
setContentView（R.layout.layout_gallery）；
Integer[] images = { R.drawable.img0001， R.drawable.img0030，
R.drawable.img0100， R.drawable.img0130， R.drawable.img0200，
R.drawable.img0230，  R.drawable.img0330，R.drawable.img0354 }；
ImageAdapter adapter = new ImageAdapter（this， images）；
adapter.createReflectedImages（）；//创建倒影效果
GalleryFlow galleryFlow = （GalleryFlow） this.findViewById（R.id.Gallery01）；
galleryFlow.setFadingEdgeLength（0）；
galleryFlow.setSpacing（-100）； //图片之间的间距
galleryFlow.setAdapter（adapter）；
galleryFlow.setOnItemClickListener（new OnItemClickListener（） {
public void onItemClick（AdapterView<？> parent， View view，
int position， long id） {
Toast.makeText（getApplicationContext（）， String.valueOf（position）， Toast.LENGTH_SHORT）.show（）；
}
}）；
galleryFlow.setSelection（4）；
}
}