封装bilibili播放器 , 仿抖音视频播放效果

//需要的权限
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

implementation 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'

//通过单例得到媒体播放工具
mMediaPlayerTool = MediaPlayerTool.getInstance();
//这里会自动初始化so库 有些手机会找不到so, 会自动使用系统的播放器
private MediaPlayerTool(){
       try {
           IjkMediaPlayer.loadLibrariesOnce(null);
           IjkMediaPlayer.native_profileBegin("libijkplayer.so");
           loadIjkSucc = true;
       }catch (UnsatisfiedLinkError e){
           e.printStackTrace();
           loadIjkSucc = false;
       }
}

//一些生命周期回调
public static abstract class VideoListener {
       //视频开始播放
       public void onStart(){};
       //视频被停止播放
       public void onStop(){};
       //视频播放完成
       public void onCompletion(){};
       //视频旋转角度参数初始化完成
       public void onRotationInfo(int rotation){};
       //播放进度 0-1
       public void onPlayProgress(long currentPosition){};
       //缓存速度 1-100
       public void onBufferProgress(int progress){};
   }

//通过单例得到媒体播放工具
mMediaPlayerTool = MediaPlayerTool.getInstance();
//这里会自动初始化so库 有些手机会找不到so, 会自动使用系统的播放器
private MediaPlayerTool(){
       try {
           IjkMediaPlayer.loadLibrariesOnce(null);
           IjkMediaPlayer.native_profileBegin("libijkplayer.so");
           loadIjkSucc = true;
       }catch (UnsatisfiedLinkError e){
           e.printStackTrace();
           loadIjkSucc = false;
       }
}

//首先循环RecyclerView中所有itemView, 找到在屏幕可见范围内的item
private void checkPlayVideo(){
    currentPlayIndex = 0;
    videoPositionList.clear();

    int childCount = rv_video.getChildCount();
    for (int x = 0; x < childCount; x++) {
        View childView = rv_video.getChildAt(x);
        //isPlayRange()这个方法很重要
        boolean playRange = isPlayRange(childView.findViewById(R.id.rl_video), rv_video);
        if(playRange){
            int position = rv_video.getChildAdapterPosition(childView);
            if(position>=0 && !videoPositionList.contains(position)){
                videoPositionList.add(position);
            }
        }
    }
}

//检查当前item是否在RecyclerView可见的范围内
private boolean isPlayRange(View childView, View parentView){

    if(childView==null || parentView==null){
        return false;
    }

    int[] childLocal = new int[2];
    childView.getLocationOnScreen(childLocal);

    int[] parentLocal = new int[2];
    parentView.getLocationOnScreen(parentLocal);

    boolean playRange = childLocal[1]>=parentLocal[1] &&
            childLocal[1]<=parentLocal[1]+parentView.getHeight()-childView.getHeight();

    return playRange;
}

//视频居中播放
private void setVideoCenter(float viewWidth, float viewHeight, float videoWidth, float videoHeight){

    Matrix matrix = new Matrix();
    float sx = viewWidth/videoWidth;
    float sy = viewHeight/videoHeight;
    float maxScale = Math.max(sx, sy);

    matrix.preTranslate((viewWidth - videoWidth) / 2, (viewHeight - videoHeight) / 2);
    matrix.preScale(videoWidth/viewWidth, videoHeight/viewHeight);
    matrix.postScale(maxScale, maxScale, viewWidth/2, viewHeight/2);

    mTextureView.setTransform(matrix);
    mTextureView.postInvalidate();
}

//初始化SurfaceTexture
public SurfaceTexture newSurfaceTexture(){

    int[] textures = new int[1];
    GLES20.glGenTextures(1, textures, 0);
    int texName = textures[0];
    SurfaceTexture surfaceTexture = new SurfaceTexture(texName);
    surfaceTexture.detachFromGLContext();
    return surfaceTexture;
}

