Android为TV端助力:UDP协议(接收组播和单播)

private static String MulticastHost="224.9.9.98";
private static int POST=19999;
private static int unicast_POST=19998;

private static String TwoMulticastHost="239.9.9.98";

private boolean isStopThread = true;

/**
 * 接收单播
 */
public void requseUDPUnicast(){
    UdpReceiver receiver = new UdpReceiver(unicast_POST,isStopThread);
    receiver.addOnReceiveListener(new OnReceiveListener() {
        @Override
        public void OnReceive(UdpReceiver receiver, DatagramPacket packet) {
            if(!isStopThread){
                receiver.Stop();
                return;
            }
            byte data[] = packet.getData();
            String result = new String(data, 0, packet.getLength());
            if(!StringUtil.isEmpty(result) && result.contains("HHZT")){
                String serverIP = result.replace("HHZT","");
                LogUtil.i("serverIP::"+serverIP);
                //通过UDP协议获取点播服务器接口
                ConfigMgr.getInstance().initEpgUrl(getEPGHost(serverIP));
                UserMgr.setServerIP(getEPGHost(serverIP));
                //通过点播IP接口获取账号，账号自动在后台创建
                getUserNameAndPw();
            }
        }
    });
    try {
        receiver.Listen();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

package com.hhzt.vod.smartvod.utils;

import android.util.Log;

import com.hhzt.vod.smartvod.observer.OnReceiveListener;

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

/**
 * Created by Administrator on 2018-04-24.
 */

public class UdpReceiver {


    protected DatagramSocket client=null;
    private OnReceiveListener mOnReceiveListener=null;
    private Thread thrRecv=null;
    protected int port=0;
    public  boolean isFlag = true;
    public UdpReceiver(int port,boolean isFlag){
        this.port=port;
        this.isFlag=isFlag;
    }
    protected DatagramSocket Create() throws IOException {
        return new DatagramSocket(this.port);
    }
    public void addOnReceiveListener(OnReceiveListener mOnReceiveListener){
        this.mOnReceiveListener=mOnReceiveListener;
    }
    public void Stop(){
        if(this.thrRecv!=null){
            this.isFlag = false;
            this.thrRecv.interrupt();
        }
        this.Close();
    }
    public void Listen() throws IOException {
        this.Close();
        this.client=this.Create();
        if(this.thrRecv!=null) this.thrRecv.interrupt();
        this.thrRecv=new Thread(new Runnable() {
            @Override
            public void run() {
                while(!Thread.interrupted() && isFlag){
                    DatagramPacket packet = null;
                    try {
                        packet=UdpReceiver.this.Receive();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                 //   UdpReceiver.this.OnReceive(packet);
                    if(UdpReceiver.this.mOnReceiveListener!=null && null != packet)
                        UdpReceiver.this.mOnReceiveListener.OnReceive(UdpReceiver.this, packet);
                }
            }
        });
        this.thrRecv.start();
    }
    protected DatagramPacket Receive() throws IOException {
        byte[] recvBuf = new byte[4096];
        DatagramPacket recvPacket= new DatagramPacket(recvBuf , recvBuf.length);
        this.client.receive(recvPacket);
        return recvPacket;
    }
    protected void Close(){
        if(this.client!=null) this.client.close();
    }
    protected void OnReceive(DatagramPacket args){
        if(args == null){
            return;
        }
        byte data[] = args.getData();
        String result = new String(data, 0, args.getLength());
        Log.i("TAG","serverIP11::"+result);
        String serverIP = result.replace("HHZT","");
        Log.i("TAG","serverIP::"+serverIP);

    }

}

接收组播

public void requseUDPServerIP(){
    ThreadPoolManager.getInstance().addTask(new Runnable() {
        @Override
        public void run() {
             MulticastSocket ms = null;
            try {
                ms = new MulticastSocket(POST);
                InetAddress receiveAddress = InetAddress.getByName(MulticastHost);
                ms.joinGroup(receiveAddress);
            } catch (Exception e) {
                e.printStackTrace();
            }

            byte data[] = new byte[512];
            DatagramPacket dp = new DatagramPacket(data, 512);
            while (isStopThread) {
                try {
                    ms.receive(dp);
                    String result = new String(data, 0, dp.getLength());
                    Log.i("TAG","DatagramPacket11:"+result);
                    Log.i("TAG","DatagramPacket22:"+dp.getAddress().getHostName());
                    Log.i("TAG","DatagramPacket33:"+dp.getAddress().getHostAddress());
                    Log.i("TAG","DatagramPacket44:"+dp.getSocketAddress());
                    Log.i("TAG","DatagramPacket55:"+dp.getPort());
                    if(!StringUtil.isEmpty(result) && result.contains("HHZT")){
                        isStopThread = false;
                        String serverIP = result.replace("HHZT","");
                        LogUtil.i("serverIP::"+serverIP);
                        //通过UDP协议获取点播服务器接口
                        ConfigMgr.getInstance().initEpgUrl(getEPGHost(serverIP));
                        UserMgr.setServerIP(getEPGHost(serverIP));
                        //通过点播IP接口获取账号，账号自动在后台创建
                        getUserNameAndPw();
                        ms.disconnect();
                        ms.close();
                        break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    });}