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

package/cpp/android/NsdBackend.cpp

@@ -0,0 +1,462 @@
+#include "NsdBackend.h"
+
+#include <android/log.h>
+
+#include <map>
+#include <mutex>
+#include <optional>
+#include <utility>
+
+using namespace facebook;
+
+namespace rnzeroconf {
+
+namespace {
+
+constexpr const char *kHostClass = "com/balthazargronon/RCTZeroconf/NsdHost";
+constexpr const char *kPromiseClass = "com/balthazargronon/RCTZeroconf/NsdPromise";
+constexpr const char *kPayloadClass = "com/balthazargronon/RCTZeroconf/NsdPayload";
+
+// What the Java side's handles point to: integers looked up here, so a late callback finds nothing
+// instead of a freed object
+struct Registry {
+  std::mutex mutex;
+  int64_t next = 0;
+  std::map<int64_t, Events> hosts;
+  std::map<int64_t, std::pair<ServiceCallback, ErrorCallback>> promises;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+// Runs with the app's class loader, which finds the library's classes from any thread
+template <typename F>
+void WithEnv(F &&f) {
+  jni::ThreadScope::WithClassLoader([&] { f(jni::Environment::current()); });
+}
+
+bool ClearException(JNIEnv *env, const char *what) {
+  if (!env->ExceptionCheck()) {
+    return false;
+  }
+  __android_log_print(ANDROID_LOG_ERROR, "RNZeroconf", "Java exception in %s", what);
+  env->ExceptionDescribe();
+  env->ExceptionClear();
+  return true;
+}
+
+jclass GlobalClass(const char *name) {
+  return static_cast<jclass>(jni::Environment::current()->NewGlobalRef(jni::findClassLocal(name).get()));
+}
+
+jclass HostClass() {
+  static jclass cls = GlobalClass(kHostClass);
+  return cls;
+}
+
+jclass PromiseClass() {
+  static jclass cls = GlobalClass(kPromiseClass);
+  return cls;
+}
+
+jclass StringClass() {
+  static jclass cls = GlobalClass("java/lang/String");
+  return cls;
+}
+
+std::string ToString(jstring value) {
+  return value ? jni::wrap_alias(value)->toStdString() : std::string();
+}
+
+std::vector<std::string> ToStrings(JNIEnv *env, jobjectArray array) {
+  std::vector<std::string> strings;
+  if (!array) {
+    return strings;
+  }
+  jsize length = env->GetArrayLength(array);
+  for (jsize i = 0; i < length; i++) {
+    auto element = static_cast<jstring>(env->GetObjectArrayElement(array, i));
+    strings.push_back(ToString(element));
+    env->DeleteLocalRef(element);
+  }
+  return strings;
+}
+
+jobjectArray ToArray(JNIEnv *env, const std::vector<std::string> &strings) {
+  jobjectArray array = env->NewObjectArray(static_cast<jsize>(strings.size()), StringClass(), nullptr);
+  for (size_t i = 0; i < strings.size(); i++) {
+    auto element = jni::make_jstring(strings[i]);
+    env->SetObjectArrayElement(array, static_cast<jsize>(i), element.get());
+  }
+  return array;
+}
+
+// NsdPayload -> Service
+Service ToService(JNIEnv *env, jobject payload) {
+  Service service;
+  if (!payload) {
+    return service;
+  }
+  static jclass payloadClass = GlobalClass(kPayloadClass);
+  static jmethodID getString = env->GetMethodID(payloadClass, "getString", "(Ljava/lang/String;)Ljava/lang/String;");
+  static jmethodID getInt = env->GetMethodID(payloadClass, "getInt", "(Ljava/lang/String;)I");
+  static jmethodID getStrings = env->GetMethodID(payloadClass, "getStrings", "(Ljava/lang/String;)[Ljava/lang/String;");
+  static jmethodID getMapKeys = env->GetMethodID(payloadClass, "getMapKeys", "(Ljava/lang/String;)[Ljava/lang/String;");
+  static jmethodID getMapValues = env->GetMethodID(payloadClass, "getMapValues", "(Ljava/lang/String;)[Ljava/lang/String;");
+
+  auto string = [&](const char *key) {
+    auto name = jni::make_jstring(key);
+    auto value = static_cast<jstring>(env->CallObjectMethod(payload, getString, name.get()));
+    std::string result = ToString(value);
+    env->DeleteLocalRef(value);
+    return result;
+  };
+  auto strings = [&](jmethodID method, const char *key) {
+    auto name = jni::make_jstring(key);
+    auto value = static_cast<jobjectArray>(env->CallObjectMethod(payload, method, name.get()));
+    auto result = ToStrings(env, value);
+    env->DeleteLocalRef(value);
+    return result;
+  };
+
+  service.name = string("name");
+  service.fullName = string("fullName");
+  service.host = string("host");
+  {
+    auto key = jni::make_jstring("port");
+    service.port = static_cast<uint16_t>(env->CallIntMethod(payload, getInt, key.get()));
+  }
+  service.addresses = strings(getStrings, "addresses");
+  auto keys = strings(getMapKeys, "txt");
+  auto values = strings(getMapValues, "txt");
+  for (size_t i = 0; i < keys.size() && i < values.size(); i++) {
+    service.txt.emplace_back(keys[i], values[i]);
+  }
+  ClearException(env, "NsdPayload");
+  return service;
+}
+
+std::optional<Events> HostEvents(jlong handle) {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  auto found = registry().hosts.find(handle);
+  if (found == registry().hosts.end()) {
+    return std::nullopt;
+  }
+  return found->second;
+}
+
+std::optional<std::pair<ServiceCallback, ErrorCallback>> TakePromise(jlong id) {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  auto found = registry().promises.find(id);
+  if (found == registry().promises.end()) {
+    return std::nullopt;
+  }
+  auto callbacks = std::move(found->second);
+  registry().promises.erase(found);
+  return callbacks;
+}
+
+// NsdHost.nativeEvent: the event names of the Java side
+void NativeEvent(JNIEnv *env, jclass, jlong handle, jstring eventName, jobject payload) {
+  auto events = HostEvents(handle);
+  if (!events) {
+    return;
+  }
+  std::string event = ToString(eventName);
+  Service service = ToService(env, payload);
+  std::string scanId;
+  if (payload) {
+    static jclass payloadClass = GlobalClass(kPayloadClass);
+    static jmethodID getString = env->GetMethodID(payloadClass, "getString", "(Ljava/lang/String;)Ljava/lang/String;");
+    auto key = jni::make_jstring("scanId");
+    auto value = static_cast<jstring>(env->CallObjectMethod(payload, getString, key.get()));
+    scanId = ToString(value);
+    env->DeleteLocalRef(value);
+  }
+  if (event == "RNZeroconfStart" && events->start) {
+    events->start(scanId);
+  } else if (event == "RNZeroconfStop" && events->stop) {
+    events->stop(scanId);
+  } else if (event == "RNZeroconfFound" && events->found) {
+    events->found(scanId, service.name);
+  } else if (event == "RNZeroconfRemove" && events->remove) {
+    events->remove(scanId, service.name);
+  } else if (event == "RNZeroconfResolved" && events->resolved) {
+    events->resolved(scanId, service);
+  } else if (event == "RNZeroconfServiceRegistered" && events->published) {
+    events->published(service);
+  } else if (event == "RNZeroconfServiceUnregistered" && events->unpublished) {
+    events->unpublished(service);
+  }
+}
+
+void NativeError(JNIEnv *, jclass, jlong handle, jstring scanId, jstring domain, jstring code, jstring message, jstring serviceName) {
+  auto events = HostEvents(handle);
+  if (events && events->error) {
+    events->error(ToString(scanId), Error{ToString(domain), ToString(code), ToString(message), ToString(serviceName)});
+  }
+}
+
+void NativeResolve(JNIEnv *env, jclass, jlong id, jobject payload) {
+  auto callbacks = TakePromise(id);
+  if (callbacks && callbacks->first) {
+    callbacks->first(ToService(env, payload));
+  }
+}
+
+void NativeReject(JNIEnv *, jclass, jlong id, jstring domain, jstring code, jstring message, jstring serviceName) {
+  auto callbacks = TakePromise(id);
+  if (callbacks && callbacks->second) {
+    callbacks->second(Error{ToString(domain), ToString(code), ToString(message), ToString(serviceName)});
+  }
+}
+
+void RegisterNatives() {
+  static std::once_flag once;
+  std::call_once(once, [] {
+    WithEnv([](JNIEnv *env) {
+      JNINativeMethod hostMethods[] = {
+          {const_cast<char *>("nativeEvent"), const_cast<char *>("(JLjava/lang/String;Lcom/balthazargronon/RCTZeroconf/NsdPayload;)V"),
+           reinterpret_cast<void *>(NativeEvent)},
+          {const_cast<char *>("nativeError"),
+           const_cast<char *>("(JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
+           reinterpret_cast<void *>(NativeError)},
+      };
+      env->RegisterNatives(HostClass(), hostMethods, 2);
+      ClearException(env, "registering NsdHost");
+      JNINativeMethod promiseMethods[] = {
+          {const_cast<char *>("nativeResolve"), const_cast<char *>("(JLcom/balthazargronon/RCTZeroconf/NsdPayload;)V"),
+           reinterpret_cast<void *>(NativeResolve)},
+          {const_cast<char *>("nativeReject"),
+           const_cast<char *>("(JLjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
+           reinterpret_cast<void *>(NativeReject)},
+      };
+      env->RegisterNatives(PromiseClass(), promiseMethods, 2);
+      ClearException(env, "registering NsdPromise");
+    });
+  });
+}
+
+// A new NsdPromise settling these callbacks
+jobject NewPromise(JNIEnv *env, ServiceCallback resolve, ErrorCallback reject) {
+  int64_t id;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    id = ++registry().next;
+    registry().promises[id] = {std::move(resolve), std::move(reject)};
+  }
+  static jmethodID constructor = env->GetMethodID(PromiseClass(), "<init>", "(J)V");
+  return env->NewObject(PromiseClass(), constructor, static_cast<jlong>(id));
+}
+
+// Rejects a call whose promise never reached Java
+void RejectLocally(jobject promise, JNIEnv *env, const std::string &name) {
+  static jfieldID idField = env->GetFieldID(PromiseClass(), "id", "J");
+  if (!promise) {
+    return;
+  }
+  auto callbacks = TakePromise(env->GetLongField(promise, idField));
+  if (callbacks && callbacks->second) {
+    callbacks->second(LibraryError("EXCEPTION", "The NSD implementation failed", name));
+  }
+}
+
+std::pair<std::vector<std::string>, std::vector<std::string>> Split(const TxtPairs &txt) {
+  std::vector<std::string> keys;
+  std::vector<std::string> values;
+  for (const auto &[key, value] : txt) {
+    keys.push_back(key);
+    values.push_back(value);
+  }
+  return {keys, values};
+}
+
+} // namespace
+
+std::shared_ptr<NsdBackend> NsdBackend::Create(Events events) {
+  RegisterNatives();
+  int64_t handle;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    handle = ++registry().next;
+    registry().hosts[handle] = std::move(events);
+  }
+  jni::global_ref<jobject> host;
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID constructor = env->GetMethodID(HostClass(), "<init>", "(J)V");
+    jobject local = env->NewObject(HostClass(), constructor, static_cast<jlong>(handle));
+    if (!ClearException(env, "NsdHost()") && local) {
+      host = jni::make_global(jni::wrap_alias(local));
+      env->DeleteLocalRef(local);
+    }
+  });
+  return std::shared_ptr<NsdBackend>(new NsdBackend(handle, std::move(host)));
+}
+
+NsdBackend::NsdBackend(int64_t handle, jni::global_ref<jobject> host) : handle_(handle), host_(std::move(host)) {}
+
+NsdBackend::~NsdBackend() {
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  registry().hosts.erase(handle_);
+}
+
+void NsdBackend::Scan(
+    const std::string &scanId,
+    const std::string &type,
+    const std::string &protocol,
+    const std::string &domain,
+    const ScanOptions &options) {
+  if (!host_) {
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID scan = env->GetMethodID(
+        HostClass(), "scan", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;D)V");
+    env->CallVoidMethod(host_.get(), scan, jni::make_jstring(scanId).get(), jni::make_jstring(type).get(), jni::make_jstring(protocol).get(),
+                        jni::make_jstring(domain).get(), jni::make_jstring(options.subtype).get(), jni::make_jstring(options.networkInterface).get(),
+                        options.resolveTimeoutSeconds);
+    ClearException(env, "NsdHost.scan");
+  });
+}
+
+void NsdBackend::Stop(const std::string &scanId) {
+  if (!host_) {
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID stop = env->GetMethodID(HostClass(), "stop", "(Ljava/lang/String;)V");
+    env->CallVoidMethod(host_.get(), stop, jni::make_jstring(scanId).get());
+    ClearException(env, "NsdHost.stop");
+  });
+}
+
+void NsdBackend::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) {
+  if (!host_) {
+    reject(LibraryError("EXCEPTION", "The NSD implementation is not available", name));
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID registerService = env->GetMethodID(
+        HostClass(), "registerService",
+        "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Lcom/balthazargronon/RCTZeroconf/NsdPromise;)V");
+    auto [keys, values] = Split(txt);
+    jobjectArray keyArray = ToArray(env, keys);
+    jobjectArray valueArray = ToArray(env, values);
+    jobjectArray subtypeArray = ToArray(env, options.subtypes);
+    jobject promise = NewPromise(env, std::move(resolve), std::move(reject));
+    env->CallVoidMethod(host_.get(), registerService, jni::make_jstring(type).get(), jni::make_jstring(protocol).get(), jni::make_jstring(domain).get(),
+                        jni::make_jstring(name).get(), static_cast<jint>(port), keyArray, valueArray, subtypeArray,
+                        jni::make_jstring(options.networkInterface).get(), promise);
+    if (ClearException(env, "NsdHost.registerService")) {
+      RejectLocally(promise, env, name);
+    }
+    env->DeleteLocalRef(keyArray);
+    env->DeleteLocalRef(valueArray);
+    env->DeleteLocalRef(subtypeArray);
+    env->DeleteLocalRef(promise);
+  });
+}
+
+void NsdBackend::Unpublish(const std::string &name, ServiceCallback resolve, ErrorCallback reject) {
+  if (!host_) {
+    reject(LibraryError("EXCEPTION", "The NSD implementation is not available", name));
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID unregisterService =
+        env->GetMethodID(HostClass(), "unregisterService", "(Ljava/lang/String;Lcom/balthazargronon/RCTZeroconf/NsdPromise;)V");
+    jobject promise = NewPromise(env, std::move(resolve), std::move(reject));
+    env->CallVoidMethod(host_.get(), unregisterService, jni::make_jstring(name).get(), promise);
+    if (ClearException(env, "NsdHost.unregisterService")) {
+      RejectLocally(promise, env, name);
+    }
+    env->DeleteLocalRef(promise);
+  });
+}
+
+void NsdBackend::Update(const std::string &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) {
+  if (!host_) {
+    reject(LibraryError("EXCEPTION", "The NSD implementation is not available", name));
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID updateService = env->GetMethodID(
+        HostClass(), "updateService", "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;Lcom/balthazargronon/RCTZeroconf/NsdPromise;)V");
+    auto [keys, values] = Split(txt);
+    jobjectArray keyArray = ToArray(env, keys);
+    jobjectArray valueArray = ToArray(env, values);
+    jobject promise = NewPromise(env, std::move(resolve), std::move(reject));
+    env->CallVoidMethod(host_.get(), updateService, jni::make_jstring(name).get(), keyArray, valueArray, promise);
+    if (ClearException(env, "NsdHost.updateService")) {
+      RejectLocally(promise, env, name);
+    }
+    env->DeleteLocalRef(keyArray);
+    env->DeleteLocalRef(valueArray);
+    env->DeleteLocalRef(promise);
+  });
+}
+
+void NsdBackend::ResolveService(
+    const std::string &name,
+    const std::string &type,
+    const std::string &protocol,
+    const std::string &domain,
+    const ResolveOptions &options,
+    ServiceCallback resolve,
+    ErrorCallback reject) {
+  if (!host_) {
+    reject(LibraryError("EXCEPTION", "The NSD implementation is not available", name));
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID resolveService = env->GetMethodID(
+        HostClass(), "resolveService",
+        "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;DLcom/balthazargronon/RCTZeroconf/NsdPromise;)V");
+    jobject promise = NewPromise(env, std::move(resolve), std::move(reject));
+    env->CallVoidMethod(host_.get(), resolveService, jni::make_jstring(name).get(), jni::make_jstring(type).get(), jni::make_jstring(protocol).get(),
+                        jni::make_jstring(domain).get(), jni::make_jstring(options.networkInterface).get(), options.timeoutSeconds, promise);
+    if (ClearException(env, "NsdHost.resolveService")) {
+      RejectLocally(promise, env, name);
+    }
+    env->DeleteLocalRef(promise);
+  });
+}
+
+void NsdBackend::Shutdown() {
+  if (!host_) {
+    return;
+  }
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID shutdown = env->GetMethodID(HostClass(), "shutdown", "()V");
+    env->CallVoidMethod(host_.get(), shutdown);
+    ClearException(env, "NsdHost.shutdown");
+  });
+  std::lock_guard<std::mutex> lock(registry().mutex);
+  registry().hosts.erase(handle_);
+}
+
+std::string NsdBackend::CheckLocalNetworkAccess() {
+  std::string status = "unknown";
+  WithEnv([&](JNIEnv *env) {
+    static jmethodID check = env->GetStaticMethodID(HostClass(), "checkLocalNetworkAccess", "()Ljava/lang/String;");
+    auto result = static_cast<jstring>(env->CallStaticObjectMethod(HostClass(), check));
+    if (!ClearException(env, "NsdHost.checkLocalNetworkAccess")) {
+      status = ToString(result);
+    }
+    env->DeleteLocalRef(result);
+  });
+  return status;
+}
+
+} // namespace rnzeroconf