private void playVideoByPosition(int position){
   //根据传进来的position找到对应的ViewHolder
   final MainAdapter.MyViewHolder vh = (MainAdapter.MyViewHolder)       
   rv_video.findViewHolderForAdapterPosition(position);
   if(vh == null){
       return ;
   }

   currentPlayView = vh.rl_video;

   //初始化一些播放状态, 如进度条,播放按钮,加载框等
   //显示正在加载的界面
   vh.iv_play_icon.setVisibility(View.GONE);
   vh.pb_video.setVisibility(View.VISIBLE);
   vh.iv_cover.setVisibility(View.VISIBLE);
   vh.tv_play_time.setText("");

   //初始化播放器
   mMediaPlayerTool.initMediaPLayer();
   mMediaPlayerTool.setVolume(0);

   //设置视频url
   String videoUrl = dataList.get(position).getVideoUrl();
   mMediaPlayerTool.setDataSource(videoUrl);

   myVideoListener = new MediaPlayerTool.VideoListener() {
       @Override
       public void onStart() {
           //将播放图标和封面隐藏
           vh.iv_play_icon.setVisibility(View.GONE);
           vh.pb_video.setVisibility(View.GONE);
           //防止闪屏
           vh.iv_cover.postDelayed(new Runnable() {
               @Override
               public void run() {
                   vh.iv_cover.setVisibility(View.GONE);
               }
           }, 300);
       }
       @Override
       public void onStop() {
           //播放停止
           vh.pb_video.setVisibility(View.GONE);
           vh.iv_cover.setVisibility(View.VISIBLE);
           vh.iv_play_icon.setVisibility(View.VISIBLE);
           vh.tv_play_time.setText("");
           currentPlayView = null;
       }
       @Override
       public void onCompletion() {
           //播放下一个
           currentPlayIndex++;
           playVideoByPosition(-1);
       }
       @Override
       public void onRotationInfo(int rotation) {
           //设置旋转播放
           vh.playTextureView.setRotation(rotation);
       }
       @Override
       public void onPlayProgress(long currentPosition) {
           //显示播放时长
           String date = MyUtil.fromMMss(mMediaPlayerTool.getDuration() - currentPosition);
           vh.tv_play_time.setText(date);
       }
   };
   mMediaPlayerTool.setVideoListener(myVideoListener);

   //这里重置一下TextureView
   vh.playTextureView.resetTextureView();
   mMediaPlayerTool.setPlayTextureView(vh.playTextureView);
   mMediaPlayerTool.setSurfaceTexture(vh.playTextureView.getSurfaceTexture());
   //准备播放
   mMediaPlayerTool.prepare();
}

public long getSize() throws IOException {
    //开始播放时, 播放器会调用一下getSize()来初始化视频大小, 这时我们就要初始化一条视频播放流
    if(networkInPutStream == null) {
        initInputStream();
    }
    return contentLength;
}

//初始化一个视频流出来, 可能是本地或网络
private void initInputStream() throws IOException{

    File file = checkCache(mMd5);
    if(file != null){
        //更新一下缓存文件
        VideoLRUCacheUtil.updateVideoCacheBean(mMd5, file.getAbsolutePath(), file.length());
        //读取的本地缓存文件
        isCacheVideo = true;
        localVideoFile = file;
        //开启一个本地视频流
        localStream = new RandomAccessFile(localVideoFile, "rw");
        contentLength = file.length();
    }else {
        //没有缓存 开启一个网络流, 并且开启一个缓存流, 实现视频缓存
        isCacheVideo = false;
        //开启一个网络视频流
        networkInPutStream = openHttpClient(0);
        //要写入的本地缓存文件
        localVideoFile = VideoLRUCacheUtil.createCacheFile(MyApplication.mContext, mMd5, contentLength);
        //要写入的本地缓存视频流
        localStream = new RandomAccessFile(localVideoFile, "rw");
    }
}

/**
 * @param position 视频流读取进度
 * @param buffer 要把读取到的数据存到这个数组
 * @param offset 数据开始写入的坐标
 * @param size 本次一共读取数据的大小
 * @throws IOException
 */
//记录当前读取流的索引
long mPosition = 0;
@Override
public int readAt(long position, byte[] buffer, int offset, int size) throws IOException {

    if(position>=contentLength || localStream==null){
        return -1;
    }

    //是否将此字节缓存到本地
    boolean isWriteVideo = syncInputStream(position);

    //读取的流的长度不能大于contentLength
    if (position+size > contentLength) {
        size -= position+size-contentLength;
    }

    //读取指定大小的视频数据
    byte[] bytes;
    if(isCacheVideo){
        //从本地读取
        bytes = readByteBySize(localStream, size);
    }else{
        //从网络读取
        bytes = readByteBySize(networkInPutStream, size);
    }
    if(bytes != null) {
        //写入到播放器的数组中
        System.arraycopy(bytes, 0, buffer, offset, size);
        if (isWriteVideo && !isCacheVideo) {
            //将视频缓存到本地
            localStream.write(bytes);
        }
        //记录数据流读取到哪步了
        mPosition += size;
    }

    return size;
}

 /**
 * 从inputStream里读取size大小的数据
 */
private byte[] readByteBySize(InputStream inputStream, int size) throws IOException{

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    byte[] buf = new byte[size];
    int len;
    while ((len = inputStream.read(buf)) != -1) {
        out.write(buf, 0, len);
        if (out.size() == size) {
            return out.toByteArray();
        } else {
            buf = new byte[size - out.size()];
        }
    }
    return null;
}

 /**
 * 删除file一部分字节, 从position到file.size
 */
private void deleteFileByPosition(long position) throws IOException{

    FileInputStream in = new FileInputStream(localVideoFile);

    File tempFile = VideoLRUCacheUtil.createTempFile(MyApplication.mContext);
    FileOutputStream out = new FileOutputStream(tempFile);

    byte[] buf = new byte[8192];
    int len;
    while ((len = in.read(buf)) != -1) {
        if(position <= len){
            out.write(buf, 0, (int) position);
            out.close();

            in.close();
            localVideoFile.delete();
            tempFile.renameTo(localVideoFile);
            localStream = new RandomAccessFile(localVideoFile, "rw");
            return ;
        }else{
            position -= len;
            out.write(buf, 0, len);
        }
    }
    tempFile.delete();
}

