Android接收UDP TS流实现边缓存边播放

      Android播放本地文件视频是硬解，这样对CPU占用比较少，所以将直播收到的数据临时缓存3个文件，给定每个文件的大小，然后进行播放。后续还会进行优化。

具体实现代码如下：

package com.cayden.videodemo;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;


import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.media.MediaPlayer.OnErrorListener;
import android.media.MediaPlayer.OnPreparedListener;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.MediaController;
import android.widget.TextView;
import android.widget.VideoView;
import com.cayden.videodemo.R;
/**
 * 
 *  接收UDP TS流实现边缓存边播放<br/>
 * 该类可以实现，但存在以下不足<br/>
 * 1、播放过程会稍微卡一下这是 由于播放时候setOnCompletionListener中方法被执行<br/>
 * 2、需要思考怎么解决调用onError方法
 * @author cuiran
 * @version 1.0.0
 */
public class UDPFileMPlayer extends Activity {

	private static final String TAG="UDPFileMPlayer";
	private VideoView mVideoView;
	private TextView tvcache;
	private String remoteUrl;
	private String localUrl;
	private ProgressDialog progressDialog = null;
	private Thread receiveThread=null;
	/**
	 * 定义了初始缓存区的大小，当视频加载到初始缓存区满的时候，播放器开始播放，
	 */
	private static final int READY_BUFF = 1316 * 1024*10;
	
	private static final String FILE_DIR=Environment.getExternalStorageDirectory().getAbsolutePath()+"/VideoCache/";
			
	/**
	 * 核心交换缓存区，主要是用来动态调节缓存区，当网络环境较好的时候，该缓存区为初始大小，
	 * 当网络环境差的时候，该缓存区会动态增加，主要就是为了避免视频播放的时候出现一卡一卡的现象。
	 */
	private static final int CACHE_BUFF = 10 * 1024;
	/**
	 * 单播或组播端口
	 */
	private static final int PORT = 1234;
	
