ijkplayer和SurfaceView搭配做在线视频的播放和缓存

记录下 ijkplayer和SurfaceView搭配做在线视频的播放的代码，便于以后需要时查看：

自定义视频播放控件类 IjkplayerVideoView，这个控件是从网上找的，具体链接忘记了，这里只是记录下使用的过程，你可以自己去封装定义再

public class IjkplayerVideoView extends FrameLayout {


    public IjkplayerVideoView(@NonNull Context context) {
        super(context);
        initVideoView(context);
    }

    public IjkplayerVideoView(@NonNull Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        initVideoView(context);
    }

    public IjkplayerVideoView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        initVideoView(context);
    }

    @SuppressLint("NewApi")
    public IjkplayerVideoView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        initVideoView(context);
    }




    /**
     * 由ijkplayer提供，用于播放视频，需要给他传入一个surfaceView
     */
    private IMediaPlayer mMediaPlayer = null;

    /**
     * 视频文件地址
     */
    private String mPath = "";

    private SurfaceView surfaceView;

    private VideoPlayerListener listener;
    private Context mContext;


    private void initVideoView(Context context) {
        mContext = context;
        //获取焦点
//        setFocusable(true);
    }

    /**
     * 设置视频地址。
     * 根据是否第一次播放视频，做不同的操作。
     *
     * @param path the path of the video.
     */
    public void setVideoPath(String path) {
        if (TextUtils.equals("", mPath)) {
            //如果是第一次播放视频，那就创建一个新的surfaceView
            mPath = path;
            createSurfaceView();
        } else {
            //否则就直接load
            mPath = path;
            load();
        }
    }

    /**
     * 新建一个surfaceview
     */
    private void createSurfaceView() {
        //生成一个新的surface view
        surfaceView = new SurfaceView(mContext);
        surfaceView.getHolder().addCallback(new LmnSurfaceCallback());
        LayoutParams layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT
                , LayoutParams.MATCH_PARENT, Gravity.CENTER);
        surfaceView.setLayoutParams(layoutParams);
        this.addView(surfaceView);
    }

    /**
     * surfaceView的监听器
     */
    private class LmnSurfaceCallback implements SurfaceHolder.Callback {
        @Override
        public void surfaceCreated(SurfaceHolder holder) {
        }

        @Override
        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            //surfaceview创建成功后，加载视频
            load();
        }

        @Override
        public void surfaceDestroyed(SurfaceHolder holder) {
        }
    }



    /**
     * 加载视频
     */
    private void load() {
        //每次都要重新创建IMediaPlayer
        createPlayer();
        try {
            mMediaPlayer.setDataSource(mPath);
            mMediaPlayer.setLooping(true);
            mMediaPlayer.setVolume(0f,0f);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //给mediaPlayer设置视图
        mMediaPlayer.setDisplay(surfaceView.getHolder());

        mMediaPlayer.prepareAsync();
    }

    /**
     * 创建一个新的player
     */
    private void createPlayer() {
        if (mMediaPlayer != null) {
            mMediaPlayer.stop();
            mMediaPlayer.setDisplay(null);
            mMediaPlayer.release();
        }
        IjkMediaPlayer ijkMediaPlayer = new IjkMediaPlayer();
        ijkMediaPlayer.native_setLogLevel(IjkMediaPlayer.IJK_LOG_DEBUG);

//开启硬解码        ijkMediaPlayer.setOption(IjkMediaPlayer.OPT_CATEGORY_PLAYER, "mediacodec", 1);

        mMediaPlayer = ijkMediaPlayer;

        if (listener != null) {
            mMediaPlayer.setOnPreparedListener(listener);
            mMediaPlayer.setOnInfoListener(listener);
            mMediaPlayer.setOnSeekCompleteListener(listener);
            mMediaPlayer.setOnBufferingUpdateListener(listener);
            mMediaPlayer.setOnErrorListener(listener);
        }
    }


    public void setListener(VideoPlayerListener listener) {
        this.listener = listener;
        if (mMediaPlayer != null) {
            mMediaPlayer.setOnPreparedListener(listener);
        }
    }

    /**
     *下面封装了控制视频的方法
     */

    public void setVolume(float v1,float v2 ){
        //关闭声音
        if (mMediaPlayer!=null){
            mMediaPlayer.setVolume(v1,v2);
        }
    }

    public void start() {
        if (mMediaPlayer != null) {
            mMediaPlayer.start();
        }
    }

    public void release() {
        if (mMediaPlayer != null) {
            mMediaPlayer.reset();
            mMediaPlayer.release();
            mMediaPlayer = null;
        }
    }

    public void pause() {
        if (mMediaPlayer != null) {
            mMediaPlayer.pause();
        }
    }

    public void stop() {
        if (mMediaPlayer != null) {
            mMediaPlayer.stop();
        }
    }


    public void reset() {
        if (mMediaPlayer != null) {
            mMediaPlayer.reset();
        }
    }


    public long getDuration() {
        if (mMediaPlayer != null) {
            return mMediaPlayer.getDuration();
        } else {
            return 0;
        }
    }


    public long getCurrentPosition() {
        if (mMediaPlayer != null) {
            return mMediaPlayer.getCurrentPosition();
        } else {
            return 0;
        }
    }


    public void seekTo(long l) {
        if (mMediaPlayer != null) {
            mMediaPlayer.seekTo(l);
        }
    }
}

：布局里面引用该自定义控件：

<com.wj.widget.ijkplayerVideo.IjkplayerVideoView
            android:id="@+id/video_wallpaper_img2"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:keepScreenOn="true">

        </com.wj.widget.ijkplayerVideo.IjkplayerVideoView>

代码里面调用：

  view.video_wallpaper_img2.setListener(object : VideoPlayerListener() {
                            override fun onSeekComplete(p0: IMediaPlayer?) {
                            }

                            override fun onInfo(p0: IMediaPlayer?, p1: Int, p2: Int): Boolean {
                                return false
                            }

                            override fun onVideoSizeChanged(p0: IMediaPlayer?, p1: Int, p2: Int, p3: Int, p4: Int) {
                            }

                            override fun onBufferingUpdate(p0: IMediaPlayer?, p1: Int) {
                            }

                            override fun onPrepared(mp: IMediaPlayer?) {
                                // 视频准备好播放了，但是他不会自动播放，需要手动让他开始。
                                mp?.start()
                                view.iv_wallpaper_video_preview.visibility = View.GONE
                            }

                            override fun onCompletion(p0: IMediaPlayer?) {
                            }

                            override fun onError(p0: IMediaPlayer?, p1: Int, p2: Int): Boolean {
                                return false
                            }
                        } )
                        // 缓存
                        var proxy: HttpProxyCacheServer = HttpProxyCacheServer.Builder(acty).build()
                        //注意不能传入本地路径，本地的你还传进来干嘛。
                        var proxyUrl = proxy.getProxyUrl(bean!!.wurl_preview)
                        view.video_wallpaper_img2.setVideoPath(proxyUrl)

这样就可以播放了，HttpProxyCacheServer视频缓存是用了一个库，需要在glide中引入这个库的依赖：

dependencies {
    compile 'com.danikula:videocache:2.6.4'
}

关于HttpProxyCacheServer详细使用教程可以看这篇博客https://blog.csdn.net/wjj1996825/article/details/84562496