//同步数据流
private boolean syncInputStream(long position) throws IOException{
    boolean isWriteVideo = true;
    //判断两次读取数据是否连续
    if(mPosition != position){
        if(isCacheVideo){
            //如果是本地缓存, 直接跳转到该索引
            localStream.seek(position);
        }else{
            if(mPosition > position){
                //同步本地缓存流
                localStream.close();
                deleteFileByPosition(position);
                localStream.seek(position);
            }else{
                isWriteVideo = false;
            }
            networkInPutStream.close();
            //重新开启一个网络流
            networkInPutStream = openHttpClient((int) position);
        }
        mPosition = position;
    }
    return isWriteVideo;
}

public void close() throws IOException {
    if(networkInPutStream != null){
        networkInPutStream.close();
        networkInPutStream = null;
    }
    if(localStream != null){
        localStream.close();
        localStream = null;
    }
    if(localVideoFile.length()!=contentLength){
        localVideoFile.delete();
    }
}

localVideoFile = VideoLRUCacheUtil.createCacheFile(MyApplication.mContext, mMd5, contentLength);

public static File createCacheFile(Context context, String md5, long fileSize){
    //创建一个视频缓存文件, 在data/data目录下
    File filesDir = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);

    File cacheFile = new File(filesDir, md5);
    if(!cacheFile.exists()) {
        cacheFile.createNewFile();
    }
    //将缓存信息存到数据库
    VideoLRUCacheUtil.updateVideoCacheBean(md5, cacheFile.getAbsolutePath(), fileSize);
    return cacheFile;
}

//检查本地是否有缓存, 2步确认, 数据库中是否存在, 本地文件是否存在
private File checkCache(String md5){
    //查询数据库
    VideoCacheBean bean = VideoCacheDBUtil.query(md5);
    if(bean != null){
        File file = new File(bean.getVideoPath());
        if(file.exists()){
            return file;
        }
    }
    return null;
}

//清理超过大小和存储时间的视频缓存文件
VideoLRUCacheUtil.checkCacheSize(mContext);

public static void checkCacheSize(Context context){

    ArrayList<VideoCacheBean> videoCacheList = VideoCacheDBUtil.query();

    //检查一下数据库里面的缓存文件是否存在
    for (VideoCacheBean bean : videoCacheList){
        if(bean.getFileSize() == 0){
            File videoFile = new File(bean.getVideoPath());
            //如果文件不存在或者文件大小不匹配, 那么删除
            if(!videoFile.exists() && videoFile.length()!=bean.getFileSize()){
                VideoCacheDBUtil.delete(bean);
            }
        }
    }

    long currentSize = 0;
    long currentTime = System.currentTimeMillis();
    for (VideoCacheBean bean : videoCacheList){
        //太久远的文件删除
        if(currentTime-bean.getPlayTime() > maxCacheTime){
            VideoCacheDBUtil.delete(bean);
        }else {
            //大于存储空间的删除
            if (currentSize + bean.getFileSize() > maxDirSize) {
                VideoCacheDBUtil.delete(bean);
            } else {
                currentSize += bean.getFileSize();
            }
        }
    }

    //删除不符合规则的缓存
    deleteDirRoom(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), VideoCacheDBUtil.query());
}

//更新缓存文件的播放次数和最后播放时间
public static void updateVideoCacheBean(String md5, String videoPath, long fileSize){

    VideoCacheBean videoCacheBean = VideoCacheDBUtil.query(md5);
    if(videoCacheBean == null){
        videoCacheBean = new VideoCacheBean();
        videoCacheBean.setKey(md5);
        videoCacheBean.setVideoPath(videoPath);
        videoCacheBean.setFileSize(fileSize);
    }
    videoCacheBean.setPlayCount(videoCacheBean.getPlayCount()+1);
    videoCacheBean.setPlayTime(System.currentTimeMillis());

    VideoCacheDBUtil.save(videoCacheBean);
}

//首先跳转时通知一下activity
mainActivity.jumpNotCloseMediaPlay(position);

//然后在onPause里
protected void onPause() {
    super.onPause();
    //如果要跳转播放, 那么不关闭播放器
    if (videoPositionList.size()>currentPlayIndex && jumpVideoPosition==videoPositionList.get(currentPlayIndex)) {
          ...这里就不关闭播放器
    }else{
        //如果不要求跳转播放, 那么就重置播放器
        mMediaPlayerTool.reset();
  }
}

private void playVideoByPosition(int position){
    ......一切初始化代码照旧(注意不要重置播放器), 这里省略不提

     //把播放器当前绑定的SurfaceTexture取出起来, 设置给当前界面的TextureView
     vh.playTextureView.resetTextureView(mMediaPlayerTool.getAvailableSurfaceTexture());
     mMediaPlayerTool.setPlayTextureView(vh.playTextureView);
     //最后刷新一下view
     vh.playTextureView.postInvalidate();
}