react-native-zeroconf 0.15.2 → 0.16.1

package/android/src/main/java/com/balthazargronon/RCTZeroconf/ZeroconfModule.java

@@ -3,11 +3,14 @@ package com.balthazargronon.RCTZeroconf;
 
 import android.util.Log;
 
+import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 import javax.annotation.Nullable;
@@ -35,6 +38,15 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     public static final String KEY_SERVICE_PORT = "port";
     public static final String KEY_SERVICE_ADDRESSES = "addresses";
     public static final String KEY_SERVICE_TXT = "txt";
+    // Id of the JS instance whose scan an event belongs to
+    public static final String KEY_SCAN_ID = "scanId";
+
+    // Where an error code comes from
+    public static final String ERROR_DOMAIN_NSD = "NsdManager";
+    public static final String ERROR_DOMAIN_DNSSD = "DNSSD";
+    public static final String ERROR_DOMAIN_LIBRARY = "RNZeroconf";
+    public static final String ERROR_CODE_EXCEPTION = "EXCEPTION";
+    public static final String ERROR_CODE_NOT_PUBLISHED = "NOT_PUBLISHED";
 
     private ZeroConfImplFactory zeroConfFactory;
 
@@ -49,22 +61,30 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void scan(String type, String protocol, String domain, String implType) {
+    public void scan(String scanId, String type, String protocol, String domain, String implType) {
         try {
-            getZeroconfImpl(implType).scan(type, protocol, domain);
+            getZeroconfImpl(implType).scan(scanId, type, protocol, domain);
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
-            sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Exception During Scan: " + e.getMessage());
+            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception during scan: " + e.getMessage(), null, scanId);
         }
     }
 
+    /**
+     * Stops the scan with this id, or every scan of the implementation without one
+     */
     @ReactMethod
-    public void stop(String implType) {
+    public void stop(@Nullable String scanId, String implType) {
         try {
-            getZeroconfImpl(implType).stop();
+            Zeroconf impl = getZeroconfImpl(implType);
+            if (scanId == null || scanId.isEmpty()) {
+                impl.stopAll();
+            } else {
+                impl.stop(scanId);
+            }
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
-            sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Exception During Stop: " + e.getMessage());
+            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception during stop: " + e.getMessage(), null, scanId);
         }
     }
 
@@ -73,22 +93,26 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, String implType) {
+    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, String implType, Promise promise) {
         try {
-            getZeroconfImpl(implType).registerService(type, protocol, domain, name, port, txt);
+            getZeroconfImpl(implType).registerService(type, protocol, domain, name, port, txt, promise);
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
-            sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Exception During Register Service: " + e.getMessage());
+            String message = "Exception while registering service: " + e.getMessage();
+            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
+            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
         }
     }
 
     @ReactMethod
-    public void unregisterService(String serviceName, String implType) {
+    public void unregisterService(String serviceName, String implType, Promise promise) {
         try {
-            getZeroconfImpl(implType).unregisterService(serviceName);
+            getZeroconfImpl(implType).unregisterService(serviceName, promise);
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
-            sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Exception During Unregister Service: " + e.getMessage());
+            String message = "Exception while unregistering service: " + e.getMessage();
+            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, serviceName);
+            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, serviceName);
         }
     }
 
@@ -105,6 +129,64 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
         }
     }
 
