Android SurfaceView + MediaPlayer实现分段视频无缝播放

时间  2019-11-21
标签 android surfaceview mediaplayer 实现 分段 视频 无缝 播放 栏目 Android 繁體版
原文   原文链接

Android当中实现视频播放的方式有两种，即：经过VideoView实现或者经过SurfaceView + MediaPlayer实现。android

由浅至深，首先来看下想要在Android上播放一段视频，咱们应当怎么作。web

前面咱们已经提到了两种方式，这里咱们来看一下具备更好的拓展性的第二种方式，也就是经过SurfaceView + MediaPlayer进行实现。缓存

首先，咱们来定义一个布局文件以下，为了方便起见，咱们仅仅只在该布局中定义了一个SurfaceView：app

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:id="@+id/videoLayout" >

    <SurfaceView
        android:id="@+id/surface"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_gravity="center">
    </SurfaceView>

</FrameLayout>

接着就是Activity类文件的定义：ide

package com.example.videodemo;

import android.app.Activity;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.os.Bundle;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public class VideoPlayActivity extends Activity implements
        SurfaceHolder.Callback {
    /** Called when the activity is first created. */
    MediaPlayer player;
    SurfaceView surface;
    SurfaceHolder surfaceHolder;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_video_play);

        initView();
    }

    private void initView() {
        surface = (SurfaceView) findViewById(R.id.surface);
        surfaceHolder = surface.getHolder(); // SurfaceHolder是SurfaceView的控制接口
        surfaceHolder.addCallback(this); // 由于这个类实现了SurfaceHolder.Callback接口，因此回调参数直接this
    }

    @Override
    public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
    }

    @Override
    public void surfaceCreated(SurfaceHolder arg0) {
        // 必须在surface建立后才能初始化MediaPlayer,不然不会显示图像
        player = new MediaPlayer();
        player.setAudioStreamType(AudioManager.STREAM_MUSIC);
        player.setDisplay(surfaceHolder);
        // 设置显示视频显示在SurfaceView上
        try {
            player.setDataSource("你要播放的视频的url");
            player.prepare();
            player.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        if (player.isPlaying()) {
            player.stop();
        }
        player.release();
        // Activity销毁时中止播放，释放资源。不作这个操做，即便退出仍是能听到视频播放的声音
    }
}

由此你能够看到，这种实现方式有几点值得注意的地方是：布局

一、你须要一个媒体播放器对象"MediaPlayer"，该对象会负责播放你指定的视频。测试

二、若是说MediaPlayer负责播放视频，那么咱们刚刚定义的SurfaceView则用于在屏幕中显示播放视频。this

  （因此又能够理解为，若是MediaPlayer是一副画，而SurfaceView则是让这幅画呈如今人们眼前的画纸）url

三、MediaPlayer类的成员方法设置用于显示媒体视频的SurfaceHolder，正如上面所说，就如同你择不一样的画纸来呈现你的画。spa

四、MediaPlayer类的成员方法setDataSource用于指定你要播放的视频数据源。

五、仅仅是设置完数据源是不足够的，设置完数据源和显示的Surface后，你须要调用prepare()或prepareAsync()来让你的视频数据源stand by..

六、因此你也可能已经发现，对于一段视频的播放，MediaPlayer是关键，关于该类的更多使用，这篇博客里有更详细的说明：Android - MediaPlayer类的使用说明

由此咱们已经基本掌握了，在android端简单的播放视频的方法。一切看上去十分美好。

但作开发就是有这么蛋疼，maybe有不少时候为了加快video与server端之间上传于下载的速率，有时候会对视频作分段处理。

正如同作web开发时，上传和下载文件时，若是文件过大，不少时候咱们会选择对文件作“切割处理同样”。

那么这个时候，就出现了一种状况，就是可能你要播放的一段视频，

事实上是由几小段视频组合而成的。因此就涉及到了连续播放。

可能当面对到这样的需求时，咱们首先最容易想到的就是：

对每段视频进行监听，当监听到它播放结束时，马上作Refresh切换到下一段视频分段的播放。

而MediaPlayer的确也提供了这样的监听事件，正是：MediaPlayer.OnCompletionListener()。

我在网上查阅相关实现的功能时，也只看到相似的说法，也就是说在该监听内作实现：

当一段数据源播放完毕后，执行player.reset()释放数据源，而后再设置新的资源进行播放。

但这样作有很大的一个弊端就是，reset掉旧的数据源以后，新的数据源会有一段“加载时间”。

也就是说，在这段时间内，用户看到的播放界面就处于一个停顿状态。

那么，为了最大化的避免这个所谓的“停顿时间”，又应该怎么去作呢？

