Android NSD学习与使用

最新推荐文章于 2023-11-17 09:08:30 发布

hfut_why

最新推荐文章于 2023-11-17 09:08:30 发布

阅读量2.4k

点赞数

文章标签： Nsd NsdManager 网络 Android

本文链接：https://blog.csdn.net/hfut_why/article/details/89643812

版权

随笔同时被 2 个专栏收录

119 篇文章 1 订阅

订阅专栏

Android基础

101 篇文章 9 订阅

订阅专栏

在我们的实际开发中，经常会有点对点通讯的需求，我们知道，通讯的基础是知道彼此的标识，在网络中便是IP，如果具体到某一个应用，还需要端口号。那我们的NSD技术其实就是实现在同一wifi的局域网情况下，实现查询设备网络信息（IP和端口）的。NSD的全称是Network Service Discovery。从名称我们也可以看出来其是通过一个服务实现上述功能--Demo源码下载。那我们就来简单看一下其使用流程。关于使用流程，我觉得NSD相关API中NsdManager（系统服务）中的描述可以非常详细和简单的概括了：

/**
 * The Network Service Discovery Manager class provides the API to discover services
 * on a network. As an example, if device A and device B are connected over a Wi-Fi
 * network, a game registered on device A can be discovered by a game on device
 * B. Another example use case is an application discovering printers on the network.
 *
 * <p> The API currently supports DNS based service discovery and discovery is currently
 * limited to a local network over Multicast DNS. DNS service discovery is described at
 * http://files.dns-sd.org/draft-cheshire-dnsext-dns-sd.txt
 *
 * <p> The API is asynchronous and responses to requests from an application are on listener
 * callbacks on a seperate internal thread.
 *
 * <p> There are three main operations the API supports - registration, discovery and resolution.
 * <pre>
 *                          Application start
 *                                 |
 *                                 |
 *                                 |                  onServiceRegistered()
 *                     Register any local services  /
 *                      to be advertised with       \
 *                       registerService()            onRegistrationFailed()
 *                                 |
 *                                 |
 *                          discoverServices()
 *                                 |
 *                      Maintain a list to track
 *                        discovered services
 *                                 |
 *                                 |--------->
 *                                 |          |
 *                                 |      onServiceFound()
 *                                 |          |
 *                                 |     add service to list
 *                                 |          |
 *                                 |<----------
 *                                 |
 *                                 |--------->
 *                                 |          |
 *                                 |      onServiceLost()
 *                                 |          |
 *                                 |   remove service from list
 *                                 |          |
 *                                 |<----------
 *                                 |
 *                                 |
 *                                 | Connect to a service
 *                                 | from list ?
 *                                 |
 *                          resolveService()
 *                                 |
 *                         onServiceResolved()
 *                                 |
 *                     Establish connection to service
 *                     with the host and port information
 *
 * </pre>
 * An application that needs to advertise itself over a network for other applications to
 * discover it can do so with a call to {@link #registerService}. If Example is a http based
 * application that can provide HTML data to peer services, it can register a name "Example"
 * with service type "_http._tcp". A successful registration is notified with a callback to
 * {@link RegistrationListener#onServiceRegistered} and a failure to register is notified
 * over {@link RegistrationListener#onRegistrationFailed}
 *
 * <p> A peer application looking for http services can initiate a discovery for "_http._tcp"
 * with a call to {@link #discoverServices}. A service found is notified with a callback
 * to {@link DiscoveryListener#onServiceFound} and a service lost is notified on
 * {@link DiscoveryListener#onServiceLost}.
 *
 * <p> Once the peer application discovers the "Example" http service, and either needs to read the
 * attributes of the service or wants to receive data from the "Example" application, it can
 * initiate a resolve with {@link #resolveService} to resolve the attributes, host, and port
 * details. A successful resolve is notified on {@link ResolveListener#onServiceResolved} and a
 * failure is notified on {@link ResolveListener#onResolveFailed}.
 *
 * Applications can reserve for a service type at
 * http://www.iana.org/form/ports-service. Existing services can be found at
 * http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml
 *
 * {@see NsdServiceInfo}
 */

上面是对NsdManager的描述，我觉得看了这个再加上些许整理基本上就掌握了Nsd使用的整体流程。在看之前，我们先做一些说明，首先同一台设备无法实现API功能演示，为了便于理解，我们使用两台设备来说明。一台我们定义为S，另一台定义为C，接着我们来看看上面的描述：

