Android作业:一个3D相册源码

我们专业课有Android的学习,最后老师让做一个简单的Android应用程序.我在网上找些资料,加上自己改造一下做了一个3D相册.

程序仿照Android的相册功能,调用Gallery类对相片进行浏览.实现3D效果.其中不足的地方就是里面的图片都是写死的.这一点可以改进.程序中使用Png格式图片,注意图片不要太大,500*500一下最好.

首先:

GalleryFlow.java 类用来实现图片放映查看效果.

   1: package com.android.CustomGallery;

2:

   3: import android.content.Context;

   4: import android.graphics.Camera;

   5: import android.graphics.Matrix;

   6: import android.util.AttributeSet;

   7: import android.util.Log;

   8: import android.view.View;

   9: import android.view.animation.Transformation;

  10: import android.widget.Gallery;

  11: import android.widget.ImageView;

12:

  13: public class GalleryFlow extends Gallery {

14:

  15:         /**

  16:          * Graphics Camera used for transforming the matrix of ImageViews

  17:          */

  18:         private Camera mCamera = new Camera();

19:

  20:         /**

  21:          * The maximum angle the Child ImageView will be rotated by

  22:          */

  23:         private int mMaxRotationAngle = 60;

24:

  25:         /**

  26:          * The maximum zoom on the centre Child

  27:          */

  28:         private int mMaxZoom = -120;

29:

  30:         /**

  31:          * The Centre of the Coverflow

  32:          */

  33:         private int mCoveflowCenter;

34:

  35:         public GalleryFlow(Context context) {

  36:                 super(context);

  37:                 this.setStaticTransformationsEnabled(true);

  38:         }

39:

  40:         public GalleryFlow(Context context, AttributeSet attrs) {

  41:                 super(context, attrs);

  42:                 this.setStaticTransformationsEnabled(true);

  43:         }

44:

  45:         public GalleryFlow(Context context, AttributeSet attrs, int defStyle) {

  46:                 super(context, attrs, defStyle);

  47:                 this.setStaticTransformationsEnabled(true);

  48:         }

49:

  50:         /**

  51:          * Get the max rotational angle of the image

  52:          *

  53:          * @return the mMaxRotationAngle

  54:          */

  55:         public int getMaxRotationAngle() {

  56:                 return mMaxRotationAngle;

  57:         }

58:

  59:         /**

  60:          * Set the max rotational angle of each image

  61:          *

  62:          * @param maxRotationAngle

  63:          *            the mMaxRotationAngle to set

  64:          */

  65:         public void setMaxRotationAngle(int maxRotationAngle) {

  66:                 mMaxRotationAngle = maxRotationAngle;

  67:         }

68:

  69:         /**

  70:          * Get the Max zoom of the centre image

  71:          *

  72:          * @return the mMaxZoom

  73:          */

  74:         public int getMaxZoom() {

  75:                 return mMaxZoom;

  76:         }

77:

  78:         /**

  79:          * Set the max zoom of the centre image

  80:          *

  81:          * @param maxZoom

  82:          *            the mMaxZoom to set

  83:          */

  84:         public void setMaxZoom(int maxZoom) {

  85:                 mMaxZoom = maxZoom;

  86:         }

87:

  88:         /**

  89:          * Get the Centre of the Coverflow

  90:          *

  91:          * @return The centre of this Coverflow.

  92:          */

  93:         private int getCenterOfCoverflow() {

  94:                 //Log.e("CoverFlow Width+Height", getWidth() + "*" + getHeight());

  95:                 return (getWidth() - getPaddingLeft() - getPaddingRight()) / 2

  96:                                 + getPaddingLeft();

  97:         }

98:

  99:         /**

 100:          * Get the Centre of the View

 101:          *

 102:          * @return The centre of the given view.

 103:          */

 104:         private static int getCenterOfView(View view) {

 105:                 /*Log.e("ChildView Width+Height", view.getWidth() + "*"

 106:                                 + view.getHeight());*/

 107:                 return view.getLeft() + view.getWidth() / 2;

 108:         }

 109:

 110:         /**

 111:          * {@inheritDoc}

 112:          *

 113:          * @see #setStaticTransformationsEnabled(boolean)

 114:          */

 115:         protected boolean getChildStaticTransformation(View child, Transformation t) {

 116:

 117:                 final int childCenter = getCenterOfView(child);

 118:                 final int childWidth = child.getWidth();

 119:                 int rotationAngle = 0;

 120:

 121:                 t.clear();

 122:                 t.setTransformationType(Transformation.TYPE_MATRIX);

 123:

 124:                 if (childCenter == mCoveflowCenter) {

 125:                         transformImageBitmap((ImageView) child, t, 0);

 126:                 } else {

 127:                         rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);

 128:                         if (Math.abs(rotationAngle) > mMaxRotationAngle) {

 129:                                 rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle

 130:                                                 : mMaxRotationAngle;

 131:                         }

 132:                         transformImageBitmap((ImageView) child, t, rotationAngle);

 133:                 }

 134:

 135:                 return true;

 136:         }

 137:

 138:         /**

 139:          * This is called during layout when the size of this view has changed. If

 140:          * you were just added to the view hierarchy, you're called with the old

 141:          * values of 0.

 142:          *

 143:          * @param w

 144:          *            Current width of this view.

 145:          * @param h

 146:          *            Current height of this view.

 147:          * @param oldw

 148:          *            Old width of this view.

 149:          * @param oldh

 150:          *            Old height of this view.

 151:          */

 152:         protected void onSizeChanged(int w, int h, int oldw, int oldh) {

 153:                 mCoveflowCenter = getCenterOfCoverflow();

 154:                 super.onSizeChanged(w, h, oldw, oldh);

 155:         }

 156:

 157:         /**

 158:          * Transform the Image Bitmap by the Angle passed

 159:          *

 160:          * @param imageView

 161:          *            ImageView the ImageView whose bitmap we want to rotate

 162:          * @param t

 163:          *            transformation

 164:          * @param rotationAngle

 165:          *            the Angle by which to rotate the Bitmap

 166:          */

 167:         private void transformImageBitmap(ImageView child, Transformation t,

 168:                         int rotationAngle) {

 169:                 mCamera.save();

 170:                 final Matrix imageMatrix = t.getMatrix();

 171:                 final int imageHeight = child.getLayoutParams().height;

 172:                 final int imageWidth = child.getLayoutParams().width;

 173:                 final int rotation = Math.abs(rotationAngle);

 174:

 175:                 // 在Z轴上正向移动camera的视角，实际效果为放大图片。

 176:                 // 如果在Y轴上移动，则图片上下移动；X轴上对应图片左右移动。

 177:                 mCamera.translate(0.0f, 0.0f, 100.0f);

 178:

 179:                 // As the angle of the view gets less, zoom in

 180:                 if (rotation < mMaxRotationAngle) {

 181:                         float zoomAmount = (float) (mMaxZoom + (rotation * 1.5));

 182:                         mCamera.translate(0.0f, 0.0f, zoomAmount);

 183:                 }

 184:

 185:                 // 在Y轴上旋转，对应图片竖向向里翻转。

 186:                 // 如果在X轴上旋转，则对应图片横向向里翻转。

 187:                 mCamera.rotateY(rotationAngle);

 188:                 mCamera.getMatrix(imageMatrix);

 189:                 // Preconcats matrix相当于右乘矩阵，Postconcats matrix相当于左乘矩阵。

 190:                 imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));

 191:                 imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));

 192:                 mCamera.restore();

 193:         }

 194: }

