局域网发现设备代码实现：udp组播

udp 单播、组播、广播都可以实现，单为什么我使用udp组播，

请参考我的上一篇  局域网发现之UDP组播

本篇讲解的是如何使用代码来实现局域网发现功能；

我的需求背景：

使用场景，手机上安装有app A，同一局域网内的电视 上安装有app B，要求当app B 这个版本支持来自A的某个互动功能（比如投屏、游戏控制）时，A就应该能搜到到B所在的设备提示给用户，然后用户才进行互动，局域网搜索设备则是互动的第一步也是前提；

我的设计如下：

在上面的需求中，手机就是这个搜索者，我定义为SearchClient，电视就是这个被搜索者，我定义为SearchServer；

由于我的需求是要用到app级别的发现，并不是设备级别；强调这个是为了和dlna 进行区分，大家如果了解了dlna，发现它的搜索设备是集成到rom 系统中，只要系统支持，那么app便能搜索到设备，但是这样会让dlna使用起来有些局限性，同一设备上app使用dlna必定发现标准都一致，app则不能自定义多种发现条件；比如手机上某个app A，某种场景下下是想要和支持功能A的app互动，另一种场景下需要和支持功能B的app互动，毕竟app之间想要相互发现的条件是根据需求多变的，而且app级别，只要能搜索到，就能确定app已经安装到设备上；我的设计正是适用这种情况；

采用自定义协议：所有协议格式统一采用  prefix + packType(1) + seq(4) +[userData]（标志性前缀+消息类型+序列号+自定义数据）

具体的userData 属于集成者自定义部分，主要包括搜索请求数据 和返回的设备数据，格式统一采用：[filedType + filedLength+ filedValue]（字段类型标志+字段长度+字段值）

看下面的代码之前，你可能需要补充下基础知识：socket自定义数据格式转化二进制   System.arraycopy方法的使用

下面直接上主要代码：

SearchClient 设备搜索者，要询问的搜索功能在ClientConfig中配置，使用int，int 有32个byte位，这样可以传输最少的数据，表达更多的信息，每个byte来表示一个功能控制位，如果对应的byte功能位和SearchServer支持的功能一致，则

该SearchServer就是要找的目标设备，它就需要在收到搜索请求后做出应答，带上自己的设备信息；

ClientConfig 类实现

package com.example.amyli.my.client;

/**
 * Created by amyli on 2017/2/15.
 */

public class ClientConfig {
    private static int askFunc;

    public static int getAskFunc() {
        return askFunc;
    }

    public static void setAskFunc(int func) {
        askFunc = func;
    }
}

SearchClient 类实现

package com.example.amyli.my.client;

import com.example.amyli.my.base.DeviceData;
import com.example.amyli.my.base.RequestSearchData;
import com.example.amyli.my.base.SearchConst;
import com.example.amyli.my.base.Utils;
import com.example.amyli.my.base.BaseUserData;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by amyli on 2017/2/13.
 * 局域网中的设备搜索者，包含开启搜索，关闭搜索，以及搜索设备的状态回调
 */

public abstract class SearchClient {

    private int mUserDataMaxLen;
    private static boolean isOpen = false;

    private Set<BaseUserData> mDeviceSet;
    private static MulticastSocket sock;
    private String mDeviceIP;
    private DatagramPacket mSendPack;
    Thread sendThread, receiveThread;
    private InetAddress multicastInet;
    private int seq;

    public SearchClient(int userDataMaxLen) {
        seq = 0;
        mUserDataMaxLen = userDataMaxLen;
        mDeviceSet = new HashSet<>();
        try {
            sock = new MulticastSocket(SearchConst.C_PORT);
            multicastInet = InetAddress.getByName(SearchConst.MULTICAST_IP);
            sock.joinGroup(multicastInet);
            sock.setLoopbackMode(false);// 必须是false才能开启广播功能

            byte[] sendData = new byte[1024];
            mSendPack = new DatagramPacket(sendData, sendData.length, multicastInet, SearchConst
                    .S_PORT);

        } catch (IOException e) {
            printLog(e.toString());
            e.printStackTrace();
            close();
        }
    }

