媒体播放器从广播流播放，并从数据流 [英] Media Player play from radio stream and get data from stream

问题描述

我打的媒体播放器，从网上流电台：

  mMediaPlayer =新的MediaPlayer（）;
尝试{
    mMediaPlayer.setDataSource（http://online-radioroks.tavrmedia.ua/RadioROKS）;
    。mMediaPlayer prepareAsync（）;    mMediaPlayer.setOn preparedListener（新MediaPlayer.On preparedListener（）{        在prepared（MediaPlayer的MP）公共无效{
            开始（）;
        }
    }）;    notifyCallbackListeners（PlayerCallbackEvent.PLAYER_SONG_CHANGE）;
}
赶上（抛出：IllegalArgumentException五）{
    e.printStackTrace（）;
}
赶上（IOException异常五）{
    e.printStackTrace（）;
}赶上（IllegalStateException异常前）{
    ex.printStackTrace（）;
}
 

它工作正常，但我可以从流获取数据，如什么歌现在正在播放的电台的名字吗？

解决方案

  

从流获取数据，如什么歌现在正在播放的电台的名字吗？

对于流媒体URL应该提供的数据比相应可以读取数据。

对于您在问题中头部与要求冰爽的元数据和标题提到其提供数据的URL冰冷-metaint 。有关这些类型的URL和头数据的更多详细信息，请查看此链接。

  

现在你怎么能解析头数据？

您可以试试下面的贴code

 公共类ParsingHeaderData {
    公共类TrackData {
        公共字符串艺术家=;
        公共字符串标题=;
    }    受保护的URL streamUrl;
    私人地图＆LT;字符串，字符串＆GT;元数据;
    私人TrackData trackData;    公共ParsingHeaderData（）{    }    公共TrackData getTrackDetails（URL streamUrl）{
        trackData =新TrackData（）;
        setStreamUrl（streamUrl）;
        串strTitle =;
        串strArtist =;
        尝试{
            元= executeToFetchData（）;
            如果（元数据！= NULL）{
                串streamHeading =;
                地图＆LT;字符串，字符串＆GT;数据=元数据;
                如果（数据= NULL＆放大器;！＆安培; data.containsKey（StreamTitle））{
                    strArtist = data.get（StreamTitle）;
                    streamHeading = strArtist;
                }
                如果（TextUtils.isEmpty（strArtist）及＆放大器; strArtist.contains（ - ）！）{
                    strArtist = strArtist.substring（0，strArtist.indexOf（ - ））;
                    trackData.artist = strArtist.trim（）;
                }
                如果（！TextUtils.isEmpty（streamHeading））{
                    如果（streamHeading.contains（ - ））{
                        strTitle = streamHeading.substring（streamHeading
                                .indexOf（ - ）+1）;
                        trackData.title = strTitle.trim（）;
                    }
                }
            }
        }赶上（例外五）{
            e.printStackTrace（）;
        }        返回trackData;
    }    私人的URLConnection CON;
    私人的InputStream流;
    私人列表＆LT;串GT; headerList;    私人地图＆LT;字符串，字符串＆GT; executeToFetchData（）抛出IOException
        尝试{
            CON = streamUrl.openConnection（）;            con.setRequestProperty（冰 - 元数据，1）;
            // con.setRequestProperty（连接，关闭）;
            // con.setRequestProperty（接受，NULL）;
            con.connect（）;            INT metaDataOffset = 0;
            地图＆LT;字符串列表＆LT;串GT;＆GT;标题= con.getHeaderFields（）;
            流= con.getInputStream（）;            如果（headers.containsKey（冰冷-metaint））{
                headerList = headers.get（冰冷-metaint）;
                如果（headerList！= NULL）{
                    如果（headerList.size（）大于0）{
                        metaDataOffset =的Integer.parseInt（headers.get（
                                冰-metaint）得到（0））。
                    }其他
                        返回null;
                }其他
                    返回null;            }其他{
                返回null;            }            //如果没有发送数据
            如果（metaDataOffset == 0）{
                返回null;
            }            //读取元
            INT B：
            诠释计数= 0;
            INT metaDataLength = 4080; // 4080是最大长度
            布尔INDATA = FALSE;
            StringBuilder的元数据=新的StringBuilder（）;
            而（（二= stream.read（））！=  -  1）{
                算上++;
                如果（计数== metaDataOffset + 1）{
                    metaDataLength = B * 16;
                }
                如果（计数＆GT; metaDataOffset + 1
                        ＆功放;＆安培;算上＆LT; （metaDataOffset + metaDataLength））{
                    INDATA = TRUE;
                }其他{
                    INDATA = FALSE;
                }
                如果（INDATA）{
                    如果（二！= 0）{
                        metaData.append（（char）的B）;
                    }
                }
                如果（计数＆GT;（metaDataOffset + metaDataLength））{
                    打破;
                }            }
            元= ParsingHeaderData.parsingMetadata（metaData.toString（））;
            stream.close（）;
        }赶上（例外五）{
            如果（E = NULL＆放大器;！＆安培; e.equals（空））
                Log.e（错误，e.getMessage（））;
        } {最后
            如果（流！= NULL）
                stream.close（）;
        }
        返回的元数据;    }    公共URL getStreamUrl（）{
        返回streamUrl;
    }    公共无效setStreamUrl（URL streamUrl）{
        this.metadata = NULL;
        this.streamUrl = streamUrl;
    }    公共静态地图＆LT;字符串，字符串＆GT; parsingMetadata（字符串metaString）{
        @燮pressWarnings（{rawtypes，未}）
        地图＆LT;字符串，字符串＆GT;元数据=新的HashMap（）;
        的String [] = metaParts metaString.split（）;
        模式P = Pattern.compile（^（[A-ZA-Z] +）= \\\\（[^ \\\\'] *）\\\\$）;
        匹配器米;
        的for（int i = 0; I＆LT; metaParts.length;我++）{
            M = p.matcher（metaParts [I]）;
            如果（m.find（））{
                metadata.put（（字符串）m.group（1），（字符串）m.group（2））;
            }
        }        返回的元数据;
    }
}
 

  