（1）NSD主要功能介绍
（2）实现机制
（3）运行特点（异步，独立线程）
（4）实现功能与步骤
（5）对于（4）详细解释

上面的五步就是上面的英文的概括，对于其功能我们已经知道了，我们主要关注的如何使用以及具体的实现，所以重点是第4和第5。我们接着来看一下第4部分的内容：

* <p> There are three main operations the API supports - registration, discovery and resolution.
* <pre>
*                          Application start
*                                 |
*                                 |
*                                 |                  onServiceRegistered()
*                     Register any local services  /
*                      to be advertised with       \
*                       registerService()            onRegistrationFailed()
*                                 |
*                                 |
*                          discoverServices()
*                                 |
*                      Maintain a list to track
*                        discovered services
*                                 |
*                                 |--------->
*                                 |          |
*                                 |      onServiceFound()
*                                 |          |
*                                 |     add service to list
*                                 |          |
*                                 |<----------
*                                 |
*                                 |--------->
*                                 |          |
*                                 |      onServiceLost()
*                                 |          |
*                                 |   remove service from list
*                                 |          |
*                                 |<----------
*                                 |
*                                 |
*                                 | Connect to a service
*                                 | from list ?
*                                 |
*                          resolveService()
*                                 |
*                         onServiceResolved()
*                                 |
*                     Establish connection to service
*                     with the host and port information

上面说到这NsdManager主要实现三个功能：

注册（NsdService以及对应的监听NSDServer.IRegisterState)
发现（NsdService）
解析（NsdServiceInfo：里面封装了设备网络的相关信息，host，port等）

具体的使用步骤如下：

（1）注册NsdService，初始化注册监听器，成功或者失败会走对应的回调接口
（2）发现NsdService，通过初始化设备发现回调接口DiscoveryListener来获取发现设备的信息，通过回调函数onServiceFound实现，同时还可以实时监测丢失的设备，通过onServiceLost实现
（3）初始化NsdServiceInfo解析器监听接口，解析发现设备的网络信息，通过回调函数onServiceResolved实现
（4）初始化完上述两个接口即可开启扫描
（5）备注：扫描到指定设备并成功获取设备的IP和Port后，即可通过网络API建立连接和通讯。

因为NsdManager既完成了注册服务由完成了发现与解析服务的功能，所以上面的步骤我们还需要分解一下，对于被发现设备S，我们只需要完成第一步即可；对于发现设备C，我们需要实现（2）（3）（4），且最好都在子线程中执行。下面就来看看具体的实现。考虑到实际的应用，我们这里分为服务端和客户端，分别对应于设备S和设备C。我们来看看注册服务的具体实现：

 private void registerService(Context context, String serviceName, int port) {
        mNsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);
        NsdServiceInfo serviceInfo = new NsdServiceInfo();
        serviceInfo.setServiceName(serviceName);
        serviceInfo.setPort(port);
        serviceInfo.setServiceType(mServerType);
        mNsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, mRegistrationListener);
    }

其中，就是通过NsdManager的registerService来实现，其中的mRegistrationListener的初始化如下：

 //初始化化注册监听器
    private void initializeRegistrationListener() {
        mRegistrationListener = new NsdManager.RegistrationListener() {
            @Override
            public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
                Log.e(TAG, "NsdServiceInfo onRegistrationFailed");
                if (registerState != null) {
                    registerState.onRegistrationFailed(serviceInfo, errorCode);
                }
            }

            @Override
            public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
                Log.i(TAG, "onUnregistrationFailed serviceInfo: " + serviceInfo + " ,errorCode:" + errorCode);
                if (registerState != null) {
                    registerState.onUnRegistrationFailed(serviceInfo, errorCode);
                }
            }

            @Override
            public void onServiceRegistered(NsdServiceInfo serviceInfo) {
                mServerName = serviceInfo.getServiceName();
                Log.i(TAG, "onServiceRegistered: " + serviceInfo.toString());
                Log.i(TAG, "mServerName onServiceRegistered: " + mServerName);
                if (registerState != null) {
                    registerState.onServiceRegistered(serviceInfo);
                }
            }

            @Override
            public void onServiceUnregistered(NsdServiceInfo serviceInfo) {
                Log.i(TAG, "onServiceUnregistered serviceInfo: " + serviceInfo);
                if (registerState != null) {
                    registerState.onServiceUnregistered(serviceInfo);
                }
            }
        };
    }

