Android中提供了对网络上流媒体的支持,我们可以使用MediaPlayer类来播放一个网络上的音频文件。

但是网络上的站点并不建议我们直接访问流,我们需要获取他提供的M3U文件,根据M3U文件来实现流的获取。

M3U是音频流地址索引文件,相当于播放列表。

 

本文通过实例演示,Android中如何访问网络上的M3U文件,实现网络音频文件的播放。

 

本文包含三个部分:

1、根据用户输入的M3U文件的Url,访问网络,获取该M3U文件

2、对获取到的M3U文件进行解析,Android中并没有提供现成的方法来解析M3U文件

3、显示解析结果,并利用MediaPlayer来播放列表

 

代码如下:

 

1、HttpConnect类:封装网络访问

  1. package demo.camera;  
  2. import java.io.BufferedReader;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import org.apache.http.HttpResponse;  
  6. import org.apache.http.HttpStatus;  
  7. import org.apache.http.client.HttpClient;  
  8. import org.apache.http.client.methods.HttpGet;  
  9. import org.apache.http.impl.client.DefaultHttpClient;  
  10. import android.util.Log;  
  11. /**  
  12.  * 给类提供访问网络的方法  
  13.  * @author Administrator  
  14.  *  
  15.  */ 
  16. public final class HttpConnect {  
  17.       
  18.     /**  
  19.      * 利用HttpClient获取指定的Url对应的HttpResponse对象  
  20.      * @param url  
  21.      * @return  
  22.      */ 
  23.     public static HttpResponse getResponseFromUrl(String url){  
  24.         try {  
  25.             HttpClient client = new DefaultHttpClient();  
  26.             HttpGet get = new HttpGet(url);  
  27.             Log.v("URI : ", get.getURI().toString());  
  28.             HttpResponse response = client.execute(get);  
  29.             if(response.getStatusLine().getStatusCode() == HttpStatus.SC_OK){  
  30.                 return response;  
  31.             }  
  32.         } catch (Exception e) {  
  33.             // TODO: handle exception  
  34.             e.printStackTrace();  
  35.         }  
  36.         return null;  
  37.     }  
  38.       
  39.     /**  
  40.      * 利用HttpClient获取指定Url对应的字符串对象  
  41.      * @param url  
  42.      * @return  
  43.      */ 
  44.     public static String getStringFromUrl(String url){  
  45.         try {  
  46.             StringBuilder result = new StringBuilder();  
  47.             HttpResponse res = HttpConnect.getResponseFromUrl(url);  
  48.             if(res != null){  
  49.                 InputStream is = res.getEntity().getContent();  
  50.                 BufferedReader reader = new BufferedReader(new InputStreamReader(is));  
  51.                 String line = "";  
  52.                 while((line = reader.readLine()) != null){  
  53.                     result.append(line);  
  54.                 }  
  55.                 is.close();  
  56.                 return result.toString();  
  57.             }  
  58.         } catch (Exception e) {  
  59.             // TODO: handle exception  
  60.         }  
  61.           
  62.         return null;  
  63.     }  
  64. }  