+    /**
+     * Emits an error event as { message, code, domain, serviceName }
+     *
+     * @param code an Integer for platform error codes, a String for the library's own
+     */
+    public void sendError(String domain, Object code, String message, @Nullable String serviceName) {
+        sendError(domain, code, message, serviceName, null);
+    }
+
+    /**
+     * @param scanId the scan the error belongs to, null for errors not related to a scan
+     */
+    public void sendError(String domain, Object code, String message, @Nullable String serviceName, @Nullable String scanId) {
+        WritableMap error = buildError(domain, code, message, serviceName);
+        if (scanId != null) {
+            error.putString(KEY_SCAN_ID, scanId);
+        }
+        sendEvent(getReactApplicationContext(), EVENT_ERROR, error);
+    }
+
+    /**
+     * Rejects a promise with the same { message, code, domain, serviceName } shape as error events, in userInfo
+     */
+    public static void reject(@Nullable Promise promise, String domain, Object code, String message, @Nullable String serviceName) {
+        if (promise != null) {
+            promise.reject(String.valueOf(code), message, buildError(domain, code, message, serviceName));
+        }
+    }
+
+    private static WritableMap buildError(String domain, Object code, String message, @Nullable String serviceName) {
+        WritableMap error = new WritableNativeMap();
+        error.putString("message", message);
+        error.putString("domain", domain);
+        if (code instanceof Integer) {
+            error.putInt("code", (Integer) code);
+        } else {
+            error.putString("code", String.valueOf(code));
+        }
+        if (serviceName != null) {
+            error.putString("serviceName", serviceName);
+        }
+        return error;
+    }
+
+    /**
+     * Readable description of an NsdManager failure code
+     */
+    public static String describeNsdError(int errorCode) {
+        switch (errorCode) {
+            case 0: return "internal error"; // FAILURE_INTERNAL_ERROR
+            case 3: return "operation already active"; // FAILURE_ALREADY_ACTIVE
+            case 4: return "maximum number of requests reached"; // FAILURE_MAX_LIMIT
+            case 5: return "operation not running"; // FAILURE_OPERATION_NOT_RUNNING (API 34)
+            case 6: return "bad parameters"; // FAILURE_BAD_PARAMETERS (API 34)
+            default: return "error " + errorCode;
+        }
+    }
+
     // Called on teardown by current React Native versions.
     // No @Override so it still compiles against versions that don't declare it.
     public void invalidate() {
@@ -120,7 +202,7 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     private void teardown() {
         try {
             for (Zeroconf impl : zeroConfFactory.getCreatedImpls()) {
-                impl.stop();
+                impl.stopAll();
                 impl.unregisterAllServices();
             }
         } catch (Throwable e) {

package/android/src/main/java/com/balthazargronon/RCTZeroconf/nsd/NsdServiceImpl.java

@@ -12,6 +12,7 @@ import android.util.Log;
 
 import com.balthazargronon.RCTZeroconf.Zeroconf;
 import com.balthazargronon.RCTZeroconf.ZeroconfModule;
+import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 
 import com.facebook.react.bridge.ReadableArray;
@@ -25,123 +26,210 @@ import java.nio.charset.StandardCharsets;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import javax.annotation.Nullable;
 
 public class NsdServiceImpl implements Zeroconf {
     private static final String TAG = "NsdServiceImpl";
     private static final long RESOLVE_RETRY_DELAY_MS = 100;
 
     private NsdManager mNsdManager;
-    private NsdManager.DiscoveryListener mDiscoveryListener;
+    // Reference counted: acquired once per running scan
     private WifiManager.MulticastLock multicastLock;
-    private Map<String, NsdManager.RegistrationListener> mPublishedServices;
+    private Map<String, ServiceRegistrationListener> mPublishedServices;
     private ZeroconfModule zeroconfModule;
     private ReactApplicationContext reactApplicationContext;
 
-    // NsdManager can only resolve one service at a time before API 34, so resolves are queued
-    private final ArrayDeque<NsdServiceInfo> mResolveQueue = new ArrayDeque<>();
+    // Running scans, keyed by the id of the JS instance that started them
+    private final Map<String, NsdScan> mScans = new ConcurrentHashMap<>();
+    // Not the main thread: serviceInfoToMap can do a blocking reverse lookup for the host name
+    private final ExecutorService mCallbackExecutor = Executors.newSingleThreadExecutor();
+
+    // NsdManager can only resolve one service at a time before API 34, so resolves are queued across scans
+    private final ArrayDeque<PendingResolve> mResolveQueue = new ArrayDeque<>();
     private boolean mIsResolving = false;
     private final Handler mHandler = new Handler(Looper.getMainLooper());
 
+    private static class NsdScan {
+        final String scanId;
+        NsdManager.DiscoveryListener discoveryListener;
+        // Android 14+: services are followed with registerServiceInfoCallback, null before
+        @Nullable ServiceInfoCallbacks infoCallbacks;
+
+        NsdScan(String scanId) {
+            this.scanId = scanId;
+        }
+    }
+
+    private static class PendingResolve {
+        final String scanId;
+        final NsdServiceInfo serviceInfo;
+
+        PendingResolve(String scanId, NsdServiceInfo serviceInfo) {
+            this.scanId = scanId;
+            this.serviceInfo = serviceInfo;
+        }
+    }
+
     public NsdServiceImpl(ZeroconfModule zeroconfModule, ReactApplicationContext reactApplicationContext) {
         this.zeroconfModule = zeroconfModule;
         this.reactApplicationContext = reactApplicationContext;
-        mPublishedServices = new ConcurrentHashMap<String, NsdManager.RegistrationListener>();
+        mPublishedServices = new ConcurrentHashMap<String, ServiceRegistrationListener>();
     }
 
     @Override
-    public void scan(String type, String protocol, String domain) {
-        if (mNsdManager == null) {
-            mNsdManager = (NsdManager) getReactApplicationContext().getSystemService(Context.NSD_SERVICE);
-        }
+    public void scan(final String scanId, String type, String protocol, String domain) {
+        final NsdManager nsdManager = getNsdManager();
 
-        this.stop();
+        this.stop(scanId);
+        acquireMulticastLock();
 
-        if (multicastLock == null) {
-            @SuppressLint("WifiManagerLeak") WifiManager wifi = (WifiManager) getReactApplicationContext().getSystemService(Context.WIFI_SERVICE);
-            multicastLock = wifi.createMulticastLock("multicastLock");
-            multicastLock.setReferenceCounted(true);
-            multicastLock.acquire();
+        final NsdScan scan = new NsdScan(scanId);
+
+        if (Build.VERSION.SDK_INT >= 34) {
+            scan.infoCallbacks = new ServiceInfoCallbacks(nsdManager, mCallbackExecutor, new ServiceInfoCallbacks.Listener() {
+                @Override
+                public void onServiceUpdated(NsdServiceInfo serviceInfo) {
+                    if (getHostAddresses(serviceInfo).isEmpty()) {
+                        return;
+                    }
+                    sendScanEvent(ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(serviceInfo), scanId);
+                }
+
+                @Override
+                public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
+                    zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Resolving service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode), serviceInfo.getServiceName(), scanId);
+                }
+            });
         }
 
-        mDiscoveryListener = new NsdManager.DiscoveryListener() {
+        scan.discoveryListener = new NsdManager.DiscoveryListener() {
             @Override
             public void onStartDiscoveryFailed(String serviceType, int errorCode) {
-                String error = "Starting service discovery failed with code: " + errorCode;
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Starting service discovery failed: " + ZeroconfModule.describeNsdError(errorCode), null, scanId);
+                // The discovery never started, nothing to stop
+                if (mScans.remove(scanId, scan)) {
+                    releaseMulticastLock();
+                }
             }
 
             @Override
             public void onStopDiscoveryFailed(String serviceType, int errorCode) {
-                String error = "Stopping service discovery failed with code: " + errorCode;
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Stopping service discovery failed: " + ZeroconfModule.describeNsdError(errorCode), null, scanId);
             }
 
             @Override
             public void onDiscoveryStarted(String serviceType) {
-                Log.d(TAG, "Discovery started");
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_START, null);
+                Log.d(TAG, "Discovery started for " + scanId);
+                sendScanEvent(ZeroconfModule.EVENT_START, new WritableNativeMap(), scanId);
             }
 
             @Override
             public void onDiscoveryStopped(String serviceType) {
-                Log.d(TAG, "Discovery stopped");
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_STOP, null);
+                Log.d(TAG, "Discovery stopped for " + scanId);
+                sendScanEvent(ZeroconfModule.EVENT_STOP, new WritableNativeMap(), scanId);
             }
 
             @Override
             public void onServiceFound(NsdServiceInfo serviceInfo) {
                 Log.d(TAG, "Service found");
-                WritableMap service = new WritableNativeMap();
-                service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
-
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_FOUND, service);
-                enqueueResolve(serviceInfo);
+                sendScanEvent(ZeroconfModule.EVENT_FOUND, serviceNameToMap(serviceInfo), scanId);
+                if (scan.infoCallbacks != null) {
+                    scan.infoCallbacks.register(serviceInfo);
+                } else {
+                    enqueueResolve(scanId, serviceInfo);
+                }
             }
 
             @Override
             public void onServiceLost(NsdServiceInfo serviceInfo) {
                 Log.d(TAG, "Service lost");
-                WritableMap service = new WritableNativeMap();
-                service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_REMOVE, service);
+                sendScanEvent(ZeroconfModule.EVENT_REMOVE, serviceNameToMap(serviceInfo), scanId);
+                if (scan.infoCallbacks != null) {
+                    scan.infoCallbacks.unregister(serviceInfo.getServiceName());
+                }
             }
         };
 
+        mScans.put(scanId, scan);
         String serviceType = String.format("_%s._%s.", type, protocol);
-        mNsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, mDiscoveryListener);
+        nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, scan.discoveryListener);
     }
 
     @Override
