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

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

package/cpp/apple/LocalNetworkAccess.h

@@ -0,0 +1,19 @@
+// The Local Network permission on Apple platforms
+#pragma once
+
+#include "../Backend.h"
+
+#include <functional>
+#include <string>
+
+namespace rnzeroconf {
+
+// Settles with 'granted', 'denied' or 'unknown', on the main queue. type is a service type from
+// NSBonjourServices ("_http._tcp"), the first one listed when empty. Can show the permission prompt
+void CheckLocalNetworkAccess(
+    const std::string &type,
+    double timeout,
+    std::function<void(const std::string &status)> resolve,
+    std::function<void(const Error &error)> reject);
+
+} // namespace rnzeroconf

package/cpp/apple/LocalNetworkAccess.mm

@@ -0,0 +1,87 @@
+// The Local Network check of Apple platforms, with Network.framework. No React Native dependency:
+// ios/ZeroconfOnLoad.mm hands it to the module, test/apple/local-network-access.mm tests it.
+#import "LocalNetworkAccess.h"
+
+#import <Foundation/Foundation.h>
+#import <Network/Network.h>
+#include <dns_sd.h>
+
+namespace rnzeroconf {
+
+/**
+ * Resolves 'granted', 'denied' or 'unknown'. There is no API to read the Local Network permission,
+ * so this advertises a temporary Bonjour service and browses for it: seeing it means access is granted,
+ * a browser waiting with kDNSServiceErr_PolicyDenied until the timeout means it is denied.
+ * The type must be listed in NSBonjourServices, defaults to the first one. It can show the permission prompt.
+ */
+void CheckLocalNetworkAccess(
+    const std::string &type,
+    double timeout,
+    std::function<void(const std::string &status)> resolve,
+    std::function<void(const Error &error)> reject) {
+  NSString *serviceType = type.empty() ? nil : [NSString stringWithUTF8String:type.c_str()];
+  if (serviceType.length == 0) {
+    NSArray *declared = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSBonjourServices"];
+    serviceType = [declared isKindOfClass:[NSArray class]] ? declared.firstObject : nil;
+  }
+  if (serviceType.length == 0) {
+    reject(LibraryError("MISSING_BONJOUR_SERVICES", "No service type to check with, add one to NSBonjourServices in Info.plist"));
+    return;
+  }
+  // "_http._tcp." -> "_http._tcp"
+  if ([serviceType hasSuffix:@"."]) {
+    serviceType = [serviceType substringToIndex:serviceType.length - 1];
+  }
+
+  NSString *name = [NSString stringWithFormat:@"rnzeroconf-%@", [[NSUUID UUID].UUIDString substringToIndex:8]];
+  dispatch_queue_t queue = dispatch_get_main_queue();
+
+  nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION);
+  nw_listener_t listener = nw_listener_create(parameters);
+  nw_listener_set_advertise_descriptor(listener, nw_advertise_descriptor_create_bonjour_service(name.UTF8String, serviceType.UTF8String, "local."));
+  nw_listener_set_queue(listener, queue);
+  nw_listener_set_new_connection_handler(listener, ^(nw_connection_t connection) {
+    nw_connection_cancel(connection);
+  });
+
+  nw_browse_descriptor_t descriptor = nw_browse_descriptor_create_bonjour_service(serviceType.UTF8String, "local.");
+  nw_browser_t browser = nw_browser_create(descriptor, nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION));
+  nw_browser_set_queue(browser, queue);
+
+  __block BOOL finished = NO;
+  __block BOOL policyDenied = NO;
+  void (^finish)(NSString *) = ^(NSString *result) {
+    if (finished) {
+      return;
+    }
+    finished = YES;
+    nw_browser_cancel(browser);
+    nw_listener_cancel(listener);
+    resolve(result.UTF8String);
+  };
+
+  nw_browser_set_browse_results_changed_handler(browser, ^(nw_browse_result_t, nw_browse_result_t newResult, bool) {
+    nw_endpoint_t endpoint = newResult ? nw_browse_result_copy_endpoint(newResult) : nil;
+    const char *found = endpoint ? nw_endpoint_get_bonjour_service_name(endpoint) : NULL;
+    if (found && strcmp(found, name.UTF8String) == 0) {
+      finish(@"granted");
+    }
+  });
+  nw_browser_set_state_changed_handler(browser, ^(nw_browser_state_t state, nw_error_t error) {
+    if (error && nw_error_get_error_domain(error) == nw_error_domain_dns) {
+      // Stays waiting while the prompt is shown, only conclude on timeout
+      policyDenied = nw_error_get_error_code(error) == kDNSServiceErr_PolicyDenied;
+    } else if (state == nw_browser_state_ready) {
+      policyDenied = NO;
+    }
+  });
+
+  nw_listener_start(listener);
+  nw_browser_start(browser);
+
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)((timeout > 0 ? timeout : 5.0) * NSEC_PER_SEC)), queue, ^{
+    finish(policyDenied ? @"denied" : @"unknown");
+  });
+}
+
+} // namespace rnzeroconf