上述两步其实就是注册服务的实现了，在实际的应用中结合线程即可完成注册服务的工作，下面就来看看客户端发现并解析服务的实现，首先是初始化发现监听：

  /**
     * 扫描解析前的 NsdServiceInfo
     * 用于服务发现的回调调用接口
     */
    private void initializeDiscoveryListener() {
        mDiscoveryListener = new NsdManager.DiscoveryListener() {
            @Override
            public void onStartDiscoveryFailed(String serviceType, int errorCode) {
                mNsdManager.stopServiceDiscovery(this);
                Log.e(TAG, "onStartDiscoveryFailed():");
            }

            @Override
            public void onStopDiscoveryFailed(String serviceType, int errorCode) {
                mNsdManager.stopServiceDiscovery(this);
                Log.e(TAG, "onStopDiscoveryFailed():");
            }

            @Override
            public void onDiscoveryStarted(String serviceType) {
                Log.e(TAG, "onDiscoveryStarted():");

            }

            @Override
            public void onDiscoveryStopped(String serviceType) {
                Log.e(TAG, "onDiscoveryStopped():");
            }

            /**
             *
             * @param serviceInfo
             */
            @Override
            public void onServiceFound(NsdServiceInfo serviceInfo) {
                Log.e(TAG, "onServiceFound: "+serviceInfo );
                discoveryList.add(serviceInfo.toString());
                //根据咱服务器的定义名称，指定解析该 NsdServiceInfo
                if (serviceInfo.getServiceName().equals(mServiceName)) {
                    mNsdManager.resolveService(serviceInfo, mResolverListener);
                }
            }

            @Override
            public void onServiceLost(NsdServiceInfo serviceInfo) {
                Log.e(TAG, "onServiceLost(): serviceInfo=" + serviceInfo);
                discoveryList.remove(serviceInfo.toString());
            }
        };
    }

初始化解析器监听器：

/**
     * 解析发现的NsdServiceInfo
     */
    private void initializeResolveListener() {
        mResolverListener = new NsdManager.ResolveListener() {
            @Override
            public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {

            }

            @Override
            public void onServiceResolved(NsdServiceInfo serviceInfo) {
                int port = serviceInfo.getPort();
                String serviceName = serviceInfo.getServiceName();
                String hostAddress = serviceInfo.getHost().getHostAddress();

                Message message=Message.obtain();
                message.what=1;
                message.obj=serviceInfo.toString();
                mHandler.sendMessage(message);

                Log.e(TAG, "onServiceResolved 已解析:" + " host:" + hostAddress + ":" + port + " ----- serviceName: " + serviceName);
                resolveList.add(" host:" + hostAddress + ":" + port );
                //TODO 建立网络连接

            }
        };
    }

开始扫描：

 public void startNSDClient(Handler handler) {
        mHandler=handler;
        mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);
        initializeDiscoveryListener();//初始化监听器
        initializeResolveListener();//初始化解析器
        mNsdManager.discoverServices(NSD_SERVER_TYPE, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);//开启扫描

    }

上面只是一个流程，没有形成一个完整的示例，下面我就结合上面的介绍给出一个完整的示例代码功能，示例中由服务端和客户端组成，服务端有以下功能：

完整NsdService注册
更改NsdService注册的名称
取消注册

客户端主要有以下功能：

发现并解析服务端的网络信息
设置发现NsdService的名称
显示发现的服务网络信息

服务端代码：

NsdServer.java:

package aoto.com.operationnsd;

import android.content.Context;
import android.net.nsd.NsdManager;
import android.net.nsd.NsdServiceInfo;
import android.util.Log;


/**
 * @author why
 * @date 2019.04.28
 */

public class NSDServer {
    public static final String TAG = "NSDServerWhy";
    private NsdManager mNsdManager;
    private NsdManager.RegistrationListener mRegistrationListener;
    private IRegisterState registerState; //NSD服务接口对象
    private String mServerName;
    private final String mServerType = "_http._tcp.";  // 服务器type，要客户端扫描服务器的一致

    public NSDServer() {
    }

    public void startNSDServer(Context context, String serviceName, int port) {
        initializeRegistrationListener();
        registerService(context, serviceName, port);
    }

