android.net.nsd.NsdManager Java Examples

@SuppressLint("NewApi")
@Override
public void onDiscoveryRequestChanged(MediaRouteDiscoveryRequest request) {
    if (android.os.Build.VERSION.SDK_INT < 16) {
        return;
    }

    if (request != null && request.isValid() && request.isActiveScan()) {
        if (request.getSelector() != null) {
            for (String category : request.getSelector().getControlCategories()) {
                if (CastMediaControlIntent.isCategoryForCast(category)) {
                    this.customCategories.add(category);
                }
            }
        }
        if (this.state == State.NOT_DISCOVERING) {
            mNsdManager.discoverServices("_googlecast._tcp.", NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
            this.state = State.DISCOVERY_REQUESTED;
        }
    } else {
        if (this.state == State.DISCOVERING) {
            mNsdManager.stopServiceDiscovery(mDiscoveryListener);
            this.state = State.DISCOVERY_STOP_REQUESTED;
        }
    }
}
 

@Override
protected void onResume() {
    super.onResume();

    mNsdManager.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, this);

    handler = new Handler();
    handler.post(new Runnable() {

        @Override
        public void run() {
            update();

            if (handler != null)
                handler.postDelayed(this, 20);
        }
    });

}
 

private void initPiResolveListener() {
    piResolveListener = new NsdManager.ResolveListener() {
        @Override
        public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
            piSocketConnected = false;
            piConnected = false;
        }

        @Override
        public void onServiceResolved(NsdServiceInfo serviceInfo) {
            mServiceInfo = serviceInfo;
            piIp = mServiceInfo.getHost().getHostAddress();
            piSocketConnected = false;
            piConnected = true;
        }
    };
}
 

private void initializeResolveListener() {
    mResolveListener = new NsdManager.ResolveListener() {
        @Override
        public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
            Log.d(TAG, "Resolve failed");
        }

        @Override
        public void onServiceResolved(NsdServiceInfo serviceInfo) {
            NsdServiceInfo info = serviceInfo;
            // sometimes it returns an IPv6 address...
            if (!info.getHost().getCanonicalHostName().contains(":"))
                listener.onResolved(NsdHelper.this, serviceInfo);
        }
    };
}
 

