Android多媒体技术之视频播放

1、Android中视频播放方式

surfaceView+MediaPlayer，通过MediaPlayer来控制视频的播放、暂停、进度等；
使用VideoView 来播放，这个类其实也是继承了SurfaceView 类，并且实现了MediaController。MediaPlayerController 这个用于控制媒体播放的接口，另外在VideoView上还有一个用于对媒体播放进行控制的面板，包括快进、快退、播放、暂停按钮以及一个进度条；
系统提供的播放器

2、surfaceView+MediaPlayer实现视频播放基本步骤

在布局文件内定义SurfaceView
在代码中实现SurfaceHolder.Callback接口，重写三个方法
通过方法getHolder();得到SurfaceHolder，然后设置SurfaceHolder
为MediaPlayer通过setDisplay()方法，设置SurfaceHolder
使用setDataSource()方法为MediaPlayer设置播放文件
进行播放

优点：灵活性高，可以进行自定义；
缺点：难度比较大；

 public class MainActivity extends Activity implements OnClickListener {
     private EditText et_path;
     private Button bt_play, bt_replay, bt_pause, bt_stop;
     private SurfaceView sv;

     private MediaPlayer mediaPlayer;

     private int currentPosition;
     private SeekBar sb;

     private boolean isplaying;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         et_path = (EditText) findViewById(R.id.et_path);
         bt_play = (Button) findViewById(R.id.bt_play);
         bt_replay = (Button) findViewById(R.id.bt_replay);
         bt_pause = (Button) findViewById(R.id.bt_pause);
         bt_stop = (Button) findViewById(R.id.bt_stop);
         sb = (SeekBar) findViewById(R.id.sb);

         sb.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
             @Override
             public void onStopTrackingTouch(SeekBar seekBar) {
                 int process = seekBar.getProgress();
                 if (mediaPlayer != null && mediaPlayer.isPlaying()) {
                     mediaPlayer.seekTo(process);
                 }
             }

             @Override
             public void onStartTrackingTouch(SeekBar seekBar) {
             }

             @Override
             public void onProgressChanged(SeekBar seekBar, int progress,
                     boolean fromUser) {
             }
         });

         sv = (SurfaceView) findViewById(R.id.sv);
         // 低版本手机加上参数，指定自己不维护缓冲区
         /* 下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前 */
         sv.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

         sv.getHolder().addCallback(new Callback() {
             @Override
             public void surfaceDestroyed(SurfaceHolder holder) {
                 System.out.println("holder被销毁了");
                 if (mediaPlayer != null && mediaPlayer.isPlaying()) {
                     currentPosition = mediaPlayer.getCurrentPosition();
                     stop();
                 }
             }

             @Override
             public void surfaceCreated(SurfaceHolder holder) {
                 System.out.println("holder被创建了");
                 if (currentPosition > 0) {
                     play(currentPosition);
                 }
             }

             @Override
             public void surfaceChanged(SurfaceHolder holder, int format,
                     int width, int height) {
                 System.out.println("holder大小变化了");
             }
         });

         bt_play.setOnClickListener(this);
         bt_replay.setOnClickListener(this);
         bt_pause.setOnClickListener(this);
         bt_stop.setOnClickListener(this);
     }

     @Override
     public void onClick(View v) {
         switch (v.getId()) {
         case R.id.bt_play:
             play(0);
             break;
         case R.id.bt_replay:
             replay();
             break;
         case R.id.bt_stop:
             stop();
             break;
         case R.id.bt_pause:
             pause();
             break;
         }
     }

     /**
      * 暂停播放
      */
     private void pause() {
         if ("继续".equals(bt_pause.getText().toString().trim())) {
             mediaPlayer.start();
             bt_pause.setText("暂停");
             return;
         }
         if (mediaPlayer != null && mediaPlayer.isPlaying()) {
             mediaPlayer.pause();
             bt_pause.setText("继续");
             return;
         }
     }

     /**
      * 重新播放
      */
     private void replay() {
         bt_pause.setText("暂停");
         if (mediaPlayer != null && mediaPlayer.isPlaying()) {
             mediaPlayer.seekTo(0);
             return;
         }
         play(0);
     }

     /**
      * 停止播放音乐
      */
     private void stop() {
         if (mediaPlayer != null && mediaPlayer.isPlaying()) {
             mediaPlayer.stop();
             mediaPlayer.release();
             mediaPlayer = null;
             bt_pause.setText("暂停");
             bt_play.setEnabled(true);
             isplaying = false;
         }
     }

     /**
      * 播放视频
      */
     private void play(final int currentPosition2) {
         String path = et_path.getText().toString().trim();
         try {
             mediaPlayer = new MediaPlayer();
             mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
             /* 设置Video影片以SurfaceHolder播放 */
             mediaPlayer.setDisplay(sv.getHolder());
             mediaPlayer.setDataSource(path);
             mediaPlayer.prepareAsync();
             mediaPlayer.setOnPreparedListener(new OnPreparedListener() {
                 @Override
                 public void onPrepared(MediaPlayer mp) {
                     mediaPlayer.start();
                     int max = mediaPlayer.getDuration();
                     sb.setMax(max);
                     mediaPlayer.seekTo(currentPosition2);

                     new Thread() {
                         public void run() {
                             isplaying = true;
                             while (isplaying) {
                                 int position = mediaPlayer.getCurrentPosition();
                                 sb.setProgress(position);
                                 try {
                                     Thread.sleep(500);
                                 } catch (InterruptedException e) {
                                     e.printStackTrace();
                                 }
                             }
                         }
                     }.start();
                 }
             });
             mediaPlayer.setOnCompletionListener(new OnCompletionListener() {
                 @Override
                 public void onCompletion(MediaPlayer mp) {
                     bt_play.setEnabled(true);
                 }
             });
             mediaPlayer.setOnErrorListener(new OnErrorListener() {
                 @Override
                 public boolean onError(MediaPlayer mp, int what, int extra) {
                     bt_play.setEnabled(true);
                     isplaying = false;
                     return false;
                 }
             });
             bt_play.setEnabled(false);
         } catch (Exception e) {
             Toast.makeText(this, "播放失败", 0).show();
             e.printStackTrace();
         }
     }

 }