    /**
     * 完成初始化，开始搜索设备
     * @return
     */
    public boolean init() {
        isOpen = true;
        onSearchStart();

        sendThread = new Thread(new Runnable() {
            @Override
            public void run() {
                printLog("start send thread");
                send(sock);
            }
        });
        sendThread.start();

        receiveThread = new Thread(new Runnable() {
            @Override
            public void run() {
                printLog("start receive thread");
                receive(sock);
            }
        });
        receiveThread.start();

        return true;
    }


    /**
     * 关闭搜索设备，释放资源等
     */
    public void close() {
        isOpen = false;
        if (sendThread != null) {
            sendThread.interrupt();
        }
        if (receiveThread != null) {
            receiveThread.interrupt();
        }
        if (sock != null) {
            try {
                sock.leaveGroup(multicastInet);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                sock.close();
            }
        }
        onSearchFinish();
    }

    /**
     * 是否开启了局域网搜索功能
     * @return
     */
    public static boolean isOpen() {
        return isOpen;
    }

    public static void setIsOpen(boolean isOpen) {
        SearchClient.isOpen = isOpen;
    }

    /**
     * 开启了搜索功能，回调给app
     */
    public abstract void onSearchStart();

    /**
     * 发现了设备，回调给app
     * @param dev
     */
    public abstract void onSearchDev(BaseUserData dev);

    /**
     * 结束了发现过程，回调给app
     */
    protected abstract void onSearchFinish();

    public abstract void printLog(String msg);