private void expungeAllRequests() {
    int globalId, clientId, i;
    // TODO: to keep handler responsive, do not clean all requests for that client at once.
    for (i = 0; i < mClientIds.size(); i++) {
        clientId = mClientIds.keyAt(i);
        globalId = mClientIds.valueAt(i);
        mIdToClientInfoMap.remove(globalId);
        if (DBG) Slog.d(TAG, "Terminating client-ID " + clientId +
                " global-ID " + globalId + " type " + mClientRequests.get(clientId));
        switch (mClientRequests.get(clientId)) {
            case NsdManager.DISCOVER_SERVICES:
                stopServiceDiscovery(globalId);
                break;
            case NsdManager.RESOLVE_SERVICE:
                stopResolveService(globalId);
                break;
            case NsdManager.REGISTER_SERVICE:
                unregisterService(globalId);
                break;
            default:
                break;
        }
    }
    mClientIds.clear();
    mClientRequests.clear();
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private static void doDiscovery(Context context) {
    synchronized (nsdToolsLock) {
        if (mNsdManager == null) {
            if(!connectNsdManager(context)) {
                return;
            }
        }

        if (state == NsdState.Init || state == NsdState.Idle) {
            initializeDiscoveryListener();
            state = NsdState.Discovery;
            mNsdManager.discoverServices(SERVICE_TYPE,
                    NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
        }
    }
}
 

void start() {
    mNsdManager = (NsdManager) getSystemService(Context.NSD_SERVICE);
    mNsdManager.discoverServices(Device.SERVICE_TYPE,
            NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);

    mThisDeviceName = new Settings(getContext()).getString(Settings.Key.DEVICE_NAME);
}
 

/**
 * Start discovering services.
 *
 * @param serviceType Service type, eg. "_http._tcp.". Typical names can be obtain from {@link com.rafakob.nsdhelper.NsdType}
 * @param serviceName When service is discovered it will check if it's name contains this text. It is NOT case sensitive.
 */
public void startDiscovery(String serviceType, String serviceName) {
    if (!mDiscoveryStarted) {
        mDiscoveryStarted = true;
        mDiscoveryTimer.start();
        mDiscoveryServiceType = serviceType;
        mDiscoveryServiceName = serviceName;
        mDiscoveryListener = new NsdListenerDiscovery(this);
        mNsdManager.discoverServices(mDiscoveryServiceType, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
    }
}
 

private void onWifiConnected() {
    if (mIsWifiConnected) {
        return;
    }
    mIsWifiConnected = true;
    mIsWifiDisconnected = false;

    closeDiscoveryListenerSafety();
    RxBus.getInstance().post(new WifiConnectedEvent());

    mNsdManager = (NsdManager) getSystemService(NSD_SERVICE);
    mDiscoveryListener = buildDiscoveryListener();
    mNsdManager.discoverServices(SERVICE_TYPE, PROTOCOL_TYPE, mDiscoveryListener);
}
 

@Override
public void onServiceFound(final NsdServiceInfo serviceInfo) {
    mLogger.info("onServiceFound: serviceInfo=" + serviceInfo);
    if (serviceInfo != null) {
        NsdManager nsdManager = mNsdManager;
        if (nsdManager != null) {
            nsdManager.resolveService(serviceInfo, mResolveListener);
        }
    }
}
 

@Override
public synchronized void start(final Context context) {
    if (mIsStarted) {
        return;
    }
    mIsStarted = true;
    mNsdManager = (NsdManager) context.getApplicationContext().getSystemService(Context.NSD_SERVICE);
    if (mNsdManager != null) {
        mNsdManager.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, mNsdDiscoveryListener);
    }
}
 

public synchronized void start() {
    if (mStarted) {
        throw new IllegalStateException();
    }
    if (!mTransitioning) {
        discoverServices(mServiceType, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
        mTransitioning = true;
    }
    mStarted = true;
}
 

@Override
public void onDiscoveryStopped(String serviceType) {
    Log.d(TAG, "onDiscoveryStopped() serviceType = [" + serviceType + "]");
    if (mStarted) {
        discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, this);
    } else {
        mTransitioning = false;
    }
}
 

public synchronized void discover(final DiscoveryListener l) {
    if (mDiscoveryListener != null || mNsdManager == null) {
        return;
    }

    Log.v(TAG, "starting discovery...");
    mUrls.clear();

    ArrayList<String> types = new ArrayList<>();
    types.add("_openhab-server._tcp");
    types.add("_openhab-server-ssl._tcp");

    try {
        for (String serviceType : types) {
            try {
                Log.v(TAG, "starting discovery for " + serviceType + "...");
                mDiscoveryListener = new NsdDiscoveryListener(l);
                mNsdManager.discoverServices(
                        serviceType, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);

                Log.v(TAG, "waiting for results...");
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                Log.e(TAG, "Interrupted while waiting for discovery", e);
            } finally {
                Log.v(TAG, "stopping discovery for " + serviceType + "...");
                stopDiscovery();
            }
        }
    } finally {
        stopDiscovery();
    }

    Log.v(TAG, "discovery finished.");
}
 

public void testStartStop() {
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    verify(mDiscoverResolver, never()).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
    stopDiscoveryOnMainThread();
    verify(mDiscoverResolver).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
}
 

/**
 * Register new service with given serivce name, type and port.
 *
 * @param desiredServiceName Desired service name. If the name already exists in network it will be change to something like 'AppChat (1)'.
 * @param serviceType        Service type.
 * @param port               Service port.
 */
public void registerService(String desiredServiceName, String serviceType, int port) {
    if (port == 0) return;

    mRegisteredServiceInfo = new NsdServiceInfo();
    mRegisteredServiceInfo.setServiceName(desiredServiceName);
    mRegisteredServiceInfo.setServiceType(serviceType);
    mRegisteredServiceInfo.setPort(port);

    mRegistrationListener = new NsdListenerRegistration(this);
    mNsdManager.registerService(mRegisteredServiceInfo, NsdManager.PROTOCOL_DNS_SD, mRegistrationListener);
}
 

/**
 * @param nsdManager  Android {@link NsdManager}.
 * @param nsdListener Service discovery listener.
 */
public NsdHelper(NsdManager nsdManager, NsdListener nsdListener) {
    this.mNsdManager = nsdManager;
    this.mNsdListener = nsdListener;
    this.mDiscoveryTimer = new DiscoveryTimer(this, mDiscoveryTimeout);
    this.mResolveQueue = new ResolveQueue(this);
}
 

private void initPiDiscoveryListener() {
    piDiscoveryListener = new NsdManager.DiscoveryListener() {
        @Override
        public void onStartDiscoveryFailed(String serviceType, int errorCode) {
            mNsdManager.stopServiceDiscovery(this);
        }

        @Override
        public void onStopDiscoveryFailed(String serviceType, int errorCode) {
            mNsdManager.stopServiceDiscovery(this);
        }

        @Override
        public void onDiscoveryStarted(String serviceType) {
        }

        @Override
        public void onDiscoveryStopped(String serviceType) {
        }

        @Override
        public void onServiceFound(NsdServiceInfo serviceInfo) {
            String name = serviceInfo.getServiceName();
            String type = serviceInfo.getServiceType();
            if (type.equals(SERVICE_TYPE) && name.contains("Rucky")) {
                mNsdManager.resolveService(serviceInfo, piResolveListener);
            }
        }

        @Override
        public void onServiceLost(NsdServiceInfo serviceInfo) {
        }
    };
}
 

/**
 * @param context     Context is only needed to create {@link NsdManager} instance.
 * @param nsdListener Service discovery listener.
 */
public NsdHelper(Context context, NsdListener nsdListener) {
    this.mNsdManager = (NsdManager) context.getSystemService(Context.NSD_SERVICE);
    this.mNsdListener = nsdListener;
    this.mDiscoveryTimer = new DiscoveryTimer(this, mDiscoveryTimeout);
    this.mResolveQueue = new ResolveQueue(this);
}
 

public void testDebounceStartStop() {
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    stopDiscoveryOnMainThread();
    verify(mDiscoverResolver, never()).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    verify(mDiscoverResolver).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
}
 

public void testDebounceStartStopStart() {
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    stopDiscoveryOnMainThread();
    startDiscoveryOnMainThread();
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    verify(mDiscoverResolver, times(1)).discoverServices(anyString(), anyInt(), any(NsdManager.DiscoveryListener.class));
    verify(mDiscoverResolver, never()).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
}
 

public void startListening(String serviceType, String serviceName, NsdHelperListener listener) {
        stopListening();
        this.listener = listener;
        this.serviceName = serviceName;
        this.serviceType = serviceType;
        initializeResolveListener();
        initializeDiscoveryListener();
        mNsdManager = (NsdManager) mContext.getSystemService(Context.NSD_SERVICE);
        mNsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
//        mNsdManager.discoverServices("_snapcast-jsonrpc._tcp.", NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
    }
 

public void testDebounceStartStopStartStop() {
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    stopDiscoveryOnMainThread();
    startDiscoveryOnMainThread();
    stopDiscoveryOnMainThread();
    verify(mDiscoverResolver, never()).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    verify(mDiscoverResolver).stopServiceDiscovery(any(NsdManager.DiscoveryListener.class));
}
 

@Override
public boolean onEvent(int code, String raw, String[] cooked) {
    // TODO: NDC translates a message to a callback, we could enhance NDC to
    // directly interact with a state machine through messages
    NativeEvent event = new NativeEvent(code, raw, cooked);
    mNsdStateMachine.sendMessage(NsdManager.NATIVE_DAEMON_EVENT, event);
    return true;
}
 

private void sendNsdStateChangeBroadcast(boolean isEnabled) {
    final Intent intent = new Intent(NsdManager.ACTION_NSD_STATE_CHANGED);
    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
    int nsdState = isEnabled ? NsdManager.NSD_STATE_ENABLED : NsdManager.NSD_STATE_DISABLED;
    intent.putExtra(NsdManager.EXTRA_NSD_STATE, nsdState);
    mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL);
}
 

public void testStartAgainWhileNsdIsStopping() {
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    stopDiscoveryOnMainThread();
    verify(mDiscoverResolver).stopServiceDiscovery(eq(mDiscoveryListener));
    // we call start() again before onDiscoveryStopped() => must restart discovery automatically
    startDiscoveryOnMainThread();
    verify(mDiscoverResolver, times(1)).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStopped(SERVICE_TYPE);
    verify(mDiscoverResolver, times(2)).discoverServices(eq(SERVICE_TYPE), eq(NsdManager.PROTOCOL_DNS_SD), any(NsdManager.DiscoveryListener.class));
    mDiscoveryListener.onDiscoveryStarted(SERVICE_TYPE);
    stopDiscoveryOnMainThread();
    verify(mDiscoverResolver, times(2)).stopServiceDiscovery(eq(mDiscoveryListener));
}
 

@Override
public boolean processMessage(Message msg) {
    switch (msg.what) {
        case NsdManager.ENABLE:
            transitionTo(mEnabledState);
            break;
        default:
            return NOT_HANDLED;
    }
    return HANDLED;
}
 

protected void stopServiceDiscovery(NsdManager.DiscoveryListener listener) {
    ((NsdManager) mContext.getSystemService(Context.NSD_SERVICE)).stopServiceDiscovery(listener);
}
 

protected void discoverServices(String serviceType, int protocol, NsdManager.DiscoveryListener listener) {
    ((NsdManager) mContext.getSystemService(Context.NSD_SERVICE)).discoverServices(serviceType, protocol, listener);
}
 

private void registerService(final int port)
{
    final NsdServiceInfo serviceInfo  = new NsdServiceInfo();
    serviceInfo.setServiceName("ProtectBabyMonitor");
    serviceInfo.setServiceType("_babymonitor._tcp.");
    serviceInfo.setPort(port);

    _registrationListener = new NsdManager.RegistrationListener()
    {
        @Override
        public void onServiceRegistered(NsdServiceInfo nsdServiceInfo) {
            // Save the service name.  Android may have changed it in order to
            // resolve a conflict, so update the name you initially requested
            // with the name Android actually used.
            final String serviceName = nsdServiceInfo.getServiceName();

            Log.i(TAG, "Service name: " + serviceName);

            MonitorActivity.this.runOnUiThread(new Runnable() {
                @Override
                public void run()
                {
                    final TextView statusText = (TextView) findViewById(R.id.textStatus);
                    statusText.setText(R.string.waitingForParent);

                    final TextView serviceText = (TextView) findViewById(R.id.textService);
                    serviceText.setText(serviceName);

                    final TextView portText = (TextView) findViewById(R.id.port);
                    portText.setText(Integer.toString(port));
                }
            });
        }

        @Override
        public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode)
        {
            // Registration failed!  Put debugging code here to determine why.
            Log.e(TAG, "Registration failed: " + errorCode);
        }

        @Override
        public void onServiceUnregistered(NsdServiceInfo arg0)
        {
            // Service has been unregistered.  This only happens when you call
            // NsdManager.unregisterService() and pass in this listener.

            Log.i(TAG, "Unregistering service");
        }

        @Override
        public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode)
        {
            // Unregistration failed.  Put debugging code here to determine why.

            Log.e(TAG, "Unregistration failed: " + errorCode);
        }
    };

    _nsdManager.registerService(
            serviceInfo, NsdManager.PROTOCOL_DNS_SD, _registrationListener);
}