    //初始化化注册监听器
    private void initializeRegistrationListener() {
        mRegistrationListener = new NsdManager.RegistrationListener() {
            @Override
            public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
                Log.e(TAG, "NsdServiceInfo onRegistrationFailed");
                if (registerState != null) {
                    registerState.onRegistrationFailed(serviceInfo, errorCode);
                }
            }

            @Override
            public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
                Log.i(TAG, "onUnregistrationFailed serviceInfo: " + serviceInfo + " ,errorCode:" + errorCode);
                if (registerState != null) {
                    registerState.onUnRegistrationFailed(serviceInfo, errorCode);
                }
            }

            @Override
            public void onServiceRegistered(NsdServiceInfo serviceInfo) {
                mServerName = serviceInfo.getServiceName();
                Log.i(TAG, "onServiceRegistered: " + serviceInfo.toString());
                Log.i(TAG, "mServerName onServiceRegistered: " + mServerName);
                if (registerState != null) {
                    registerState.onServiceRegistered(serviceInfo);
                }
            }

            @Override
            public void onServiceUnregistered(NsdServiceInfo serviceInfo) {
                Log.i(TAG, "onServiceUnregistered serviceInfo: " + serviceInfo);
                if (registerState != null) {
                    registerState.onServiceUnregistered(serviceInfo);
                }
            }
        };
    }

    private void registerService(Context context, String serviceName, int port) {
        mNsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);
        NsdServiceInfo serviceInfo = new NsdServiceInfo();
        serviceInfo.setServiceName(serviceName);
        serviceInfo.setPort(port);
        serviceInfo.setServiceType(mServerType);
        mNsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, mRegistrationListener);
    }

    public void stopNSDServer() {
        mNsdManager.unregisterService(mRegistrationListener);
    }


    //NSD服务注册监听接口
    public interface IRegisterState {
        void onServiceRegistered(NsdServiceInfo serviceInfo);     //注册NSD成功

        void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode);   //注册NSD失败

        void onServiceUnregistered(NsdServiceInfo serviceInfo);  //取消NSD注册成功

        void onUnRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode); //取消NSD注册失败

    }


    //设置NSD服务接口对象
    public void setRegisterState(IRegisterState registerState) {
        this.registerState = registerState;
    }
}

独立线程处理注册任务：

package aoto.com.operationnsd;

import android.content.Context;
import android.net.nsd.NsdServiceInfo;
import android.util.Log;


/**
 * author:why
 * created on: 2019/3/4 15:11
 * description:
 */
public class NsdServerRunnable implements Runnable {

    private static final String TAG = "NsdServerRunnableWhy";
    /**
     * 注册 NSD 服务的名称 和 端口 这个可以设置默认固定址，用于客户端通过 NSD_SERVER_NAME 筛选得到服务端地址和端口
     */
    private String nsdServerName ;
    private final int NSD_PORT = 8088;
    private NSDServer nsdServer;
    private Context context;

    public NsdServerRunnable(String nsdServerName, NSDServer nsdServer, Context context){
        this.nsdServerName=nsdServerName;
        this.nsdServer=nsdServer;
        this.context=context;
    }

    @Override
    public void run() {

        nsdServer.startNSDServer(context, nsdServerName, NSD_PORT);
        nsdServer.setRegisterState(new NSDServer.IRegisterState() {
            @Override
            public void onServiceRegistered(NsdServiceInfo serviceInfo) {
                Log.e(TAG, "onServiceRegistered: " + serviceInfo.toString());
                //已经注册可停止该服务
//                    nsdServer.stopNSDServer();
            }
            @Override
            public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

            }
            @Override
            public void onServiceUnregistered(NsdServiceInfo serviceInfo) {

            }
            @Override
            public void onUnRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {

            }
        });
    }
}

对外接口管理类：

package aoto.com.operationnsd;

import android.content.Context;
import android.util.Log;


/**
 * author:why
 * created on: 2019/3/4 15:15
 * description:
 */
public class NsdServerManager {
    private static final String TAG = "NsdServerManagerWhy";
    private volatile  static NsdServerManager nsdServerManager;
    private static NSDServer nsdServer;
    private Context context;

    public NsdServerManager(Context context){
        this.context=context;
    }

    public static NsdServerManager getInstance(Context context){
        if(nsdServerManager==null){
            synchronized (NsdServerManager.class){
                if (nsdServerManager==null) {
                    nsdServer=new NSDServer();
                    nsdServerManager = new NsdServerManager(context);
                }
            }
        }
        return nsdServerManager;
    }

    /**
     * 注册Nsd服务
     * @param nsdServerName
     */
    public void registerNsdServer(String nsdServerName) {
        new Thread(new NsdServerRunnable(nsdServerName,nsdServer,context)).start();
    }
    