2、M3UParser类:解析M3U文件

  1. package demo.camera;  
  2. import java.io.BufferedReader;  
  3. import java.io.InputStream;  
  4. import java.io.InputStreamReader;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7. import org.apache.http.HttpResponse;  
  8. /**  
  9.  * 该类提供对M3U文件的解析  
  10.  * @author Administrator  
  11.  *  
  12.  */ 
  13. public final class M3UParser {  
  14.       
  15.     /**  
  16.      * 从指定的Url进行解析,返回一个包含FilePath对象的列表  
  17.      * FilePath封装每一个Audio路径。  
  18.      * @param url  
  19.      * @return  
  20.      */ 
  21.     public static List<FilePath> parseFromUrl(String url){  
  22.         List<FilePath> resultList = null;  
  23.         HttpResponse res = HttpConnect.getResponseFromUrl(url);  
  24.         try {  
  25.             if(res != null){  
  26.                 resultList = new ArrayList<M3UParser.FilePath>();  
  27.                 InputStream in = res.getEntity().getContent();  
  28.                 BufferedReader reader = new BufferedReader(new InputStreamReader(in));  
  29.                 String line = "";  
  30.                 while((line = reader.readLine()) != null){  
  31.                     if(line.startsWith("#")){  
  32.                         //这里是Metadata信息  
  33.                     }else if(line.length() > 0 && line.startsWith("http://")){  
  34.                         //这里是一个指向的音频流路径  
  35.                         FilePath filePath = new FilePath(line);  
  36.                         resultList.add(filePath);  
  37.                     }  
  38.                 }  
  39.                 in.close();  
  40.             }  
  41.         } catch (Exception e) {  
  42.             e.printStackTrace();  
  43.         }  
  44.         return resultList;  
  45.     }  
  46.       
  47.     /**  
  48.      * 返回List<String>类型  
  49.      * @param url  
  50.      * @return  
  51.      */ 
  52.     public static List<String> parseStringFromUrl(String url){  
  53.         List<String> resultList = null;  
  54.         HttpResponse res = HttpConnect.getResponseFromUrl(url);  
  55.         try {  
  56.             if(res != null){  
  57.                 resultList = new ArrayList<String>();  
  58.                 InputStream in = res.getEntity().getContent();  
  59.                 BufferedReader reader = new BufferedReader(new InputStreamReader(in));  
  60.                 String line = "";  
  61.                 while((line = reader.readLine()) != null){  
  62.                     if(line.startsWith("#")){  
  63.                         //这里是Metadata信息  
  64.                     }else if(line.length() > 0 && line.startsWith("http://")){  
  65.                         //这里是一个指向的音频流路径  
  66.                         resultList.add(line);  
  67.                     }  
  68.                 }  
  69.                 in.close();  
  70.             }  
  71.         } catch (Exception e) {  
  72.             e.printStackTrace();  
  73.         }  
  74.         return resultList;        
  75.     }  
  76.       
  77.       
  78.     //解析后的实体对象  
  79.     static class FilePath{  
  80.           
  81.         private String filePath;  
  82.           
  83.         public FilePath(String filePath){  
  84.             this.filePath = filePath;  
  85.         }  
  86.         public String getFilePath() {  
  87.             return filePath;  
  88.         }  
  89.         public void setFilePath(String filePath) {  
  90.             this.filePath = filePath;  
  91.         }         
  92.     }  
  93. }  

