android和RTSP视频文件播放(一)

       说起实时流传输协议，没有做过的就会感到很陌生，但是项目组必须用到，就要去查资料，将其解决。我前不久做的项目正好碰上，就在此说说自己的拙见。既然用到rtsp，那很有可能是做的视频监控软件，毕竟他是需要实时监控周期场景的一举一动。

我们在实现播放rtsp协议之前，有以下几个问题需要搞定：

(1).什么是rtsp协议？他的协议头和协议头与http有什么区别，参数分别代表什么？

(2).如果利用Android的播放控件VideoView来播放RTSP的流，怎样与服务器进行桥接？

其实这些是前期准备工作，下边直接供应代码：

1.定义服务器连接和断开以及发生错误的接口。

1.  
   public interface IEvent{
2.  
    
3.  
   /**
4.  
    
5.  
   *当channel得到connect事件时调用这个方法.
6.  
    
7.  
   *@paramkey
8.  
    
9.  
   *@throwsIOException
10.  
     
11.  
    */
12.  
     
13.  
    public void connect(SelectionKeykey)throwsIOException;
14.  
     
15.  
    /**
16.  
     
17.  
    *当channel可读时调用这个方法.
18.  
     
19.  
    *@paramkey
20.  
     
21.  
    *@throwsIOException
22.  
     
23.  
    */
24.  
     
25.  
    public void read(SelectionKeykey)throwsIOException;
26.  
     
27.  
    /**
28.  
     
29.  
    *当channel可写时调用这个方法
30.  
     
31.  
    *@throwsIOException
32.  
     
33.  
    */
34.  
     
35.  
    public void write()throwsIOException;
36.  
     
37.  
    /**
38.  
     
39.  
    *当channel发生错误时调用.
40.  
     
41.  
    *@parame
42.  
     
43.  
    */
44.  
     
45.  
    public void error(Exceptione);
46.  
     
47.  
    }

2.用线程来控制实时播放的情况，实现接口