-    public void stop() {
-        if (mDiscoveryListener != null && mNsdManager != null) {
+    public void stop(String scanId) {
+        NsdScan scan = mScans.remove(scanId);
+        if (scan == null) {
+            return;
+        }
+
+        if (scan.discoveryListener != null && mNsdManager != null) {
             try {
-                mNsdManager.stopServiceDiscovery(mDiscoveryListener);
+                mNsdManager.stopServiceDiscovery(scan.discoveryListener);
             } catch (IllegalArgumentException e) {
                 // Listener was never registered or already unregistered (e.g. discovery failed to start)
                 Log.w(TAG, "stopServiceDiscovery failed", e);
             }
         }
 
-        mHandler.removeCallbacksAndMessages(null);
+        if (scan.infoCallbacks != null) {
+            scan.infoCallbacks.unregisterAll();
+        }
+
         synchronized (mResolveQueue) {
-            mResolveQueue.clear();
-            mIsResolving = false;
+            Iterator<PendingResolve> iterator = mResolveQueue.iterator();
+            while (iterator.hasNext()) {
+                if (iterator.next().scanId.equals(scanId)) {
+                    iterator.remove();
+                }
+            }
+        }
+
+        releaseMulticastLock();
+    }
+
+    @Override
+    public void stopAll() {
+        for (String scanId : new ArrayList<>(mScans.keySet())) {
+            stop(scanId);
+        }
+    }
+
+    private void acquireMulticastLock() {
+        if (multicastLock == null) {
+            @SuppressLint("WifiManagerLeak") WifiManager wifi = (WifiManager) getReactApplicationContext().getSystemService(Context.WIFI_SERVICE);
+            multicastLock = wifi.createMulticastLock("multicastLock");
+            multicastLock.setReferenceCounted(true);
         }
+        multicastLock.acquire();
+    }
 
-        if (multicastLock != null) {
+    private void releaseMulticastLock() {
+        if (multicastLock != null && multicastLock.isHeld()) {
             multicastLock.release();
         }
+    }
 
-        mDiscoveryListener = null;
-        multicastLock = null;
+    private void sendScanEvent(String eventName, WritableMap body, String scanId) {
+        body.putString(ZeroconfModule.KEY_SCAN_ID, scanId);
+        zeroconfModule.sendEvent(getReactApplicationContext(), eventName, body);
+    }
+
+    private static WritableMap serviceNameToMap(NsdServiceInfo serviceInfo) {
+        WritableMap service = new WritableNativeMap();
+        service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
+        return service;
     }
 
     @Override
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt) {
+    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, Promise promise) {
         String serviceType = String.format("_%s._%s.", type, protocol);
 
         final NsdManager nsdManager = this.getNsdManager();
@@ -156,26 +244,30 @@ public class NsdServiceImpl implements Zeroconf {
         }
 
         nsdManager.registerService(
-                serviceInfo, NsdManager.PROTOCOL_DNS_SD, new ServiceRegistrationListener());
+                serviceInfo, NsdManager.PROTOCOL_DNS_SD, new ServiceRegistrationListener(promise));
     }
 
     @Override
-    public void unregisterService(String serviceName) {
+    public void unregisterService(String serviceName, @Nullable Promise promise) {
 
         final NsdManager nsdManager = this.getNsdManager();
 
-        NsdManager.RegistrationListener serviceListener = mPublishedServices.get(serviceName);
+        ServiceRegistrationListener serviceListener = mPublishedServices.get(serviceName);
 
-        if (serviceListener != null) {
-            mPublishedServices.remove(serviceName);
-            nsdManager.unregisterService(serviceListener);
+        if (serviceListener == null) {
+            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_NOT_PUBLISHED, "Service " + serviceName + " is not published", serviceName);
+            return;
         }
+
+        mPublishedServices.remove(serviceName);
+        serviceListener.unregisterPromise = promise;
+        nsdManager.unregisterService(serviceListener);
     }
 
     @Override
     public void unregisterAllServices() {
         for (String serviceName : new ArrayList<>(mPublishedServices.keySet())) {
-            unregisterService(serviceName);
+            unregisterService(serviceName, null);
         }
     }
 
@@ -190,15 +282,15 @@ public class NsdServiceImpl implements Zeroconf {
         return reactApplicationContext;
     }
 
-    private void enqueueResolve(NsdServiceInfo serviceInfo) {
+    private void enqueueResolve(String scanId, NsdServiceInfo serviceInfo) {
         synchronized (mResolveQueue) {
-            mResolveQueue.add(serviceInfo);
+            mResolveQueue.add(new PendingResolve(scanId, serviceInfo));
         }
         resolveNext();
     }
 
     private void resolveNext() {
-        NsdServiceInfo next;
+        PendingResolve next;
         synchronized (mResolveQueue) {
             if (mIsResolving || mResolveQueue.isEmpty()) {
                 return;
@@ -207,10 +299,11 @@ public class NsdServiceImpl implements Zeroconf {
             mIsResolving = true;
         }
         try {
-            getNsdManager().resolveService(next, new ZeroResolveListener());
+            getNsdManager().resolveService(next.serviceInfo, new ZeroResolveListener(next.scanId));
         } catch (Throwable e) {
             Log.e(TAG, "resolveService failed", e);
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Resolving service failed: " + e.getMessage());
+            String serviceName = next.serviceInfo.getServiceName();
+            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_EXCEPTION, "Resolving service " + serviceName + " failed: " + e.getMessage(), serviceName, next.scanId);
             onResolveDone();
         }
     }
@@ -223,31 +316,46 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     private class ZeroResolveListener implements NsdManager.ResolveListener {
+        private final String scanId;
+
+        ZeroResolveListener(String scanId) {
+            this.scanId = scanId;
+        }
+
         @Override
         public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
             if (errorCode == NsdManager.FAILURE_ALREADY_ACTIVE) {
                 // Another resolve (possibly from another app or listener) is in flight: retry shortly
                 synchronized (mResolveQueue) {
-                    mResolveQueue.addFirst(serviceInfo);
+                    mResolveQueue.addFirst(new PendingResolve(scanId, serviceInfo));
                     mIsResolving = false;
                 }
                 mHandler.postDelayed(NsdServiceImpl.this::resolveNext, RESOLVE_RETRY_DELAY_MS);
                 return;
             }
-            String error = "Resolving service failed with code: " + errorCode;
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+            if (mScans.containsKey(scanId)) {
+                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Resolving service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode), serviceInfo.getServiceName(), scanId);
+            }
             onResolveDone();
         }
 
         @Override
         public void onServiceResolved(NsdServiceInfo serviceInfo) {
-            WritableMap service = serviceInfoToMap(serviceInfo);
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_RESOLVE, service);
+            // The scan may have been stopped while resolving
+            if (mScans.containsKey(scanId)) {
+                sendScanEvent(ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(serviceInfo), scanId);
+            }
             onResolveDone();
         }
     }
 
     private class ServiceRegistrationListener implements NsdManager.RegistrationListener {
+        @Nullable private Promise registerPromise;
+        @Nullable private Promise unregisterPromise;
+
+        ServiceRegistrationListener(@Nullable Promise registerPromise) {
+            this.registerPromise = registerPromise;
+        }
 
         @Override
         public void onServiceRegistered(NsdServiceInfo NsdServiceInfo) {
@@ -260,12 +368,18 @@ public class NsdServiceImpl implements Zeroconf {
 
             WritableMap service = serviceInfoToMap(NsdServiceInfo);
             zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_PUBLISHED, service);
+            if (registerPromise != null) {
+                registerPromise.resolve(serviceInfoToMap(NsdServiceInfo));
+                registerPromise = null;
+            }
         }
 
         @Override
         public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
-            String error = "Registering service " + serviceInfo.getServiceName() + " failed with code: " + errorCode;
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+            String message = "Registering service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode);
+            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName());
+            ZeroconfModule.reject(registerPromise, ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName());
+            registerPromise = null;
         }
 
         @Override
@@ -274,12 +388,18 @@ public class NsdServiceImpl implements Zeroconf {
             // NsdManager.unregisterService() and pass in this listener.
             final WritableMap service = serviceInfoToMap(nsdServiceInfo);
             zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_UNREGISTERED, service);
+            if (unregisterPromise != null) {
+                unregisterPromise.resolve(serviceInfoToMap(nsdServiceInfo));
+                unregisterPromise = null;
+            }
         }
 
         @Override
         public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
-            String error = "Unregistering service " + serviceInfo.getServiceName() + " failed with code: " + errorCode;
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+            String message = "Unregistering service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode);
+            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName());
+            ZeroconfModule.reject(unregisterPromise, ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName());
+            unregisterPromise = null;
         }
     }