1. 홈
  2. 질의 응답
  3. 갤러리가없는 안드로이드 커버 플로우

갤러리가없는 안드로이드 커버 플로우

2014-10-11 2 views
1

안녕하세요 저는 갤러리를 사용하지 않는 안드로이드 커버 플로우를 찾고 있습니다. 갤러리를 사용하고 있기 때문에 fancyflow 나 neil davis와 같은 갤러리를 사용하는 솔루션을 제공하지 마십시오.갤러리가없는 안드로이드 커버 플로우

그와 비슷한 것이 있습니까?

출처

2014-10-11 Barak Kedem

+0

https://github.com/dolphin을 시도해 볼 수 있습니다. wang/ImageCoverFlow 및 http://stackoverflow.com/a/19174166/3360307 –

답변

2

당신이 (main_layout.xml) MainActivity에서

<your.packageName.CoverFlowView 
    android:id="@+id/coverflow" 
    android:layout_width="fill_parent" 
    android:layout_height="match_parent" 
    android:background="@android:color/white" />

당신의 activity`s 레이아웃 파일이 클래스

을 사용할 수 있습니다

import java.lang.ref.WeakReference; 
import java.util.HashMap; 
import java.util.HashSet; 
import java.util.Map; 
import java.util.Set; 
import java.util.SortedSet; 
import java.util.TreeSet; 

import android.content.Context; 
import android.graphics.Bitmap; 
import android.graphics.Camera; 
import android.graphics.Matrix; 
import android.util.AttributeSet; 
import android.view.Gravity; 
import android.view.MotionEvent; 
import android.view.View; 
import android.view.ViewGroup; 
import android.view.animation.Animation; 
import android.view.animation.Transformation; 
import android.widget.FrameLayout; 
import android.widget.HorizontalScrollView; 
import android.widget.ImageView; 
import android.widget.LinearLayout; 

public class CoverFlowView extends LinearLayout { 
public static class Config { 
    public int COVER_SPACING = 60; 
    public int CENTER_COVER_OFFSET = 130; 
    public float SIDE_COVER_ANGLE = 40; 
    public int SIDE_COVER_ZPOSITION = 120; 
    public float REFLECTION_FRACTION = 0.15f; 
    public long FOCUS_ANIMATION_DURATION = 200; 
    public int COVER_BUFFER = 6; 
    public long BLUR_ANIMATION_DURATION = 120; 
    public int DROP_SHADOW_RADIUS = 15; 
    public boolean HORIZONTAL_SCROLLBAR_ENABLED = false; 
    public boolean FADING_EDGES_ENABLED = true; 
    public float IMAGE_SCALE_X = 1; 
    public float IMAGE_SCALE_Y = 1; 
    public long LONG_CLICK_DURATION = 2000; 
} 

Config mConfig = new Config(); 
WeakReference<DataSource> mDataSource; 
WeakReference<Listener> mListener; 
Set<CoverFlowItem> mOffscreenCovers = new HashSet<CoverFlowItem>(); 
Map<Integer, CoverFlowItem> mOnscreenCovers = new HashMap<Integer, CoverFlowItem>(); 
Map<Integer, Bitmap> mCoverImages = new HashMap<Integer, Bitmap>(); 
Map<Integer, Integer> mCoverImageHeights = new HashMap<Integer, Integer>(); 
Bitmap mDefaultBitmap; 
int mDefaultBitmapHeight; 
float mDefaultImageHeight; 
ScrollView mScrollView; 
ViewGroup mItemContainer; 
Thread mLongClickThread; 
boolean mCancelNextClick; 

int mLowerVisibleCover = -1; 
int mUpperVisibleCover = -1; 
int mNumberOfImages; 
int mBeginningCover; 
CoverFlowItem mSelectedCoverView = null; 

int mHalfScreenHeight; 
int mHalfScreenWidth; 

boolean mIsSingleTap; 
boolean mIsDraggingCover; 
float mStartScrollX; 
float mStartX; 

SortedSet<Integer> mTouchedCovers = new TreeSet<Integer>(); 

public CoverFlowView(Context context, AttributeSet attrs, int defStyle) { 
    super(context, attrs); 
    setUpInitialState(); 
} 

public CoverFlowView(Context context, AttributeSet attrs) { 
    super(context, attrs); 
    setUpInitialState(); 
} 

public CoverFlowView(Context context) { 
    super(context); 
    setUpInitialState(); 
} 

public Config getConfig() { 
    return mConfig; 
} 

void setUpInitialState() { 

    // Create the scrollView 
    mScrollView = new ScrollView(getContext()) { 
     // Catch trackball events 
     @Override 
     public boolean onTrackballEvent(MotionEvent event) { 
      return CoverFlowView.this.onTrackballEvent(event); 
     } 

    }; 
    mScrollView.setOnTouchListener(new OnTouchListener() { 
     public boolean onTouch(View v, MotionEvent event) { 
      return CoverFlowView.this.onTouchEvent(event); 
     } 
    }); 
    ViewGroup.LayoutParams params = new ViewGroup.LayoutParams(
      LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 
    mScrollView.setLayoutParams(params); 
    mScrollView 
      .setHorizontalScrollBarEnabled(mConfig.HORIZONTAL_SCROLLBAR_ENABLED); 
    mScrollView 
      .setHorizontalFadingEdgeEnabled(mConfig.FADING_EDGES_ENABLED); 
    addView(mScrollView); 

    // Create an intermediate LinearLayout 
    LinearLayout linearLayout = new LinearLayout(getContext()); 
    mScrollView.addView(linearLayout); 

    // Create the item container 
    mItemContainer = new FrameLayout(getContext()); 
    linearLayout.addView(mItemContainer); 

} 

CoverFlowItem coverForIndex(int coverIndex) { 
    CoverFlowItem coverItem = dequeueReusableCover(); 
    if (null == coverItem) { 
     coverItem = new CoverFlowItem(getContext()); 
     coverItem.setScaleType(ImageView.ScaleType.FIT_XY); 
     coverItem.setScaleX(mConfig.IMAGE_SCALE_X); 
     coverItem.setScaleY(mConfig.IMAGE_SCALE_Y); 
     coverItem.setOnTouchListener(new OnTouchListener() { 
      public boolean onTouch(View v, MotionEvent event) { 
       onTouchItem((CoverFlowItem) v, event); 
       return false; 
      } 
     }); 
    } 
    coverItem.setNumber(coverIndex); 
    return coverItem; 
} 

void updateCoverBitmap(CoverFlowItem cover) { 
    int coverNumber = cover.getNumber(); 
    Bitmap bitmap = mCoverImages.get(coverNumber); 
    if (null != bitmap) { 
     Integer coverImageHeight = mCoverImageHeights.get(coverNumber); 
     if (null != coverImageHeight) 
      cover.setImageBitmap(bitmap, coverImageHeight, 
        mConfig.REFLECTION_FRACTION); 
    } else { 
     cover.setImageBitmap(mDefaultBitmap, mDefaultBitmapHeight, 
       mConfig.REFLECTION_FRACTION); 
     mDataSource.get().requestBitmapForIndex(this, coverNumber); 
    } 
} 

void layoutCover(CoverFlowItem cover, int selectedCover, boolean animated) { 
    if (null == cover) 
     return; 

    int coverNumber = cover.getNumber(); 
    int newX = mHalfScreenWidth + cover.getNumber() * mConfig.COVER_SPACING 
      - (int) (cover.getCoverWidth()/2.0f); 
    int newY = mHalfScreenHeight - cover.getCoverHeight()/2; 

    ItemAnimation oldAnimation = (ItemAnimation) cover.getAnimation(); 
    float oldAngle = oldAnimation != null ? oldAnimation 
      .getStopAngleDegrees() : 0; 
    int oldZOffset = oldAnimation != null ? oldAnimation.getStopZOffset() 
      : 0; 
    int oldXOffset = oldAnimation != null ? oldAnimation.getStopXOffset() 
      : 0; 

    ItemAnimation anim = null; 

    if (coverNumber < selectedCover) { 
     if (oldAngle != mConfig.SIDE_COVER_ANGLE 
       || oldXOffset != -mConfig.CENTER_COVER_OFFSET 
       || oldZOffset != mConfig.SIDE_COVER_ZPOSITION) { 
      anim = new ItemAnimation(); 
      anim.setRotation(oldAngle, mConfig.SIDE_COVER_ANGLE); 
      anim.setViewDimensions(cover.getCoverWidth(), 
        cover.getOriginalCoverHeight()); 
      anim.setXTranslation(oldXOffset, -mConfig.CENTER_COVER_OFFSET); 
      anim.setZTranslation(oldZOffset, mConfig.SIDE_COVER_ZPOSITION); 
      if (animated) 
       anim.setDuration(mConfig.BLUR_ANIMATION_DURATION); 
      else 
       anim.setStatic(); 
     } 
    } else if (coverNumber > selectedCover) { 
     if (oldAngle != -mConfig.SIDE_COVER_ANGLE 
       || oldXOffset != mConfig.CENTER_COVER_OFFSET 
       || oldZOffset != mConfig.SIDE_COVER_ZPOSITION) { 
      anim = new ItemAnimation(); 
      anim.setRotation(oldAngle, -mConfig.SIDE_COVER_ANGLE); 
      anim.setViewDimensions(cover.getCoverWidth(), 
        cover.getOriginalCoverHeight()); 
      anim.setXTranslation(oldXOffset, mConfig.CENTER_COVER_OFFSET); 
      anim.setZTranslation(oldZOffset, mConfig.SIDE_COVER_ZPOSITION); 
      if (animated) 
       anim.setDuration(mConfig.BLUR_ANIMATION_DURATION); 

      else 
       anim.setStatic(); 
     } 
    } else { 
     if (oldAngle != 0 || oldXOffset != 0 || oldZOffset != 0) { 
      anim = new ItemAnimation(); 
      anim.setRotation(oldAngle, 0); 
      anim.setViewDimensions(cover.getCoverWidth(), 
        cover.getOriginalCoverHeight()); 
      anim.setXTranslation(oldXOffset, 0); 
      anim.setZTranslation(oldZOffset, 0); 
      if (animated) 
       anim.setDuration(mConfig.FOCUS_ANIMATION_DURATION); 
      else 
       anim.setStatic(); 
      anim.setAnimationListener(new Animation.AnimationListener() { 
       public void onAnimationStart(Animation animation) { 
       } 

       public void onAnimationRepeat(Animation animation) { 
       } 

       public void onAnimationEnd(Animation animation) { 
        mSelectedCoverView.bringToFront(); 
        layoutZ(mSelectedCoverView.getNumber(), 
          mLowerVisibleCover, mUpperVisibleCover); 
       } 
      }); 
     } 
    } 

    FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
      cover.getLayoutParams()); 
    params.setMargins(newX, newY, 0, 0); 
    params.gravity = Gravity.LEFT | Gravity.TOP; 
    cover.setLayoutParams(params); 

    if (null != anim) 
     cover.startAnimation(anim); 
} 

void layoutCovers(int selected, int lowerBound, int upperBound) { 
    CoverFlowItem cover; 

    for (int i = lowerBound; i <= upperBound; i++) { 
     cover = mOnscreenCovers.get(i); 
     layoutCover(cover, selected, true); 
    } 
} 

void layoutZ(int selected, int lowerBound, int upperBound) { 
    CoverFlowItem cover; 
    for (int i = upperBound; i > selected; i--) { 
     cover = mOnscreenCovers.get(i); 
     if (null != cover) 
      mItemContainer.bringChildToFront(cover); 
    } 
    for (int i = lowerBound; i <= selected; i++) { 
     cover = mOnscreenCovers.get(i); 
     if (null != cover) 
      mItemContainer.bringChildToFront(cover); 
    } 

} 

CoverFlowItem dequeueReusableCover() { 
    CoverFlowItem item = null; 
    if (!mOffscreenCovers.isEmpty()) { 
     item = mOffscreenCovers.iterator().next(); 
     mOffscreenCovers.remove(item); 
    } 
    return item; 
} 

public void setBitmapForIndex(Bitmap bitmap, int index) { 
    Bitmap bitmapWithReflection = CoverFlowItem 
      .createReflectedBitmap(bitmap, mConfig.REFLECTION_FRACTION, 
        mConfig.DROP_SHADOW_RADIUS); 
    setReflectedBitmapForIndex(bitmapWithReflection, index); 
} 

public void setReflectedBitmapForIndex(Bitmap bitmapWithReflection, 
     int index) { 
    mCoverImages.put(index, bitmapWithReflection); 
    int originalHeight = (int) ((int) (bitmapWithReflection.getHeight() - 2 * mConfig.DROP_SHADOW_RADIUS)/(1 + mConfig.REFLECTION_FRACTION)); 
    mCoverImageHeights.put(index, originalHeight); 

    // If this cover is onscreen, set its image and call layoutCover. 
    CoverFlowItem cover = mOnscreenCovers.get(index); 
    if (null != cover) { 
     cover.setImageBitmap(bitmapWithReflection, originalHeight, 
       mConfig.REFLECTION_FRACTION); 
     layoutCover(cover, mSelectedCoverView.getNumber(), false); 
    } 
} 

public Bitmap[] getReflectedBitmaps() { 
    Bitmap[] result = new Bitmap[mCoverImages.size()]; 
    for (int i = 0; i < result.length; i++) 
     result[i] = mCoverImages.get(i); 
    return result; 
} 

// 
// @Override 
// protected void onLayout(boolean changed, int l, int t, int r, int b) { 
// mScrollView.layout(l, t, r, b); 
// } 
// 
@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
    ViewGroup.LayoutParams params = new LinearLayout.LayoutParams(
      mNumberOfImages * mConfig.COVER_SPACING 
        + MeasureSpec.getSize(widthMeasureSpec), 
      LayoutParams.FILL_PARENT); 
    mItemContainer.setLayoutParams(params); 
    super.onMeasure(widthMeasureSpec, heightMeasureSpec); 
} 

@Override 
protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
    super.onSizeChanged(w, h, oldw, oldh); 
    mHalfScreenWidth = w/2; 
    mHalfScreenHeight = h/2; 

    int lowerBound = Math.max(-1, 
      (mSelectedCoverView != null ? mSelectedCoverView.getNumber() 
        : 0) - mConfig.COVER_BUFFER); 
    int upperBound = Math.min(mNumberOfImages - 1, 
      (mSelectedCoverView != null ? mSelectedCoverView.getNumber() 
        : 0) + mConfig.COVER_BUFFER); 
    layoutCovers(
      mSelectedCoverView != null ? mSelectedCoverView.getNumber() : 0, 
      lowerBound, upperBound); 

    centerOnSelectedCover(false); 
} 

@Override 
public boolean onTouchEvent(MotionEvent event) { 
    try { 
     switch (event.getAction()) { 

     case MotionEvent.ACTION_DOWN: 
      mIsSingleTap = event.getPointerCount() == 1; 
      final int index = mSelectedCoverView.getNumber(); 
      if (mIsSingleTap) { 
       mStartX = event.getX(0); 

       int lowest = mTouchedCovers.first(); 
       int highest = mTouchedCovers.last(); 

       if (lowest <= mSelectedCoverView.getNumber() 
         && highest >= mSelectedCoverView.getNumber() 
         && null != mListener && null != mListener.get() 
         && null == mLongClickThread) { 
        mLongClickThread = new Thread(new Runnable() { 
         public void run() { 
          try { 
           Thread.sleep(getConfig().LONG_CLICK_DURATION); 
           post(new Runnable() { 

            public void run() { 
             mListener.get() 
               .onSelectionLongClicked(
                 CoverFlowView.this, 
                 index); 
             mCancelNextClick = true; 
            } 
           }); 
          } catch (InterruptedException e) { 
          } 

         } 
        }); 
        mLongClickThread.start(); 
        mCancelNextClick = false; 

       } 

      } 

      mBeginningCover = mSelectedCoverView.getNumber(); 
      mStartScrollX = event.getX(0) + mScrollView.getScrollX(); 
      break; 
     case MotionEvent.ACTION_MOVE: 
      int scrollOffset = (int) (mStartScrollX - event.getX(0)); 
      int xOffset = (int) Math.abs(event.getX(0) - mStartX); 

      // If finger moves too much, not a single tap anymore: 
      mIsSingleTap = mIsSingleTap && (xOffset < 20); 

      if (!mIsSingleTap) { 
       // Cancel long click 
       if (null != mLongClickThread 
         && Thread.State.TERMINATED != mLongClickThread 
           .getState()) { 
        mLongClickThread.interrupt(); 
        mLongClickThread = null; 
       } 

       // Update the scroll position 
       mScrollView 
         .scrollTo(scrollOffset, mScrollView.getScrollY()); 

       // Select new cover 
       int newCover = scrollOffset/mConfig.COVER_SPACING; 

       // make sure we're not out of bounds: 
       if (newCover < 0) 
        newCover = 0; 
       else if (newCover >= mNumberOfImages) 
        newCover = mNumberOfImages - 1; 

       // Select newCover if appropriate 
       if (newCover != mSelectedCoverView.getNumber()) { 
        setSelectedCover(newCover); 
        // Notify listener 
        if (null != mListener && null != mListener.get()) 
         mListener.get().onSelectionChanging(this, 
           mSelectedCoverView.getNumber()); 
       } 
      } 

      break; 
     case MotionEvent.ACTION_UP: 

      // Cancel long click 
      if (null != mLongClickThread) { 
       if (Thread.State.TERMINATED != mLongClickThread.getState()) 
        mLongClickThread.interrupt(); 
       mLongClickThread = null; 
      } 

      if (mIsSingleTap && 0 < mTouchedCovers.size()) { 
       int lowest = mTouchedCovers.first(); 
       int highest = mTouchedCovers.last(); 
       if (mSelectedCoverView.getNumber() < lowest) 
        setSelectedCover(lowest); 
       else if (mSelectedCoverView.getNumber() > highest) 
        setSelectedCover(highest); 
       else if (lowest <= mSelectedCoverView.getNumber() 
         && highest >= mSelectedCoverView.getNumber() 
         && null != mListener && null != mListener.get()) { 
        if (!mCancelNextClick) { 
         mListener.get().onSelectionClicked(this, 
           mSelectedCoverView.getNumber()); 
        } 
       } 

      } 

      mCancelNextClick = false; 

      // Smooth scroll to the center of the cover 
      mScrollView.smoothScrollTo(mSelectedCoverView.getNumber() 
        * mConfig.COVER_SPACING, mScrollView.getScrollY()); 

      if (mBeginningCover != mSelectedCoverView.getNumber()) { 
       // Notify listener 
       if (null != mListener && null != mListener.get()) 
        mListener.get().onSelectionChanged(this, 
          mSelectedCoverView.getNumber()); 
      } 

      // Clear touched covers 
      mTouchedCovers.clear(); 

      break; 
     } 
    } catch (Exception e) { 

    } 

    return true; 
} 

@Override 
public boolean onTrackballEvent(MotionEvent event) { 
    switch (event.getAction()) { 
    case MotionEvent.ACTION_MOVE: 
     int newCover = -1; 
     if (event.getX(0) > 0) 
      newCover = mSelectedCoverView.getNumber() + 1; 
     else if (event.getX(0) < 0) 
      newCover = mSelectedCoverView.getNumber() - 1; 

     if (0 <= newCover && mNumberOfImages > newCover 
       && mSelectedCoverView.getNumber() != newCover) { 
      setSelectedCover(newCover); 
      mScrollView.smoothScrollTo(newCover * mConfig.COVER_SPACING, 
        mScrollView.getScrollY()); 
      // Notify listener 
      if (null != mListener && null != mListener.get()) 
       mListener.get().onSelectionChanged(this, 
         mSelectedCoverView.getNumber()); 

     } 
     break; 
    } 
    return true; 
} 

void onTouchItem(CoverFlowItem cover, MotionEvent event) { 
    mTouchedCovers.add(cover.getNumber()); 
} 

public void clear() { 
    mNumberOfImages = 0; 
    mSelectedCoverView = null; 
    mOffscreenCovers.clear(); 
    mOnscreenCovers.clear(); 
    mCoverImages.clear(); 
    mCoverImageHeights.clear(); 
    mDefaultBitmap = null; 
    mLowerVisibleCover = -1; 
    mUpperVisibleCover = -1; 

    // Recreate the item container to force free memory 
    LinearLayout parent = (LinearLayout) mItemContainer.getParent(); 
    parent.removeView(mItemContainer); 
    mItemContainer = new FrameLayout(getContext()); 
    parent.addView(mItemContainer); 

} 

public void setNumberOfImages(int numberOfImages) { 
    mNumberOfImages = numberOfImages; 

    int lowerBound = Math.max(-1, 
      (mSelectedCoverView != null ? mSelectedCoverView.getNumber() 
        : 0) - mConfig.COVER_BUFFER); 
    int upperBound = Math.min(mNumberOfImages - 1, 
      (mSelectedCoverView != null ? mSelectedCoverView.getNumber() 
        : 0) + mConfig.COVER_BUFFER); 
    if (null != mSelectedCoverView) 
     layoutCovers(mSelectedCoverView.getNumber(), lowerBound, upperBound); 
    else 
     setSelectedCover(0); 

    centerOnSelectedCover(false); 
} 

public void setDefaultBitmap(Bitmap bitmap) { 
    mDefaultBitmapHeight = null != bitmap ? bitmap.getHeight() : 0; 
    mDefaultBitmap = bitmap; 
} 

public void setDataSource(DataSource dataSource) { 
    mDataSource = new WeakReference<DataSource>(dataSource); 
    setDefaultBitmap(dataSource.defaultBitmap()); 
} 

public void setListener(Listener listener) { 
    mListener = new WeakReference<Listener>(listener); 
} 

public void centerOnSelectedCover(final boolean animated) { 
    if (null == mSelectedCoverView) 
     return; 

    final int offset = mConfig.COVER_SPACING 
      * mSelectedCoverView.getNumber(); 
    mScrollView.post(new Runnable() { 
     public void run() { 
      if (animated) 
       mScrollView.smoothScrollTo(offset, 0); 
      else 
       mScrollView.scrollTo(offset, 0); 
     } 
    }); 
} 

public void setSelectedCover(int newSelectedCover) { 
    if (null != mSelectedCoverView 
      && newSelectedCover == mSelectedCoverView.getNumber()) 
     return; 

    if (newSelectedCover >= mNumberOfImages) 
     return; 

    CoverFlowItem cover; 
    int newLowerBound = Math 
      .max(0, newSelectedCover - mConfig.COVER_BUFFER); 
    int newUpperBound = Math.min(mNumberOfImages - 1, newSelectedCover 
      + mConfig.COVER_BUFFER); 
    if (null == mSelectedCoverView) { 
     // Allocate and display covers from newLower to newUpper bounds. 
     for (int i = newLowerBound; i <= newUpperBound; i++) { 
      cover = coverForIndex(i); 
      mOnscreenCovers.put(i, cover); 
      updateCoverBitmap(cover); 
      if (i == newSelectedCover) { 
       // We'll add it later 
       continue; 
      } else if (i < newSelectedCover) { 
       mItemContainer.addView(cover); 
      } else { 
       mItemContainer.addView(cover, 0); 
      } 
      layoutCover(cover, newSelectedCover, false); 
     } 
     // Add the selected cover 
     cover = mOnscreenCovers.get(newSelectedCover); 
     mItemContainer.addView(cover); 
     layoutCover(cover, newSelectedCover, false); 

     mLowerVisibleCover = newLowerBound; 
     mUpperVisibleCover = newUpperBound; 
     mSelectedCoverView = cover; 
     return; 
    } else { 
     layoutZ(mSelectedCoverView.getNumber(), mLowerVisibleCover, 
       mUpperVisibleCover); 

    } 

    if ((newLowerBound > mUpperVisibleCover) 
      || (newUpperBound < mLowerVisibleCover)) { 
     // They do not overlap at all. 
     // This does not animate--assuming it's programmatically set from 
     // view controller. 
     // Recycle all onscreen covers. 
     for (int i = mLowerVisibleCover; i <= mUpperVisibleCover; i++) { 
      cover = mOnscreenCovers.get(i); 
      mOffscreenCovers.add(cover); 
      mItemContainer.removeView(cover); 
      mOnscreenCovers.remove(i); 
     } 

     // Move all available covers to new location. 
     for (int i = newLowerBound; i <= newUpperBound; i++) { 
      cover = coverForIndex(i); 
      mOnscreenCovers.put(i, cover); 
      updateCoverBitmap(cover); 
      if (i == newSelectedCover) { 
       // We'll add it later 
       continue; 
      } else if (i < newSelectedCover) { 
       mItemContainer.addView(cover); 
      } else { 
       mItemContainer.addView(cover, 0); 
      } 
     } 
     cover = mOnscreenCovers.get(newSelectedCover); 
     mItemContainer.addView(cover); 

     mLowerVisibleCover = newLowerBound; 
     mUpperVisibleCover = newUpperBound; 
     mSelectedCoverView = cover; 
     layoutCovers(newSelectedCover, newLowerBound, newUpperBound); 

     return; 

    } else if (newSelectedCover > mSelectedCoverView.getNumber()) { 
     // Move covers that are now out of range on the left to the right 
     // side, 
     // but only if appropriate (within the range set by newUpperBound). 
     for (int i = mLowerVisibleCover; i < newLowerBound; i++) { 
      cover = mOnscreenCovers.get(i); 
      if (mUpperVisibleCover < newUpperBound) { 
       // Tack it on the right side. 
       mUpperVisibleCover++; 
       cover.setNumber(mUpperVisibleCover); 
       updateCoverBitmap(cover); 
       mOnscreenCovers.put(cover.getNumber(), cover); 
       layoutCover(cover, newSelectedCover, false); 
      } else { 
       // Recycle this cover. 
       mOffscreenCovers.add(cover); 
       mItemContainer.removeView(cover); 
      } 
      mOnscreenCovers.remove(i); 
     } 

     mLowerVisibleCover = newLowerBound; 

     // Add in any missing covers on the right up to the newUpperBound. 
     for (int i = mUpperVisibleCover + 1; i <= newUpperBound; i++) { 
      cover = coverForIndex(i); 
      mOnscreenCovers.put(i, cover); 
      updateCoverBitmap(cover); 
      mItemContainer.addView(cover, 0); 
      layoutCover(cover, newSelectedCover, false); 
     } 
     mUpperVisibleCover = newUpperBound; 
    } else { 
     // Move covers that are now out of range on the right to the left 
     // side, 
     // but only if appropriate (within the range set by newLowerBound). 
     for (int i = mUpperVisibleCover; i > newUpperBound; i--) { 
      cover = mOnscreenCovers.get(i); 
      if (mLowerVisibleCover > newLowerBound) { 
       // Tack it on the left side. 
       mLowerVisibleCover--; 
       cover.setNumber(mLowerVisibleCover); 
       updateCoverBitmap(cover); 
       mOnscreenCovers.put(cover.getNumber(), cover); 
       layoutCover(cover, newSelectedCover, false); 

      } else { 
       // Recycle this cover. 
       mOffscreenCovers.add(cover); 
       mItemContainer.removeView(cover); 
      } 
      mOnscreenCovers.remove(i); 
     } 

     mUpperVisibleCover = newUpperBound; 

     // Add in any missing covers on the left down to the newLowerBound. 
     for (int i = mLowerVisibleCover - 1; i >= newLowerBound; i--) { 
      cover = coverForIndex(i); 
      mOnscreenCovers.put(i, cover); 
      updateCoverBitmap(cover); 
      mItemContainer.addView(cover, 0); 
      layoutCover(cover, newSelectedCover, false); 
     } 

     mLowerVisibleCover = newLowerBound; 
    } 

    if (mSelectedCoverView.getNumber() > newSelectedCover) { 
     layoutCovers(newSelectedCover, newSelectedCover, 
       mSelectedCoverView.getNumber()); 
    } else if (newSelectedCover > mSelectedCoverView.getNumber()) { 
     layoutCovers(newSelectedCover, mSelectedCoverView.getNumber(), 
       newSelectedCover); 
    } 

    mSelectedCoverView = mOnscreenCovers.get(newSelectedCover); 

} 

private static class ScrollView extends HorizontalScrollView { 

    public ScrollView(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 
    } 

    public ScrollView(Context context, AttributeSet attrs) { 
     super(context, attrs); 
    } 

    public ScrollView(Context context) { 
     super(context); 
    } 

} 

public interface DataSource { 
    public void requestBitmapForIndex(CoverFlowView coverFlow, int index); 

    public Bitmap defaultBitmap(); 
} 

public interface Listener { 
    public void onSelectionChanging(CoverFlowView coverFlow, int index); 

    public void onSelectionChanged(CoverFlowView coverFlow, int index); 

    public void onSelectionClicked(CoverFlowView coverFlow, int index); 

    public void onSelectionLongClicked(CoverFlowView coverFlow, int index); 
} 

public static class ItemAnimation extends Animation { 
    private int mViewWidth; 
    private int mViewHeight; 
    private int mStartZOffset; 
    private int mStopZOffset; 
    private int mStartXOffset; 
    private int mStopXOffset; 
    private float mStopAngleDegrees = 0; 
    // private double mStopAngleRadians = 0; 
    private float mStartAngleDegrees = 0; 
    private boolean mStatic = false; 

    // private double mStartAngleRadians = 0; 

    public ItemAnimation() { 
     super(); 
     setFillAfter(true); 
     setFillBefore(true); 
    } 

    public void setStatic() { 
     mStatic = true; 
     setDuration(0); 
    } 

    public void setRotation(float start, float stop) { 
     mStartAngleDegrees = start; 
     mStopAngleDegrees = stop; 
    } 

    public void setXTranslation(int start, int stop) { 
     mStartXOffset = start; 
     mStopXOffset = stop; 
    } 

    public void setZTranslation(int start, int stop) { 
     mStartZOffset = start; 
     mStopZOffset = stop; 
    } 

    public void setViewDimensions(int width, int height) { 
     mViewWidth = width; 
     mViewHeight = height; 
    } 

    public float getStopAngleDegrees() { 
     return mStopAngleDegrees; 
    } 

    public float getStartAngleDegrees() { 
     return mStartAngleDegrees; 
    } 

    public int getStartXOffset() { 
     return mStartXOffset; 
    } 

    public int getStopXOffset() { 
     return mStopXOffset; 
    } 

    public int getStopZOffset() { 
     return mStopZOffset; 
    } 

    @Override 
    protected void applyTransformation(float interpolatedTime, 
      Transformation t) { 
     t.setTransformationType(mStatic ? Transformation.TYPE_BOTH 
       : Transformation.TYPE_MATRIX); 

     if (mStatic) 
      t.setAlpha(interpolatedTime < 1.0f ? 0 : 1); 

     float angleDegrees = mStartAngleDegrees + interpolatedTime 
       * (mStopAngleDegrees - mStartAngleDegrees); 
     float zOffset = mStartZOffset + interpolatedTime 
       * (mStopZOffset - mStartZOffset); 
     int xOffset = mStartXOffset 
       + (int) (interpolatedTime * (mStopXOffset - mStartXOffset)); 
     Matrix m = new Matrix(); 
     Camera camera = new Camera(); 
     camera.translate(0, 0, zOffset); 

     camera.rotateY(angleDegrees); 

     camera.getMatrix(m); 
     m.preTranslate(-(mViewWidth/2), -(mViewHeight/2)); 
     m.postTranslate((mViewWidth/2) + xOffset, (mViewHeight/2)); 

     t.getMatrix().set(m); 
     super.applyTransformation(interpolatedTime, t); 
    } 

} 
}

CoverFlowView.java, 자바

private CoverFlowView mCoverflow; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main_layout); 

    // Find the coverflow 
    mCoverflow = (CoverFlowView) findViewById(R.id.coverflow); 


}

출처

2014-10-11 05:49:50

+0

말해주십시오, 특정 이미지를 어떻게 추가합니까? –

+1

CoverFlowItem 개체를 사용하고 있는데,이 개체는 무엇입니까? 이 클래스 객체에 대한 링크를 제공 하시겠습니까? –

+0

CoverFlowItem은 Coverflow 항목을 탭한 다음 thats 객체가 특정 항목을 반환 할 때 사용합니다 (ListView의 setonitemclicklistener처럼) –

관련 문제

 관련 문제