1.  
   publicclassRTPHandleextendsThreadimplementsIEvent{
2.  
    
3.  
   privatefinalStringTAG="RTPHandle";
4.  
    
5.  
   privatestaticfinalintBUFFER_SIZE=10240;
6.  
    
7.  
   privateSocketChannelRTPChannel;
8.  
    
9.  
   publicbooleanisRunning=true;
10.  
     
11.  
    privateSelectorselector;
12.  
     
13.  
    privatefinalByteBufferreceiveBuf;
14.  
     
15.  
    /*服务器地址*/
16.  
     
17.  
    privatefinalInetSocketAddressremoteAddr;
18.  
     
19.  
    @SuppressWarnings("unused")
20.  
     
21.  
    privatefinalInetAddressaddr;
22.  
     
23.  
    @SuppressWarnings("unused")
24.  
     
25.  
    privatefinalintport;
26.  
     
27.  
    privatefinalInetSocketAddresslocalAddress;
28.  
     
29.  
    privateintlocalPort;
30.  
     
31.  
    privateAtomicBooleanshutdown;
32.  
     
33.  
    publicRTPHandle(InetSocketAddressremoteAddr){
34.  
     
35.  
    this.remoteAddr=remoteAddr;
36.  
     
37.  
    this.addr=remoteAddr.getAddress();
38.  
     
39.  
    this.port=remoteAddr.getPort();
40.  
     
41.  
    this.localAddress=newInetSocketAddress(getLocalAddress(),0);
42.  
     
43.  
    receiveBuf=ByteBuffer.allocate(BUFFER_SIZE);
44.  
     
45.  
    if(selector==null){
46.  
     
47.  
    try{
48.  
     
49.  
    selector=Selector.open();
50.  
     
51.  
    }catch(Exceptione){
52.  
     
53.  
    Log.e(TAG,"SelectoropenERROR");
54.  
     
55.  
    e.printStackTrace();
56.  
     
57.  
    }
58.  
     
59.  
    }
60.  
     
61.  
    initial();
62.  
     
63.  
    shutdown=newAtomicBoolean(false);
64.  
     
65.  
    }
66.  
     
67.  
    privatevoidinitial(){
68.  
     
69.  
    //TODOAuto-generatedmethodstub
70.  
     
71.  
    try{
72.  
     
73.  
    RTPChannel=SocketChannel.open();
74.  
     
75.  
    RTPChannel.configureBlocking(false);
76.  
     
77.  
    RTPChannel.socket().bind(localAddress);
78.  
     
79.  
    localPort=RTPChannel.socket().getLocalPort();
80.  
     
81.  
    Log.e(TAG,"isBound:"+RTPChannel.socket().isBound()
82.  
     
83.  
    +"localPort:"+localPort);
84.  
     
85.  
    if(RTPChannel.connect(remoteAddr)){
86.  
     
87.  
    Log.i(TAG,"RTPChannelstarttoconnect"+remoteAddr);
88.  
     
89.  
    }
90.  
     
91.  
    RTPChannel.register(selector,SelectionKey.OP_CONNECT
92.  
     
93.  
    |SelectionKey.OP_READ,this);
94.  
     
95.  
    Log.i(TAG,"RTPportopenSuccess");
96.  
     
97.  
    }catch(Exceptione){
98.  
     
99.  
    e.printStackTrace();
100.  
      
101.  
     }
102.  
      
103.  
     }
104.  
      
105.  
     @Override
106.  
      
107.  
     publicvoidrun(){
108.  
      
109.  
     while(!shutdown.get()){
110.  
      
111.  
     select();
112.  
      
113.  
     try{
114.  
      
115.  
     Thread.sleep(100);
116.  
      
117.  
     }catch(finalExceptione){
118.  
      
119.  
     e.printStackTrace();
120.  
      
121.  
     }
122.  
      
123.  
     }
124.  
      
125.  
     shutdown();
126.  
      
127.  
     }
128.  
      
129.  
     privatevoidshutdown(){
130.  
      
131.  
     //TODOAuto-generatedmethodstub
132.  
      
133.  
     if(isConnected()){
134.  
      
135.  
     try{
136.  
      
137.  
     RTPChannel.close();
138.  
      
139.  
     Log.i(TAG,"端口关闭成功");
140.  
      
141.  
     }catch(finalIOExceptione){
142.  
      
143.  
     Log.i(TAG,"端口关闭错误:");
144.  
      
145.  
     }finally
146.  
     {
147.  
      
148.  
     RTPChannel=null;
149.  
      
150.  
     }
151.  
      
152.  
     }else{
153.  
      
154.  
     Log.i(TAG,"通道为空或者没有连接");
155.  
      
156.  
     }
157.  
      
158.  
     }
159.  
      
160.  
     privatevoidselect(){
161.  
      
162.  
     //TODOAuto-generatedmethodstub
163.  
      
164.  
     intn=0;
165.  
      
166.  
     try{
167.  
      
168.  
     if(selector==null){
169.  
      
170.  
     return;
171.  
      
172.  
     }
173.  
      
174.  
     n=selector.select(1000);
175.  
      
176.  
     }catch(finalExceptione){
177.  
      
178.  
     e.printStackTrace();
179.  
      
180.  
     }
181.  
      
182.  
     //如果select返回大于0，处理事件
183.  
      
184.  
     if(n>0){
185.  
      
186.  
     for(finalIterator<SelectionKey>i=selector.selectedKeys()
187.  
      
188.  
     .iterator();i.hasNext();){
189.  
      
190.  
     //得到下一个Key
191.  
      
192.  
     finalSelectionKeysk=i.next();
193.  
      
194.  
     i.remove();
195.  
      
196.  
     //检查其是否还有效
197.  
      
198.  
     if(!sk.isValid()){
199.  
      
200.  
     continue;
201.  
      
202.  
     }
203.  
      
204.  
     //处理事件
205.  
      
206.  
     finalIEventhandler=(IEvent)sk.attachment();
207.  
      
208.  
     try{
209.  
      
210.  
     if(sk.isConnectable()){
211.  
      
212.  
     handler.connect(sk);
213.  
      
214.  
     }elseif(sk.isReadable()){
215.  
      
216.  
     handler.read(sk);
217.  
      
218.  
     }else{
219.  
      
220.  
     //System.err.println("Ooops");
221.  
      
222.  
     }
223.  
      
224.  
     }catch(finalExceptione){
225.  
      
226.  
     handler.error(e);
227.  
      
228.  
     sk.cancel();
229.  
      
230.  
     }
231.  
      
232.  
     }
233.  
      
234.  
     }
235.  
      
236.  
     }
237.  
      
238.  
     privatebooleanisConnected(){
239.  
      
240.  
     returnRTPChannel!=null&&RTPChannel.isConnected();
241.  
      
242.  
     }
243.  
      
244.  
     privatebyte[]recieve(){
245.  
      
246.  
     if(isConnected()){
247.  
      
248.  
     try{
249.  
      
250.  
     intlen=0;
251.  
      
252.  
     intreadBytes=0;
253.  
      
254.  
     synchronized(receiveBuf){
255.  
      
256.  
     receiveBuf.clear();
257.  
      
258.  
     try{
259.  
      
260.  
     while((len=RTPChannel.read(receiveBuf))>0){
261.  
      
262.  
     readBytes+=len;
263.  
      
264.  
     }
265.  
      
266.  
     }finally{
267.  
      
268.  
     receiveBuf.flip();
269.  
      
270.  
     }
271.  
      
272.  
     if(readBytes>0){
273.  
      
274.  
     finalbyte[]tmp=newbyte[readBytes];
275.  
      
276.  
     receiveBuf.get(tmp);
277.  
      
278.  
     returntmp;
279.  
      
280.  
     }else{
281.  
      
282.  
     Log.i(TAG,"ReceiveEmpty");
283.  
      
284.  
     returnnull;
285.  
      
286.  
     }
287.  
      
288.  
     }
289.  
      
290.  
     }catch(finalIOExceptione){
291.  
      
292.  
     Log.e(TAG,"ReceiveEmpty");
293.  
      
294.  
     e.printStackTrace();
295.  
      
296.  
     }
297.  
      
298.  
     }else{
299.  
      
300.  
     Log.e(TAG,"portdisconnect");
301.  
      
302.  
     }
303.  
      
304.  
     returnnull;
305.  
      
306.  
     }
307.  
      
308.  
     privatevoidhandle(byte[]msg){
309.  
      
310.  
     Stringtmp=newString(msg);
311.  
      
312.  
     Log.i(TAG,tmp);
313.  
      
314.  
     }
315.  
      
316.  
     //@Override
317.  
      
318.  
     publicvoidconnect(SelectionKeykey)throwsIOException{
319.  
      
320.  
     //TODOAuto-generatedmethodstub
321.  
      
322.  
     if(isConnected()){
323.  
      
324.  
     return;
325.  
      
326.  
     }
327.  
      
328.  
     RTPChannel.finishConnect();
329.  
      
330.  
     while(!RTPChannel.isConnected()){
331.  
      
332.  
     try{
333.  
      
334.  
     Thread.sleep(300);
335.  
      
336.  
     }catch(finalInterruptedExceptione){
337.  
      
338.  
     e.printStackTrace();
339.  
      
340.  
     }
341.  
      
342.  
     RTPChannel.finishConnect();
343.  
      
344.  
     }
345.  
      
346.  
     }
347.  
      
348.  
     //@Override
349.  
      
350.  
     publicvoiderror(Exceptione){
351.  
      
352.  
     //TODOAuto-generatedmethodstub
353.  
      
354.  
     e.printStackTrace();
355.  
      
356.  
     }
357.  
      
358.  
     //@Override
359.  
      
360.  
     publicvoidread(SelectionKeykey)throwsIOException{
361.  
      
362.  
     //TODOAuto-generatedmethodstub
363.  
      
364.  
     finalbyte[]msg=recieve();
365.  
      
366.  
     if(msg!=null){
367.  
      
368.  
     handle(msg);
369.  
      
370.  
     }else{
371.  
      
372.  
     key.cancel();
373.  
      
374.  
     }
375.  
      
376.  
     }
377.  
      
378.  
     //@Override
379.  
      
380.  
     publicvoidwrite()throwsIOException{
381.  
      
382.  
     //TODOAuto-generatedmethodstub
383.  
      
384.  
     }
385.  
      
386.  
     publicintgetRTPChannelPort(){
387.  
      
388.  
     returnlocalPort;
389.  
      
390.  
     }
391.  
      
392.  
     privateStringgetLocalAddress(){
393.  
      
394.  
     Enumeration<NetworkInterface>netInterfaces=null;
395.  
      
396.  
     StringBuffersb=newStringBuffer("");
397.  
      
398.  
     try{
399.  
      
400.  
     netInterfaces=NetworkInterface.getNetworkInterfaces();
401.  
      
402.  
     while(netInterfaces.hasMoreElements()){
403.  
      
404.  
     NetworkInterfaceni=netInterfaces.nextElement();
405.  
      
406.  
     Enumeration<InetAddress>ips=ni.getInetAddresses();
407.  
      
408.  
     while(ips.hasMoreElements()){
409.  
      
410.  
     if(sb.toString().length()>0)
411.  
      
412.  
     returnsb.toString();
413.  
      
414.  
     ;
415.  
      
416.  
     InetAddresslocal=ips.nextElement();
417.  
      
418.  
     sb.append(local.getHostAddress());
419.  
      
420.  
     }
421.  
      
422.  
     }
423.  
      
424.  
     }catch(Exceptione){
425.  
      
426.  
     e.printStackTrace();
427.  
      
428.  
     }
429.  
      
430.  
     returnsb.toString();
431.  
      
432.  
     }
433.  
      
434.  
     }