ageAdapter.java 图片适配器类,用来将文件中的图片资源加载到应用程序

   1: package com.android.CustomGallery;

2:

   3: import android.content.Context;

   4: import android.graphics.Bitmap;

   5: import android.graphics.BitmapFactory;

   6: import android.graphics.Canvas;

   7: import android.graphics.LinearGradient;

   8: import android.graphics.Matrix;

   9: import android.graphics.Paint;

  10: import android.graphics.PorterDuffXfermode;

  11: import android.graphics.Bitmap.Config;

  12: import android.graphics.PorterDuff.Mode;

  13: import android.graphics.Shader.TileMode;

  14: import android.graphics.drawable.BitmapDrawable;

  15: import android.view.View;

  16: import android.view.ViewGroup;

  17: import android.widget.BaseAdapter;

  18: import android.widget.ImageView;

19:

  20: /*

  21: * Copyright (C) 2010 Neil Davies

  22: *

  23: * Licensed under the Apache License, Version 2.0 (the "License");

  24: * you may not use this file except in compliance with the License.

  25: * You may obtain a copy of the License at

  26: *

  27: * http://www.apache.org/licenses/LICENSE-2.0

  28: *

  29: * Unless required by applicable law or agreed to in writing, software

  30: * distributed under the License is distributed on an "AS IS" BASIS,

  31: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  32: * See the License for the specific language governing permissions and

  33: * limitations under the License.

  34: *

  35: * This code is base on the Android Gallery widget and was Created

  36: * by Neil Davies neild001 'at' gmail dot com to be a Coverflow widget

  37: *

  38: * @author Neil Davies

  39: */

  40: public class ImageAdapter extends BaseAdapter {

  41:         int mGalleryItemBackground;

  42:         private Context mContext;

43:

  44:         private int[] mImageIds;

45:

  46:         private ImageView[] mImages;

47:

  48:         public ImageAdapter(Context c, int[] ImageIds) {

  49:                 mContext = c;

  50:                 mImageIds = ImageIds;

  51:                 mImages = new ImageView[mImageIds.length];

  52:         }

53:

  54:         public boolean createReflectedImages() {

  55:                 // The gap we want between the reflection and the original image

  56:                 final int reflectionGap = 4;

57:

58:

59:

  60:                 int index = 0;

  61:                 for (int imageId : mImageIds) {

  62:                         Bitmap originalImage = BitmapFactory.decodeResource(mContext

  63:                                         .getResources(), imageId);

  64:                         int width = originalImage.getWidth();

  65:                         int height = originalImage.getHeight();

66:

  67:                         // This will not scale but will flip on the Y axis

  68:                         Matrix matrix = new Matrix();

  69:                         matrix.preScale(1, -1);

70:

  71:                         // Create a Bitmap with the flip matrix applied to it.

  72:                         // We only want the bottom half of the image

  73:                         Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,

  74:                                         height / 2, width, height / 2, matrix, false);

75:

  76:                         // Create a new bitmap with same width but taller to fit

  77:                         // reflection

  78:                         Bitmap bitmapWithReflection = Bitmap.createBitmap(width,

  79:                                         (height + height / 2), Config.ARGB_8888);

80:

  81:                         // Create a new Canvas with the bitmap that's big enough for

  82:                         // the image plus gap plus reflection

  83:                         Canvas canvas = new Canvas(bitmapWithReflection);

  84:                         // Draw in the original image

  85:                         canvas.drawBitmap(originalImage, 0, 0, null);

  86:                         // Draw in the gap

  87:                         Paint deafaultPaint = new Paint();

  88:                         canvas.drawRect(0, height, width, height + reflectionGap,

  89:                                         deafaultPaint);

  90:                         // Draw in the reflection

  91:                         canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);

92:

  93:                         // Create a shader that is a linear gradient that covers the

  94:                         // reflection

  95:                         Paint paint = new Paint();

  96:                         LinearGradient shader = new LinearGradient(0, originalImage

  97:                                         .getHeight(), 0, bitmapWithReflection.getHeight()

  98:                                         + reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);

  99:                         // Set the paint to use this shader (linear gradient)

 100:                         paint.setShader(shader);

 101:                         // Set the Transfer mode to be porter duff and destination in

 102:                         paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));

 103:                         // Draw a rectangle using the paint with our linear gradient

 104:                         canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()

 105:                                         + reflectionGap, paint);

 106:                         //解决图片的锯齿现象

 107:                         BitmapDrawable bd = new BitmapDrawable(bitmapWithReflection);

 108:                         bd.setAntiAlias(true);

 109:

 110:                         ImageView imageView = new ImageView(mContext);

 111:                         //imageView.setImageBitmap(bitmapWithReflection);

 112:                         imageView.setImageDrawable(bd);

 113:                         imageView.setLayoutParams(new GalleryFlow.LayoutParams(160, 240));

 114:                         // imageView.setScaleType(ScaleType.MATRIX);

 115:                         mImages[index++] = imageView;

 116:

 117:                 }

 118:                 return true;

 119:         }

 120:

 121:         public int getCount() {

 122:                 return mImageIds.length;

 123:         }

 124:

 125:         public Object getItem(int position) {

 126:                 return position;

 127:         }

 128:

 129:         public long getItemId(int position) {

 130:                 return position;

 131:         }

 132:

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

 134:

 135:                 // Use this code if you want to load from resources

 136:                 /*

 137:                  * ImageView i = new ImageView(mContext);

 138:                  * i.setImageResource(mImageIds[position]); i.setLayoutParams(new

 139:                  * CoverFlow.LayoutParams(350,350));

 140:                  * i.setScaleType(ImageView.ScaleType.CENTER_INSIDE);

 141:                  *

 142:                  * //Make sure we set anti-aliasing otherwise we get jaggies

 143:                  * BitmapDrawable drawable = (BitmapDrawable) i.getDrawable();

 144:                  * drawable.setAntiAlias(true); return i;

 145:                  */

 146:

 147:                 return mImages[position];

 148:         }

 149:

 150:         /**

 151:          * Returns the size (0.0f to 1.0f) of the views depending on the 'offset' to

 152:          * the center.

 153:          */

 154:         public float getScale(boolean focused, int offset) {

 155:                 /* Formula: 1 / (2 ^ offset) */

 156:                 return Math.max(0, 1.0f / (float) Math.pow(2, Math.abs(offset)));

 157:         }

 158:

 159: }

