CoverFlowOpenGL.java
/*
* Copyright 2013 - Android Coverflow Gallery. (Vladyslav Yarovyi)
*
* 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.
*/
package com.masterofcode.android.coverflow_library;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.graphics.RectF;
import android.opengl.GLSurfaceView;
import android.opengl.GLU;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.animation.AnimationUtils;
import com.masterofcode.android.coverflow_library.listeners.CoverFlowListener;
import com.masterofcode.android.coverflow_library.listeners.DataChangedListener;
import com.masterofcode.android.coverflow_library.render_objects.Background;
import com.masterofcode.android.coverflow_library.render_objects.CoverImage;
import com.masterofcode.android.coverflow_library.render_objects.EmptyImage;
import com.masterofcode.android.coverflow_library.utils.CoverflowQuery;
import com.masterofcode.android.coverflow_library.utils.DataCache;
import com.masterofcode.android.coverflow_library.utils.EQuality;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import java.util.ArrayList;
import java.util.List;
/**
* Custom Cover Flow Gallery View. This core class is responsible for drawing
* all images.
*
* @author skynet67
*/
public class CoverFlowOpenGL extends GLSurfaceView implements
GLSurfaceView.Renderer {
public static final String TAG = "CoverFlowOpenGL";
// 滑動的最小像素偏移量
private static final int TOUCH_MINIMUM_MOVE = 5;
// 動畫阻力
private static final float FRICTION = 20.0f; // 10.f
// 滑動的最大速度
private static final float MAX_SPEED = 5.0f; // 6.f
// ------------------------------
private static final int COEF = 5; // 10 // 影響到滑動多少像素能切換到下一 tile
private static final int OFFSET = 0; // 5
private static final float RCOEF = 0.25f;
// ------------------------------
private int maxTiles = 21; // 緩存中總共可以容納的 tiles
private int visibleTiles = 4; // 除了中間,左側/右側最多可見 tiles 數
private int imageSize = 512; // 統一的圖像大小(外框)
private float mOffset; // 記錄偏移了多少 tiles(目前中間tile的索引)
//private int mLastOffset;
//private RectF mTouchRect; // click 顯示 toast 的範圍
private int mWidth;
private int mHeight;
private boolean mTouchMoved;
private float mTouchStartPos;
private float mTouchStartX; // 按下起始的坐标
private float mTouchStartY;
private float mStartOffset; // 起始 tile 的索引
private long mStartTime;
private float mStartSpeed;
private float mDuration;
private Runnable mAnimationRunnable;
private VelocityTracker mVelocity;
private CoverFlowListener mListener;
private DataCache<Integer, CoverImage> mCache;
private CoverflowQuery aQuery;
private List<String> imagesList;
private List<CoverImage> images;
private Activity mActivity;
private EmptyImage emptyImage;
private Background mBackground;
// true:RGB_565 false:ARGB_8888
private boolean showBlackBars;
public CoverFlowOpenGL(Context context) {
super(context);
init();
}
public CoverFlowOpenGL(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public void setActivity(Activity activity) {
this.mActivity = activity;
aQuery = new CoverflowQuery(mActivity);
}
public void init() {
setEGLConfigChooser(8, 8, 8, 8, 16, 0);
setRenderer(this);
// 設定渲染模式
setRenderMode(RENDERMODE_WHEN_DIRTY);
getHolder().setFormat(PixelFormat.TRANSLUCENT);
setZOrderMediaOverlay(true);
setZOrderOnTop(true);
// int cacheForVisibleTiles = (visibleTiles * 2 + 1) + 10; //
// visible_left + center + visible_right + 10 additional
mCache = new DataCache<Integer, CoverImage>(maxTiles);
// Math.min(maxTiles,cacheForVisibleTiles));
// mLastOffset = 0;
mOffset = 0;
}
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
gl.glEnable(GL10.GL_TEXTURE_2D); // Enable Texture Mapping ( NEW )
gl.glShadeModel(GL10.GL_SMOOTH); // Enable Smooth Shading
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
gl.glDisable(GL10.GL_DEPTH_TEST); // Enables Depth Testing
// Really Nice Perspective Calculations
gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);
}
public void onSurfaceChanged(GL10 gl, int w, int h) {
mCache.clear();
mWidth = w;
mHeight = h;
if (mBackground != null) {
mBackground.setGL(gl);
mBackground.initBuffers(w, h);
mBackground.loadGLTexture();
}
if (emptyImage != null) {
emptyImage.setGL(gl);
emptyImage.setViewportData(w, h);
emptyImage.setImageSize(imageSize);
emptyImage.loadGLTexture();
}
if (images != null && images.size() > 0) {
for (CoverImage cImg : images) {
if (cImg != null) {
cImg.setGL(gl);
cImg.setViewportData(w, h);
cImg.removeTexture();
}
}
}
// float imagew = w * RCOEF / 2.0f;
// float imageh = h * RCOEF/ 2.0f;
// 螢幕中心的一定範圍,響應 click 事件
// mTouchRect = new RectF(w / 2 - imagew, h / 2 - imageh, w / 2 + imagew,
// h / 2 + imageh);
gl.glViewport(0, 0, w, h); // Reset The Current Viewport
// 選擇投影矩陣
gl.glMatrixMode(GL10.GL_PROJECTION);
// 重置投影矩陣
gl.glLoadIdentity();
GLU.gluOrtho2D(gl, 0, w, 0, h);
gl.glMatrixMode(GL10.GL_MODELVIEW);
gl.glLoadIdentity();
// updateCache();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
touchBegan(event);
return true;
case MotionEvent.ACTION_MOVE:
touchMoved(event);
return true;
case MotionEvent.ACTION_UP:
touchEnded(event);
return true;
}
return false;
}
// 對 offset 的範圍進行截斷
private float checkValid(float off) {
int max = imagesList.size() - 1;
if (off < 0)
return 0;
else if (off > max)
return max;
return off;
}
private void touchBegan(MotionEvent event) {
endAnimation();
float x = event.getX();
mTouchStartX = x;
mTouchStartY = event.getY();
mStartTime = System.currentTimeMillis();
// 起始元件偏移
mStartOffset = mOffset;
Log.e(TAG, "touchBegan mStartOffset: " + mStartOffset);
mTouchMoved = false;
// -2.5 ~ 2.5
mTouchStartPos = (x / mWidth) * COEF - OFFSET;
mTouchStartPos /= 2;
// ------- 統計滑動速度 ------
mVelocity = VelocityTracker.obtain();
mVelocity.addMovement(event);
// ------- 統計滑動速度 ------
}
private void touchMoved(MotionEvent event) {
// -2.5 ~ 2.5
float pos = (event.getX() / mWidth) * COEF - OFFSET;
pos /= 2;
if (!mTouchMoved) {
// 與按下那刻位置的像素偏移量
float dx = Math.abs(event.getX() - mTouchStartX);
float dy = Math.abs(event.getY() - mTouchStartY);
// 如果偏移很小,則不動
if (dx < TOUCH_MINIMUM_MOVE && dy < TOUCH_MINIMUM_MOVE)
return;
mTouchMoved = true;
}
// 更新元件偏移(注意是浮點數)
mOffset = checkValid(mStartOffset + mTouchStartPos - pos);
//Log.e(TAG, "touchMoved mOffset: " + mOffset);
requestRender();
// ------- 統計滑動速度 ------
mVelocity.addMovement(event);
// ------- 統計滑動速度 ------
}
private void touchEnded(MotionEvent event) {
float pos = (event.getX() / mWidth) * COEF - OFFSET;
pos /= 2;
if (mTouchMoved) {
mStartOffset += mTouchStartPos - pos;
mStartOffset = checkValid(mStartOffset);
// 更新元件的偏移(注意是浮點數)
mOffset = mStartOffset;
// ------- 統計滑動速度 ------
mVelocity.addMovement(event);
// 初始化速率機關
// 1000表示 1秒内運動了多少像素
mVelocity.computeCurrentVelocity(1000);
double speed = mVelocity.getXVelocity();
speed = (speed / mWidth) * COEF;
if (speed > MAX_SPEED)
speed = MAX_SPEED;
else if (speed < -MAX_SPEED)
speed = -MAX_SPEED;
// ------- 統計滑動速度 ------
// 開始一段時間的滑動動畫
startAnimation(-speed);
} else {
// MainActivity中實作接口
// if (mTouchRect.contains(event.getX(), event.getY())) {
// mListener.topTileClicked(this, (int) (mOffset + 0.01));
// }
}
}
private void startAnimation(double speed) {
if (mAnimationRunnable != null)
return;
double delta = speed * speed / (FRICTION * 2);
// 如果反向滑動
if (speed < 0)
delta = -delta;
double nearest = mStartOffset + delta;
// 取整
nearest = Math.floor(nearest + 0.5);
nearest = checkValid((float) nearest);
// 計算動畫速度
mStartSpeed = (float) Math.sqrt(Math.abs(nearest - mStartOffset)
* FRICTION * 2);
// 反向動畫速度
if (nearest < mStartOffset)
mStartSpeed = -mStartSpeed;
Log.i(TAG, "startAnimation! mStartSpeed: " + mStartSpeed);
// 計算動畫總時長
mDuration = Math.abs(mStartSpeed / FRICTION);
// 記錄動畫起始時間
mStartTime = AnimationUtils.currentAnimationTimeMillis();
// 動畫 Runnable對象
mAnimationRunnable = new Runnable() {
public void run() {
driveAnimation();
}
};
// △ 繼續執行driveAnimation
post(mAnimationRunnable);
}
private void driveAnimation() {
//Log.i(TAG, "driveAnimation! ");
// 動畫經過的時間
float elapsed = (AnimationUtils.currentAnimationTimeMillis() - mStartTime) / 1000.0f;
// 如果逾時則結束動畫
if (elapsed >= mDuration)
endAnimation();
else {
// 根據經過的時間來重新整理動畫
updateAnimationAtElapsed(elapsed);
// △ 繼續執行本身
post(mAnimationRunnable);
}
}
private void endAnimation() {
if (mAnimationRunnable != null) {
// 對元件的偏移進行取整(對齊元件的效果)
mOffset = (float) Math.floor(mOffset + 0.5);
mOffset = checkValid(mOffset);
Log.i(TAG, "endAnimation: mOffset = " + mOffset);
// 重新整理動畫
requestRender();
// △ 停止執行driveAnimation()
removeCallbacks(mAnimationRunnable);
mAnimationRunnable = null;
// updateCache();
}
}
private void updateAnimationAtElapsed(float elapsed) {
if (elapsed > mDuration)
elapsed = mDuration;
// 根據 起始動畫速度 和 經過的時間 來計算目前的總偏移量
float delta = Math.abs(mStartSpeed) * elapsed - FRICTION * elapsed
* elapsed / 2;
if (mStartSpeed < 0)
delta = -delta;
// 注意是浮點數
mOffset = checkValid(mStartOffset + delta);
//Log.i(TAG, "Update Anim: mOffset = " + mOffset);
requestRender();
}
// private void updateCache(){
// int diff = VISIBLE_TILES * 2 + 5;
// int diffLeft = Math.max(0,(int)mOffset - diff);
// int diffRight = Math.min(images.size(),(int)mOffset + diff);
//
// for(int i = 0; i < images.size(); i++){
// if(mCache.containsKey(i) && (i < diffLeft || i > diffRight)){
// mCache.removeObjectForKey(i);
// } else
// if(!mCache.containsKey(i) && i >= diffLeft && i <= diffRight){
// CoverImage img = images.get(i);
// img.tryLoadTexture(dataChangedListener, i);
// mCache.putObjectForKey(i, img);
// }
// }
// }
public int getMaxTiles() {
return maxTiles;
}
public void setMaxTiles(int maxTiles) {
this.maxTiles = maxTiles;
mCache = new DataCache<Integer, CoverImage>(maxTiles);
}
public int getVisibleTiles() {
return visibleTiles;
}
public void setVisibleTiles(int visibleTiles) {
this.visibleTiles = visibleTiles;
}
public void setImageQuality(EQuality size) {
imageSize = size.getValue();
}
public void setImageShowBlackBars(boolean value) {
showBlackBars = value;
}
public void setImagesList(List<String> imagesList) {
this.imagesList = imagesList;
if (imagesList != null && imagesList.size() > 0) {
images = new ArrayList<CoverImage>(imagesList.size());
for (String imageUrl : imagesList) {
CoverImage ci = new CoverImage(mActivity, aQuery)
.setUrl(imageUrl).setImageSize(imageSize)
.setShowBlackBars(showBlackBars);
images.add(ci);
}
}
}
public void setCoverFlowListener(CoverFlowListener listener) {
mListener = listener;
}
public void setSelection(int position) {
endAnimation();
if (images != null && images.size() > 0) {
position = Math.min(position, images.size() - 1);
}
mOffset = position;
Log.w(TAG, "setSelection: mOffset = " + mOffset);
requestRender();
}
public void setBackgroundRes(int res) {
mBackground = new Background(mActivity, res);
}
public void setEmptyRes(int res) {
emptyImage = new EmptyImage(mActivity, res);
}
// public void setBackgroundUrl(String url){
// mBackground = new Background(mActivity, url);
// }
// public void setEmtpyUrl(String url){
// emptyImage = new EmptyImage(mActivity, url);
// }
public void onDrawFrame(GL10 gl) {
gl.glMatrixMode(GL10.GL_MODELVIEW);
gl.glLoadIdentity();
// clear Screen and Depth Buffer
gl.glDisable(GL10.GL_DEPTH_TEST);
gl.glClearColor(0, 0, 0, 0);
gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
// Drawing
gl.glTranslatef(0.0f, 0.0f, 0.0f);
if (mBackground != null) {
mBackground.draw(gl);
}
final float offset = mOffset;
//Log.e(TAG, "onDrawFrame: offset = " + offset);
int i;
int max = imagesList != null ? imagesList.size() - 1 : 0;
// 中間的最大 tile 的索引(取整)
int mid = (int) Math.floor(offset + 0.5);
// 可見的最左側 tile 的索引(取整)
int iStartPos = mid - visibleTiles;
//Log.e(TAG, "onDrawFrame: iStartPos = " + iStartPos);
if (iStartPos < 0)
iStartPos = 0;
// 繪制左側 tiles
for (i = iStartPos; i < mid; ++i) {
drawTile(i, i - offset, gl); // 如果用 mid 就沒有過渡特效
}
// 可見的最右側的 tile 的索引
int iEndPos = mid + visibleTiles;
//Log.e(TAG, "onDrawFrame: iEndPos = " + iEndPos);
// 繪制右側和中間的 tiles
if (iEndPos > max)
iEndPos = max;
for (i = iEndPos; i >= mid; --i) {
drawTile(i, i - offset, gl); // 如果用 mid 就沒有過渡特效
}
// MainActivity中實作接口
// if (mLastOffset != (int) offset) {
// mListener.tileOnTop(this, (int) offset);
// mLastOffset = (int) offset;
// //Log.e(TAG, "mLastOffset: " + offset);
// }
}
private void drawTile(
int position, // 目前的 tile
float off, // 目前 tile 離 中間的 tile 的偏移
GL10 gl) {
// ☆ 從鍵值對緩存中取出對應的 CoverImage ☆
// 不用每次都去下載下傳
CoverImage cacheImg = mCache.objectForKey(position);
boolean canDraw = false;
if (cacheImg == null) {
// 目前的 tile 所對應的圖檔
cacheImg = images.get(position);
cacheImg.tryLoadTexture(dataChangedListener, position);
// 添加到 鍵值對 緩存中
mCache.putObjectForKey(position, cacheImg);
if (cacheImg.getTexture() != 0) {
canDraw = true;
}
} else if (cacheImg.getTexture() != 0) {
canDraw = true;
}
// 圖像等比例縮放(還有稍稍偏移)後的大小
float desiredSize = canDraw ? cacheImg.getDesiredSize() : emptyImage
.getDesiredSize();
// 一半寬度/一側可見的tiles數
float spread = (mWidth - desiredSize) * 0.5f / visibleTiles;
// 水準偏移
float trans = off * spread;
// 根據離中心的距離,控制縮放比例
float sc = 1.0f - (Math.abs(off) / (visibleTiles + 1));
if (canDraw) {
cacheImg.draw(gl, trans, sc);
} else {
emptyImage.draw(gl, trans, sc);
}
}
// 定義監聽器
private DataChangedListener dataChangedListener = new DataChangedListener() {
public void imageUpdated(int position) {
synchronized (this) {
// 顯示範圍:(mOffset - visibleTiles, mOffset + visibleTiles)
if (mOffset - visibleTiles < position
|| position < mOffset + visibleTiles) {
requestRender();
}
}
}
};
}