3.连接服务器操作

1.  
   publicclassRTSPConnectextendsThreadimplementsIEvent{
2.  
    
3.  
   privatestaticfinalStringTAG="RTSPConnect";
4.  
    
5.  
   privatestaticfinalStringRTSP_VERSION="RTSP/1.0\r\n";
6.  
    
7.  
   privatestaticfinalStringRTSP_OK="RTSP/1.0200OK";
8.  
    
9.  
   /*远程主机地址*/
10.  
     
11.  
    privatefinalInetSocketAddressremoteAddress;
12.  
     
13.  
    /*本机地址*/
14.  
     
15.  
    privatefinalInetSocketAddresslocalAddress;
16.  
     
17.  
    /*数据源地址*/
18.  
     
19.  
    privateStringaddress;
20.  
     
21.  
    /*发送缓冲区*/
22.  
     
23.  
    privatefinalByteBuffersendBuf;
24.  
     
25.  
    /*接收缓冲区*/
26.  
     
27.  
    privatefinalByteBufferreceiveBuf;
28.  
     
29.  
    privatestaticfinalintBUFFER_SIZE=10240;
30.  
     
31.  
    /*端口选择器*/
32.  
     
33.  
    privateSelectorselector;
34.  
     
35.  
    privateSocketChannelsocketChannel;
36.  
     
37.  
    privateRTPReceiveUDPrtp;
38.  
     
39.  
    /*RTP接收端口*/
40.  
     
41.  
    privateintRTPPort;
42.  
     
43.  
    /*连接状态*/
44.  
     
45.  
    privateStatussysStatus;
46.  
     
47.  
    privateStringsessionId;
48.  
     
49.  
    privateStringtrackInfo;
50.  
     
51.  
    privateintseq=1;
52.  
     
53.  
    privatebooleanisSended;
54.  
     
55.  
    /**
56.  
     
57.  
    *线程是否结束的标志
58.  
     
59.  
    */
60.  
     
61.  
    privateAtomicBooleanshutdown;
62.  
     
63.  
    /**
64.  
     
65.  
    *计算进度的Handler
66.  
     
67.  
    */
68.  
     
69.  
    privateHandlermHandler;
70.  
     
71.  
    privateenumStatus{
72.  
     
73.  
    init,options,describe,getparameter,setup,play,setparameter,pause,teardown
74.  
     
75.  
    }
76.  
     
77.  
    /**
78.  
     
79.  
    *获得主机地址
80.  
     
81.  
    *
82.  
     
83.  
    *@return
84.  
     
85.  
    */
86.  
     
87.  
    publicstaticStringgetLocalAddress(){
88.  
     
89.  
    Enumeration<NetworkInterface>netInterfaces=null;
90.  
     
91.  
    StringBuffersb=newStringBuffer("");
92.  
     
93.  
    try{
94.  
     
95.  
    netInterfaces=NetworkInterface.getNetworkInterfaces();
96.  
     
97.  
    while(netInterfaces.hasMoreElements()){
98.  
     
99.  
    NetworkInterfaceni=netInterfaces.nextElement();
100.  
      
101.  
     Enumeration<InetAddress>ips=ni.getInetAddresses();
102.  
      
103.  
     while(ips.hasMoreElements()){
104.  
      
105.  
     if(sb.toString().length()>0)
106.  
      
107.  
     returnsb.toString();
108.  
      
109.  
     InetAddresslocal=ips.nextElement();
110.  
      
111.  
     sb.append(local.getHostAddress());
112.  
      
113.  
     }
114.  
      
115.  
     }
116.  
      
117.  
     }catch(Exceptione){
118.  
      
119.  
     e.printStackTrace();
120.  
      
121.  
     }
122.  
      
123.  
     returnsb.toString();
124.  
      
125.  
     }
126.  
      
127.  
     /**
128.  
      
129.  
     *连接服务器
130.  
      
131.  
     *
132.  
      
133.  
     *@paramremoteAddress
134.  
      
135.  
     *@paramaddress
136.  
      
137.  
     */
138.  
      
139.  
     publicRTSPConnect(InetSocketAddressremoteAddress,Stringaddress){
140.  
      
141.  
     //TODOAuto-generatedconstructorstub
142.  
      
143.  
     this.remoteAddress=remoteAddress;
144.  
      
145.  
     this.localAddress=newInetSocketAddress(getLocalAddress(),0);
146.  
      
147.  
     this.address=address;
148.  
      
149.  
     //初始化缓冲区
150.  
      
151.  
     sendBuf=ByteBuffer.allocateDirect(BUFFER_SIZE);
152.  
      
153.  
     receiveBuf=ByteBuffer.allocateDirect(BUFFER_SIZE);
154.  
      
155.  
     if(selector==null){
156.  
      
157.  
     try{
158.  
      
159.  
     selector=Selector.open();
160.  
      
161.  
     }catch(Exceptione){
162.  
      
163.  
     Log.e(TAG,"SelectoropenERROR");
164.  
      
165.  
     e.printStackTrace();
166.  
      
167.  
     }
168.  
      
169.  
     }
170.  
      
171.  
     startup();
172.  
      
173.  
     sysStatus=Status.init;
174.  
      
175.  
     shutdown=newAtomicBoolean(false);
176.  
      
177.  
     isSended=false;
178.  
      
179.  
     }
180.  
      
181.  
     /**
182.  
      
183.  
     *连接服务器
184.  
      
185.  
     *
186.  
      
187.  
     *@parammHandler
188.  
      
189.  
     *@paramremoteAddress
190.  
      
191.  
     *@paramaddress
192.  
      
193.  
     */
194.  
      
195.  
     publicRTSPConnect(HandlermHandler,InetSocketAddressremoteAddress,
196.  
      
197.  
     Stringaddress){
198.  
      
199.  
     //TODOAuto-generatedconstructorstub
200.  
      
201.  
     this.mHandler=mHandler;
202.  
      
203.  
     this.remoteAddress=remoteAddress;
204.  
      
205.  
     this.localAddress=newInetSocketAddress(getLocalAddress(),0);
206.  
      
207.  
     this.address=address;
208.  
      
209.  
     //初始化缓冲区
210.  
      
211.  
     sendBuf=ByteBuffer.allocateDirect(BUFFER_SIZE);
212.  
      
213.  
     receiveBuf=ByteBuffer.allocateDirect(BUFFER_SIZE);
214.  
      
215.  
     if(selector==null){
216.  
      
217.  
     try{
218.  
      
219.  
     selector=Selector.open();
220.  
      
221.  
     }catch(Exceptione){
222.  
      
223.  
     Log.e(TAG,"SelectoropenERROR");
224.  
      
225.  
     e.printStackTrace();
226.  
      
227.  
     }
228.  
      
229.  
     }
230.  
      
231.  
     startup();
232.  
      
233.  
     sysStatus=Status.init;
234.  
      
235.  
     shutdown=newAtomicBoolean(false);
236.  
      
237.  
     isSended=false;
238.  
      
239.  
     }
240.  
      
241.  
     publicvoidstartup(){
242.  
      
243.  
     try{
244.  
      
245.  
     socketChannel=SocketChannel.open();//打开端口
246.  
      
247.  
     socketChannel.configureBlocking(false);
248.  
      
249.  
     socketChannel.socket().bind(localAddress);
250.  
      
251.  
     Log.e(TAG,"isBound:"+socketChannel.socket().isBound()
252.  
      
253.  
     +"Port:"+socketChannel.socket().getLocalPort());
254.  
      
255.  
     if(socketChannel.connect(remoteAddress)){
256.  
      
257.  
     Log.i(TAG,"socketChannelstarttoConnect"+remoteAddress);
258.  
      
259.  
     }
260.  
      
261.  
     socketChannel.register(selector,SelectionKey.OP_CONNECT
262.  
      
263.  
     |SelectionKey.OP_READ|SelectionKey.OP_WRITE,this);
264.  
      
265.  
     Log.i(TAG,"portopenSuccess");
266.  
      
267.  
     }catch(Exceptione){
268.  
      
269.  
     e.printStackTrace();
270.  
      
271.  
     }
272.  
      
273.  
     rtp=newRTPReceiveUDP();
274.  
      
275.  
     }
276.  
      
277.  
     /*判断是否连接*/
278.  
      
279.  
     privatebooleanisConnected(){
280.  
      
281.  
     returnsocketChannel!=null&&socketChannel.isConnected();
282.  
      
283.  
     }
284.  
      
285.  
     /**
286.  
      
287.  
     *接收收据
288.  
      
289.  
     *
290.  
      
291.  
     *@return
292.  
      
293.  
     */
294.  
      
295.  
     privatebyte[]recieve(){
296.  
      
297.  
     //TODOAuto-generatedmethodstub
298.  
      
299.  
     if(isConnected()){
300.  
      
301.  
     try{
302.  
      
303.  
     intlen=0;
304.  
      
305.  
     intreadBytes=0;
306.  
      
307.  
     synchronized(receiveBuf){
308.  
      
309.  
     receiveBuf.clear();
310.  
      
311.  
     try{
312.  
      
313.  
     while((len=socketChannel.read(receiveBuf))>0){
314.  
      
315.  
     readBytes+=len;
316.  
      
317.  
     System.out.println("接收收据======>>>>>>"+readBytes
318.  
      
319.  
     +"byte");
320.  
      
321.  
     //Messagemsg=newMessage();
322.  
      
323.  
     //msg.what=2012062011;
324.  
      
325.  
     //msg.obj=readBytes;
326.  
      
327.  
     //mHandler.sendMessage(msg);
328.  
      
329.  
     }
330.  
      
331.  
     }finally{
332.  
      
333.  
     receiveBuf.flip();
334.  
      
335.  
     }
336.  
      
337.  
     if(readBytes>0){
338.  
      
339.  
     finalbyte[]tmp=newbyte[readBytes];
340.  
      
341.  
     receiveBuf.get(tmp);
342.  
      
343.  
     returntmp;
344.  
      
345.  
     }else{
346.  
      
347.  
     Log.i(TAG,"接收到数据为空,重新启动连接");
348.  
      
349.  
     returnnull;
350.  
      
351.  
     }
352.  
      
353.  
     }
354.  
      
355.  
     }catch(finalIOExceptione){
356.  
      
357.  
     Log.e(TAG,"接收消息错误!");
358.  
      
359.  
     e.printStackTrace();
360.  
      
361.  
     }
362.  
      
363.  
     }else{
364.  
      
365.  
     Log.e(TAG,"端口没有连接");
366.  
      
367.  
     }
368.  
      
369.  
     returnnull;
370.  
      
371.  
     }
372.  
      
373.  
     privatevoidhandle(byte[]msg){
374.  
      
375.  
     //TODOAuto-generatedmethodstub
376.  
      
377.  
     Stringtmp=newString(msg);
378.  
      
379.  
     Log.i(TAG,"handletmp===>>>>>"+tmp);
380.  
      
381.  
     if(tmp.startsWith(RTSP_OK)){
382.  
      
383.  
     switch(sysStatus){
384.  
      
385.  
     caseinit:
386.  
      
387.  
     sysStatus=Status.options;
388.  
      
389.  
     break;
390.  
      
391.  
     caseoptions:
392.  
      
393.  
     sysStatus=Status.describe;
394.  
      
395.  
     trackInfo="Audio";//默认为Audio
396.  
      
397.  
     break;
398.  
      
399.  
     casedescribe:
400.  
      
401.  
     sysStatus=Status.getparameter;
402.  
      
403.  
     break;
404.  
      
405.  
     casegetparameter:
406.  
      
407.  
     sessionId=tmp.substring(tmp.indexOf("Session:")+9,tmp.indexOf(";timeout="));
408.  
      
409.  
     Log.e(TAG,"sessionID:"+sessionId);
410.  
      
411.  
     if(sessionId!=null&&sessionId.length()>0){
412.  
      
413.  
     sysStatus=Status.setup;
414.  
      
415.  
     }
416.  
      
417.  
     break;
418.  
      
419.  
     casesetup:
420.  
      
421.  
     sysStatus=Status.play;
422.  
     break;
423.  
      
424.  
     caseplay:
425.  
      
426.  
     sysStatus=Status.setparameter;
427.  
      
428.  
     break;
429.  
      
430.  
     casesetparameter:
431.  
      
432.  
     sysStatus=Status.pause;
433.  
      
434.  
     break;
435.  
      
436.  
     casepause:
437.  
      
438.  
     sysStatus=Status.teardown;
439.  
      
440.  
     break;
441.  
      
442.  
     caseteardown:
443.  
      
444.  
     sysStatus=Status.init;
445.  
      
446.  
     break;
447.  
      
448.  
     default:
449.  
      
450.  
     Log.e(TAG,"MSGERROR:"+tmp);
451.  
      
452.  
     break;
453.  
      
454.  
     }
455.  
      
456.  
     isSended=false;
457.  
      
458.  
     }else{
459.  
      
460.  
     Log.e(TAG,"RETURNERROR:"+tmp);
461.  
      
462.  
     }
463.  
      
464.  
     }
465.  
      
466.  
     //@Override
467.  
      
468.  
     publicvoidconnect(SelectionKeykey)throwsIOException{
469.  
      
470.  
     //TODOAuto-generatedmethodstub
471.  
      
472.  
     if(isConnected()){
473.  
      
474.  
     return;
475.  
      
476.  
     }
477.  
      
478.  
     socketChannel.finishConnect();
479.  
      
480.  
     while(!socketChannel.isConnected()){
481.  
      
482.  
     try{
483.  
      
484.  
     Thread.sleep(300);
485.  
      
486.  
     }catch(finalInterruptedExceptione){
487.  
      
488.  
     e.printStackTrace();
489.  
      
490.  
     }
491.  
      
492.  
     socketChannel.finishConnect();
493.  
      
494.  
     }
495.  
      
496.  
     }
497.  
      
498.  
     //@Override
499.  
      
500.  
     publicvoiderror(Exceptione){
501.  
      
502.  
     //TODOAuto-generatedmethodstub
503.  
      
504.  
     e.printStackTrace();
505.  
      
506.  
     }
507.  
      
508.  
     //@Override
509.  
      
510.  
     publicvoidread(SelectionKeykey)throwsIOException{
511.  
      
512.  
     //TODOAuto-generatedmethodstub
513.  
      
514.  
     finalbyte[]msg=recieve();
515.  
      
516.  
     if(msg!=null){
517.  
      
518.  
     handle(msg);
519.  
      
520.  
     }else{
521.  
      
522.  
     key.cancel();
523.  
      
524.  
     }
525.  
      
526.  
     }
527.  
      
528.  
     //@Override
529.  
      
530.  
     publicvoidwrite()throwsIOException{
531.  
      
532.  
     //TODOAuto-generatedmethodstub
533.  
      
534.  
     if(isConnected()){
535.  
      
536.  
     try{
537.  
      
538.  
     socketChannel.write(sendBuf);
539.  
      
540.  
     }catch(finalIOExceptione){
541.  
      
542.  
     e.printStackTrace();
543.  
      
544.  
     }
545.  
      
546.  
     }else{
547.  
      
548.  
     Log.e(TAG,"writeERROR:通道为空或者未连接");
549.  
      
550.  
     }
551.  
      
552.  
     }
553.  
      
554.  
     @Override
555.  
      
556.  
     publicvoidrun(){
557.  
      
558.  
     while(!shutdown.get()){
559.  
      
560.  
     try{
561.  
      
562.  
     if(isConnected()&&(!isSended)){
563.  
      
564.  
     switch(sysStatus){
565.  
      
566.  
     caseinit:
567.  
      
568.  
     doOption();
569.  
      
570.  
     break;
571.  
      
572.  
     caseoptions:
573.  
      
574.  
     doDescribe();
575.  
      
576.  
     break;
577.  
      
578.  
     casedescribe:
579.  
      
580.  
     doGetParameter();
581.  
      
582.  
     break;
583.  
      
584.  
     casegetparameter:
585.  
      
586.  
     rtp.start();
587.  
      
588.  
     doSetup();
589.  
      
590.  
     break;
591.  
      
592.  
     casesetup:
593.  
      
594.  
     if(sessionId==null&&sessionId.length()>0){
595.  
      
596.  
     Log.e(TAG,"setupERROR");
597.  
      
598.  
     }else{
599.  
      
600.  
     doPlay();
601.  
      
602.  
     }
603.  
      
604.  
     break;
605.  
      
606.  
     caseplay:
607.  
      
608.  
     doSetParameter();
609.  
      
610.  
     break;
611.  
      
612.  
     casesetparameter:
613.  
      
614.  
     doPause();
615.  
      
616.  
     break;
617.  
      
618.  
     casepause:
619.  
      
620.  
     doTeardown();
621.  
      
622.  
     break;
623.  
      
624.  
     default:
625.  
      
626.  
     break;
627.  
      
628.  
     }
629.  
      
630.  
     }
631.  
      
632.  
     select();
633.  
      
634.  
     try{
635.  
      
636.  
     Thread.sleep(100);
637.  
      
638.  
     }catch(finalExceptione){
639.  
      
640.  
     e.printStackTrace();
641.  
      
642.  
     }
643.  
      
644.  
     }catch(finalExceptione){
645.  
      
646.  
     e.printStackTrace();
647.  
      
648.  
     }
649.  
      
650.  
     }
651.  
      
652.  
     shutdown();
653.  
      
654.  
     }
655.  
      
656.  
     publicvoidshutdown(){
657.  
      
658.  
     //TODOAuto-generatedmethodstub
659.  
      
660.  
     if(isConnected()){
661.  
      
662.  
     try{
663.  
      
664.  
     socketChannel.close();
665.  
      
666.  
     Log.i(TAG,"端口关闭成功");
667.  
      
668.  
     }catch(finalIOExceptione){
669.  
      
670.  
     Log.i(TAG,"端口关闭错误:"+e.getMessage().toString());
671.  
      
672.  
     }finally{
673.  
      
674.  
     socketChannel=null;
675.  
      
676.  
     }
677.  
      
678.  
     }else{
679.  
      
680.  
     Log.i(TAG,"通道为空或者没有连接");
681.  
      
682.  
     }
683.  
      
684.  
     }
685.  
      
686.  
     privatevoidselect(){
687.  
      
688.  
     //TODOAuto-generatedmethodstub
689.  
      
690.  
     intn=0;
691.  
      
692.  
     try{
693.  
      
694.  
     if(selector==null){
695.  
      
696.  
     return;
697.  
      
698.  
     }
699.  
      
700.  
     n=selector.select(1000);
701.  
      
702.  
     }catch(finalExceptione){
703.  
      
704.  
     e.printStackTrace();
705.  
      
706.  
     }
707.  
      
708.  
     //如果select返回大于0，处理事件
709.  
      
710.  
     if(n>0){
711.  
      
712.  
     for(finalIterator<SelectionKey>i=selector.selectedKeys()
713.  
      
714.  
     .iterator();i.hasNext();){
715.  
      
716.  
     //得到下一个Key
717.  
      
718.  
     finalSelectionKeysk=i.next();
719.  
      
720.  
     i.remove();
721.  
      
722.  
     //检查其是否还有效
723.  
      
724.  
     if(!sk.isValid()){
725.  
      
726.  
     continue;
727.  
      
728.  
     }
729.  
      
730.  
     //处理事件
731.  
      
732.  
     finalIEventhandler=(IEvent)sk.attachment();
733.  
      
734.  
     try{
735.  
      
736.  
     if(sk.isConnectable()){
737.  
      
738.  
     handler.connect(sk);
739.  
      
740.  
     }elseif(sk.isReadable()){
741.  
      
742.  
     handler.read(sk);
743.  
      
744.  
     }else{
745.  
      
746.  
     //System.err.println("Ooops");
747.  
      
748.  
     }
749.  
      
750.  
     }catch(finalExceptione){
751.  
      
752.  
     handler.error(e);
753.  
      
754.  
     sk.cancel();
755.  
      
756.  
     }
757.  
      
758.  
     }
759.  
      
760.  
     }
761.  
      
762.  
     }
763.  
      
764.  
     privatevoiddoSetup(){
765.  
      
766.  
     //TODOAuto-generatedmethodstub
767.  
      
768.  
     StringBuildersb=newStringBuilder();
769.  
      
770.  
     sb.append("SETUP");
771.  
      
772.  
     sb.append(this.address);
773.  
      
774.  
     sb.append("/");
775.  
      
776.  
     sb.append(trackInfo);
777.  
      
778.  
     sb.append(RTSP_VERSION);
779.  
      
780.  
     sb.append("Cseq:");
781.  
      
782.  
     sb.append(seq++);
783.  
      
784.  
     sb.append("\r\n");
785.  
      
786.  
     //sb.append("Transport:RTP/AVP;UNICAST;client_port=16264-16265;mode=play\r\n");
787.  
      
788.  
     RTPPort=rtp.getLocalPort();
789.  
      
790.  
     sb.append("Transport:RTP/AVP;unicast;client_port="+RTPPort
791.  
      
792.  
     +";mode=PLAY\r\n");
793.  
      
794.  
     sb.append("\r\n");
795.  
      
796.  
     Log.w(TAG,"doSetup:"+sb.toString());
797.  
      
798.  
     send(sb.toString().getBytes());
799.  
      
800.  
     }
801.  
      
802.  
     privatevoiddoTeardown(){
803.  
      
804.  
     //TODOAuto-generatedmethodstub
805.  
      
806.  
     StringBuildersb=newStringBuilder();
807.  
      
808.  
     sb.append("TEARDOWN");
809.  
      
810.  
     sb.append(this.address);
811.  
      
812.  
     sb.append("/");
813.  
      
814.  
     sb.append(RTSP_VERSION);
815.  
      
816.  
     sb.append("Cseq:");
817.  
      
818.  
     sb.append(seq++);
819.  
      
820.  
     sb.append("\r\n");
821.  
      
822.  
     sb.append("User-Agent:RealMediaPlayerHelixDNAClient/10.0.0.11279(win32)\r\n");
823.  
      
824.  
     sb.append("Session:");
825.  
      
826.  
     sb.append(sessionId);
827.  
      
828.  
     sb.append("\r\n");
829.  
      
830.  
     send(sb.toString().getBytes());
831.  
      
832.  
     Log.w(TAG,"doTeardown:"+sb.toString());
833.  
      
834.  
     }
835.  
      
836.  
     privatevoiddoPause(){
837.  
      
838.  
     //TODOAuto-generatedmethodstub
839.  
      
840.  
     StringBuildersb=newStringBuilder();
841.  
      
842.  
     sb.append("PAUSE");
843.  
      
844.  
     sb.append(this.address);
845.  
      
846.  
     sb.append("/");
847.  
      
848.  
     sb.append(RTSP_VERSION);
849.  
      
850.  
     sb.append("Cseq:");
851.  
      
852.  
     sb.append(seq++);
853.  
      
854.  
     sb.append("\r\n");
855.  
      
856.  
     sb.append("Session:");
857.  
      
858.  
     sb.append(sessionId);
859.  
      
860.  
     sb.append("\r\n");
861.  
      
862.  
     send(sb.toString().getBytes());
863.  
      
864.  
     Log.w(TAG,"doPause:"+sb.toString());
865.  
      
866.  
     }
867.  
      
868.  
     privatevoiddoPlay(){
869.  
      
870.  
     //TODOAuto-generatedmethodstub
871.  
      
872.  
     StringBuildersb=newStringBuilder();
873.  
      
874.  
     sb.append("PLAY");
875.  
      
876.  
     sb.append(this.address);
877.  
      
878.  
     sb.append(RTSP_VERSION);
879.  
      
880.  
     sb.append("Session:");
881.  
      
882.  
     sb.append(sessionId);
883.  
      
884.  
     sb.append("\r\n");
885.  
      
886.  
     sb.append("Cseq:");
887.  
      
888.  
     sb.append(seq++);
889.  
      
890.  
     sb.append("\r\n");
891.  
      
892.  
     sb.append("Range:npt=0.000-");
893.  
      
894.  
     sb.append("\r\n");
895.  
      
896.  
     sb.append("\r\n");
897.  
      
898.  
     Log.w(TAG,"doPlay:"+sb.toString());
899.  
      
900.  
     send(sb.toString().getBytes());
901.  
      
902.  
     }
903.  
      
904.  
     privatevoiddoGetParameter(){
905.  
      
906.  
     StringBuildersb=newStringBuilder();
907.  
      
908.  
     sb.append("GET_PARAMETER");
909.  
      
910.  
     sb.append(this.address);
911.  
      
912.  
     sb.append(RTSP_VERSION);
913.  
      
914.  
     sb.append("Content-length:0");
915.  
      
916.  
     sb.append("\r\n");
917.  
      
918.  
     sb.append("Cseq:");
919.  
      
920.  
     sb.append(seq++);
921.  
      
922.  
     sb.append("\r\n");
923.  
      
924.  
     sb.append("\r\n");
925.  
      
926.  
     Log.w(TAG,"doGetParameter:"+sb.toString());
927.  
      
928.  
     send(sb.toString().getBytes());
929.  
      
930.  
     }
931.  
      
932.  
     privatevoiddoSetParameter(){
933.  
      
934.  
     StringBuildersb=newStringBuilder();
935.  
      
936.  
     sb.append("SET_PARAMETER");
937.  
      
938.  
     sb.append(this.address);
939.  
      
940.  
     sb.append(RTSP_VERSION);
941.  
      
942.  
     sb.append("Seission:");
943.  
      
944.  
     sb.append(sessionId);
945.  
      
946.  
     sb.append("\r\n");
947.  
      
948.  
     sb.append("Cseq:");
949.  
      
950.  
     sb.append(seq++);
951.  
      
952.  
     sb.append("\r\n");
953.  
      
954.  
     sb.append("\r\n");
955.  
      
956.  
     Log.w(TAG,"doSetParameter:"+sb.toString());
957.  
      
958.  
     send(sb.toString().getBytes());
959.  
      
960.  
     }
961.  
      
962.  
     privatevoiddoDescribe(){
963.  
      
964.  
     //TODOAuto-generatedmethodstub
965.  
      
966.  
     StringBuildersb=newStringBuilder();
967.  
      
968.  
     sb.append("DESCRIBE");
969.  
      
970.  
     sb.append(this.address);
971.  
      
972.  
     sb.append(RTSP_VERSION);
973.  
      
974.  
     sb.append("Cseq:");
975.  
      
976.  
     sb.append(seq++);
977.  
      
978.  
     sb.append("\r\n");
979.  
      
980.  
     sb.append("\r\n");
981.  
      
982.  
     Log.w(TAG,"doDescribe:"+sb.toString());
983.  
      
984.  
     send(sb.toString().getBytes());
985.  
      
986.  
     }
987.  
      
988.  
     privatevoiddoOption(){
989.  
      
990.  
     //TODOAuto-generatedmethodstub
991.  
      
992.  
     StringBuildersb=newStringBuilder();
993.  
      
994.  
     sb.append("OPTIONS");
995.  
      
996.  
     sb.append(this.address);
997.  
      
998.  
     sb.append(RTSP_VERSION);
999.  
      
1000.  
      sb.append("Cseq:");
1001.  
       
1002.  
      sb.append(seq++);
1003.  
       
1004.  
      sb.append("\r\n");
1005.  
       
1006.  
      sb.append("\r\n");
1007.  
       
1008.  
      Log.w(TAG,"doOption:"+sb.toString());
1009.  
       
1010.  
      send(sb.toString().getBytes());
1011.  
       
1012.  
      }
1013.  
       
1014.  
      privatevoidsend(byte[]out){
1015.  
       
1016.  
      //TODOAuto-generatedmethodstub
1017.  
       
1018.  
      if(out==null||out.length<1){
1019.  
       
1020.  
      return;
1021.  
       
1022.  
      }
1023.  
       
1024.  
      synchronized(sendBuf){
1025.  
       
1026.  
      sendBuf.clear();
1027.  
       
1028.  
      sendBuf.put(out);
1029.  
       
1030.  
      sendBuf.flip();
1031.  
       
1032.  
      }
1033.  
       
1034.  
      //发送出去
1035.  
       
1036.  
      try{
1037.  
       
1038.  
      write();
1039.  
       
1040.  
      isSended=true;
1041.  
       
1042.  
      }catch(finalIOExceptione){
1043.  
       
1044.  
      e.printStackTrace();
1045.  
       
1046.  
      }
1047.  
       
1048.  
      }
1049.  
       
1050.  
      }

