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

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

package/cpp/ZeroconfModule.h

@@ -0,0 +1,144 @@
+// The native module, one C++ TurboModule for every platform. It bridges a platform's backends
+// (cpp/Backend.h) to JavaScript: calls go to the backend for the call's implType, backend callbacks
+// become events and settled promises.
+#pragma once
+
+#include <RNZeroconfSpecJSI.h>
+
+#include "Backend.h"
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+using ZeroconfTxtEntry = NativeZeroconfTxtEntry<std::string, std::string>;
+template <>
+struct Bridging<ZeroconfTxtEntry> : NativeZeroconfTxtEntryBridging<ZeroconfTxtEntry> {};
+
+using ZeroconfService = NativeZeroconfNativeService<std::string, std::string, std::string, double, std::vector<std::string>, std::vector<ZeroconfTxtEntry>>;
+template <>
+struct Bridging<ZeroconfService> : NativeZeroconfNativeServiceBridging<ZeroconfService> {};
+
+using ZeroconfError = NativeZeroconfNativeError<std::string, std::string, std::string, std::string>;
+template <>
+struct Bridging<ZeroconfError> : NativeZeroconfNativeErrorBridging<ZeroconfError> {};
+
+using ZeroconfResult = NativeZeroconfNativeResult<std::optional<ZeroconfService>, std::optional<ZeroconfError>>;
+template <>
+struct Bridging<ZeroconfResult> : NativeZeroconfNativeResultBridging<ZeroconfResult> {};
+
+using ZeroconfAccessResult = NativeZeroconfNativeAccessResult<std::optional<std::string>, std::optional<ZeroconfError>>;
+template <>
+struct Bridging<ZeroconfAccessResult> : NativeZeroconfNativeAccessResultBridging<ZeroconfAccessResult> {};
+
+using ZeroconfScanEvent = NativeZeroconfScanEvent<std::string>;
+template <>
+struct Bridging<ZeroconfScanEvent> : NativeZeroconfScanEventBridging<ZeroconfScanEvent> {};
+
+using ZeroconfNameEvent = NativeZeroconfNameEvent<std::string, std::string>;
+template <>
+struct Bridging<ZeroconfNameEvent> : NativeZeroconfNameEventBridging<ZeroconfNameEvent> {};
+
+using ZeroconfResolvedEvent = NativeZeroconfResolvedEvent<std::string, ZeroconfService>;
+template <>
+struct Bridging<ZeroconfResolvedEvent> : NativeZeroconfResolvedEventBridging<ZeroconfResolvedEvent> {};
+
+using ZeroconfErrorEvent = NativeZeroconfErrorEvent<std::string, ZeroconfError>;
+template <>
+struct Bridging<ZeroconfErrorEvent> : NativeZeroconfErrorEventBridging<ZeroconfErrorEvent> {};
+
+using ZeroconfScanOptions = NativeZeroconfNativeScanOptions<std::optional<double>, std::optional<std::string>, std::optional<std::string>>;
+template <>
+struct Bridging<ZeroconfScanOptions> : NativeZeroconfNativeScanOptionsBridging<ZeroconfScanOptions> {};
+
+using ZeroconfPublishOptions = NativeZeroconfNativePublishOptions<std::optional<std::vector<std::string>>, std::optional<std::string>>;
+template <>
+struct Bridging<ZeroconfPublishOptions> : NativeZeroconfNativePublishOptionsBridging<ZeroconfPublishOptions> {};
+
+using ZeroconfResolveOptions = NativeZeroconfNativeResolveOptions<std::optional<double>, std::optional<std::string>>;
+template <>
+struct Bridging<ZeroconfResolveOptions> : NativeZeroconfNativeResolveOptionsBridging<ZeroconfResolveOptions> {};
+
+// What a platform provides to the module, set before the module is created
+struct ZeroconfPlatform {
+  // The backend for a key; the platform maps implTypes to keys, so platforms with one backend ignore implType
+  std::function<std::string(const std::string &implType)> backendKey;
+  std::function<std::shared_ptr<rnzeroconf::Backend>(const std::string &key, rnzeroconf::Events events)> createBackend;
+  // Settles with 'granted', 'denied' or 'unknown', or an error
+  std::function<void(
+      const std::string &type,
+      double timeoutSeconds,
+      std::function<void(const std::string &status)> resolve,
+      std::function<void(const rnzeroconf::Error &error)> reject)>
+      checkLocalNetworkAccess;
+  // Called when the module starts or stops having anything running: scans, published services,
+  // publishes and resolves in flight. Android holds its multicast lock in between
+  std::function<void(bool active)> setActive;
+};
+
+class ZeroconfModule : public NativeZeroconfCxxSpec<ZeroconfModule> {
+ public:
+  ZeroconfModule(std::shared_ptr<CallInvoker> jsInvoker, ZeroconfPlatform platform);
+  ~ZeroconfModule() override;
+
+  void scan(jsi::Runtime &rt, std::string scanId, std::string type, std::string protocol, std::string domain, std::string implType, ZeroconfScanOptions options);
+  void stop(jsi::Runtime &rt, std::string scanId, std::string implType);
+  AsyncPromise<ZeroconfResult> 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);
+  AsyncPromise<ZeroconfResult> updateService(jsi::Runtime &rt, std::string name, std::vector<ZeroconfTxtEntry> txt, std::string implType);
+  AsyncPromise<ZeroconfResult> unregisterService(jsi::Runtime &rt, std::string name, std::string implType);
+  AsyncPromise<ZeroconfResult> resolveService(
+      jsi::Runtime &rt,
+      std::string name,
+      std::string type,
+      std::string protocol,
+      std::string domain,
+      std::string implType,
+      ZeroconfResolveOptions options);
+  AsyncPromise<ZeroconfAccessResult> checkLocalNetworkAccess(jsi::Runtime &rt, std::string type, double timeout);
+
+ private:
+  // Backend callbacks can outlive the module, they go through this
+  struct Emitter {
+    std::mutex mutex;
+    ZeroconfModule *module = nullptr;
+  };
+
+  std::shared_ptr<rnzeroconf::Backend> Backend(const std::string &implType);
+  rnzeroconf::Events MakeEvents();
+  AsyncPromise<ZeroconfResult> Settle(
+      jsi::Runtime &rt,
+      const std::function<void(rnzeroconf::ServiceCallback, rnzeroconf::ErrorCallback)> &call,
+      bool active = false);
+
+  // What is running, for ZeroconfPlatform::setActive
+  enum class Activity { ScanStarted, ScanStopped, AllScansStopped, Published, Unpublished, CallStarted, CallSettled };
+  void Track(Activity activity, const std::string &key = "");
+
+  ZeroconfPlatform platform_;
+  std::shared_ptr<Emitter> emitter_;
+  std::mutex backendsMutex_;
+  std::map<std::string, std::shared_ptr<rnzeroconf::Backend>> backends_;
+  std::mutex activityMutex_;
+  std::set<std::string> runningScans_;
+  std::set<std::string> publishedServices_;
+  int callsInFlight_ = 0;
+  bool active_ = false;
+};
+
+} // namespace facebook::react