react-native-zeroconf 0.17.2 → 1.0.0-rc.1

package/android/src/main/jni/mdnsresponder/mDNSPosix/mDNSPosix.c

@@ -505,7 +505,7 @@ mDNSexport int ParseDNSServers(mDNS *m, const char *filePath)
 	{
 	char line[256];
 	char nameserver[16];
-	char keyword[10];
+	char keyword[11];	// "%10s" writes up to 10 characters and the terminator
 	int  numOfServers = 0;
 	FILE *fp = fopen(filePath, "r");
 	if (fp == NULL) return -1;
@@ -1333,6 +1333,107 @@ mDNSexport mStatus mDNSPlatformPosixRefreshInterfaceList(mDNS *const m)
 #pragma mark ***** Locking
 #endif
 
+#ifdef EMBEDDED
+
+// The embedded build enters mDNS core from several threads: the DNS-SDEmbedded thread
+// runs mDNS_Execute() and delivers the callbacks, while the DNSService* calls, and in
+// particular DNSServiceRefDeallocate(), arrive on whatever thread the client uses.
+// mDNS core relies on mDNSPlatformLock() for mutual exclusion between those, so here it
+// is a real lock. It is recursive because the core holds it while it calls back into the
+// client, and the client may call back into the core from there (see mDNS_DropLockBeforeCallback).
+
+#include <pthread.h>
+
+static pthread_mutex_t gCoreLock;
+static pthread_once_t  gCoreLockOnce = PTHREAD_ONCE_INIT;
+
+// The event loop sleeps in select() until the core's next scheduled event. A DNSService* call
+// from another thread changes that schedule (a new question has to be answered now), so when
+// such a call releases the lock, the loop is woken through a pipe it listens to. Otherwise the
+// call would wait for the next timer or the next packet from the network.
+// The pipe is created together with the lock and lives as long as the process, so that the
+// write in mDNSPlatformUnlock() can never hit a descriptor another thread has closed and reused.
+static pthread_t gLoopThread;
+static int       gLoopThreadSet = 0;
+static int       gWakePipe[2]   = { -1, -1 };
+
+static void WakeCallback(int fd, short filter, void *context)
+	{
+	char buffer[64];
+	(void) filter;	// Unused
+	(void) context;	// Unused
+	while (read(fd, buffer, sizeof(buffer)) > 0) { }
+	}
+
+static void InitCoreLockAndWakePipe(void)
+	{
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init(&gCoreLock, &attr);
+	pthread_mutexattr_destroy(&attr);
+	if (pipe(gWakePipe) == 0)
+		{
+		fcntl(gWakePipe[0], F_SETFL, fcntl(gWakePipe[0], F_GETFL, 0) | O_NONBLOCK);
+		fcntl(gWakePipe[1], F_SETFL, fcntl(gWakePipe[1], F_GETFL, 0) | O_NONBLOCK);
+		}
+	else
+		{
+		gWakePipe[0] = gWakePipe[1] = -1;
+		LogMsg("mDNSPosix: pipe() failed (%d), other threads will not wake the event loop", errno);
+		}
+	}
+
+mDNSexport void mDNSPosixEmbeddedLoopStarting(void)
+	{
+	mDNSPlatformLock(mDNSNULL);
+	gLoopThread = pthread_self();
+	gLoopThreadSet = 1;
+	if (gWakePipe[0] >= 0)
+		{
+		mStatus err = mDNSPosixAddFDToEventLoop(gWakePipe[0], WakeCallback, mDNSNULL);
+		if (err) LogMsg("mDNSPosix: cannot listen to the wake-up pipe (%d), other threads will not wake the event loop", err);
+		}
+	mDNSPlatformUnlock(mDNSNULL);
+	}
+
+mDNSexport void mDNSPosixEmbeddedLoopStopping(void)
+	{
+	mDNSPlatformLock(mDNSNULL);
+	if (gWakePipe[0] >= 0)
+		{
+		mDNSPosixRemoveFDFromEventLoop(gWakePipe[0]);
+		WakeCallback(gWakePipe[0], 0, mDNSNULL);	// Drain, for the next loop
+		}
+	gLoopThreadSet = 0;
+	mDNSPlatformUnlock(mDNSNULL);
+	}
+
+mDNSexport void mDNSPosixEmbeddedWakeLoop(void)
+	{
+	if (gWakePipe[1] >= 0)
+		{
+		if (write(gWakePipe[1], "", 1) < 0) { }	// A full pipe means the loop is about to wake anyway
+		}
+	}
+
+mDNSexport void    mDNSPlatformLock   (const mDNS *const m)
+	{
+	(void) m;	// Unused
+	pthread_once(&gCoreLockOnce, InitCoreLockAndWakePipe);
+	pthread_mutex_lock(&gCoreLock);
+	}
+
+mDNSexport void    mDNSPlatformUnlock (const mDNS *const m)
+	{
+	(void) m;	// Unused
+	int fromLoopThread = gLoopThreadSet && pthread_equal(pthread_self(), gLoopThread);
+	pthread_mutex_unlock(&gCoreLock);
+	if (!fromLoopThread) mDNSPosixEmbeddedWakeLoop();
+	}
+
+#else
+
 // On the Posix platform, locking is a no-op because we only ever enter
 // mDNS core on the main thread.
 
@@ -1350,6 +1451,8 @@ mDNSexport void    mDNSPlatformUnlock (const mDNS *const m)
 	(void) m;	// Unused
 	}
 
