Android Coverflow Gallery 的关键源码解析AndroidOpenGL

Posted 2021-12-22 ShaderJoy

CoverFlowOpenGL.java

/*
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * 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
 * 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;
/**
 * 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();
        
      
    
  ;