package/cpp/android/NsdBackend.h

@@ -0,0 +1,61 @@
+// The backend for Android's NsdManager (NSD), which is a Java API: it drives the NSD code of the library's
+// Java side (NsdHost) through JNI, events and results come back through native methods.
+#pragma once
+
+#include "../Backend.h"
+
+#include <fbjni/fbjni.h>
+
+#include <memory>
+#include <string>
+
+namespace rnzeroconf {
+
+class NsdBackend : public Backend {
+ public:
+  static std::shared_ptr<NsdBackend> Create(Events events);
+  ~NsdBackend() override;
+
+  void Scan(
+      const std::string &scanId,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ScanOptions &options) override;
+  void Stop(const std::string &scanId) override;
+
+  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) override;
+  void Unpublish(const std::string &name, ServiceCallback resolve, ErrorCallback reject) override;
+  void Update(const std::string &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) override;
+
+  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) override;
+
+  void Shutdown() override;
+
+  // "granted", "denied" or "unknown": Android 17's ACCESS_LOCAL_NETWORK permission
+  static std::string CheckLocalNetworkAccess();
+
+ private:
+  NsdBackend(int64_t handle, facebook::jni::global_ref<jobject> host);
+
+  int64_t handle_;
+  facebook::jni::global_ref<jobject> host_;
+};
+
+} // namespace rnzeroconf