首先考虑到的即是，在一段视频开始播放的同时，便开始作第二段视频播放的“准备工做”。

可是经过前面的例子咱们之前看到了，基于MediaPlayer自己的特性和限制。

若是咱们想要实现这样的方式，那么单一的MediaPlayer是知足不了咱们的需求的。

因此咱们要作的工做即是：当咱们进入视频播放界面，第一段视频准备完毕，开始播放后，

便开始着手初始化另外一个新的MediaPlayer，这个新的MediaPlayer的数据源固然是接下来要播放的下一段视频的url！

当这个MediaPlayer对象的准备工做都搞定后，剩下的工做就是：

咱们须要“一颗钉子”，来将两个分段的视频段链接起来。

而这个钉子就是Android r16后添加的一个方法：setNextMediaPlayer()方法。

关于这个方法的使用，我找了又找，终于在一篇文章里，看到了一个这样简短的说明：

在第一个MediaPlayer类执行结束前的任什么时候间调用setNextMediaPlayer(MediaPlayernext)这个方法，

该方法的参数是第二个文件建立的MediaPlayer实例。而后Android系统将会在您第一个中止的时候紧接着播放第二个文件。

但我认为，在这个说明里，你应该注意到的关键点是：第一个MediaPlayer类执行结束前的任什么时候间调用这个方法。

也就是说，你必须在前一个MediaPlayer对象播放完毕以前使用该方法。

例如我后来发现，若是理想的在咱们前面提到的OnCompletionListener监听中使用该方法，是无效的。

而且，彷佛并不如该说明而言的“Android系统将会在您第一个中止的时候紧接着播放第二个文件”。

也就是说，这个切换播放的动做不是自动的，还须要咱们手动的作一个小的控制，立刻接下来就会说到。

到了这里，咱们要实现的思路已经很明确了：在一段视频播放的同时，作下一段视频的player的初始化准备工做。

而此时另外一个格外须要记住的就是：不要再在UI线程去开启新的MediaPlayer的赋值工做.

原理很简单，其实也是Android开发所必须记住的，便是永远不要在UI线程里去作耗时的操做。

这样作的后果基本有几种，一种是报告“在主线程作了太多操做”的异常，而另外也可能出现，屏幕响应迟缓，

也就是说，例如你的视频播放界面可能还存在一些按钮和响应事件之类，这个响应会出现延迟。最后，固然也极可能出现ANR。

因此，咱们还须要作的工做就是，将其它负责后续播放的MediaPlayer对象的初始化与赋值工做放在新的线程里去执行。

而最后咱们须要作的，则是在OnCompletionListener里进行监听，当一段视频播放完毕后，

立刻执行mp.setDisplay(null),而后调用负责下一个视频分段播放的MediaPlayer执行setDisplay(surfaceHolder)。

说了这么多，仍是经过代码说话吧:

@SuppressLint("NewApi")
public class MainActivity extends Activity implements SurfaceHolder.Callback {
    //用于播放视频的mediaPlayer对象
    private MediaPlayer firstPlayer,     //负责播放进入视频播放界面后的第一段视频
                        nextMediaPlayer, //负责一段视频播放结束后，播放下一段视频
                        cachePlayer,     //负责setNextMediaPlayer的player缓存对象
                        currentPlayer;   //负责当前播放视频段落的player对象
    //负责配合mediaPlayer显示视频图像播放的surfaceView
    private SurfaceView surface;
    private SurfaceHolder surfaceHolder;
    //底部聊天栏
    private LinearLayout bottom_bar_layout;
    private FrameLayout video_layout;
    
    //================================================================
    