	private boolean isready = false;
	private boolean iserror = false;
	private int errorCnt = 0;
	private int curPosition = 0;
	private long mediaLength = 0;
	private long readSize = 0;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.bbvideoplayer);

		findViews();
		init();
		playvideo();
	}
	/**
	 * 初始化组件
	 * 2013-11-21 下午2:20:10
	 *
	 */
	private void findViews() {
		this.mVideoView = (VideoView) findViewById(R.id.bbvideoview);
		this.tvcache = (TextView) findViewById(R.id.tvcache);
	}
	
	private void init() {
		Intent intent = getIntent();

		this.remoteUrl = intent.getStringExtra("url");
		System.out.println("remoteUrl: " + remoteUrl);

		if (this.remoteUrl == null) {
			finish();
			return;
		}

//		this.localUrl = intent.getStringExtra("cache");
		mVideoView.setMediaController(new MediaController(this));
		mVideoView.setOnPreparedListener(new OnPreparedListener() {

			public void onPrepared(MediaPlayer mediaplayer) {
				Log.i(TAG, "onPrepared");
				dismissProgressDialog();
				mVideoView.seekTo(curPosition);
				mediaplayer.start();
			}
		});

		mVideoView.setOnCompletionListener(new OnCompletionListener() {

			public void onCompletion(MediaPlayer mediaplayer) {
				Log.i(TAG, "onCompletion"+localUrl);
//				curPosition = 0;
				if(localUrl.endsWith("1.mp4")){
					localUrl=localUrl.replace("1.mp4", "2.mp4");
					mVideoView.setVideoPath(localUrl);
					mVideoView.start();
				}else if(localUrl.endsWith("2.mp4")){
					localUrl=localUrl.replace("2.mp4", "3.mp4");
					mVideoView.setVideoPath(localUrl);
					mVideoView.start();
				}else{
					localUrl=localUrl.replace("3.mp4", "1.mp4");
					mVideoView.setVideoPath(localUrl);
					mVideoView.start();
				}
				
			}
		});

		mVideoView.setOnErrorListener(new OnErrorListener() {

			public boolean onError(MediaPlayer mediaplayer, int i, int j) {
				Log.i(TAG, "onError");
				iserror = true;
				errorCnt++;
				mVideoView.pause();
				showProgressDialog();
				return true;
			}
		});
	}

	private void showProgressDialog() {
		mHandler.post(new Runnable() {

			@Override
			public void run() {
				if (progressDialog == null) {
					progressDialog = ProgressDialog.show(UDPFileMPlayer.this,
							"视频缓存", "正在努力加载中 ...", true, false);
				}
			}
		});
	}

	private void dismissProgressDialog() {
		mHandler.post(new Runnable() {

			@Override
			public void run() {
				if (progressDialog != null) {
					progressDialog.dismiss();
					progressDialog = null;
				}
			}
		});
	}
	/**
	 * 播放视频
	 * 2013-11-21 下午2:20:34
	 *
	 */
	private void playvideo() {
		

		showProgressDialog();

		receiveThread=new Thread(new Runnable() {

			@Override
			public void run() {
				FileOutputStream out = null;
				DatagramSocket dataSocket=null;
				DatagramPacket dataPacket=null;
				try {
					 dataSocket = new DatagramSocket(PORT);
					byte[] receiveByte = new byte[8192];
					 dataPacket = new DatagramPacket(receiveByte, receiveByte.length);
					Log.i(TAG, "UDP服务启动...");
					if (localUrl == null) {
						localUrl = FILE_DIR+"1.mp4";
					}
					Log.i(TAG, "localUrl="+localUrl);
					File cacheFile = new File(localUrl);

					if (!cacheFile.exists()) {
						cacheFile.getParentFile().mkdirs();
						cacheFile.createNewFile();
					}
					
					out = new FileOutputStream(cacheFile, true);
					int size = 0;
					long lastReadSize = 0;
					int number=0;
					
					int fileNum=0;
//					mHandler.sendEmptyMessage(VIDEO_STATE_UPDATE);
				
					 while(size==0){
						// 无数据，则循环
						 dataSocket.receive(dataPacket);
						 size = dataPacket.getLength();
			              if (size > 0) {
			            	    try {
			            	    	if(readSize>=READY_BUFF){
			            	    		fileNum++;
			            	    		
			            	    		switch(fileNum%3){
			            	    			case 0:
			            	    				out=new FileOutputStream(FILE_DIR+"1.mp4");
			            	    				break;
			            	    			case 1:
			            	    				out=new FileOutputStream(FILE_DIR+"2.mp4");
			            	    				break;
			            	    			case 2:
			            	    				out=new FileOutputStream(FILE_DIR+"3.mp4");
			            	    				break;
			            	    		}
			            	    		
			            	    		readSize=0;
			            	    		if (!isready) {
			            	    			mHandler.sendEmptyMessage(CACHE_VIDEO_READY);
			            	    		}
			            	    	}
									out.write(dataPacket.getData(), 0, size);
									out.flush();
									readSize += size;
									size = 0;// 循环接收
									
									
								} catch (Exception e) {
									Log.e(TAG, "出现异常0",e);
								}
			            	  	
			              }else{
			            	  Log.i(TAG, "TS流停止发送数据");
			              }
			              
					 }
				
					mHandler.sendEmptyMessage(CACHE_VIDEO_END);
				} catch (Exception e) {
					Log.e(TAG, "出现异常",e);
				} finally {
					if (out != null) {
						try {
							out.close();
						} catch (IOException e) {
							//
							Log.e(TAG, "出现异常1",e);
						}
					}

					if (dataSocket != null) {
						try {
							dataSocket.close();
						} catch (Exception e) {
							Log.e(TAG, "出现异常2",e);
						}
					}
				}

			}
		});
		receiveThread.start();
	}

	private final static int VIDEO_STATE_UPDATE = 0;
	/**
	 * 缓存准备
	 */
	private final static int CACHE_VIDEO_READY = 1;
	/**
	 * 缓存修改
	 */
	private final static int CACHE_VIDEO_UPDATE = 2;
	/**
	 * 缓存结束
	 */
	private final static int CACHE_VIDEO_END = 3;
	/**
	 * 缓存播放
	 */
	private final static int CACHE_VIDEO_PLAY = 4;

	private final Handler mHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
			switch (msg.what) {
			case VIDEO_STATE_UPDATE:
				boolean isPlay=mVideoView.isPlaying();
				Log.i(TAG, "更新显示 isPlay="+isPlay);
				double cachepercent = readSize * 100.00 / mediaLength * 1.0;
				String s = String.format("已缓存: [%.2f%%]", cachepercent);
				if (isPlay) {
					curPosition = mVideoView.getCurrentPosition();
					int duration = mVideoView.getDuration();
					duration = duration == 0 ? 1 : duration;

					double playpercent = curPosition * 100.00 / duration * 1.0;

					int i = curPosition / 1000;
					int hour = i / (60 * 60);
					int minute = i / 60 % 60;
					int second = i % 60;

					s += String.format(" 播放: %02d:%02d:%02d [%.2f%%]", hour,
							minute, second, playpercent);
				}
//
//				tvcache.setText(s);
				tvcache.setVisibility(View.GONE);
				mHandler.sendEmptyMessageDelayed(VIDEO_STATE_UPDATE, 1000);
				

				
				break;

			case CACHE_VIDEO_READY:
				Log.i(TAG, "缓存准备");
				isready = true;
				mVideoView.setVideoPath(localUrl);
				mVideoView.start();
				
				break;

			case CACHE_VIDEO_UPDATE:
				Log.i(TAG, "缓存修改"+iserror);
				if (iserror) {
					mVideoView.setVideoPath(localUrl);
					mVideoView.start();
					iserror = false;
				}
				break;

			case CACHE_VIDEO_END:
				Log.i(TAG, "缓存结束"+iserror);
				if (iserror) {
					
					mVideoView.setVideoPath(localUrl);
					mVideoView.start();
					iserror = false;
				}
				break;
			case CACHE_VIDEO_PLAY:
				Log.i(TAG, "CACHE_VIDEO_PLAY");
				mVideoView.setVideoPath(localUrl);
				mVideoView.start();
				mHandler.sendEmptyMessageDelayed(CACHE_VIDEO_PLAY, 5000);
				break;
			}

			super.handleMessage(msg);
		}
	};

	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
		if(mVideoView!=null){
			mVideoView.stopPlayback();
		}
		super.onDestroy();
	}
	
	
}