MainActivity.java 用来显示界面

   1: package com.android.CustomGallery;

2:

   3: /**

   4: * 一个实现了3D效果的Gallery，就像iPhone中的相册浏览一样炫……

   5: */

   6: import android.app.Activity;

   7: import android.os.Bundle;

8:

   9: public class MainActivity extends Activity {

  10:         /** Called when the activity is first created. */

  11:         @Override

  12:         public void onCreate(Bundle savedInstanceState) {

  13:                 super.onCreate(savedInstanceState);

14:

  15:                 setContentView(R.layout.main);

16:

  17:                 int[] images = { R.drawable.photo1, R.drawable.photo2,

  18:                                 R.drawable.photo3, R.drawable.photo4, R.drawable.photo5,

  19:                                 R.drawable.photo6, R.drawable.photo7, R.drawable.photo8, };

20:

  21:                 ImageAdapter adapter = new ImageAdapter(this, images);

  22:                 adapter.createReflectedImages();

23:

  24:                 GalleryFlow galleryFlow = (GalleryFlow) findViewById(R.id.gallery_flow);

  25:                 galleryFlow.setAdapter(adapter);

26:

  27:         }

  28: }

main.xml 程序设置文件

   1: <!--l version=<span style="color: #006080" mce_style="color: #00608-->"1.0" encoding="utf-8"?>

   2: "http://schemas.android.com/apk/res/android"

   3:     android:orientation="vertical"

   4:     android:layout_width="fill_parent"

   5:     android:layout_height="fill_parent"

   6:     >

   7:      8:         android:id="@+id/gallery_flow"
<!--CRLF-->   9:         android:layout_width="fill_parent"
<!--CRLF-->  10:         android:layout_height="fill_parent"
<!--CRLF-->  11:         />
<!--CRLF--> <!--CRLF-->

更多相关文章

随机推荐