VideoPlayerDemo

Introduction: 自定义高性能播放器, 实现边下边播缓存等功能
More: Author   ReportBugs   
Tags:

本项目使用播放器是ijkplay, 并且进行封装和修改

主要功能:
1.重新编辑 ijkplay 的 so 库, 使其更精简和支持 https 协议
2.自定义 MediaDataSource, 使用 okhttp 重写网络框架, 网络播放更流畅
3.实现视频缓存, 并且自定义 LRUCache 算法管理缓存文件
4.全局使用一个播放器, 实现视频在多个 Activity 之前无缝切换, 流畅播放
5.加入更多兼容性判断, 适配绝大数机型

①导入 ijkplay:

//需要的权限
<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"/>

首先将 lib 文件夹下的 so 库粘贴过来, (因为官方自带的 so 库是不支持 https 的, 我重新编译的这个 so 库支持 https 协议, 
并且使用的是精简版的配置, 网上关于 ijkplay 编译的流程和配置挺多的, 可以根据自己的需求自定义)

然后在 module 的 build 中加入 "implementation 'tv.danmaku.ijk.media:ijkplayer-java:0.8.8'"

②使用播放器的方法:

1.我封装了一个 MediaPlayerTool 工具类包含的初始化 so 库和一些回调等等

 //通过单例得到媒体播放工具
 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){};
    }

2.因为我使用的是 RecyclerView,所以先找到当前屏幕中 处于可以播放范围的 item

    //首先循环 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;
    }

3.我还封装了一个 TextureView, 里面包含一些初始化 SurfaceTexture 和视频裁剪播放的方法

    //视频居中播放
    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;
    }

4.接下来就是播放代码了

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();
    }

③重写 MediaDataSource, 使用 okhttp 实现边下边播和视频缓存

1.一共需要重写 3 个方法 getSize(),close()和 readAt(); 先说 getSize()

    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");
        }
    }

2.然后是 readAt()方法, 也是最重要的一个方法

    /**
     * @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();
    }

3.主要说一下 syncInputStream(), 因为有可能出现一种情况, 比如一个视频长度 100, 播放器首先读取视频的 1 到 10 之间的数据, 然后在读取 90 到 100 之间的数据, 然后在从 1 播放到 100; 所以这时我们需要同步视频流, 和播放进度保持一致这时就需要重新开启一个 IO 流(如果在读取本地缓存时可以直接使用 RandomAccessFile.seek()方法跳转)

 //同步数据流
    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;
    }

4.最后一个是 close()方法, 主要播放停止后释放一些资源

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();
        }
    }

④视频缓存和 LRUCache 管理

1.首先创建缓存文件, 在刚才的 MediaDataSource.getSize()方法里有一句代码

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.然后是读取缓存文件, 在刚才的 MediaDataSource.getSize()方法里还有一句代码

 //检查本地是否有缓存, 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;
    }

3.LRUCache 的实现

//清理超过大小和存储时间的视频缓存文件
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 同步播放状态, 无缝切换

1.首先在跳转时, 通知被覆盖的 activity 不关闭播放器

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

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

2.然后在新页面初始化播放器

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

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

至此代码讲解完毕, 亲测在 4g 网络下视频初始化速度毫秒级, 并且在低性能手机下, 页面来回切换无卡顿.

大家如果有不解, 可以查看源码了解更多, 有 bug 或优化思路 也可以提issues


MIT License

Copyright (c) 2018 Zhaoss (838198688@qq.com)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Support Me
Apps
About Me
Google+: Trinea trinea
GitHub: Trinea