    /**
     * 取消注册NsdServer
     */
    public void unRegisterNsdServer(){
        Log.e(TAG, "unRegisterNsdServer: " );
        nsdServer.stopNSDServer();
    }


}

调用代码：

package aoto.com.operationnsd;


import android.Manifest;
import android.net.nsd.NsdServiceInfo;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.RequiresApi;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;


/**
 * 无论两端哪边先结束应用再打开 Netty 都可以 可实现断线重连
 */
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "ServerWhy";

    TextView clientMessage;
    TextView serverTitle;
    EditText newNsdServerView;
    NsdServerManager nsdServerManager;

    /**
     * 注册 NSD 服务的名称 和 端口 这个可以设置默认固定址，用于客户端通过 NSD_SERVER_NAME 筛选得到服务端地址和端口
     */
    private String nsd_server_name = "WhySystem";
    private int nsd_server_port = 8088;

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initUI();

        nsdServerManager = NsdServerManager.getInstance(this);
        nsdServerManager.registerNsdServer(nsd_server_name);
    }


    private void initUI() {
        clientMessage = findViewById(R.id.message_from_client);
        serverTitle = findViewById(R.id.server_title);
        serverTitle.append("----" + nsd_server_name);
        newNsdServerView = findViewById(R.id.nsd_server_name);
    }


    /**
     * 重置NSD服务器名称
     *
     * @param view
     */
    public void resetServerName(View view) {
        nsd_server_name = newNsdServerView.getText().toString();
        serverTitle.setText("Nsd 服务端----" + nsd_server_name);
        nsdServerManager.registerNsdServer(nsd_server_name);
    }

    public void unRegister(View view) {
        nsdServerManager.unRegisterNsdServer();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        nsdServerManager.unRegisterNsdServer();
    }
}

客户端代码如下：

package aoto.com.nsdclient;


import android.content.Context;
import android.net.nsd.NsdManager;
import android.net.nsd.NsdServiceInfo;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import java.util.ArrayList;


/**
 * @author why
 * @date 2019.04.28
 */
public class NsdClient {

    public static final String TAG = "NsdClientWhy";

    private final String NSD_SERVER_TYPE = "_http._tcp.";
    private NsdManager.DiscoveryListener mDiscoveryListener;
    private NsdManager.ResolveListener mResolverListener;
    public NsdManager mNsdManager;
    private Context mContext;
    private String mServiceName;
    private Handler mHandler;
    private IServerFound mIServerFound;
    private ArrayList<String> discoveryList=new ArrayList<>();
    private ArrayList<String> resolveList=new ArrayList<>();

    /**
     * @param context:上下文对象
     * @param serviceName  客户端扫描 指定的地址
     * @param iServerFound 回调
     */
    public NsdClient(Context context, String serviceName, IServerFound iServerFound) {
        mContext = context;
        mServiceName = serviceName;
        mIServerFound = iServerFound;
    }