如何调用

 公共类测试扩展的AsyncTask＆LT;太虚，太虚，太虚＆GT; {        / *
         *（非Javadoc中）
         *
         * @see android.os.AsyncTask＃doInBackground（PARAMS []）
         * /
        @覆盖
        保护无效doInBackground（虚空...... PARAMS）{
            尝试{
                网址URL =新的URL（
                        http://online-radioroks.tavrmedia.ua/RadioROKS）;
                ParsingHeaderData流=新ParsingHeaderData（）;
                TrackData trackData = streaming.getTrackDetails（URL）;
                Log.e（宋演员姓名，trackData.artist）;
            Log.e（歌曲艺术家标题，trackData.title）;
            }赶上（例外五）{
                e.printStackTrace（）;
            }
            返回null;
        }    }
 

调用execute任务

 新测试（）执行（）;
 

I'm playing media player from online stream radio:

mMediaPlayer = new MediaPlayer();
try {
    mMediaPlayer.setDataSource("http://online-radioroks.tavrmedia.ua/RadioROKS");
    mMediaPlayer.prepareAsync();

    mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {

        public void onPrepared(MediaPlayer mp) {
            start();
        }
    });

    notifyCallbackListeners(PlayerCallbackEvent.PLAYER_SONG_CHANGE);
}
catch (IllegalArgumentException e) {
    e.printStackTrace();
}
catch (IOException e) {
    e.printStackTrace();
} catch (IllegalStateException ex){
    ex.printStackTrace();
}

It works fine, but can i get data from stream like what song now is playing and name of radio?

解决方案

get data from stream like what song now is playing and name of radio?

For that streaming url should provide that data than accordingly that you can read data.

For the url which you have mentioned in the question its providing data in header with request Icy-MetaData and header icy-metaint. More details regarding those type of url and header data please check this link.

Now how can you parse that header data ?

You can try the below posted code

public class ParsingHeaderData {
    public class TrackData {
        public String artist = "";
        public String title = "";
    }

    protected URL streamUrl;
    private Map<String, String> metadata;
    private TrackData trackData;

    public ParsingHeaderData() {

    }