3、VideoView实现视频播放基本步骤

* 在onCreate方法中，首先获取布局管理器中添加的VideoView组件。并创建一个要播放视频所对应的对象。
* 然后创建一个MediaController对象，用于控制视频的播放。
*使用VideoView播放该视频

优点：比较简单，可以直接进行使用；
缺点：灵活性不高；

 public class MainActivity extends Activity {
     private VideoView vv;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         vv = (VideoView) findViewById(R.id.vv);

         MediaController mc = new MediaController(this);
         mc.setAnchorView(vv);

         vv.setMediaController(mc);
         vv.setVideoPath("mnt/sdcard/areyouok.3gp");
         vv.start();
     }
 }

4、View, surfaceView, GLSurfaceView区别

view是最基础的，必须在UI主线程内更新画面，速度较慢。
SurfaceView 是view的子类，类似使用双缓机制，在新的线程中更新画面所以刷新界面速度比view快
GLSurfaceView 是SurfaceView的子类，opengl 专用的

　　SurfaceView和View最本质的区别在于，surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。

　　那么在UI的主线程中更新画面可能会引发问题，比如你更新画面的时间过长，那么你的主UI线程会被你正在画的函数阻塞。那么将无法响应按键，触屏等消息。

　　当使用surfaceView 由于是在新的线程中更新画面所以不会阻塞你的UI主线程。但这也带来了另外一个问题，就是事件同步。比如你触屏了一下，你需要surfaceView中thread处理，一般就需要有一个event queue的设计来保存touch event，这会稍稍复杂一点，因为涉及到线程同步。

　　基于以上，根据游戏特点，一般分成两类。

被动更新画面的。比如棋类，这种用view就好了。因为画面的更新是依赖于 onTouch 来更新，可以直接使用 invalidate。因为这种情况下，这一次Touch和下一次的Touch需要的时间比较长些，不会产生影响。
主动更新。比如一个人在一直跑动。这就需要一个单独的thread不停的重绘人的状态，避免阻塞main UI thread。所以显然view不合适，需要surfaceView来控制。

　　Android中的SurfaceView类就是双缓冲机制。因此，开发游戏时尽量使用SurfaceView而不要使用View，这样的话效率较高，而且SurfaceView的功能也更加完善。

5、SurfaceHolder

　　可以通过SurfaceHolder接口访问这个Surface.用getHolder()方法可以得到这个接口。

　　surfaceview变得可见时，surface被创建；surfaceview隐藏前，surface被销毁。这样能节省资源。

　　如果你要查看 surface被创建和销毁的时机，可以重载surfaceCreated(SurfaceHolder)和 surfaceDestroyed(SurfaceHolder)。

　　surfaceview的核心在于提供了两个线程：UI线程和渲染线程。

　　这里应注意：

所有SurfaceView和SurfaceHolder.Callback的方法都应该在UI线程里调用，一般来说就是应用程序主线程。渲染线程所要访问的各种变量应该作同步处理。
由于surface可能被销毁，它只在SurfaceHolder.Callback.surfaceCreated()和 SurfaceHolder.Callback.surfaceDestroyed()之间有效，所以要确保渲染线程访问的是合法有效的surface。

http://sunzone.iteye.com/blog/1884184