+#endif // EMBEDDED
+
 #if COMPILER_LIKES_PRAGMA_MARK
 #pragma mark ***** Strings
 #endif

package/android/src/main/jni/mdnsresponder/mDNSPosix/mDNSPosix.h

@@ -81,6 +81,13 @@ extern mStatus mDNSPosixListenForSignalInEventLoop( int signum);
 extern mStatus mDNSPosixIgnoreSignalInEventLoop( int signum);
 extern mStatus mDNSPosixRunEventLoopOnce( mDNS *m, const struct timeval *pTimeout, sigset_t *pSignalsReceived, mDNSBool *pDataDispatched);
 
+#ifdef EMBEDDED
+// The embedded build is driven from several threads, see the locking section of mDNSPosix.c.
+extern void mDNSPosixEmbeddedLoopStarting(void);	// Call on the event loop thread, before running the loop
+extern void mDNSPosixEmbeddedLoopStopping(void);	// Call on the event loop thread, after the loop returned
+extern void mDNSPosixEmbeddedWakeLoop(void);		// Make the loop re-read the schedule and stop flags
+#endif
+
 #ifdef  __cplusplus
     }
 #endif

package/android/src/main/jni/mdnsresponder/mDNSShared/dnssd_clientshim.c

@@ -80,6 +80,7 @@ typedef struct
 	{
 	mDNS_DirectOP_Dispose        *disposefn;
 	DNSServiceRef                aQuery;
+	DNSServiceRef                aaaaQuery;	// react-native-zeroconf: IPv6 addresses too
 	DNSServiceGetAddrInfoReply   callback;
   	void                         *context;
 	} mDNS_DirectOP_GetAddrInfo;