package/cpp/android/ZeroconfAndroidModule.cpp

@@ -0,0 +1,49 @@
+#include "ZeroconfAndroidModule.h"
+
+#include "../dnssd/DnssdBackend.h"
+#include "../embedded/EmbeddedExecutor.h"
+#include "NsdBackend.h"
+
+#include <android/log.h>
+#include <fbjni/fbjni.h>
+
+namespace facebook::react {
+
+namespace {
+
+// ZeroconfNativeSupport.setMulticastLock, from any thread
+void SetMulticastLock(bool held) {
+  jni::ThreadScope::WithClassLoader([held] {
+    static const auto support = jni::findClassStatic("com/balthazargronon/RCTZeroconf/ZeroconfNativeSupport");
+    static const auto setMulticastLock = support->getStaticMethod<void(jboolean)>("setMulticastLock");
+    setMulticastLock(support, held ? JNI_TRUE : JNI_FALSE);
+  });
+}
+
+ZeroconfPlatform AndroidPlatform() {
+  ZeroconfPlatform platform;
+  // NSD (the default) is Android's NsdManager, DNSSD the mDNSResponder embedded in the library
+  platform.backendKey = [](const std::string &implType) { return std::string(implType == "DNSSD" ? "DNSSD" : "NSD"); };
+  platform.createBackend = [](const std::string &key, rnzeroconf::Events events) -> std::shared_ptr<rnzeroconf::Backend> {
+    if (key == "NSD") {
+      return rnzeroconf::NsdBackend::Create(std::move(events));
+    }
+    auto executor = rnzeroconf::EmbeddedExecutor::Shared();
+    if (executor->StartError() != 0) {
+      __android_log_print(ANDROID_LOG_ERROR, "RNZeroconf", "The embedded mDNSResponder failed to start (%d)", executor->StartError());
+    }
+    return rnzeroconf::DnssdBackend::Create(executor, std::move(events));
+  };
+  platform.setActive = SetMulticastLock;
+  // Android 17's ACCESS_LOCAL_NETWORK, JavaScript requests it when it is denied
+  platform.checkLocalNetworkAccess = [](const std::string &, double, std::function<void(const std::string &)> resolve,
+                                        std::function<void(const rnzeroconf::Error &)>) { resolve(rnzeroconf::NsdBackend::CheckLocalNetworkAccess()); };
+  return platform;
+}
+
+} // namespace
+
+ZeroconfAndroidModule::ZeroconfAndroidModule(std::shared_ptr<CallInvoker> jsInvoker)
+    : ZeroconfModule(std::move(jsInvoker), AndroidPlatform()) {}
+
+} // namespace facebook::react