    /**
     * 发送搜索请求，并能指定想要发现的是支持哪种功能
     * @param sock
     */
    private void send(MulticastSocket sock) {
        if (sock == null || sock.isClosed()) {
            return;
        }

        while (isOpen) {
            byte mPackType = SearchConst.PACKET_TYPE_FIND_DEVICE_REQ;
            RequestSearchData request = new RequestSearchData(ClientConfig.getAskFunc());
            byte[] userData = RequestSearchData.packRequestUserData
                    (request);
            if (userData == null) {
                printLog("userdata null,return");
                return;
            }

            byte[] bytes = Utils.packData(seq, mPackType, userData);
            if (bytes == null) {
                printLog("send null,return");
                return;
            }

            mSendPack.setData(bytes);
            try {
                sock.send(mSendPack);
                printLog("send seq:" + seq);
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
            seq++;
        }
        close();
    }

    /**
     * 实现收到server返回设备信息，并解析数据
     * @param sock
     */
    private void receive(MulticastSocket sock) {
        if (sock == null || sock.isClosed()) {
            return;
        }

        byte[] receData = new byte[SearchConst.PACKET_HEADER_LENGTH + mUserDataMaxLen];
        DatagramPacket recePack = new DatagramPacket(receData, receData.length);

        while (isOpen) {
            recePack.setData(receData);
            try {
                sock.receive(recePack);
                if (recePack.getLength() > 0) {
                    mDeviceIP = recePack.getAddress().getHostAddress();
                    //check if it's itself
                    //check the ip if already exist
                    if (parseResponsePack(recePack)) {
                        printLog("a response from：" + mDeviceIP);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
        close();
    }

    /**
     * 解析报文
     * 协议：$ + packType(1) + userData(n)
     *
     * @param pack 数据报
     */
    private boolean parseResponsePack(DatagramPacket pack) {
        if (pack == null || pack.getAddress() == null) {
            return false;
        }

        String ip = pack.getAddress().getHostAddress();
        int port = pack.getPort();
        for (BaseUserData d : mDeviceSet) {
            if (d.getIp().equals(ip)) {
                printLog("is the same ip device");
                return false;
            }
        }

        // 解析头部数据
        byte[] data = pack.getData();
        int dataLen = pack.getLength();
        int offset = pack.getOffset();

        if (dataLen < SearchConst.PACKET_HEADER_LENGTH || data[offset++] != SearchConst
                .PACKET_PREFIX || data[offset++] !=
                SearchConst.PACKET_TYPE_FIND_DEVICE_RSP) {
            printLog("parse return false");
            return false;
        }

        int sendSeq = Utils.bytesToInt(data, offset);
        printLog("receive response,seq:" + sendSeq);
        if (sendSeq < 0) {
            return false;
        }
        if (mUserDataMaxLen == 0 && dataLen == SearchConst.PACKET_HEADER_LENGTH) {
            return false;
        }

        // 解析用户数据
        int userDataLen = dataLen - SearchConst.PACKET_HEADER_LENGTH;
        byte[] userData = new byte[userDataLen];
        System.arraycopy(data, SearchConst.PACKET_HEADER_LENGTH, userData, 0, userDataLen);

        DeviceData device = DeviceData.parseDeviceUserData(userData);
        device.setIp(ip);
        device.setPort(port);
        printLog("receive response,device:" + device.toString());
        mDeviceSet.add(device);
        onSearchDev(device);
        return true;
    }

}

SearchServer 类实现

package com.example.amyli.my.server;

/**
 * Created by amyli on 2017/2/13.
 */

import com.example.amyli.my.base.BaseUserData;
import com.example.amyli.my.base.DeviceData;
import com.example.amyli.my.base.RequestSearchData;
import com.example.amyli.my.base.SearchConst;
import com.example.amyli.my.base.Utils;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;

public abstract class SearchServer {

    private int mUserDataMaxLen;

    private volatile boolean mOpenFlag;

    private MulticastSocket sock;
    private InetAddress multicastInet;
    private Thread serverThread;

    /**
     * 构造函数
     * 不需要用户数据
     */
    public SearchServer() {
        this(0);
    }

    /**
     * 构造函数
     *
     * @param userDataMaxLen 搜索主机发送数据的最大长度
     */
    public SearchServer(int userDataMaxLen) {
        this.mUserDataMaxLen = userDataMaxLen;

        try {
            sock = new MulticastSocket(SearchConst.S_PORT);
            multicastInet = InetAddress.getByName(SearchConst.MULTICAST_IP);

            sock.joinGroup(multicastInet);
            sock.setLoopbackMode(false);// 必须是false才能开启广播功能

        } catch (IOException e) {
            printLog(e.toString());
            e.printStackTrace();
            close();
        }
    }

    /**
     * 打开
     * 即可以上线
     */
    public boolean init() {
        printLog("init");
        mOpenFlag = true;
        serverThread = new Thread(new Runnable() {
            @Override
            public void run() {
                receiveAndSend();
            }
        });
        serverThread.start();
        return true;
    }

    /**
     * 关闭
     */
    public void close() {
        printLog("close");

        mOpenFlag = false;
        if (serverThread != null) {
            serverThread.interrupt();
        }

        if (sock != null) {
            try {
                sock.leaveGroup(multicastInet);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                sock.close();
            }
        }
    }

    private int curSeq;

    public void receiveAndSend() {
        byte[] buf = new byte[mUserDataMaxLen];
        DatagramPacket recePack = new DatagramPacket(buf, buf.length);

        if (sock == null || sock.isClosed() || recePack == null) {
            return;
        }

        while (mOpenFlag) {
            try {
                printLog("server before receive");
                // waiting for search from host
                sock.receive(recePack);
                // verify the data
                if (verifySearchReq(recePack)) {
                    byte[] userData = DeviceData.packDeviceData(ServerConfig.getDeviceData());
                    if (userData == null) {
                        return;
                    }

                    byte[] sendData = Utils.packData(curSeq, SearchConst
                            .PACKET_TYPE_FIND_DEVICE_RSP, userData);
                    if (sendData == null) {
                        return;
                    }

                    printLog("send response,seq:" + curSeq + ",userdata:" + ServerConfig
                            .getDeviceData().toString());

                    DatagramPacket sendPack = new DatagramPacket(sendData, sendData.length,
                            recePack.getAddress(), recePack.getPort());
                    sock.send(sendPack);
                }

            } catch (IOException e) {
                printLog(e.toString());
                close();
                break;
            }
        }
        printLog("设备关闭或已被找到");
    }

    /**
     * 校验客户端发的搜索请求数据
     * 协议：$ + packType(1) + sendSeq(4) [+ deviceIpLen(1) + deviceIp(n<=15)] [+ userData]
     * packType - 报文类型
     * sendSeq - 发送序列
     * deviceIpLen - 设备IP长度
     * deviceIp - 设备IP，仅在确认时携带
     * userData - 用户数据
     */
    private boolean verifySearchReq(DatagramPacket pack) {
        if (pack.getLength() < 6) {
            return false;
        }

        byte[] data = pack.getData();
        int offset = pack.getOffset();

        if (data[offset++] != SearchConst.PACKET_PREFIX || data[offset++] != SearchConst
                .PACKET_TYPE_FIND_DEVICE_REQ) {
            printLog("return false");
            return false;
        }

        int sendSeq = Utils.bytesToInt(data, offset);
        if (sendSeq < 0) {
            return false;
        }

        offset += SearchConst.INT_LENGTH;
        printLog("receive seq:" + sendSeq);

        curSeq = sendSeq;
        if (mUserDataMaxLen == 0 && offset == data.length) {
            return true;
        }

        // get userData
        byte[] userData = new byte[pack.getLength() - offset];
        System.arraycopy(data, offset, userData, 0, userData.length);

        RequestSearchData requestSearchData = RequestSearchData.parseRequestUserData(userData);
        String ip = pack.getAddress().getHostAddress();
        int port = pack.getPort();
        requestSearchData.setIp(ip);
        requestSearchData.setPort(port);
        printLog("receive requestSearchData:" + requestSearchData.toString());
        onReceiveSearchReq(requestSearchData);
        if (requestSearchData.getAskFunc() == ServerConfig.getFunc()) {
            return true;
        }
        return false;
    }

    /**
     * 获取本机在Wifi中的IP
     * 默认都是返回true，如果需要真实验证，需调用自己重写本方法
     *
     * @param ip 需要判断的ip地址
     * @return true-是本机地址
     */
    public boolean isOwnIp(String ip) {
        return true;
    }

    /**
     * 打印日志
     * 由调用者打印，SE和Android不同
     */
    public abstract void printLog(String log);

    public abstract void onReceiveSearchReq(RequestSearchData data);

    public boolean isOpen() {
        return mOpenFlag;
    }
}

app如何集成

我提供了一个叫LANDiscoveryLib 的java lib，app 只需引用这个library工程，并进行自己的功能配置，即可。

测试结论：

1.经过许多天的测试，使用udp组播还比较稳定可靠，至少比android自带的nsd发现要靠谱得多；

2. 但是当使用公司大wifi环境测试时，会出现udp丢包导致偶尔搜不到的情况，自己搭建的局域网就基本不存在；

3. 如果是在公司自己搭建局域网，建议调试时，可以让路由器拔掉网线，因为路由器是否联网对于你的调试没有影响，仍然能实现发现功能，因为我有一次让路由器插上公司的网口，大量测试导致了问题，路由器中有DHCP功能，稍有设置或操作不当就会影响公司的内网局域网其他用户。公司不推荐私自使用路由器设备。

4.有个注意的地方：经过测试，我发现udp组播是由当前正在使用的网卡去发送，和设备的网络环境无关,也就是加入的是组播组，并且某些组播还可以夸网段所以可见组播通信是和具体的wifi环境无关；本来我考虑到网络变化时，是否需要先关闭，再重新加入局域网，在新的网络中再次重启发现过程；但是测试发现不需要做这样的处理，

比如在同一局域网环境A，手机能发现电视，其中一个设备切换到网络B，手机无法发现到电视，但是两个都切好到B时，则又能相互发现；意思就是和最初加入组播时，使用的网络无关；

我特意强调这点，是因为我做局域网发现功能也有几个月了，在使用android自带的nsd发现服务器实现时，是和注册的网络环境有关的；由于本篇有些长，这个就不具体解释了；

5. 另外，由于本篇实现的是实时自动发现局域网内的设备，所以会不断循环的去发组播，从4如果只是wifi相互切换是不需要考虑网络变化进行处理的，但更优的做法，如果不是wifi环境，则关闭发现过程，因为这样的组播是么有意义的，具体见demo；

详细的demo 请参见我的源码：https://github.com/amylizxy/udpMulticast