react-native-zeroconf 0.16.1 → 0.17.1

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

@@ -2,6 +2,7 @@ package com.balthazargronon.RCTZeroconf.nsd;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
+import android.net.Network;
 import android.net.nsd.NsdManager;
 import android.net.nsd.NsdServiceInfo;
 import android.net.wifi.WifiManager;
@@ -12,6 +13,7 @@ import android.util.Log;
 
 import com.balthazargronon.RCTZeroconf.Zeroconf;
 import com.balthazargronon.RCTZeroconf.ZeroconfModule;
+import com.balthazargronon.RCTZeroconf.ZeroconfOptions;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 
@@ -28,6 +30,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Set;
+import java.util.HashSet;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -59,9 +63,16 @@ public class NsdServiceImpl implements Zeroconf {
 
     private static class NsdScan {
         final String scanId;
+        double resolveTimeoutSeconds = 5;
         NsdManager.DiscoveryListener discoveryListener;
         // Android 14+: services are followed with registerServiceInfoCallback, null before
         @Nullable ServiceInfoCallbacks infoCallbacks;
+        // Service type scans query the network directly, NsdManager can't list types
+        @Nullable ServiceTypesQuery typesQuery;
+        // Types listed, and those answered by the network: the others are this app's own services,
+        // which the system mDNS stack doesn't answer back
+        final Set<String> listedTypes = new HashSet<>();
+        final Set<String> networkTypes = new HashSet<>();
 
         NsdScan(String scanId) {
             this.scanId = scanId;
@@ -69,12 +80,18 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     private static class PendingResolve {
-        final String scanId;
+        @Nullable final String scanId;
         final NsdServiceInfo serviceInfo;
+        // resolveService(): settled instead of emitting events
+        @Nullable final Promise promise;
+        // Seconds before the TIMEOUT error, counted from the start of the resolve
+        final double timeoutSeconds;
 
-        PendingResolve(String scanId, NsdServiceInfo serviceInfo) {
+        PendingResolve(@Nullable String scanId, NsdServiceInfo serviceInfo, @Nullable Promise promise, double timeoutSeconds) {
             this.scanId = scanId;
             this.serviceInfo = serviceInfo;
+            this.promise = promise;
+            this.timeoutSeconds = timeoutSeconds;
         }
     }
 
@@ -85,16 +102,65 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     @Override
-    public void scan(final String scanId, String type, String protocol, String domain) {
+    public void scan(final String scanId, String type, String protocol, String domain, ZeroconfOptions options) {
         final NsdManager nsdManager = getNsdManager();
 
         this.stop(scanId);
-        acquireMulticastLock();
 
         final NsdScan scan = new NsdScan(scanId);
+        scan.resolveTimeoutSeconds = options.resolveTimeoutSeconds;
+        final boolean typesOnly = ZeroconfModule.isServiceTypesScan(type, protocol);
+
+        Network network = null;
+        if (options.networkInterface != null && !typesOnly) {
+            String networkError = checkNetworkSupport(options.networkInterface);
+            network = networkError == null ? ZeroconfModule.findNetwork(reactApplicationContext, options.networkInterface) : null;
+            if (network == null) {
+                sendNetworkError(networkError, options.networkInterface, null, scanId);
+                return;
+            }
+        }
+        acquireMulticastLock();
+
+        if (typesOnly) {
+            scan.typesQuery = new ServiceTypesQuery(options.networkInterface, new ServiceTypesQuery.Listener() {
+                @Override
+                public void onTypeFound(String serviceType) {
+                    synchronized (scan) {
+                        scan.networkTypes.add(serviceType);
+                        if (!scan.listedTypes.add(serviceType)) {
+                            return;
+                        }
+                    }
+                    sendScanEvent(ZeroconfModule.EVENT_FOUND, nameToMap(serviceType), scanId);
+                }
+
+                @Override
+                public void onTypeLost(String serviceType) {
+                    synchronized (scan) {
+                        scan.networkTypes.remove(serviceType);
+                        if (localServiceTypes().contains(serviceType) || !scan.listedTypes.remove(serviceType)) {
+                            return;
+                        }
+                    }
+                    sendScanEvent(ZeroconfModule.EVENT_REMOVE, nameToMap(serviceType), scanId);
+                }
+
+                @Override
+                public void onError(String message) {
+                    zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_EXCEPTION, "Listing service types failed: " + message, null, scanId);
+                }
+            });
+            mScans.put(scanId, scan);
+            scan.typesQuery.start();
+            sendScanEvent(ZeroconfModule.EVENT_START, new WritableNativeMap(), scanId);
+            syncLocalServiceTypes();
+            return;
+        }
 
         if (Build.VERSION.SDK_INT >= 34) {
-            scan.infoCallbacks = new ServiceInfoCallbacks(nsdManager, mCallbackExecutor, new ServiceInfoCallbacks.Listener() {
+            long timeoutMs = (long) (options.resolveTimeoutSeconds * 1000);
+            scan.infoCallbacks = new ServiceInfoCallbacks(nsdManager, mCallbackExecutor, mHandler, timeoutMs, new ServiceInfoCallbacks.Listener() {
                 @Override
                 public void onServiceUpdated(NsdServiceInfo serviceInfo) {
                     if (getHostAddresses(serviceInfo).isEmpty()) {
@@ -107,6 +173,11 @@ public class NsdServiceImpl implements Zeroconf {
                 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);
                 }
+
+                @Override
+                public void onTimeout(NsdServiceInfo serviceInfo) {
+                    sendResolveTimeout(serviceInfo.getServiceName(), scanId);
+                }
             });
         }
 
@@ -144,7 +215,7 @@ public class NsdServiceImpl implements Zeroconf {
                 if (scan.infoCallbacks != null) {
                     scan.infoCallbacks.register(serviceInfo);
                 } else {
-                    enqueueResolve(scanId, serviceInfo);
+                    enqueueResolve(scan, serviceInfo);
                 }
             }
 
@@ -159,8 +230,34 @@ public class NsdServiceImpl implements Zeroconf {
         };
 
         mScans.put(scanId, scan);
-        String serviceType = String.format("_%s._%s.", type, protocol);
-        nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, scan.discoveryListener);
+        // "_ipp._tcp,_printer" browses the _printer subtype
+        String serviceType = options.subtype != null
+                ? ZeroconfOptions.withSubtypes(String.format("_%s._%s", type, protocol), Collections.singletonList(options.subtype))
+                : String.format("_%s._%s.", type, protocol);
+        if (network != null && Build.VERSION.SDK_INT >= 33) {
+            nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, network, mCallbackExecutor, scan.discoveryListener);
+        } else {
+            nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, scan.discoveryListener);
+        }
+    }
+
+    // Choosing the network of NSD requests needs Android 13, null when supported
+    @Nullable
+    private static String checkNetworkSupport(String networkInterface) {
+        return Build.VERSION.SDK_INT >= 33 ? null : ZeroconfModule.ERROR_CODE_UNSUPPORTED;
+    }
+
+    private void sendNetworkError(@Nullable String code, String networkInterface, @Nullable Promise promise, @Nullable String scanId) {
+        boolean unsupported = ZeroconfModule.ERROR_CODE_UNSUPPORTED.equals(code);
+        String errorCode = unsupported ? ZeroconfModule.ERROR_CODE_UNSUPPORTED : ZeroconfModule.ERROR_CODE_UNKNOWN_INTERFACE;
+        String message = unsupported
+                ? "Choosing the network interface needs Android 13 or later with NSD, use DNSSD"
+                : "Unknown network interface " + networkInterface;
+        if (promise != null) {
+            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, errorCode, message, null);
+        } else {
+            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, errorCode, message, null, scanId);
+        }
     }
 
     @Override
@@ -183,10 +280,17 @@ public class NsdServiceImpl implements Zeroconf {
             scan.infoCallbacks.unregisterAll();
         }
 
+        if (scan.typesQuery != null) {
+            scan.typesQuery.stop();
+            // No discovery listener reports it
+            sendScanEvent(ZeroconfModule.EVENT_STOP, new WritableNativeMap(), scanId);
+        }
+
         synchronized (mResolveQueue) {
             Iterator<PendingResolve> iterator = mResolveQueue.iterator();
             while (iterator.hasNext()) {
-                if (iterator.next().scanId.equals(scanId)) {
+                // resolveService() entries have no scan id
+                if (scanId.equals(iterator.next().scanId)) {
                     iterator.remove();
                 }
             }
@@ -222,6 +326,12 @@ public class NsdServiceImpl implements Zeroconf {
         zeroconfModule.sendEvent(getReactApplicationContext(), eventName, body);
     }
 
+    private static WritableMap nameToMap(String name) {
+        WritableMap service = new WritableNativeMap();
+        service.putString(ZeroconfModule.KEY_SERVICE_NAME, name);
+        return service;
+    }
+
     private static WritableMap serviceNameToMap(NsdServiceInfo serviceInfo) {
         WritableMap service = new WritableNativeMap();
         service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
@@ -229,22 +339,119 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     @Override
-    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);
+    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, ZeroconfOptions options, Promise promise) {
+        Network network = null;
+        if (options.networkInterface != null) {
+            String networkError = checkNetworkSupport(options.networkInterface);
+            network = networkError == null ? ZeroconfModule.findNetwork(reactApplicationContext, options.networkInterface) : null;
+            if (network == null) {
+                sendNetworkError(networkError, options.networkInterface, promise, null);
+                return;
+            }
+        }
+        // "_ipp._tcp,_printer,_color" registers the subtypes too
+        String serviceType = options.subtypes.isEmpty()
+                ? String.format("_%s._%s.", type, protocol)
+                : ZeroconfOptions.withSubtypes(String.format("_%s._%s", type, protocol), options.subtypes);
+        ServiceRegistrationListener listener = new ServiceRegistrationListener(promise, serviceType, port, network);
+        getNsdManager().registerService(listener.buildServiceInfo(name, txt), NsdManager.PROTOCOL_DNS_SD, listener);
+    }
 
-        final NsdManager nsdManager = this.getNsdManager();
-        NsdServiceInfo serviceInfo  = new NsdServiceInfo();
+    /**
+     * NsdManager can't update a registration: unregisters and registers again with the new TXT record,
+     * without emitting unpublished and published
+     */
+    @Override
+    public void updateService(String serviceName, final ReadableArray txt, final Promise promise) {
+        final ServiceRegistrationListener previous = mPublishedServices.remove(serviceName);
+        if (previous == null) {
+            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_NOT_PUBLISHED, "Service " + serviceName + " is not published", serviceName);
+            return;
+        }
+        final ServiceRegistrationListener next = new ServiceRegistrationListener(promise, previous.serviceType, previous.port, previous.network);
+        next.announceRegistered = false;
+        final NsdServiceInfo serviceInfo = next.buildServiceInfo(serviceName, txt);
+        previous.announceUnregistered = false;
+        previous.afterUnregistered = () -> getNsdManager().registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, next);
+        getNsdManager().unregisterService(previous);
+    }
+
+    @Override
+    public void resolveService(String name, String type, String protocol, String domain, ZeroconfOptions options, final Promise promise) {
+        final NsdServiceInfo serviceInfo = new NsdServiceInfo();
         serviceInfo.setServiceName(name);
-        serviceInfo.setServiceType(serviceType);
-        serviceInfo.setPort(port);
+        serviceInfo.setServiceType(String.format("_%s._%s", type, protocol));
+        if (options.networkInterface != null) {
+            String networkError = checkNetworkSupport(options.networkInterface);
+            Network network = networkError == null ? ZeroconfModule.findNetwork(reactApplicationContext, options.networkInterface) : null;
+            if (network == null) {
+                sendNetworkError(networkError, options.networkInterface, promise, null);
+                return;
+            }
+            if (Build.VERSION.SDK_INT >= 33) {
+                serviceInfo.setNetwork(network);
+            }
+        }
 
-        for (int i = 0; i < txt.size(); i++) {
-            ReadableArray pair = txt.getArray(i);
-            serviceInfo.setAttribute(pair.getString(0), pair.getString(1));
+        if (Build.VERSION.SDK_INT < 34) {
+            // One resolve at a time before Android 14, shares the queue of the scans
+            synchronized (mResolveQueue) {
+                mResolveQueue.add(new PendingResolve(null, serviceInfo, promise, options.timeoutSeconds));
+            }
+            resolveNext();
+            return;
         }
 
-        nsdManager.registerService(
-                serviceInfo, NsdManager.PROTOCOL_DNS_SD, new ServiceRegistrationListener(promise));
+        final boolean[] settled = { false };
+        final NsdManager nsdManager = getNsdManager();
+        final NsdManager.ServiceInfoCallback[] callback = new NsdManager.ServiceInfoCallback[1];
+        final Runnable finish = () -> {
+            try {
+                nsdManager.unregisterServiceInfoCallback(callback[0]);
+            } catch (IllegalArgumentException e) {
+                // Already unregistered
+            }
+        };
+        callback[0] = new NsdManager.ServiceInfoCallback() {
+            @Override
+            public void onServiceInfoCallbackRegistrationFailed(int errorCode) {
+                synchronized (settled) {
+                    if (settled[0]) return;
+                    settled[0] = true;
+                }
+                ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Resolving service " + name + " failed: " + ZeroconfModule.describeNsdError(errorCode), name);
+            }
+
+            @Override
+            public void onServiceUpdated(NsdServiceInfo updated) {
+                if (getHostAddresses(updated).isEmpty()) {
+                    return;
+                }
+                synchronized (settled) {
+                    if (settled[0]) return;
+                    settled[0] = true;
+                }
+                promise.resolve(serviceInfoToMap(updated));
+                mHandler.post(finish);
+            }
+
+            @Override
+            public void onServiceLost() {
+            }
+
+            @Override
+            public void onServiceInfoCallbackUnregistered() {
+            }
+        };
+        nsdManager.registerServiceInfoCallback(serviceInfo, mCallbackExecutor, callback[0]);
+        mHandler.postDelayed(() -> {
+            synchronized (settled) {
+                if (settled[0]) return;
+                settled[0] = true;
+            }
+            finish.run();
+            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_TIMEOUT, "Resolving service " + name + " failed: timed out", name);
+        }, (long) (options.timeoutSeconds * 1000));
     }
 
     @Override
@@ -262,6 +469,53 @@ public class NsdServiceImpl implements Zeroconf {
         mPublishedServices.remove(serviceName);
         serviceListener.unregisterPromise = promise;
         nsdManager.unregisterService(serviceListener);
+        syncLocalServiceTypes();
+    }
+
+    // "_ipp._tcp,_printer" or "_http._tcp." -> "_ipp._tcp", "_http._tcp"
+    private static String baseServiceType(String serviceType) {
+        int comma = serviceType.indexOf(',');
+        String type = comma >= 0 ? serviceType.substring(0, comma) : serviceType;
+        return type.endsWith(".") ? type.substring(0, type.length() - 1) : type;
+    }
+
+    private Set<String> localServiceTypes() {
+        Set<String> types = new HashSet<>();
+        for (ServiceRegistrationListener listener : mPublishedServices.values()) {
+            types.add(baseServiceType(listener.serviceType));
+        }
+        return types;
+    }
+
+    // Lists the types this app publishes in service type scans, and removes those it no longer publishes
+    private void syncLocalServiceTypes() {
+        Set<String> local = localServiceTypes();
+        for (NsdScan scan : mScans.values()) {
+            if (scan.typesQuery == null) {
+                continue;
+            }
+            List<String> found = new ArrayList<>();
+            List<String> removed = new ArrayList<>();
+            synchronized (scan) {
+                for (String type : local) {
+                    if (scan.listedTypes.add(type)) {
+                        found.add(type);
+                    }
+                }
+                for (String type : new ArrayList<>(scan.listedTypes)) {
+                    if (!local.contains(type) && !scan.networkTypes.contains(type)) {
+                        scan.listedTypes.remove(type);
+                        removed.add(type);
+                    }
+                }
+            }
+            for (String type : found) {
+                sendScanEvent(ZeroconfModule.EVENT_FOUND, nameToMap(type), scan.scanId);
+            }
+            for (String type : removed) {
+                sendScanEvent(ZeroconfModule.EVENT_REMOVE, nameToMap(type), scan.scanId);
+            }
+        }
     }
 
     @Override
@@ -282,13 +536,19 @@ public class NsdServiceImpl implements Zeroconf {
         return reactApplicationContext;
     }
 
-    private void enqueueResolve(String scanId, NsdServiceInfo serviceInfo) {
+    private void enqueueResolve(NsdScan scan, NsdServiceInfo serviceInfo) {
+        // A resolve can't be cancelled before Android 14, so there is no retry: waiting twice as long
+        // matches the total time of the other implementations, which retry once
         synchronized (mResolveQueue) {
-            mResolveQueue.add(new PendingResolve(scanId, serviceInfo));
+            mResolveQueue.add(new PendingResolve(scan.scanId, serviceInfo, null, scan.resolveTimeoutSeconds * 2));
         }
         resolveNext();
     }
 
+    private void sendResolveTimeout(String serviceName, String scanId) {
+        zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_TIMEOUT, "Resolving service " + serviceName + " failed: timed out", serviceName, scanId);
+    }
+
     private void resolveNext() {
         PendingResolve next;
         synchronized (mResolveQueue) {
@@ -298,8 +558,11 @@ public class NsdServiceImpl implements Zeroconf {
             next = mResolveQueue.poll();
             mIsResolving = true;
         }
+        final ZeroResolveListener listener = new ZeroResolveListener(next);
         try {
-            getNsdManager().resolveService(next.serviceInfo, new ZeroResolveListener(next.scanId));
+            getNsdManager().resolveService(next.serviceInfo, listener);
+            // The system keeps the resolve until it answers or fails, the queue waits for it
+            mHandler.postDelayed(listener::timedOut, (long) (next.timeoutSeconds * 1000));
         } catch (Throwable e) {
             Log.e(TAG, "resolveService failed", e);
             String serviceName = next.serviceInfo.getServiceName();
@@ -316,33 +579,76 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     private class ZeroResolveListener implements NsdManager.ResolveListener {
-        private final String scanId;
+        private final PendingResolve pending;
+        @Nullable private final String scanId;
+        @Nullable private final Promise promise;
+        // Settled: answered, failed or timed out. A late answer after the timeout only frees the queue
+        private boolean settled = false;
+
+        ZeroResolveListener(PendingResolve pending) {
+            this.pending = pending;
+            this.scanId = pending.scanId;
+            this.promise = pending.promise;
+        }
 
-        ZeroResolveListener(String scanId) {
-            this.scanId = scanId;
+        private synchronized boolean settle() {
+            if (settled) {
+                return false;
+            }
+            settled = true;
+            return true;
+        }
+
+        void timedOut() {
+            if (!settle()) {
+                return;
+            }
+            String serviceName = pending.serviceInfo.getServiceName();
+            if (promise != null) {
+                ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_TIMEOUT, "Resolving service " + serviceName + " failed: timed out", serviceName);
+            } else if (mScans.containsKey(scanId)) {
+                sendResolveTimeout(serviceName, 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
+                if (!settle()) {
+                    onResolveDone();
+                    return;
+                }
                 synchronized (mResolveQueue) {
-                    mResolveQueue.addFirst(new PendingResolve(scanId, serviceInfo));
+                    mResolveQueue.addFirst(pending);
                     mIsResolving = false;
                 }
                 mHandler.postDelayed(NsdServiceImpl.this::resolveNext, RESOLVE_RETRY_DELAY_MS);
                 return;
             }
-            if (mScans.containsKey(scanId)) {
-                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, "Resolving service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode), serviceInfo.getServiceName(), scanId);
+            if (!settle()) {
+                onResolveDone();
+                return;
+            }
+            String message = "Resolving service " + serviceInfo.getServiceName() + " failed: " + ZeroconfModule.describeNsdError(errorCode);
+            if (promise != null) {
+                ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName());
+            } else if (mScans.containsKey(scanId)) {
+                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_NSD, errorCode, message, serviceInfo.getServiceName(), scanId);
             }
             onResolveDone();
         }
 
         @Override
         public void onServiceResolved(NsdServiceInfo serviceInfo) {
-            // The scan may have been stopped while resolving
-            if (mScans.containsKey(scanId)) {
+            if (!settle()) {
+                onResolveDone();
+                return;
+            }
+            if (promise != null) {
+                promise.resolve(serviceInfoToMap(serviceInfo));
+            } else if (mScans.containsKey(scanId)) {
+                // The scan may have been stopped while resolving
                 sendScanEvent(ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(serviceInfo), scanId);
             }
             onResolveDone();
@@ -352,9 +658,50 @@ public class NsdServiceImpl implements Zeroconf {
     private class ServiceRegistrationListener implements NsdManager.RegistrationListener {
         @Nullable private Promise registerPromise;
         @Nullable private Promise unregisterPromise;
-
-        ServiceRegistrationListener(@Nullable Promise registerPromise) {
+        // What it was registered with, to register it again on updates
+        final String serviceType;
+        final int port;
+        @Nullable final Network network;
+        // Updates replace the registration without emitting unpublished and published
+        boolean announceRegistered = true;
+        boolean announceUnregistered = true;
+        @Nullable Runnable afterUnregistered;
+        // The registration callback doesn't carry the TXT record, report the one registered
+        private final Map<String, String> txt = new java.util.LinkedHashMap<>();
+
+        ServiceRegistrationListener(@Nullable Promise registerPromise, String serviceType, int port, @Nullable Network network) {
             this.registerPromise = registerPromise;
+            this.serviceType = serviceType;
+            this.port = port;
+            this.network = network;
+        }
+
+        NsdServiceInfo buildServiceInfo(String name, ReadableArray txt) {
+            NsdServiceInfo serviceInfo = new NsdServiceInfo();
+            serviceInfo.setServiceName(name);
+            serviceInfo.setServiceType(serviceType);
+            serviceInfo.setPort(port);
+            if (network != null && Build.VERSION.SDK_INT >= 33) {
+                serviceInfo.setNetwork(network);
+            }
+            this.txt.clear();
+            for (int i = 0; i < txt.size(); i++) {
+                ReadableArray pair = txt.getArray(i);
+                serviceInfo.setAttribute(pair.getString(0), pair.getString(1));
+                this.txt.put(pair.getString(0), pair.getString(1));
+            }
+            return serviceInfo;
+        }
+
+        WritableMap registeredToMap(NsdServiceInfo serviceInfo) {
+            WritableMap service = serviceInfoToMap(serviceInfo);
+            WritableMap txtMap = new WritableNativeMap();
+            for (Map.Entry<String, String> entry : txt.entrySet()) {
+                txtMap.putString(entry.getKey(), entry.getValue());
+            }
+            service.putMap(ZeroconfModule.KEY_SERVICE_TXT, txtMap);
+            service.putInt(ZeroconfModule.KEY_SERVICE_PORT, port);
+            return service;
         }
 
         @Override
@@ -365,11 +712,13 @@ public class NsdServiceImpl implements Zeroconf {
 
             final String serviceName = NsdServiceInfo.getServiceName();
             mPublishedServices.put(serviceName, this);
+            syncLocalServiceTypes();
 
-            WritableMap service = serviceInfoToMap(NsdServiceInfo);
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_PUBLISHED, service);
+            if (announceRegistered) {
+                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_PUBLISHED, registeredToMap(NsdServiceInfo));
+            }
             if (registerPromise != null) {
-                registerPromise.resolve(serviceInfoToMap(NsdServiceInfo));
+                registerPromise.resolve(registeredToMap(NsdServiceInfo));
                 registerPromise = null;
             }
         }
@@ -386,10 +735,15 @@ public class NsdServiceImpl implements Zeroconf {
         public void onServiceUnregistered(NsdServiceInfo nsdServiceInfo) {
             // Service has been unregistered.  This only happens when you call
             // NsdManager.unregisterService() and pass in this listener.
-            final WritableMap service = serviceInfoToMap(nsdServiceInfo);
-            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_UNREGISTERED, service);
+            if (announceUnregistered) {
+                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_UNREGISTERED, registeredToMap(nsdServiceInfo));
+            }
+            if (afterUnregistered != null) {
+                afterUnregistered.run();
+                afterUnregistered = null;
+            }
             if (unregisterPromise != null) {
-                unregisterPromise.resolve(serviceInfoToMap(nsdServiceInfo));
+                unregisterPromise.resolve(registeredToMap(nsdServiceInfo));
                 unregisterPromise = null;
             }
         }