3、InternetAudioDemo类:显示解析列表吗,并实现播放

  1. package demo.camera;  
  2. import java.io.IOException;  
  3. import java.util.List;  
  4. import demo.camera.M3UParser.FilePath;  
  5. import android.app.Activity;  
  6. import android.app.ListActivity;  
  7. import android.app.ProgressDialog;  
  8. import android.media.MediaPlayer;  
  9. import android.os.Bundle;  
  10. import android.view.View;  
  11. import android.view.inputmethod.InputMethodManager;  
  12. import android.widget.ArrayAdapter;  
  13. import android.widget.Button;  
  14. import android.widget.EditText;  
  15. import android.widget.ListAdapter;  
  16. import android.widget.Toast;  
  17. /**  
  18.  * Android支持播放网络上的Audio  
  19.  * 访问网络上的Audio,我们通过Http需要获取音频流  
  20.  * 这可能要涉及到ICY协议。ICY对Http协议进行了扩展  
  21.  * 然而,网络上的站点,往往并不允许我们直接访问其音频流  
  22.  * 我们需要一种中间文件来指向我们需要的音频流的地址,以使第三方的软件可以播放。  
  23.  * 对于ICY流来说,其就是一个PLS文件或者一个M3U文件  
  24.  * PLS对应的MIME类型为:audio/x-scpls  
  25.  * M3U对应的MIME类型为:audio/x-mpegurl  
  26.  *   
  27.  * 虽然Android提供了对ICy流的支持,但是其并没有提供现成的方法来解析M3U或PLS文件  
  28.  * 所以,为了播放网络上的音频流,我们需要自己实现这些文件的解析  
  29.  * M3U文件其实就是一个音频流的索引文件,他指向要播放的音频流的路径。  
  30.  * @author Administrator  
  31.  *  
  32.  */ 
  33. public class InternetAudioDemo extends ListActivity {  
  34.       
  35.     private Button btnParse, btnPlay, btnStop;  
  36.       
  37.     private EditText editUrl;  
  38.       
  39.     private MediaPlayer player;  
  40.       
  41.     private List<String> pathList;  
  42.       
  43.     private int currPosition = 0//记录当前播放的媒体文件的index  
  44.       
  45.     //private ProgressDialog progress;  
  46.       
  47.     public void onCreate(Bundle savedInstanceState){  
  48.         super.onCreate(savedInstanceState);  
  49.         setContentView(R.layout.internet_audio);  
  50.           
  51.         btnParse = (Button)this.findViewById(R.id.btn_parse);  
  52.         btnPlay = (Button)this.findViewById(R.id.btn_start);  
  53.         btnStop = (Button)this.findViewById(R.id.btn_end);  
  54.           
  55.         editUrl = (EditText)this.findViewById(R.id.edit_url);  
  56.         editUrl.setText("http://pubint.ic.llnwd.net/stream/pubint_kmfa.m3u");  
  57. //      InputMethodManager imm = (InputMethodManager)this.getSystemService(INPUT_METHOD_SERVICE);  
  58. //      imm.showSoftInput(editUrl, InputMethodManager.SHOW_IMPLICIT);  
  59.         btnPlay.setEnabled(false);  
  60.         btnStop.setEnabled(false);  
  61.           
  62.         player = new MediaPlayer();  
  63.         player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {  
  64.               
  65.             @Override 
  66.             public void onCompletion(MediaPlayer player) {  
  67.                 // 这个方法当MediaPlayer的play()执行完后触发  
  68.                 player.stop();  
  69.                 player.reset();  
  70.                 if(pathList.size() > currPosition+1){  
  71.                     currPosition++; //转到下一首  
  72.                     prepareToPlay();  
  73.                 }  
  74.             }  
  75.         });  
  76.           
  77.         player.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {  
  78.               
  79.             @Override 
  80.             public void onPrepared(MediaPlayer arg0) {  
  81.                 // 这个方法当MediaPlayer的prepare()执行完后触发  
  82.                 btnStop.setEnabled(true);  
  83.                 player.start();  
  84.                   
  85.                 //当一曲播放完后,执行onCompletionListener的onCompletion方法  
  86.             }  
  87.         });  
  88.           
  89.     }  
  90.       
  91.     private void prepareToPlay(){  
  92.         try {  
  93.             //获取当前音频流的路径后我们需要通过MediaPlayer的setDataSource来设置,然后调用prepareAsync()来完成缓存加载  
  94.             String path = pathList.get(currPosition);  
  95.             player.setDataSource(path);  
  96.             //之所以使用prepareAsync是因为该方法是异步的,因为访问音频流是网络操作,在缓冲和准备播放时需要花费  
  97.             //较长的时间,这样用户界面就可能出现卡死的现象  
  98.             //该方法执行完成后,会执行onPreparedListener的onPrepared()方法。  
  99.             player.prepareAsync();  
  100.               
  101.         } catch (IllegalArgumentException e) {  
  102.             // TODO Auto-generated catch block  
  103.             e.printStackTrace();  
  104.         } catch (IllegalStateException e) {  
  105.             // TODO Auto-generated catch block  
  106.             e.printStackTrace();  
  107.         } catch (IOException e) {  
  108.             // TODO Auto-generated catch block  
  109.             e.printStackTrace();  
  110.         }         
  111.     }  
  112.       
  113.       
  114.     public void onClick(View v){  
  115.         int id = v.getId();  
  116.         switch(id){  
  117.         case R.id.btn_parse:  
  118.             //完成解析  
  119. //          progress = ProgressDialog.show(this, "提示", "正在解析,请稍后...");  
  120. //          progress.show();  
  121.             String url = null;  
  122.             if(editUrl.getText() != null){  
  123.                 url = editUrl.getText().toString();  
  124.             }  
  125.             if(url != null && !url.trim().equals("")){  
  126.                 pathList = M3UParser.parseStringFromUrl(url);  
  127.                 ListAdapter adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, pathList);  
  128.                 this.setListAdapter(adapter);  
  129.                 btnPlay.setEnabled(true);  
  130.             }else{  
  131.                 Toast.makeText(this"请输入正确的M3U文件访问地址", Toast.LENGTH_LONG).show();  
  132.             }  
  133.               
  134.             break;  
  135.         case R.id.btn_start:  
  136.             //这里播放是从第一个开始  
  137.             btnPlay.setEnabled(false);  
  138.             btnParse.setEnabled(false);  
  139.             this.currPosition = 0;  
  140.             if(pathList != null && pathList.size() > 0){  
  141.                   
  142.                 prepareToPlay();  
  143.                   
  144.             }  
  145.             break;  
  146.         case R.id.btn_end:  
  147.             player.pause();  
  148.             btnPlay.setEnabled(true);  
  149.             btnStop.setEnabled(false);  
  150.             break;  
  151.         default:  
  152.             break;  
  153.               
  154.         }  
  155.     }  
  156. }  

4、需要在清单文件中加入INTERNET权限。