react-native-zeroconf 0.17.0 → 0.17.1

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src=".github/banner.png" alt="react-native-zeroconf: Bonjour / mDNS discovery and publishing for React Native, on iOS, Android, macOS, tvOS and Expo" width="100%">
+  <a href="https://zeroconf.balthazar.dev"><img src=".github/banner.png" alt="react-native-zeroconf: Bonjour / mDNS discovery and publishing for React Native, on iOS, Android, Windows, macOS, tvOS and Expo" width="100%"></a>
 </p>
 
 Find the services other devices advertise on the local network (printers, speakers, cameras, your own servers) and advertise your own, on iOS, Android, macOS, tvOS and Windows.
@@ -13,7 +13,7 @@ yarn add react-native-zeroconf
 cd ios && pod install
 ```
 
-On iOS, declare the service types you use in `NSBonjourServices`, see [Permissions and Setup](https://zeroconf.balthazar.dev/Permissions-and-Setup). Expo works with development builds, see [Installation](https://zeroconf.balthazar.dev/Installation).
+On iOS, declare the service types you use in `NSBonjourServices`, see [Permissions and Setup](https://zeroconf.balthazar.dev/Permissions-and-Setup). Expo works with development builds, see [Installation with Expo](https://zeroconf.balthazar.dev/Installation-Expo).
 
 ## Usage
 

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

@@ -21,6 +21,8 @@ public class ZeroconfOptions {
     @Nullable public String networkInterface;
     /** resolveService: seconds before giving up */
     public double timeoutSeconds = 5;
+    /** Scan: seconds to resolve each service, retried once before a TIMEOUT error */
+    public double resolveTimeoutSeconds = 5;
 
     public static ZeroconfOptions from(@Nullable ReadableMap map) {
         ZeroconfOptions options = new ZeroconfOptions();
@@ -42,6 +44,9 @@ public class ZeroconfOptions {
         if (map.hasKey("timeout") && map.getType("timeout") == ReadableType.Number && map.getDouble("timeout") > 0) {
             options.timeoutSeconds = map.getDouble("timeout");
         }
+        if (map.hasKey("resolveTimeout") && map.getType("resolveTimeout") == ReadableType.Number && map.getDouble("resolveTimeout") > 0) {
+            options.resolveTimeoutSeconds = map.getDouble("resolveTimeout");
+        }
         return options;
     }
 

package/android/src/main/java/com/balthazargronon/RCTZeroconf/dnssd/DnssdImpl.java

@@ -66,6 +66,7 @@ public class DnssdImpl implements Zeroconf {
         final String scanId;
         final boolean typesOnly;
         int ifIndex = DNSSD.ALL_INTERFACES;
+        long resolveTimeoutMs = 5000;
         DNSSDService browse;
         // A service is reported once per network interface, count them so found/remove are emitted once
         final Map<String, Integer> foundInterfaces = new HashMap<>();
@@ -87,6 +88,9 @@ public class DnssdImpl implements Zeroconf {
         int port;
         Map<String, String> txt = new LinkedHashMap<>();
         final Set<String> addresses = new LinkedHashSet<>();
+        // Scans: emitted once an address is known, retried once after a timeout
+        boolean emitted;
+        boolean retried;
 
         Resolve(String name) {
             this.name = name;
@@ -144,6 +148,7 @@ public class DnssdImpl implements Zeroconf {
             return;
         }
         scan.ifIndex = ifIndex;
+        scan.resolveTimeoutMs = (long) (options.resolveTimeoutSeconds * 1000);
         // "_ipp._tcp,_printer" browses the _printer subtype
         String regType = String.format("_%s._%s", type, protocol);
         if (options.subtype != null) {
@@ -254,10 +259,25 @@ public class DnssdImpl implements Zeroconf {
 
     // Resolve: host, port and TXT record, then the host's IPv4 and IPv6 addresses
 
-    private void startResolve(@Nullable final Scan scan, int ifIndex, final String serviceName, String regType, String domain, @Nullable Resolve existing) {
+    private void startResolve(@Nullable final Scan scan, final int ifIndex, final String serviceName, final String regType, final String domain, @Nullable Resolve existing) {
         final Resolve resolve = existing != null ? existing : new Resolve(serviceName);
         if (scan != null) {
             scan.resolves.put(serviceName, resolve);
+            // DNSSD gives up silently after its own timeout, report it before
+            mainHandler.postDelayed(() -> executor.execute(() -> {
+                if (!isCurrent(scan, resolve) || resolve.emitted) {
+                    return;
+                }
+                resolve.stop();
+                // Slow devices can time out, retry once before reporting the error
+                if (!resolve.retried) {
+                    resolve.retried = true;
+                    startResolve(scan, ifIndex, serviceName, regType, domain, resolve);
+                    return;
+                }
+                scan.resolves.remove(serviceName);
+                zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_TIMEOUT, "Resolving service " + serviceName + " failed: timed out", serviceName, scan.scanId);
+            }), scan.resolveTimeoutMs);
         }
         try {
             resolve.operations.add(dnssd.resolve(0, ifIndex, serviceName, regType, domain, new ResolveListener() {
@@ -306,6 +326,7 @@ public class DnssdImpl implements Zeroconf {
                         return;
                     }
                     // Emitted for each address, the first one is usable right away
+                    resolve.emitted = true;
                     sendScanEvent(ZeroconfModule.EVENT_RESOLVE, resolveToMap(resolve), scan.scanId);
                 });
             }

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

@@ -63,6 +63,7 @@ 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;
@@ -83,11 +84,14 @@ public class NsdServiceImpl implements Zeroconf {
         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(@Nullable String scanId, NsdServiceInfo serviceInfo, @Nullable Promise promise) {
+        PendingResolve(@Nullable String scanId, NsdServiceInfo serviceInfo, @Nullable Promise promise, double timeoutSeconds) {
             this.scanId = scanId;
             this.serviceInfo = serviceInfo;
             this.promise = promise;
+            this.timeoutSeconds = timeoutSeconds;
         }
     }
 
@@ -104,6 +108,7 @@ public class NsdServiceImpl implements Zeroconf {
         this.stop(scanId);
 
         final NsdScan scan = new NsdScan(scanId);
+        scan.resolveTimeoutSeconds = options.resolveTimeoutSeconds;
         final boolean typesOnly = ZeroconfModule.isServiceTypesScan(type, protocol);
 
         Network network = null;
@@ -154,7 +159,8 @@ public class NsdServiceImpl implements Zeroconf {
         }
 
         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()) {
@@ -167,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);
+                }
             });
         }
 
@@ -204,7 +215,7 @@ public class NsdServiceImpl implements Zeroconf {
                 if (scan.infoCallbacks != null) {
                     scan.infoCallbacks.register(serviceInfo);
                 } else {
-                    enqueueResolve(scanId, serviceInfo);
+                    enqueueResolve(scan, serviceInfo);
                 }
             }
 
@@ -278,7 +289,8 @@ public class NsdServiceImpl implements Zeroconf {
         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();
                 }
             }
@@ -384,7 +396,7 @@ public class NsdServiceImpl implements Zeroconf {
         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));
+                mResolveQueue.add(new PendingResolve(null, serviceInfo, promise, options.timeoutSeconds));
             }
             resolveNext();
             return;
@@ -524,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, null));
+            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) {
@@ -540,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, next.promise));
+            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();
@@ -558,25 +579,57 @@ public class NsdServiceImpl implements Zeroconf {
     }
 
     private class ZeroResolveListener implements NsdManager.ResolveListener {
+        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(@Nullable String scanId, @Nullable Promise promise) {
-            this.scanId = scanId;
-            this.promise = promise;
+        ZeroResolveListener(PendingResolve pending) {
+            this.pending = pending;
+            this.scanId = pending.scanId;
+            this.promise = pending.promise;
+        }
+
+        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, promise));
+                    mResolveQueue.addFirst(pending);
                     mIsResolving = false;
                 }
                 mHandler.postDelayed(NsdServiceImpl.this::resolveNext, RESOLVE_RETRY_DELAY_MS);
                 return;
             }
+            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());
@@ -588,6 +641,10 @@ public class NsdServiceImpl implements Zeroconf {
 
         @Override
         public void onServiceResolved(NsdServiceInfo serviceInfo) {
+            if (!settle()) {
+                onResolveDone();
+                return;
+            }
             if (promise != null) {
                 promise.resolve(serviceInfoToMap(serviceInfo));
             } else if (mScans.containsKey(scanId)) {

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

@@ -3,6 +3,7 @@ package com.balthazargronon.RCTZeroconf.nsd;
 import android.annotation.TargetApi;
 import android.net.nsd.NsdManager;
 import android.net.nsd.NsdServiceInfo;
+import android.os.Handler;
 import android.util.Log;
 
 import java.util.ArrayList;
@@ -13,6 +14,7 @@ import java.util.concurrent.Executor;
 /**
  * Follows found services with NsdManager.registerServiceInfoCallback (Android 14+) instead of one-shot resolves:
  * services can be followed concurrently, updates (addresses, TXT records) are delivered as they change.
+ * A service without addresses after the resolve timeout is followed again once, then reported with onTimeout.
  * Only loaded on API 34+, so older devices never touch these APIs.
  */
 @TargetApi(34)
@@ -23,34 +25,55 @@ class ServiceInfoCallbacks {
         void onServiceUpdated(NsdServiceInfo serviceInfo);
 
         void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode);
+
+        void onTimeout(NsdServiceInfo serviceInfo);
+    }
+
+    private static class Followed {
+        NsdManager.ServiceInfoCallback callback;
+        Runnable timeout;
+        volatile boolean resolved;
     }
 
     private final NsdManager nsdManager;
     private final Executor executor;
+    private final Handler handler;
+    private final long timeoutMs;
     private final Listener listener;
-    private final Map<String, NsdManager.ServiceInfoCallback> callbacks = new ConcurrentHashMap<>();
+    private final Map<String, Followed> followed = new ConcurrentHashMap<>();
 
-    ServiceInfoCallbacks(NsdManager nsdManager, Executor executor, Listener listener) {
+    ServiceInfoCallbacks(NsdManager nsdManager, Executor executor, Handler handler, long timeoutMs, Listener listener) {
         this.nsdManager = nsdManager;
         this.executor = executor;
+        this.handler = handler;
+        this.timeoutMs = timeoutMs;
         this.listener = listener;
     }
 
     void register(final NsdServiceInfo serviceInfo) {
-        final String name = serviceInfo.getServiceName();
-        if (callbacks.containsKey(name)) {
+        if (followed.containsKey(serviceInfo.getServiceName())) {
             return;
         }
+        follow(serviceInfo, false);
+    }
 
-        NsdManager.ServiceInfoCallback callback = new NsdManager.ServiceInfoCallback() {
+    private void follow(final NsdServiceInfo serviceInfo, final boolean retried) {
+        final String name = serviceInfo.getServiceName();
+        final Followed entry = new Followed();
+        entry.callback = new NsdManager.ServiceInfoCallback() {
             @Override
             public void onServiceInfoCallbackRegistrationFailed(int errorCode) {
-                callbacks.remove(name);
-                listener.onRegistrationFailed(serviceInfo, errorCode);
+                if (followed.remove(name, entry)) {
+                    handler.removeCallbacks(entry.timeout);
+                    listener.onRegistrationFailed(serviceInfo, errorCode);
+                }
             }
 
             @Override
             public void onServiceUpdated(NsdServiceInfo updated) {
+                if (!updated.getHostAddresses().isEmpty()) {
+                    entry.resolved = true;
+                }
                 listener.onServiceUpdated(updated);
             }
 
@@ -63,18 +86,32 @@ class ServiceInfoCallbacks {
             public void onServiceInfoCallbackUnregistered() {
             }
         };
-        callbacks.put(name, callback);
+        entry.timeout = () -> {
+            if (followed.get(name) != entry || entry.resolved) {
+                return;
+            }
+            unregister(name);
+            // Slow devices can time out, follow again once before reporting the error
+            if (!retried) {
+                follow(serviceInfo, true);
+            } else {
+                listener.onTimeout(serviceInfo);
+            }
+        };
+        followed.put(name, entry);
         Log.d(TAG, "Following " + name + " with registerServiceInfoCallback");
-        nsdManager.registerServiceInfoCallback(serviceInfo, executor, callback);
+        nsdManager.registerServiceInfoCallback(serviceInfo, executor, entry.callback);
+        handler.postDelayed(entry.timeout, timeoutMs);
     }
 
     void unregister(String name) {
-        NsdManager.ServiceInfoCallback callback = callbacks.remove(name);
-        if (callback == null) {
+        Followed entry = followed.remove(name);
+        if (entry == null) {
             return;
         }
+        handler.removeCallbacks(entry.timeout);
         try {
-            nsdManager.unregisterServiceInfoCallback(callback);
+            nsdManager.unregisterServiceInfoCallback(entry.callback);
         } catch (IllegalArgumentException e) {
             // Registration failed or was already unregistered
             Log.w(TAG, "unregisterServiceInfoCallback failed", e);
@@ -82,7 +119,7 @@ class ServiceInfoCallbacks {
     }
 
     void unregisterAll() {
-        for (String name : new ArrayList<>(callbacks.keySet())) {
+        for (String name : new ArrayList<>(followed.keySet())) {
             unregister(name);
         }
     }

package/dist/index.js

@@ -330,6 +330,7 @@ class Zeroconf extends _events.EventEmitter {
       }
       this._scanImplType = implType;
       RNZeroconf.scan(this._scanId, type, protocol, domain, implType, nativeOptions({
+        resolveTimeout,
         subtype,
         networkInterface
       }));

package/index.d.ts

@@ -36,7 +36,10 @@ export interface ScanOptions {
   domain?: string
   /** Android only, defaults to `NSD` */
   implType?: ImplType
-  /** iOS only, seconds to try resolving a service before retrying once and giving up. Defaults to `5` */
+  /**
+   * Seconds to try resolving each service before retrying once, then emitting an `error` with code `'TIMEOUT'`.
+   * Defaults to `5`. Android `NSD` before Android 14 can't retry a resolve, the error comes after twice this time
+   */
   resolveTimeout?: number
   /** Only find services registered with this subtype, e.g. `'printer'` */
   subtype?: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-zeroconf",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "A Zeroconf discovery utility for react-native",
   "main": "dist",
   "types": "index.d.ts",

package/src/index.js

@@ -329,7 +329,7 @@ export default class Zeroconf extends EventEmitter {
         protocol,
         domain,
         implType,
-        nativeOptions({ subtype, networkInterface }),
+        nativeOptions({ resolveTimeout, subtype, networkInterface }),
       )
     } else {
       RNZeroconf.scan(

package/windows/RNZeroconf/RNZeroconf.cpp

@@ -140,7 +140,8 @@ void RNZeroconf::Emit(std::wstring_view eventName, React::JSValueObject body) no
 }
 
 void RNZeroconf::scan(std::string scanId, std::string type, std::string protocol, std::string domain, React::JSValue options) noexcept {
-  m_zeroconf->Scan(scanId, Wide(type), Wide(protocol), Wide(domain), StringOption(options, "subtype"), StringOption(options, "networkInterface"));
+  m_zeroconf->Scan(scanId, Wide(type), Wide(protocol), Wide(domain), StringOption(options, "subtype"), StringOption(options, "networkInterface"),
+                    NumberOption(options, "resolveTimeout"));
 }
 
 void RNZeroconf::stop(React::JSValue scanId) noexcept {

package/windows/RNZeroconf/ZeroconfCore.cpp

@@ -38,6 +38,8 @@ struct Resolve : Operation {
   DNS_SERVICE_RESOLVE_REQUEST request{};
   DNS_SERVICE_CANCEL cancel{};
   bool done = false;
+  // Scans: retried once after a timeout
+  bool retried = false;
   ServiceCallback promiseResolve;
   ErrorCallback promiseReject;
 };
@@ -50,6 +52,7 @@ struct Browse : Operation {
   std::wstring queryName;
   bool typesOnly = false;
   ULONG interfaceIndex = 0;
+  DWORD resolveTimeoutMs = 5000;
   DNS_SERVICE_BROWSE_REQUEST request{};
   DNS_SERVICE_CANCEL cancel{};
   // Lower-case PTR target -> name reported to JavaScript
@@ -362,7 +365,8 @@ void Zeroconf::Scan(
     const std::wstring &protocol,
     const std::wstring &domain,
     const std::wstring &subtype,
-    const std::wstring &networkInterface) {
+    const std::wstring &networkInterface,
+    double resolveTimeoutSeconds) {
   After after;
   {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -370,6 +374,7 @@ void Zeroconf::Scan(
 
     auto browse = std::make_shared<Browse>(this);
     browse->scanId = scanId;
+    browse->resolveTimeoutMs = static_cast<DWORD>((resolveTimeoutSeconds > 0 ? resolveTimeoutSeconds : 5) * 1000);
     browse->regType = L"_" + type + L"._" + protocol;
     browse->domain = DomainName(domain);
     browse->typesOnly = type == L"services._dns-sd" && protocol == L"udp";
@@ -490,7 +495,7 @@ void Zeroconf::OnBrowse(const std::shared_ptr<Browse> &browse, DWORD status, PDN
             resolve->queryName = WithoutTrailingDot(record->pName);
             resolve->interfaceIndex = browse->interfaceIndex;
             browse->resolves[instanceKey] = resolve;
-            StartResolve(resolve, after);
+            StartScanResolve(browse, resolve, after);
           }
           continue;
         }
@@ -552,7 +557,7 @@ void Zeroconf::OnBrowse(const std::shared_ptr<Browse> &browse, DWORD status, PDN
           resolve->queryName = target;
           resolve->interfaceIndex = browse->interfaceIndex;
           browse->resolves[key] = resolve;
-          StartResolve(resolve, after);
+          StartScanResolve(browse, resolve, after);
         }
       }
     }
@@ -590,6 +595,54 @@ void Zeroconf::StartResolve(const std::shared_ptr<Resolve> &resolve, After &afte
   });
 }
 
+// Resolves of a scan time out after the scan's resolveTimeout, are retried once, then reported with a TIMEOUT error
+void Zeroconf::StartScanResolve(const std::shared_ptr<Browse> &browse, const std::shared_ptr<Resolve> &resolve, After &after) {
+  StartResolve(resolve, after);
+  if (resolve->done) {
+    return;
+  }
+  std::weak_ptr<Resolve> weak = resolve;
+  auto alive = alive_;
+  DWORD timeout = browse->resolveTimeoutMs;
+  std::thread([this, weak, alive, timeout] {
+    Sleep(timeout);
+    if (!*alive) return;
+    auto expired = weak.lock();
+    if (!expired) return;
+    After timedOut;
+    {
+      std::lock_guard<std::recursive_mutex> lock(mutex_);
+      auto browse = expired->browse.lock();
+      auto current = browse ? browses_.find(browse->scanId) : browses_.end();
+      if (expired->done || current == browses_.end() || current->second != browse) return;
+      auto entry = browse->resolves.find(expired->key);
+      if (entry == browse->resolves.end() || entry->second != expired) return;
+      CancelResolve(expired, timedOut);
+      browse->resolves.erase(entry);
+      if (!expired->retried) {
+        // Slow devices can time out, retry once before reporting the error
+        auto retry = std::make_shared<Resolve>(this);
+        retry->browse = browse;
+        retry->scanId = expired->scanId;
+        retry->name = expired->name;
+        retry->key = expired->key;
+        retry->queryName = expired->queryName;
+        retry->interfaceIndex = expired->interfaceIndex;
+        retry->retried = true;
+        browse->resolves[retry->key] = retry;
+        StartScanResolve(browse, retry, timedOut);
+      } else {
+        Error error = LibraryError(L"TIMEOUT", L"Resolving service " + expired->name + L" failed: timed out", expired->name);
+        std::string scanId = expired->scanId;
+        timedOut.push_back([this, scanId, error] {
+          if (events_.error) events_.error(scanId, error);
+        });
+      }
+    }
+    Run(timedOut);
+  }).detach();
+}
+
 void Zeroconf::CancelResolve(const std::shared_ptr<Resolve> &resolve, After &after) {
   if (resolve->done) {
     return;

package/windows/RNZeroconf/ZeroconfCore.h

@@ -89,7 +89,8 @@ class Zeroconf {
       const std::wstring &protocol,
       const std::wstring &domain,
       const std::wstring &subtype,
-      const std::wstring &networkInterface);
+      const std::wstring &networkInterface,
+      double resolveTimeoutSeconds = 5);
   void Stop(const std::string &scanId);
   void StopAll();
 
@@ -128,6 +129,7 @@ class Zeroconf {
 
   void StopLocked(const std::string &scanId, After &after);
   void StartResolve(const std::shared_ptr<Resolve> &resolve, After &after);
+  void StartScanResolve(const std::shared_ptr<Browse> &browse, const std::shared_ptr<Resolve> &resolve, After &after);
   void CancelResolve(const std::shared_ptr<Resolve> &resolve, After &after);
   void PublishAs(
       const std::wstring &regType,