问题描述

在线等急...请问腾讯思品我的影院效果如何做的

曾考虑过用viewpage或者RecyclerView做。但是没有思路或者是做过的麻烦大大们告我.. 我的影院

解决方案

这个就是美工切图做出来的，没有什么特别的。

解决方案二：

用3d相册
MainActivity：
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:
<?xml version="1.0" encoding="utf-8"?>
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"
/>

GalleryFlow:
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 = 50;

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

/**
 * 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锟斤拷锟接角ｏ拷实锟斤拷效锟斤拷为锟脚达拷图片锟斤拷
    // 锟斤拷锟斤拷锟結锟斤拷锟斤拷锟狡讹拷锟斤拷锟斤拷图片锟斤拷锟斤拷锟狡讹拷锟斤拷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);
        ((ImageView) (child)).setAlpha((int) (255 - rotation * 2.5));
    }

    // 锟斤拷Y锟斤拷锟斤拷锟斤拷转锟斤拷锟斤拷应图片锟斤拷锟斤拷锟斤拷锟斤翻转锟斤拷
    // 锟斤拷锟斤拷锟絏锟斤拷锟斤拷锟斤拷转锟斤拷锟斤拷锟接ν计?拷锟斤拷锟斤拷锟斤拷锓??拷锟?
    mCamera.rotateY(rotationAngle);
    mCamera.getMatrix(imageMatrix);
    // Preconcats matrix锟洁当锟斤拷锟揭乘撅拷锟斤拷Postconcats matrix锟洁当锟斤拷锟斤拷司锟斤拷锟?
    imageMatrix.preTranslate(-(imageWidth / 2), -(imageHeight / 2));
    imageMatrix.postTranslate((imageWidth / 2), (imageHeight / 2));
    mCamera.restore();
}

}

ImageAdapter:
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)));
    }

}