    public TrackData getTrackDetails(URL streamUrl) {
        trackData = new TrackData();
        setStreamUrl(streamUrl);
        String strTitle = "";
        String strArtist = "";
        try {
            metadata = executeToFetchData();
            if (metadata != null) {
                String streamHeading = "";
                Map<String, String> data = metadata;
                if (data != null && data.containsKey("StreamTitle")) {
                    strArtist = data.get("StreamTitle");
                    streamHeading = strArtist;
                }
                if (!TextUtils.isEmpty(strArtist) && strArtist.contains("-")) {
                    strArtist = strArtist.substring(0, strArtist.indexOf("-"));
                    trackData.artist = strArtist.trim();
                }
                if (!TextUtils.isEmpty(streamHeading)) {
                    if (streamHeading.contains("-")) {
                        strTitle = streamHeading.substring(streamHeading
                                .indexOf("-") + 1);
                        trackData.title = strTitle.trim();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return trackData;
    }

    private URLConnection con;
    private InputStream stream;
    private List<String> headerList;

    private Map<String, String> executeToFetchData() throws IOException {
        try {
            con = streamUrl.openConnection();

            con.setRequestProperty("Icy-MetaData", "1");
            // con.setRequestProperty("Connection", "close");
            // con.setRequestProperty("Accept", null);
            con.connect();

            int metaDataOffset = 0;
            Map<String, List<String>> headers = con.getHeaderFields();
            stream = con.getInputStream();

            if (headers.containsKey("icy-metaint")) {
                headerList = headers.get("icy-metaint");
                if (headerList != null) {
                    if (headerList.size() > 0) {
                        metaDataOffset = Integer.parseInt(headers.get(
                                "icy-metaint").get(0));
                    } else
                        return null;
                } else
                    return null;

            } else {
                return null;

            }

            // In case no data was sent
            if (metaDataOffset == 0) {
                return null;
            }

            // Read metadata
            int b;
            int count = 0;
            int metaDataLength = 4080; // 4080 is the max length
            boolean inData = false;
            StringBuilder metaData = new StringBuilder();
            while ((b = stream.read()) != -1) {
                count++;
                if (count == metaDataOffset + 1) {
                    metaDataLength = b * 16;
                }
                if (count > metaDataOffset + 1
                        && count < (metaDataOffset + metaDataLength)) {
                    inData = true;
                } else {
                    inData = false;
                }
                if (inData) {
                    if (b != 0) {
                        metaData.append((char) b);
                    }
                }
                if (count > (metaDataOffset + metaDataLength)) {
                    break;
                }

            }
            metadata = ParsingHeaderData.parsingMetadata(metaData.toString());
            stream.close();
        } catch (Exception e) {
            if (e != null && e.equals(null))
                Log.e("Error", e.getMessage());
        } finally {
            if (stream != null)
                stream.close();
        }
        return metadata;

    }

    public URL getStreamUrl() {
        return streamUrl;
    }

    public void setStreamUrl(URL streamUrl) {
        this.metadata = null;
        this.streamUrl = streamUrl;
    }

    public static Map<String, String> parsingMetadata(String metaString) {
        @SuppressWarnings({ "rawtypes", "unchecked" })
        Map<String, String> metadata = new HashMap();
        String[] metaParts = metaString.split(";");
        Pattern p = Pattern.compile("^([a-zA-Z]+)=\\'([^\\']*)\\'$");
        Matcher m;
        for (int i = 0; i < metaParts.length; i++) {
            m = p.matcher(metaParts[i]);
            if (m.find()) {
                metadata.put((String) m.group(1), (String) m.group(2));
            }
        }

        return metadata;
    }
}

How To call

public class Test extends AsyncTask<Void, Void, Void> {

        /*
         * (non-Javadoc)
         * 
         * @see android.os.AsyncTask#doInBackground(Params[])
         */
        @Override
        protected Void doInBackground(Void... params) {
            try {
                URL url = new URL(
                        "http://online-radioroks.tavrmedia.ua/RadioROKS");
                ParsingHeaderData streaming = new ParsingHeaderData();
                TrackData trackData = streaming.getTrackDetails(url);
                Log.e("Song Artist Name ", trackData.artist);
            Log.e("Song Artist Title", trackData.title);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }

    }

Call execute Task

new Test().execute();

这篇关于媒体播放器从广播流播放，并从数据流的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！