@@ -198,8 +199,9 @@ mDNSlocal void RegCallback(mDNS *const m, ServiceRecordSet *const sr, mStatus re
 
 	if (result == mStatus_NoError)
 		{
+		// react-native-zeroconf: kDNSServiceFlagsAdd marks a registration, as with Apple's implementation
 		if (x->callback)
-			x->callback((DNSServiceRef)x, 0, result, namestr, typestr, domstr, x->context);
+			x->callback((DNSServiceRef)x, kDNSServiceFlagsAdd, result, namestr, typestr, domstr, x->context);
 		}
 	else if (result == mStatus_NameConflict)
 		{
@@ -701,10 +703,10 @@ DNSServiceErrorType DNSServiceQueryRecord
 	x->callback  = callback;
 	x->context   = context;
 
-	x->q.ThisQInterval       = -1;		// So that DNSServiceResolveDispose() knows whether to cancel this question
+	x->q.ThisQInterval       = -1;		// So that DNSServiceQueryRecordDispose() knows whether to cancel this question
 	x->q.InterfaceID         = mDNSPlatformInterfaceIDfromInterfaceIndex(&mDNSStorage, interfaceIndex);
 	x->q.Target              = zeroAddr;
-	MakeDomainNameFromDNSNameString(&x->q.qname, fullname);
+	if (!MakeDomainNameFromDNSNameString(&x->q.qname, fullname)) { mDNSPlatformMemFree(x); err = mStatus_BadParamErr; errormsg = "MakeDomainNameFromDNSNameString"; goto fail; }
 	x->q.qtype               = rrtype;
 	x->q.qclass              = rrclass;
 	x->q.LongLived           = (flags & kDNSServiceFlagsLongLivedQuery) != 0;
@@ -721,7 +723,7 @@ DNSServiceErrorType DNSServiceQueryRecord
 	x->q.QuestionContext     = x;
 
 	err = mDNS_StartQuery(&mDNSStorage, &x->q);
-	if (err) { DNSServiceResolveDispose((mDNS_DirectOP*)x); errormsg = "mDNS_StartQuery"; goto fail; }
+	if (err) { DNSServiceQueryRecordDispose((mDNS_DirectOP*)x); errormsg = "mDNS_StartQuery"; goto fail; }
 
 	// Succeeded: Wrap up and return
 	*sdRef = (DNSServiceRef)x;
@@ -739,6 +741,7 @@ static void DNSServiceGetAddrInfoDispose(mDNS_DirectOP *op)
 	{
 	mDNS_DirectOP_GetAddrInfo *x = (mDNS_DirectOP_GetAddrInfo*)op;
 	if (x->aQuery) DNSServiceRefDeallocate(x->aQuery);
+	if (x->aaaaQuery) DNSServiceRefDeallocate(x->aaaaQuery);
 	mDNSPlatformMemFree(x);
 	}
 
@@ -757,16 +760,27 @@ static void DNSSD_API DNSServiceGetAddrInfoResponse(
 	{
 	mDNS_DirectOP_GetAddrInfo *		x = (mDNS_DirectOP_GetAddrInfo*)inContext;
 	struct sockaddr_in				sa4;
+	struct sockaddr_in6				sa6;
+	const struct sockaddr *			sa = (const struct sockaddr *) &sa4;
 
 	mDNSPlatformMemZero(&sa4, sizeof(sa4));
-	if (inErrorCode == kDNSServiceErr_NoError && inRRType == kDNSServiceType_A)
+	mDNSPlatformMemZero(&sa6, sizeof(sa6));
+	if (inErrorCode == kDNSServiceErr_NoError && inRRType == kDNSServiceType_A && inRDLen == 4)
 		{
 		sa4.sin_family = AF_INET;
 		mDNSPlatformMemCopy(&sa4.sin_addr.s_addr, inRData, 4);
 		}
+	else if (inErrorCode == kDNSServiceErr_NoError && inRRType == kDNSServiceType_AAAA && inRDLen == 16)
+		{
+		// react-native-zeroconf: AAAA answers become IPv6 addresses, as with Apple's implementation
+		sa6.sin6_family = AF_INET6;
+		mDNSPlatformMemCopy(&sa6.sin6_addr, inRData, 16);
+		sa6.sin6_scope_id = inInterfaceIndex;
+		sa = (const struct sockaddr *) &sa6;
+		}
 	
 	x->callback((DNSServiceRef)x, inFlags, inInterfaceIndex, inErrorCode, inFullName, 
-		(const struct sockaddr *) &sa4, inTTL, x->context);
+		sa, inTTL, x->context);
 	}
 
 DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo(
@@ -791,14 +805,25 @@ DNSServiceErrorType DNSSD_API DNSServiceGetAddrInfo(
 	x->callback  = inCallback;
 	x->context   = inContext;
 	x->aQuery    = mDNSNULL;
+	x->aaaaQuery = mDNSNULL;
 	
 	// Start the query.
 	// (It would probably be more efficient to code this using mDNS_StartQuery directly,
 	// instead of wrapping DNSServiceQueryRecord, which then unnecessarily allocates
 	// more memory and then just calls through to mDNS_StartQuery. -- SC June 2010)
-	err = DNSServiceQueryRecord(&x->aQuery, inFlags, inInterfaceIndex, inHostName, kDNSServiceType_A, 
-		kDNSServiceClass_IN, DNSServiceGetAddrInfoResponse, x);
-	if (err) { DNSServiceGetAddrInfoDispose((mDNS_DirectOP*)x); errormsg = "DNSServiceQueryRecord"; goto fail; }
+	// react-native-zeroconf: an A query for IPv4 and an AAAA query for IPv6, both without a protocol
+	if (!inProtocol || (inProtocol & kDNSServiceProtocol_IPv4))
+		{
+		err = DNSServiceQueryRecord(&x->aQuery, inFlags, inInterfaceIndex, inHostName, kDNSServiceType_A, 
+			kDNSServiceClass_IN, DNSServiceGetAddrInfoResponse, x);
+		if (err) { DNSServiceGetAddrInfoDispose((mDNS_DirectOP*)x); errormsg = "DNSServiceQueryRecord"; goto fail; }
+		}
+	if (!inProtocol || (inProtocol & kDNSServiceProtocol_IPv6))
+		{
+		err = DNSServiceQueryRecord(&x->aaaaQuery, inFlags, inInterfaceIndex, inHostName, kDNSServiceType_AAAA, 
+			kDNSServiceClass_IN, DNSServiceGetAddrInfoResponse, x);
+		if (err) { DNSServiceGetAddrInfoDispose((mDNS_DirectOP*)x); errormsg = "DNSServiceQueryRecord"; goto fail; }
+		}
 	
 	*outRef = (DNSServiceRef)x;
 	return(mStatus_NoError);

package/cpp/Backend.cpp

@@ -0,0 +1,16 @@
+#include "Backend.h"
+
+namespace rnzeroconf {
+
+Error LibraryError(const std::string &code, const std::string &message, const std::string &serviceName) {
+  return Error{"RNZeroconf", code, message, serviceName};
+}
+
+std::string SubtypeLabel(const std::string &subtype) {
+  if (subtype.empty() || subtype[0] == '_') {
+    return subtype;
+  }
+  return "_" + subtype;
+}
+
+} // namespace rnzeroconf

package/cpp/Backend.h

@@ -0,0 +1,116 @@
+// What a platform implements: scanning, resolving and publishing on one mDNS stack.
+// No React Native dependency: ZeroconfModule bridges a backend to JavaScript, the native harnesses test it directly.
+// Strings are UTF-8. Callbacks run on the backend's own thread.
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rnzeroconf {
+
+// TXT records as ordered [key, value] pairs
+using TxtPairs = std::vector<std::pair<std::string, std::string>>;
+
+struct Service {
+  std::string name;
+  std::string fullName;
+  std::string host;
+  uint16_t port = 0;
+  std::vector<std::string> addresses;
+  TxtPairs txt;
+};
+
+// { message, code, domain, serviceName } as JavaScript sees it.
+// The code is a string for domain "RNZeroconf" ('TIMEOUT'), the platform's number otherwise (-65555)
+struct Error {
+  std::string domain;
+  std::string code;
+  std::string message;
+  std::string serviceName;
+};
+
+Error LibraryError(const std::string &code, const std::string &message, const std::string &serviceName = "");
+
+using ServiceCallback = std::function<void(const Service &)>;
+using ErrorCallback = std::function<void(const Error &)>;
+
+// Scan events carry the id of the scan they belong to. An error with an empty scanId is not about a scan
+struct Events {
+  std::function<void(const std::string &scanId)> start;
+  std::function<void(const std::string &scanId)> stop;
+  std::function<void(const std::string &scanId, const std::string &name)> found;
+  std::function<void(const std::string &scanId, const std::string &name)> remove;
+  std::function<void(const std::string &scanId, const Service &)> resolved;
+  std::function<void(const Service &)> published;
+  std::function<void(const Service &)> unpublished;
+  std::function<void(const std::string &scanId, const Error &)> error;
+};
+
+struct ScanOptions {
+  // "printer" or "_printer", empty for none
+  std::string subtype;
+  // "en0", empty for every interface
+  std::string networkInterface;
+  // Each found service is resolved for this long, retried once, then reported with a TIMEOUT error
+  double resolveTimeoutSeconds = 5;
+};
+
+struct PublishOptions {
+  std::vector<std::string> subtypes;
+  std::string networkInterface;
+};
+
+struct ResolveOptions {
+  std::string networkInterface;
+  double timeoutSeconds = 5;
+};
+
+class Backend {
+ public:
+  virtual ~Backend() = default;
+
+  // type and protocol without underscore ("http", "tcp"); "services._dns-sd" / "udp" lists the service types.
+  // Starting a scan with the id of a running one replaces it
+  virtual void Scan(
+      const std::string &scanId,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ScanOptions &options) = 0;
+  // Stops the scan with this id, or every scan with an empty one
+  virtual void Stop(const std::string &scanId) = 0;
+
+  virtual void Publish(
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const std::string &name,
+      uint16_t port,
+      const TxtPairs &txt,
+      const PublishOptions &options,
+      ServiceCallback resolve,
+      ErrorCallback reject) = 0;
+  virtual void Unpublish(const std::string &name, ServiceCallback resolve, ErrorCallback reject) = 0;
+  virtual void Update(const std::string &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) = 0;
+
+  virtual void ResolveService(
+      const std::string &name,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ResolveOptions &options,
+      ServiceCallback resolve,
+      ErrorCallback reject) = 0;
+
+  // Stops the scans and unpublishes the services, when the module goes away
+  virtual void Shutdown() = 0;
+};
+
+// "printer" or "_printer" -> "_printer", empty stays empty
+std::string SubtypeLabel(const std::string &subtype);
+
+} // namespace rnzeroconf

package/cpp/ZeroconfModule.cpp

@@ -0,0 +1,280 @@
+#include "ZeroconfModule.h"
+
+#include <utility>
+
+namespace facebook::react {
+
+namespace {
+
+rnzeroconf::TxtPairs ToTxt(const std::vector<ZeroconfTxtEntry> &entries) {
+  rnzeroconf::TxtPairs txt;
+  for (const auto &entry : entries) {
+    txt.emplace_back(entry.key, entry.value);
+  }
+  return txt;
+}
+
+ZeroconfService ToJs(const rnzeroconf::Service &service) {
+  std::vector<ZeroconfTxtEntry> txt;
+  for (const auto &[key, value] : service.txt) {
+    txt.push_back(ZeroconfTxtEntry{key, value});
+  }
+  return ZeroconfService{service.name, service.fullName, service.host, static_cast<double>(service.port), service.addresses, txt};
+}
+
+ZeroconfError ToJs(const rnzeroconf::Error &error) {
+  return ZeroconfError{error.message, error.code, error.domain, error.serviceName};
+}
+
+} // namespace
+
+ZeroconfModule::ZeroconfModule(std::shared_ptr<CallInvoker> jsInvoker, ZeroconfPlatform platform)
+    : NativeZeroconfCxxSpec(std::move(jsInvoker)), platform_(std::move(platform)), emitter_(std::make_shared<Emitter>()) {
+  emitter_->module = this;
+}
+
+ZeroconfModule::~ZeroconfModule() {
+  {
+    std::lock_guard<std::mutex> lock(emitter_->mutex);
+    emitter_->module = nullptr;
+  }
+  {
+    std::lock_guard<std::mutex> lock(activityMutex_);
+    if (active_ && platform_.setActive) {
+      platform_.setActive(false);
+    }
+  }
+  // Stops the scans and unpublishes the services, on reload for example
+  std::lock_guard<std::mutex> lock(backendsMutex_);
+  for (auto &entry : backends_) {
+    entry.second->Shutdown();
+  }
+}
+
+std::shared_ptr<rnzeroconf::Backend> ZeroconfModule::Backend(const std::string &implType) {
+  std::string key = platform_.backendKey ? platform_.backendKey(implType) : implType;
+  std::lock_guard<std::mutex> lock(backendsMutex_);
+  auto found = backends_.find(key);
+  if (found != backends_.end()) {
+    return found->second;
+  }
+  auto backend = platform_.createBackend(key, MakeEvents());
+  backends_[key] = backend;
+  return backend;
+}
+
+rnzeroconf::Events ZeroconfModule::MakeEvents() {
+  std::weak_ptr<Emitter> weak = emitter_;
+  // Runs an emit while the module exists
+  auto with = [weak](const std::function<void(ZeroconfModule &)> &emit) {
+    auto emitter = weak.lock();
+    if (!emitter) {
+      return;
+    }
+    std::lock_guard<std::mutex> lock(emitter->mutex);
+    if (emitter->module) {
+      emit(*emitter->module);
+    }
+  };
+
+  rnzeroconf::Events events;
+  events.start = [with](const std::string &scanId) {
+    with([&](ZeroconfModule &module) { module.emitOnStart(ZeroconfScanEvent{scanId}); });
+  };
+  events.stop = [with](const std::string &scanId) {
+    with([&](ZeroconfModule &module) {
+      // Also when the scan ended by itself, after an error
+      module.Track(Activity::ScanStopped, scanId);
+      module.emitOnStop(ZeroconfScanEvent{scanId});
+    });
+  };
+  events.found = [with](const std::string &scanId, const std::string &name) {
+    with([&](ZeroconfModule &module) { module.emitOnFound(ZeroconfNameEvent{scanId, name}); });
+  };
+  events.remove = [with](const std::string &scanId, const std::string &name) {
+    with([&](ZeroconfModule &module) { module.emitOnRemove(ZeroconfNameEvent{scanId, name}); });
+  };
+  events.resolved = [with](const std::string &scanId, const rnzeroconf::Service &service) {
+    with([&](ZeroconfModule &module) { module.emitOnResolved(ZeroconfResolvedEvent{scanId, ToJs(service)}); });
+  };
+  events.published = [with](const rnzeroconf::Service &service) {
+    with([&](ZeroconfModule &module) {
+      module.Track(Activity::Published, service.name);
+      module.emitOnPublished(ToJs(service));
+    });
+  };
+  events.unpublished = [with](const rnzeroconf::Service &service) {
+    with([&](ZeroconfModule &module) {
+      module.Track(Activity::Unpublished, service.name);
+      module.emitOnUnpublished(ToJs(service));
+    });
+  };
+  events.error = [with](const std::string &scanId, const rnzeroconf::Error &error) {
+    with([&](ZeroconfModule &module) { module.emitOnError(ZeroconfErrorEvent{scanId, ToJs(error)}); });
+  };
+  return events;
+}
+
+AsyncPromise<ZeroconfResult> ZeroconfModule::Settle(
+    jsi::Runtime &rt,
+    const std::function<void(rnzeroconf::ServiceCallback, rnzeroconf::ErrorCallback)> &call,
+    bool active) {
+  AsyncPromise<ZeroconfResult> promise(rt, jsInvoker_);
+  // Publishes and resolves need the network until they settle
+  std::shared_ptr<bool> settled;
+  if (active) {
+    Track(Activity::CallStarted);
+    settled = std::make_shared<bool>(false);
+  }
+  std::weak_ptr<Emitter> weak = emitter_;
+  auto done = [weak, settled] {
+    if (!settled || *settled) {
+      return;
+    }
+    *settled = true;
+    if (auto emitter = weak.lock()) {
+      std::lock_guard<std::mutex> lock(emitter->mutex);
+      if (emitter->module) {
+        emitter->module->Track(Activity::CallSettled);
+      }
+    }
+  };
+  call(
+      [promise, done](const rnzeroconf::Service &service) mutable {
+        done();
+        promise.resolve(ZeroconfResult{ToJs(service), std::nullopt});
+      },
+      [promise, done](const rnzeroconf::Error &error) mutable {
+        done();
+        promise.resolve(ZeroconfResult{std::nullopt, ToJs(error)});
+      });
+  return promise;
+}
+
+void ZeroconfModule::Track(Activity activity, const std::string &key) {
+  std::lock_guard<std::mutex> lock(activityMutex_);
+  switch (activity) {
+    case Activity::ScanStarted:
+      runningScans_.insert(key);
+      break;
+    case Activity::ScanStopped:
+      runningScans_.erase(key);
+      break;
+    case Activity::AllScansStopped:
+      runningScans_.clear();
+      break;
+    case Activity::Published:
+      publishedServices_.insert(key);
+      break;
+    case Activity::Unpublished:
+      publishedServices_.erase(key);
+      break;
+    case Activity::CallStarted:
+      callsInFlight_++;
+      break;
+    case Activity::CallSettled:
+      callsInFlight_--;
+      break;
+  }
+  bool active = !runningScans_.empty() || !publishedServices_.empty() || callsInFlight_ > 0;
+  if (active != active_) {
+    active_ = active;
+    if (platform_.setActive) {
+      platform_.setActive(active);
+    }
+  }
+}
+
+void ZeroconfModule::scan(
+    jsi::Runtime &,
+    std::string scanId,
+    std::string type,
+    std::string protocol,
+    std::string domain,
+    std::string implType,
+    ZeroconfScanOptions options) {
+  rnzeroconf::ScanOptions scanOptions;
+  scanOptions.resolveTimeoutSeconds = options.resolveTimeout.value_or(5);
+  scanOptions.subtype = options.subtype.value_or("");
+  scanOptions.networkInterface = options.networkInterface.value_or("");
+  Track(Activity::ScanStarted, scanId);
+  Backend(implType)->Scan(scanId, type, protocol, domain, scanOptions);
+}
+
+void ZeroconfModule::stop(jsi::Runtime &, std::string scanId, std::string implType) {
+  Track(scanId.empty() ? Activity::AllScansStopped : Activity::ScanStopped, scanId);
+  Backend(implType)->Stop(scanId);
+}
+
+AsyncPromise<ZeroconfResult> ZeroconfModule::registerService(
+    jsi::Runtime &rt,
+    std::string type,
+    std::string protocol,
+    std::string domain,
+    std::string name,
+    double port,
+    std::vector<ZeroconfTxtEntry> txt,
+    std::string implType,
+    ZeroconfPublishOptions options) {
+  rnzeroconf::PublishOptions publishOptions;
+  publishOptions.subtypes = options.subtypes.value_or(std::vector<std::string>{});
+  publishOptions.networkInterface = options.networkInterface.value_or("");
+  auto backend = Backend(implType);
+  return Settle(
+      rt,
+      [&](rnzeroconf::ServiceCallback resolve, rnzeroconf::ErrorCallback reject) {
+        backend->Publish(type, protocol, domain, name, static_cast<uint16_t>(port), ToTxt(txt), publishOptions, std::move(resolve), std::move(reject));
+      },
+      true);
+}
+
+AsyncPromise<ZeroconfResult> ZeroconfModule::updateService(jsi::Runtime &rt, std::string name, std::vector<ZeroconfTxtEntry> txt, std::string implType) {
+  auto backend = Backend(implType);
+  return Settle(rt, [&](rnzeroconf::ServiceCallback resolve, rnzeroconf::ErrorCallback reject) {
+    backend->Update(name, ToTxt(txt), std::move(resolve), std::move(reject));
+  });
+}
+
+AsyncPromise<ZeroconfResult> ZeroconfModule::unregisterService(jsi::Runtime &rt, std::string name, std::string implType) {
+  auto backend = Backend(implType);
+  return Settle(rt, [&](rnzeroconf::ServiceCallback resolve, rnzeroconf::ErrorCallback reject) {
+    backend->Unpublish(name, std::move(resolve), std::move(reject));
+  });
+}
+
+AsyncPromise<ZeroconfResult> ZeroconfModule::resolveService(
+    jsi::Runtime &rt,
+    std::string name,
+    std::string type,
+    std::string protocol,
+    std::string domain,
+    std::string implType,
+    ZeroconfResolveOptions options) {
+  rnzeroconf::ResolveOptions resolveOptions;
+  resolveOptions.timeoutSeconds = options.timeout.value_or(5);
+  resolveOptions.networkInterface = options.networkInterface.value_or("");
+  auto backend = Backend(implType);
+  return Settle(
+      rt,
+      [&](rnzeroconf::ServiceCallback resolve, rnzeroconf::ErrorCallback reject) {
+        backend->ResolveService(name, type, protocol, domain, resolveOptions, std::move(resolve), std::move(reject));
+      },
+      true);
+}
+
+AsyncPromise<ZeroconfAccessResult> ZeroconfModule::checkLocalNetworkAccess(jsi::Runtime &rt, std::string type, double timeout) {
+  AsyncPromise<ZeroconfAccessResult> promise(rt, jsInvoker_);
+  if (!platform_.checkLocalNetworkAccess) {
+    // Nothing to grant on this platform
+    promise.resolve(ZeroconfAccessResult{std::string("granted"), std::nullopt});
+    return promise;
+  }
+  platform_.checkLocalNetworkAccess(
+      type,
+      timeout,
+      [promise](const std::string &status) mutable { promise.resolve(ZeroconfAccessResult{status, std::nullopt}); },
+      [promise](const rnzeroconf::Error &error) mutable { promise.resolve(ZeroconfAccessResult{std::nullopt, ToJs(error)}); });
+  return promise;
+}
+
+} // namespace facebook::react