    //存放全部视频端的url
    private ArrayList<String> VideoListQueue = new ArrayList<String>();
    //全部player对象的缓存
    private HashMap<String, MediaPlayer> playersCache = new HashMap<String, MediaPlayer>();
    //当前播放到的视频段落数
    private int currentVideoIndex;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //横屏显示
        this.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        //初始化界面控件
        initView();
    }

    /*
     * 负责界面销毁时，release各个mediaplayer
     * @see android.app.Activity#onDestroy()
     */
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (firstPlayer != null) {
            if (firstPlayer.isPlaying()) {
                firstPlayer.stop();
            }
            firstPlayer.release();
        }
        if (nextMediaPlayer != null) {
            if (nextMediaPlayer.isPlaying()) {
                nextMediaPlayer.stop();
            }
            nextMediaPlayer.release();
        }

        if (currentPlayer != null) {
            if (currentPlayer.isPlaying()) {
                currentPlayer.stop();
            }
            currentPlayer.release();
        }
        currentPlayer = null;
    }

    /*
     * 界面控件的初始化
     */
    private void initView() {
        surface = (SurfaceView) findViewById(R.id.surface);

        surfaceHolder = surface.getHolder();// SurfaceHolder是SurfaceView的控制接口
        surfaceHolder.addCallback(this); // 由于这个类实现了SurfaceHolder.Callback接口，因此回调参数直接this

        bottom_bar_layout = (LinearLayout) findViewById(R.id.live_buttom_bar);
        
        //点击屏幕任何地点，控制底部聊天栏的隐藏或显示
        video_layout = (FrameLayout) findViewById(R.id.videoLayout);
        video_layout.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                if (bottom_bar_layout.getVisibility() == View.VISIBLE) {
                    bottom_bar_layout.setVisibility(View.GONE);
                } else {
                    bottom_bar_layout.setVisibility(View.VISIBLE);
                }

            }
        });
    }

    @Override
    public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
        // TODO 自动生成的方法存根

    }

    @Override
    public void surfaceCreated(SurfaceHolder arg0) {
        //surfaceView建立完毕后，首先获取该直播间全部视频分段的url
        getVideoUrls();
        //而后初始化播放手段视频的player对象
        initFirstPlayer();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder arg0) {
        // TODO 自动生成的方法存根

    }

    /*
     * 初始化播放首段视频的player
     */
    private void initFirstPlayer() {
        firstPlayer = new MediaPlayer();
        firstPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
        firstPlayer.setDisplay(surfaceHolder);

        firstPlayer
                .setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                    @Override
                    public void onCompletion(MediaPlayer mp) {
                        onVideoPlayCompleted(mp);
                    }
                });

        //设置cachePlayer为该player对象
        cachePlayer = firstPlayer;
        initNexttPlayer();

        //player对象初始化完成后，开启播放
        startPlayFirstVideo();
    }

    private void startPlayFirstVideo() {
        try {
            firstPlayer.setDataSource(VideoListQueue.get(currentVideoIndex));
            firstPlayer.prepare();
            firstPlayer.start();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }

    /*
     * 新开线程负责初始化负责播放剩余视频分段的player对象,避免UI线程作过多耗时操做
     */
    private void initNexttPlayer() {
        new Thread(new Runnable() {

            @Override
            public void run() {

                for (int i = 1; i < VideoListQueue.size(); i++) {
                    nextMediaPlayer = new MediaPlayer();
                    nextMediaPlayer
                            .setAudioStreamType(AudioManager.STREAM_MUSIC);

                    nextMediaPlayer
                            .setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                                @Override
                                public void onCompletion(MediaPlayer mp) {
                                    onVideoPlayCompleted(mp);
                                }
                            });

                    try {
                        nextMediaPlayer.setDataSource(VideoListQueue.get(i));
                        nextMediaPlayer.prepare();
                    } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }

                    //set next mediaplayer
                    cachePlayer.setNextMediaPlayer(nextMediaPlayer);
                    //set new cachePlayer
                    cachePlayer = nextMediaPlayer;
                    //put nextMediaPlayer in cache
                    playersCache.put(String.valueOf(i), nextMediaPlayer);

                }

            }
        }).start();
    }

    /*
     * 负责处理一段视频播放事后，切换player播放下一段视频
     */
    private void onVideoPlayCompleted(MediaPlayer mp) {
        mp.setDisplay(null);
        //get next player
        currentPlayer = playersCache.get(String.valueOf(++currentVideoIndex));
        if (currentPlayer != null) {
            currentPlayer.setDisplay(surfaceHolder);
        } else {
            Toast.makeText(MainActivity.this, "视频播放完毕..", Toast.LENGTH_SHORT)
                    .show();
        }
    }
    
    private void getVideoUrls() {
        for (int i = 0; i < 5; i++) {
            String url = getURI(i);
            VideoListQueue.add(url);
        }
    }

    private String getURI(int index) {
        return "要播放的第"+index+"段视频的URI";
    }

}

而最后额外说明的就是，在上面的代码中，我选择新开线程直接根据总的视频段数，循环完成全部视频段的MediaPlayer对象的初始化与赋值工做。

其实原本另一种实现方式彷佛也很不错，便是在前一个MediaPlayer对象的OnInfoListener中进行下一个视频段MediaPlayer的初始化工做。

也就是说，当前一段视频开始或结束缓冲时，才开启它以后的一段视频段的初始化工做。但屡次测试后，发现：

这种实现方式，若是你这次的播放中，视频分段的数量较多时，总会出现一些莫名其妙的异常，也没能太弄清楚是什么缘由形成的。

因此总的来讲，仍是能够根据实际状况来选择更合适的方式。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程