    public void startNSDClient(final Handler handler) {

        new Thread(){
            @Override
            public void run() {
                mHandler=handler;
                mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);
                initializeDiscoveryListener();//初始化监听器
                initializeResolveListener();//初始化解析器
                mNsdManager.discoverServices(NSD_SERVER_TYPE, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);//开启扫描
            }
        }.start();
    }

    /**
     * 扫描解析前的 NsdServiceInfo
     */
    private void initializeDiscoveryListener() {
        mDiscoveryListener = new NsdManager.DiscoveryListener() {
            @Override
            public void onStartDiscoveryFailed(String serviceType, int errorCode) {
                mNsdManager.stopServiceDiscovery(this);
                Log.e(TAG, "onStartDiscoveryFailed():");
            }

            @Override
            public void onStopDiscoveryFailed(String serviceType, int errorCode) {
                mNsdManager.stopServiceDiscovery(this);
                Log.e(TAG, "onStopDiscoveryFailed():");
            }

            @Override
            public void onDiscoveryStarted(String serviceType) {
                Log.e(TAG, "onDiscoveryStarted():");

            }

            @Override
            public void onDiscoveryStopped(String serviceType) {
                Log.e(TAG, "onDiscoveryStopped():");
            }

            /**
             *
             * @param serviceInfo
             */
            @Override
            public void onServiceFound(NsdServiceInfo serviceInfo) {
                Log.e(TAG, "onServiceFound: "+serviceInfo );
                discoveryList.add(serviceInfo.toString());
                //根据咱服务器的定义名称，指定解析该 NsdServiceInfo
                if (serviceInfo.getServiceName().equals(mServiceName)) {
                    mNsdManager.resolveService(serviceInfo, mResolverListener);
                }
            }

            @Override
            public void onServiceLost(NsdServiceInfo serviceInfo) {
                Log.e(TAG, "onServiceLost(): serviceInfo=" + serviceInfo);
                discoveryList.remove(serviceInfo.toString());
            }
        };
    }

    /**
     * 解析发现的NsdServiceInfo
     */
    private void initializeResolveListener() {
        mResolverListener = new NsdManager.ResolveListener() {
            @Override
            public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {

            }

            @Override
            public void onServiceResolved(NsdServiceInfo serviceInfo) {
                int port = serviceInfo.getPort();
                String serviceName = serviceInfo.getServiceName();
                String hostAddress = serviceInfo.getHost().getHostAddress();

                Message message=Message.obtain();
                message.what=1;
                message.obj=serviceInfo.toString();
                mHandler.sendMessage(message);

                Log.e(TAG, "onServiceResolved 已解析:" + " host:" + hostAddress + ":" + port + " ----- serviceName: " + serviceName);
                resolveList.add(" host:" + hostAddress + ":" + port );
                //TODO 建立网络连接

            }
        };
    }

    public void stopNSDServer() {
        mNsdManager.stopServiceDiscovery(mDiscoveryListener);
    }

    public interface IServerFound {

        /**
         * 回調 指定解析的结果
         */
        void onServerFound(NsdServiceInfo serviceInfo, int port);

        /**
         * 無合適 回調失敗
         */
        void onServerFail();
    }
}

对外接口管理类：

package aoto.com.nsdclient;

import android.content.Context;
import android.net.nsd.NsdServiceInfo;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

/**
 * author:why
 * created on: 2019/4/28 15:17
 * description:
 */
public class NsdClientManager {

    private static final String TAG = "NsdClientManagerWhy";
    /**
     * Nsd 客户端搜索
     */
    private NsdClient nsdClient;
    private Context context;
    private Handler mHandler;
    private volatile static NsdClientManager mNsdClientManager=null;

    private NsdClientManager(Context context,Handler handler){
        this.context=context;
        this.mHandler=handler;
    }

    /**
     * DCL Single Instance
     * @param context
     * @param handler
     * @return
     */
    public static NsdClientManager getInstance(Context context,Handler handler){
       if(mNsdClientManager==null){
           synchronized (NsdClientManager.class){
               if(mNsdClientManager==null){
                   mNsdClientManager=new NsdClientManager(context,handler);
               }
           }
       }
       return mNsdClientManager;
    }

    /**
     * 通过Nsd 搜索注册过的服务器相关参数进行Socket连接（IP和Port）
     */
    public void searchNsdServer(final String nsdServerName) {
        nsdClient = new NsdClient(context, nsdServerName, new NsdClient.IServerFound() {
            @Override
            public void onServerFound(NsdServiceInfo info, int port) {
                if (info != null) {
                    Log.e(TAG, "onServerFound: "+info.toString() );
                    if (info.getServiceName().equals(nsdServerName)) {
                        //扫描到指定的server停止扫描
                        nsdClient.stopNSDServer();
                    }
                }
            }

            @Override
            public void onServerFail() {

            }
        });

        nsdClient.startNSDClient(mHandler);
    }
}

上面就是逻辑的主要代码，在我们获取到服务端的IP和Port之后，就可以通过网络技术进行连接和通讯了。需要注意的是，上面的搜索NsdService的时候，都是搜索特定名称的，对于服务丢失我也没有在客户端界面做相应的处理，这个可以根据具体的需求来设置和处理。此外，在测试的时候一定要处于同一网络下且不要忘了网络权限哟。结果不便于展示，可以自己下载源码测试调优。

注：欢迎扫码关注

hfut_why

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Android NSD学习与使用

在我们的实际开发中，经常会有点对点通讯的需求，我们知道，通讯的基础是知道彼此的标识，在网络中便是IP，如果具体到某一个应用，还需要端口号。那我们的NSD技术其实就是实现在同一wifi的局域网情况下，实现查询设备网络信息（IP和端口）的。NSD的全称是Network Service Discovery。从名称我们也可以看出来其是通过一个服务实现上述功能--Demo源码下载。那我们就来...
复制链接

扫一扫

专栏目录