package/cpp/android/ZeroconfAndroidModule.h

@@ -0,0 +1,15 @@
+// The C++ module on Android, constructed by React Native's autolinking (react-native.config.js):
+// Android's NsdManager for NSD (through the Java side), the mDNSResponder embedded in the library for
+// DNSSD, and the multicast lock
+#pragma once
+
+#include "../ZeroconfModule.h"
+
+namespace facebook::react {
+
+class ZeroconfAndroidModule : public ZeroconfModule {
+ public:
+  explicit ZeroconfAndroidModule(std::shared_ptr<CallInvoker> jsInvoker);
+};
+
+} // namespace facebook::react

package/cpp/apple/DispatchExecutor.cpp

@@ -0,0 +1,66 @@
+#include "DispatchExecutor.h"
+
+#include <utility>
+
+namespace rnzeroconf {
+
+namespace {
+
+struct Delayed {
+  std::shared_ptr<void> timers;
+  Executor::TimerId id;
+};
+
+} // namespace
+
+DispatchExecutor::DispatchExecutor(const char *label) : queue_(dispatch_queue_create(label, DISPATCH_QUEUE_SERIAL)) {}
+
+DispatchExecutor::~DispatchExecutor() {
+#if !OS_OBJECT_USE_OBJC
+  dispatch_release(queue_);
+#endif
+}
+
+void DispatchExecutor::Post(Task task) {
+  dispatch_async_f(queue_, new Task(std::move(task)), [](void *context) {
+    std::unique_ptr<Task> task(static_cast<Task *>(context));
+    (*task)();
+  });
+}
+
+Executor::TimerId DispatchExecutor::PostDelayed(double seconds, Task task) {
+  TimerId id = ++nextTimer_;
+  {
+    std::lock_guard<std::mutex> lock(timers_->mutex);
+    timers_->pending[id] = std::make_shared<Task>(std::move(task));
+  }
+  auto *delayed = new Delayed{timers_, id};
+  dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, static_cast<int64_t>(seconds * NSEC_PER_SEC)), queue_, delayed, [](void *context) {
+    std::unique_ptr<Delayed> delayed(static_cast<Delayed *>(context));
+    auto timers = std::static_pointer_cast<Timers>(delayed->timers);
+    std::shared_ptr<Task> task;
+    {
+      std::lock_guard<std::mutex> lock(timers->mutex);
+      auto found = timers->pending.find(delayed->id);
+      if (found == timers->pending.end()) {
+        // Cancelled
+        return;
+      }
+      task = found->second;
+      timers->pending.erase(found);
+    }
+    (*task)();
+  });
+  return id;
+}
+
+void DispatchExecutor::Cancel(TimerId timer) {
+  std::lock_guard<std::mutex> lock(timers_->mutex);
+  timers_->pending.erase(timer);
+}
+
+void DispatchExecutor::Attach(DNSServiceRef ref) {
+  DNSServiceSetDispatchQueue(ref, queue_);
+}
+
+} // namespace rnzeroconf

package/cpp/apple/DispatchExecutor.h

@@ -0,0 +1,37 @@
+// Executor on a serial dispatch queue: dns_sd delivers callbacks there with DNSServiceSetDispatchQueue
+#pragma once
+
+#include "../dnssd/Executor.h"
+
+#include <dispatch/dispatch.h>
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+
+namespace rnzeroconf {
+
+class DispatchExecutor : public Executor {
+ public:
+  explicit DispatchExecutor(const char *label);
+  ~DispatchExecutor() override;
+
+  void Post(Task task) override;
+  TimerId PostDelayed(double seconds, Task task) override;
+  void Cancel(TimerId timer) override;
+  void Attach(DNSServiceRef ref) override;
+
+ private:
+  struct Timers {
+    std::mutex mutex;
+    std::map<TimerId, std::shared_ptr<Task>> pending;
+  };
+
+  dispatch_queue_t queue_;
+  std::atomic<TimerId> nextTimer_{0};
+  // Outlives the executor while timers are scheduled
+  std::shared_ptr<Timers> timers_ = std::make_shared<Timers>();
+};
+
+} // namespace rnzeroconf