4.服务器接收客户端的请求并作出相应的反馈操作

1.  
   publicclassRTPReceiveUDPextendsThread{
2.  
    
3.  
   privatefinalstaticStringTAG="RTPRecevieUDP";
4.  
    
5.  
   privatefinalstaticintBUFFER_SIZE=10240;
6.  
    
7.  
   privatefinalstaticStringTEMP_FILE="fm932radio";
8.  
    
9.  
   //privatefinalstaticintDEFAULT_PORT=55566;//默认接收端口
10.  
     
11.  
    privateintlocalPort;
12.  
     
13.  
    privatebooleanisRunning=true;
14.  
     
15.  
    privateintreadTimestamp=0;
16.  
     
17.  
    //privateStringcurrentFilePath;
18.  
     
19.  
    privateStringtempFilePath;
20.  
     
21.  
    privateDatagramSocketRTPRecevie;
22.  
     
23.  
    privateDatagramPacketRTPPacket;
24.  
     
25.  
    privatebyte[]buf;
26.  
     
27.  
    publicRTPReceiveUDP(){
28.  
     
29.  
    try{
30.  
     
31.  
    RTPRecevie=newDatagramSocket();
32.  
     
33.  
    localPort=RTPRecevie.getLocalPort();
34.  
     
35.  
    buf=newbyte[BUFFER_SIZE];
36.  
     
37.  
    RTPPacket=newDatagramPacket(buf,BUFFER_SIZE);
38.  
     
39.  
    createTempFile();
40.  
     
41.  
    Log.i(TAG,"RTPRecevieUDPpreparedsuccess");
42.  
     
43.  
    }catch(SocketExceptione){
44.  
     
45.  
    //TODOAuto-generatedcatchblock
46.  
     
47.  
    e.printStackTrace();
48.  
     
49.  
    }
50.  
     
51.  
    }
52.  
     
53.  
    publicintgetLocalPort(){
54.  
     
55.  
    returnlocalPort;
56.  
     
57.  
    }
58.  
     
59.  
    /*没有参数则对全局的buf[]进行操作*/
60.  
     
61.  
    privateintgetTimestamp(){
62.  
     
63.  
    byte[]tmp=newbyte[4];
64.  
     
65.  
    inttimestamp;
66.  
     
67.  
    for(inti=0;i<4;i++)
68.  
     
69.  
    tmp[i]=buf[i+4];
70.  
     
71.  
    timestamp=bytesToInt(tmp);
72.  
     
73.  
    returntimestamp;
74.  
     
75.  
    }
76.  
     
77.  
    privateintbytesToInt(byte[]b){
78.  
     
79.  
    intmask=0xff;
80.  
     
81.  
    inttemp=0;
82.  
     
83.  
    intn=0;
84.  
     
85.  
    for(inti=0;i<4;i++){
86.  
     
87.  
    n<<=8;
88.  
     
89.  
    temp=b[i]&mask;
90.  
     
91.  
    n|=temp;
92.  
     
93.  
    }
94.  
     
95.  
    returnn;
96.  
     
97.  
    }
98.  
     
99.  
    privatevoidcreateTempFile(){
100.  
      
101.  
     byte[]wmaHeader=newbyte[]{(byte)0x30,(byte)0x26,(byte)0xB2,
102.  
      
103.  
     (byte)0x75,(byte)0x8E,(byte)0x66,(byte)0xCF,
104.  
      
105.  
     (byte)0x11,(byte)0xA6,(byte)0xD9,(byte)0x00,
106.  
      
107.  
     (byte)0xAA,(byte)0x62,(byte)0xCE,(byte)0x6C};
108.  
      
109.  
     byte[]allSize=newbyte[]{(byte)0x00,(byte)0x00,(byte)0x00,
110.  
      
111.  
     (byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x00};
112.  
      
113.  
     byte[]unKnown=newbyte[]{(byte)0x00,(byte)0x00,(byte)0x00,
114.  
      
115.  
     (byte)0x00,(byte)0x00,(byte)0x00};
116.  
      
117.  
     try{
118.  
      
119.  
     //文件名=日期+时间+TEMP_FILE
120.  
      
121.  
     SimpleDateFormatsdf=newSimpleDateFormat("yyyyMMddhhmmss");
122.  
      
123.  
     Datenow=newDate(System.currentTimeMillis());
124.  
      
125.  
     StringtimeResult=sdf.format(now);
126.  
      
127.  
     FiletempFile=File.createTempFile(TEMP_FILE+timeResult,".dat");
128.  
      
129.  
     tempFilePath=tempFile.getAbsolutePath();
130.  
      
131.  
     System.out.println("downloadpath======>>>>>>"+tempFilePath+",filesize===>>>>"+tempFile.length());
132.  
      
133.  
     FileOutputStreamfos=newFileOutputStream(tempFilePath,true);
134.  
      
135.  
     fos.write(wmaHeader);
136.  
      
137.  
     fos.write(allSize);
138.  
      
139.  
     fos.write(unKnown);
140.  
      
141.  
     fos.close();
142.  
      
143.  
     }catch(IOExceptione){
144.  
      
145.  
     //TODOAuto-generatedcatchblock
146.  
      
147.  
     e.printStackTrace();
148.  
      
149.  
     }
150.  
      
151.  
     }
152.  
      
153.  
     @Override
154.  
      
155.  
     publicvoidrun(){
156.  
      
157.  
     while(isRunning){
158.  
      
159.  
     try{
160.  
      
161.  
     RTPRecevie.receive(RTPPacket);
162.  
      
163.  
     inttimestamp=getTimestamp();
164.  
      
165.  
     if(readTimestamp==timestamp)
166.  
      
167.  
     continue;
168.  
      
169.  
     readTimestamp=timestamp;
170.  
      
171.  
     handle();
172.  
      
173.  
     Log.e(TAG,"timestamp:"+timestamp);
174.  
      
175.  
     }catch(IOExceptione){
176.  
      
177.  
     //TODOAuto-generatedcatchblock
178.  
      
179.  
     e.printStackTrace();
180.  
      
181.  
     }
182.  
      
183.  
     }
184.  
      
185.  
     }
186.  
      
187.  
     privatevoidhandle(){
188.  
      
189.  
     //TODOAuto-generatedmethodstub
190.  
      
191.  
     try{
192.  
      
193.  
     FileOutputStreamfos=newFileOutputStream(tempFilePath,true);
194.  
      
195.  
     fos.write(buf,12,buf.length-12);
196.  
      
197.  
     }catch(FileNotFoundExceptione){
198.  
      
199.  
     //TODOAuto-generatedcatchblock
200.  
      
201.  
     e.printStackTrace();
202.  
      
203.  
     }catch(IOExceptione){
204.  
      
205.  
     //TODOAuto-generatedcatchblock
206.  
      
207.  
     e.printStackTrace();
208.  
      
209.  
     }
210.  
      
211.  
     }
212.  
      
213.  
     }
214.  
      
215.  
     5.在Activity中调用方法，实现播放
216.  
      
217.  
     if(strHead.equals("rtsp:")){//根据已截取文件的前四个字符判断是否是rtsp协议
218.  
      
219.  
     connect=newRTSPConnect(newInetSocketAddress(
220.  
      
221.  
     "流媒体的IP地址",端口号默认为554),
222.  
      
223.  
     "rtsp://流媒体的IP地址:554");
224.  
      
225.  
     connect.start();
226.  
      
227.  
     mVideoView.setVideoURI(Uri.parse(strVideoUrl));
228.  
      
229.  
     mVideoView.requestFocus();
230.  
      
231.  
     mVideoView.start();
232.  
      
233.  
     }elseif(strHead.equals("http:")){
234.  
      
235.  
     mVideoView.setVideoURI(Uri.parse(strVideoUrl));
236.  
      
237.  
     }
1. 转自：https://blog.csdn.net/ameyume/article/details/8123382