Android 一个3D相册源码

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

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

首先:

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

package com.android.CustomGallery;

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

public class GalleryFlow extends Gallery {

        /**
         * Graphics Camera used for transforming the matrix of ImageViews
         */
        private Camera mCamera = new Camera();

        /**
         * The maximum angle the Child ImageView will be rotated by
         */
        private int mMaxRotationAngle = 60;

        /**
         * The maximum zoom on the centre Child
         */
        private int mMaxZoom = -120;

        /**
         * The Centre of the Coverflow
         */
        private int mCoveflowCenter;

        public GalleryFlow(Context context) {
                super(context);
                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);
        }

        /**
         * Get the max rotational angle of the image
         *
         * @return the mMaxRotationAngle
         */
        public int getMaxRotationAngle() {
                return mMaxRotationAngle;
        }

        /**
         * Set the max rotational angle of each image
         *
         * @param maxRotationAngle
         *            the mMaxRotationAngle to set
         */
        public void setMaxRotationAngle(int maxRotationAngle) {
                mMaxRotationAngle = maxRotationAngle;
        }

        /**
         * Get the Max zoom of the centre image
         *
         * @return the mMaxZoom
         */
        public int getMaxZoom() {
                return mMaxZoom;
        }

        /**
         * Set the max zoom of the centre image
         *
         * @param maxZoom
         *            the mMaxZoom to set
         */
        public void setMaxZoom(int maxZoom) {
                mMaxZoom = maxZoom;
        }

        /**
         * Get the Centre of the Coverflow
         *
         * @return The centre of this Coverflow.
         */
        private int getCenterOfCoverflow() {
                //Log.e("CoverFlow Width+Height", getWidth() + "*" + getHeight());
                return (getWidth() - getPaddingLeft() - getPaddingRight()) / 2
                                + getPaddingLeft();
        }

        /**
         * Get the Centre of the View
         *
         * @return The centre of the given view.
         */
        private static int getCenterOfView(View view) {
                /*Log.e("ChildView Width+Height", view.getWidth() + "*"
                                + view.getHeight());*/
                return view.getLeft() + view.getWidth() / 2;
        }

        /**
         * {@inheritDoc}
         *
         * @see #setStaticTransformationsEnabled(boolean)
         */
        protected boolean getChildStaticTransformation(View child, Transformation t) {

                final int childCenter = getCenterOfView(child);
                final int childWidth = child.getWidth();
                int rotationAngle = 0;

                t.clear();
                t.setTransformationType(Transformation.TYPE_MATRIX);

                if (childCenter == mCoveflowCenter) {
                        transformImageBitmap((ImageView) child, t, 0);
                } else {
                        rotationAngle = (int) (((float) (mCoveflowCenter - childCenter) / childWidth) * mMaxRotationAngle);
                        if (Math.abs(rotationAngle) > mMaxRotationAngle) {
                                rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle
                                                : mMaxRotationAngle;
                        }
                        transformImageBitmap((ImageView) child, t, rotationAngle);
                }

                return true;
        }

        /**
         * This is called during layout when the size of this view has changed. If
         * you were just added to the view hierarchy, you're called with the old
         * values of 0.
         *
         * @param w
         *            Current width of this view.
         * @param h
         *            Current height of this view.
         * @param oldw
         *            Old width of this view.
         * @param oldh
         *            Old height of this view.
         */
        protected void onSizeChanged(int w, int h, int oldw, int oldh) {
                mCoveflowCenter = getCenterOfCoverflow();
                super.onSizeChanged(w, h, oldw, oldh);
        }

        /**
         * Transform the Image Bitmap by the Angle passed
         *
         * @param imageView
         *            ImageView the ImageView whose bitmap we want to rotate
         * @param t
         *            transformation
         * @param rotationAngle
         *            the Angle by which to rotate the Bitmap
         */
        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);
                // Preconcats matrix相当于右乘矩阵，Postconcats matrix相当于左乘矩阵。
                imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));
                imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));
                mCamera.restore();
        }
}

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

package com.android.CustomGallery;

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.graphics.drawable.BitmapDrawable;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ImageView;

/*
* Copyright (C) 2010 Neil Davies
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* This code is base on the Android Gallery widget and was Created
* by Neil Davies neild001 'at' gmail dot com to be a Coverflow widget
*
* @author Neil Davies
*/
public class ImageAdapter extends BaseAdapter {
        int mGalleryItemBackground;
        private Context mContext;

        private int[] mImageIds;

        private ImageView[] mImages;

        public ImageAdapter(Context c, int[] ImageIds) {
                mContext = c;
                mImageIds = ImageIds;
                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(mContext
                                        .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);
                        //解决图片的锯齿现象
                        BitmapDrawable bd = new BitmapDrawable(bitmapWithReflection);
                        bd.setAntiAlias(true);

                        ImageView imageView = new ImageView(mContext);
                        //imageView.setImageBitmap(bitmapWithReflection);
                        imageView.setImageDrawable(bd);
                        imageView.setLayoutParams(new GalleryFlow.LayoutParams(160, 240));
                        // 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(350,350));
                 * i.setScaleType(ImageView.ScaleType.CENTER_INSIDE);
                 *
                 * //Make sure we set anti-aliasing otherwise we get jaggies
                 * BitmapDrawable drawable = (BitmapDrawable) i.getDrawable();
                 * drawable.setAntiAlias(true); 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)));
        }

}

 

MainActivity.java 用来显示界面

package com.android.CustomGallery;

/**
* 一个实现了3D效果的Gallery，就像iPhone中的相册浏览一样炫……
*/
import android.app.Activity;
import android.os.Bundle;

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

                setContentView(R.layout.main);

                int[] images = { R.drawable.photo1, R.drawable.photo2,
                                R.drawable.photo3, R.drawable.photo4, R.drawable.photo5,
                                R.drawable.photo6, R.drawable.photo7, R.drawable.photo8, };

                ImageAdapter adapter = new ImageAdapter(this, images);
                adapter.createReflectedImages();

                GalleryFlow galleryFlow = (GalleryFlow) findViewById(R.id.gallery_flow);
                galleryFlow.setAdapter(adapter);

        }
}

main.xml 程序设置文件

"1.0" encoding="utf-8"?>
"http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
           android:id="@+id/gallery_flow"         android:layout_width="fill_parent"         android:layout_height="fill_parent"         />