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

package/{index.d.ts → src/types.ts}

@@ -1,9 +1,9 @@
-export declare const ImplType: {
-  readonly NSD: 'NSD'
-  readonly DNSSD: 'DNSSD'
-}
-
 /** Android only: which discovery implementation to use */
+export const ImplType = {
+  NSD: 'NSD',
+  DNSSD: 'DNSSD',
+} as const
+
 export type ImplType = (typeof ImplType)[keyof typeof ImplType]
 
 export interface Service {
@@ -158,91 +158,6 @@ export interface ServiceTypesScanOptions {
   networkInterface?: string
 }
 
-/** Extends the `events` package EventEmitter */
-export default class Zeroconf {
-  constructor()
-
-  on<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): this
-  once<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): this
-  addListener<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): this
-  removeListener<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): this
-  off<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): this
-  removeAllListeners(event?: keyof ZeroconfEvents): this
-  /** Adds a listener and returns a function that removes it */
-  subscribe<E extends keyof ZeroconfEvents>(event: E, listener: ZeroconfEvents[E]): () => void
-  listenerCount(event: keyof ZeroconfEvents): number
-
-  /** Add the native event listeners (called automatically in the constructor) */
-  addDeviceListeners(): void
-
-  /** Remove the native event listeners, call it when you are done with the instance */
-  removeDeviceListeners(): void
-
-  /** All the services found so far, keyed by name */
-  getServices(): Record<string, Service>
-
-  /** Service types found by `scanServiceTypes` */
-  getServiceTypes(): ServiceType[]
-
-  /**
-   * Scan for the service types advertised on the network, emits `typeFound` and `typeRemove`.
-   * On iOS it requires the `com.apple.developer.networking.multicast` entitlement.
-   */
-  scanServiceTypes(options?: ServiceTypesScanOptions): void
-
-  /** Scan for services, defaults to `_http._tcp.` on the `local.` domain */
-  scan(options?: ScanOptions): void
-  /** @deprecated Use `scan({ type, protocol, domain, implType })` */
-  scan(type?: string, protocol?: string, domain?: string, implType?: ImplType): void
-
-  /**
-   * Checks the Local Network permission. iOS can show the permission prompt when it hasn't been answered yet.
-   * Android 17 (API 37): apps targeting API 37 need `ACCESS_LOCAL_NETWORK`, requested when missing unless
-   * `request` is `false`. Resolves `'granted'` when there is nothing to grant.
-   */
-  checkLocalNetworkAccess(
-    options?: LocalNetworkAccessOptions,
-  ): Promise<'granted' | 'denied' | 'unknown'>
-
-  /**
-   * Stop the current scan
-   * @param implType Android only, defaults to the implementation used by the last scan
-   */
-  stop(implType?: ImplType): void
-
-  /**
-   * Publish a service. Resolves with the published service once it is advertised, its name can differ
-   * from the requested one when that name is already taken. Rejects with a `ZeroconfError`.
-   */
-  publishService(options: PublishOptions): Promise<PublishedService>
-  /** @deprecated Use `publishService({ type, protocol, domain, name, port, txt, implType })` */
-  publishService(
-    type: string,
-    protocol: string,
-    domain: string | undefined,
-    name: string,
-    port: number,
-    txt?: TxtRecord,
-    implType?: ImplType,
-  ): Promise<PublishedService>
-
-  /**
-   * Unpublish a service. Resolves once it is no longer advertised, rejects with a `ZeroconfError`
-   * (e.g. code `'NOT_PUBLISHED'`).
-   * @param implType Android only, defaults to the implementation the service was published with
-   */
-  unpublishService(name: string, implType?: ImplType): Promise<PublishedService | null>
-
-  /**
-   * Replace the TXT record of a published service, resolves with the updated service.
-   * Android `NSD` has no update: the service is published again under the same name.
-   */
-  updateService(name: string, options: UpdateOptions): Promise<PublishedService>
-
-  /** Resolve one service by name without scanning. Rejects with code `'TIMEOUT'` when it doesn't answer in time */
-  resolveService(options: ResolveOptions): Promise<Service>
-}
-
 export interface UseZeroconfOptions extends ScanOptions {
   /** Scan only while true, defaults to `true` */
   enabled?: boolean
@@ -259,12 +174,6 @@ export interface UseZeroconfResult {
   restart(): void
 }
 
-/**
- * Scans while mounted and returns the resolved services. Scans again when the options change,
- * stops and cleans up on unmount. Each hook runs its own scan, several can run at once.
- */
-export function useZeroconf(options?: UseZeroconfOptions): UseZeroconfResult
-
 export interface UseServiceTypesOptions extends ServiceTypesScanOptions {
   /** Scan only while true, defaults to `true` */
   enabled?: boolean
@@ -280,6 +189,3 @@ export interface UseServiceTypesResult {
   /** Clears the service types and scans again */
   restart(): void
 }
-
-/** Lists the service types advertised on the network while mounted */
-export function useServiceTypes(options?: UseServiceTypesOptions): UseServiceTypesResult

package/windows/RNZeroconf/RNZeroconf.vcxproj

@@ -83,6 +83,8 @@
       <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
       <AdditionalIncludeDirectories>
         $(MSBuildThisFileDirectory);
+        $(MSBuildThisFileDirectory)..\..\cpp;
+        $(MSBuildThisFileDirectory)..\..\android\generated\jni\react\renderer\components\RNZeroconfSpec;
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>
     </ClCompile>
@@ -105,8 +107,9 @@
   </ItemDefinitionGroup>
   <PropertyGroup Label="UserMacros" />
   <ItemGroup>
-    <ClInclude Include="RNZeroconf.h" />
     <ClInclude Include="ZeroconfCore.h" />
+    <ClInclude Include="WindowsBackend.h" />
+    <ClInclude Include="ZeroconfWindowsModule.h" />
     <ClInclude Include="ReactPackageProvider.h">
       <DependentUpon>ReactPackageProvider.idl</DependentUpon>
     </ClInclude>
@@ -115,7 +118,19 @@
     <ClInclude Include="targetver.h" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="RNZeroconf.cpp" />
+    <!-- The C++ module shared with iOS and Android, built from codegen's spec (android/generated) -->
+    <ClCompile Include="..\..\cpp\Backend.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="..\..\cpp\ZeroconfModule.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="ZeroconfWindowsModule.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="WindowsBackend.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+    </ClCompile>
     <!-- The DNS-SD core has no React Native dependency, it is also built by test/windows/run.cmd -->
     <ClCompile Include="ZeroconfCore.cpp">
       <PrecompiledHeader>NotUsing</PrecompiledHeader>

package/windows/RNZeroconf/RNZeroconf.vcxproj.filters

@@ -21,9 +21,6 @@
     <ClInclude Include="resource.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="RNZeroconf.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="ZeroconfCore.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -32,9 +29,6 @@
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="RNZeroconf.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="ZeroconfCore.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>

package/windows/RNZeroconf/ReactPackageProvider.cpp

@@ -1,20 +1,23 @@
-#include "pch.h"
-
-#include "ReactPackageProvider.h"
-#if __has_include("ReactPackageProvider.g.cpp")
-#include "ReactPackageProvider.g.cpp"
-#endif
-
-#include "RNZeroconf.h"
-
-using namespace winrt::Microsoft::ReactNative;
-
-namespace winrt::RNZeroconf::implementation
-{
-
-void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept
-{
-  AddAttributedModules(packageBuilder, true);
-}
-
-} // namespace winrt::RNZeroconf::implementation
+#include "pch.h"
+
+#include "ReactPackageProvider.h"
+#if __has_include("ReactPackageProvider.g.cpp")
+#include "ReactPackageProvider.g.cpp"
+#endif
+
+#include <TurboModuleProvider.h>
+
+#include "ZeroconfWindowsModule.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::RNZeroconf::implementation
+{
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept
+{
+  // The C++ module of every platform (cpp/ZeroconfModule), with the windns.h backend
+  AddTurboModuleProvider<facebook::react::ZeroconfWindowsModule>(packageBuilder, L"Zeroconf");
+}
+
+} // namespace winrt::RNZeroconf::implementation

package/windows/RNZeroconf/WindowsBackend.cpp

@@ -0,0 +1,156 @@
+#include "WindowsBackend.h"
+
+#include "ZeroconfCore.h"
+
+#include <utility>
+
+namespace rnzeroconf {
+
+namespace {
+
+std::wstring Wide(const std::string &value) {
+  return win::Widen(value);
+}
+
+Service FromCore(const win::Service &service) {
+  Service converted;
+  converted.name = win::Narrow(service.name);
+  converted.fullName = win::Narrow(service.fullName);
+  converted.host = win::Narrow(service.host);
+  converted.port = service.port;
+  for (const auto &address : service.addresses) {
+    converted.addresses.push_back(win::Narrow(address));
+  }
+  for (const auto &[key, value] : service.txt) {
+    converted.txt.emplace_back(win::Narrow(key), win::Narrow(value));
+  }
+  return converted;
+}
+
+// The core's codes are numbers for domain "Windows" (Win32 / DNS_STATUS), strings for "RNZeroconf"
+Error FromCore(const win::Error &error) {
+  return Error{
+      win::Narrow(error.domain),
+      error.stringCode.empty() ? std::to_string(error.code) : win::Narrow(error.stringCode),
+      win::Narrow(error.message),
+      win::Narrow(error.serviceName)};
+}
+
+win::TxtPairs ToCore(const TxtPairs &txt) {
+  win::TxtPairs converted;
+  for (const auto &[key, value] : txt) {
+    converted.emplace_back(Wide(key), Wide(value));
+  }
+  return converted;
+}
+
+win::ServiceCallback ToCore(ServiceCallback resolve) {
+  return [resolve = std::move(resolve)](const win::Service &service) { resolve(FromCore(service)); };
+}
+
+win::ErrorCallback ToCore(ErrorCallback reject) {
+  return [reject = std::move(reject)](const win::Error &error) { reject(FromCore(error)); };
+}
+
+class WindowsBackend : public Backend {
+ public:
+  explicit WindowsBackend(Events events) : core_(std::make_unique<win::Zeroconf>(CoreEvents(std::move(events)))) {}
+
+  void Scan(
+      const std::string &scanId,
+      const std::string &type,
+      const std::string &protocol,
+      const std::string &domain,
+      const ScanOptions &options) override {
+    core_->Scan(scanId, Wide(type), Wide(protocol), Wide(domain), Wide(options.subtype), Wide(options.networkInterface),
+                options.resolveTimeoutSeconds);
+  }
+
+  void Stop(const std::string &scanId) override {
+    if (scanId.empty()) {
+      core_->StopAll();
+    } else {
+      core_->Stop(scanId);
+    }
+  }
+
+  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 {
+    // windns.h can't register subtypes
+    if (!options.subtypes.empty()) {
+      reject(LibraryError("UNSUPPORTED", "Publishing subtypes is not supported on Windows", name));
+      return;
+    }
+    core_->Publish(Wide(type), Wide(protocol), Wide(domain), Wide(name), port, ToCore(txt), Wide(options.networkInterface),
+                   ToCore(std::move(resolve)), ToCore(std::move(reject)));
+  }
+
+  void Unpublish(const std::string &name, ServiceCallback resolve, ErrorCallback reject) override {
+    core_->Unpublish(Wide(name), ToCore(std::move(resolve)), ToCore(std::move(reject)));
+  }
+
+  void Update(const std::string &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject) override {
+    core_->Update(Wide(name), ToCore(txt), ToCore(std::move(resolve)), ToCore(std::move(reject)));
+  }
+
+  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 {
+    core_->ResolveService(Wide(name), Wide(type), Wide(protocol), Wide(domain), Wide(options.networkInterface), options.timeoutSeconds,
+                          ToCore(std::move(resolve)), ToCore(std::move(reject)));
+  }
+
+  void Shutdown() override {
+    core_->StopAll();
+    core_->UnpublishAll();
+  }
+
+ private:
+  static win::Events CoreEvents(Events events) {
+    win::Events core;
+    core.start = events.start;
+    core.stop = events.stop;
+    core.found = [found = events.found](const std::string &scanId, const std::wstring &name) {
+      if (found) found(scanId, win::Narrow(name));
+    };
+    core.remove = [remove = events.remove](const std::string &scanId, const std::wstring &name) {
+      if (remove) remove(scanId, win::Narrow(name));
+    };
+    core.resolved = [resolved = events.resolved](const std::string &scanId, const win::Service &service) {
+      if (resolved) resolved(scanId, FromCore(service));
+    };
+    core.published = [published = events.published](const win::Service &service) {
+      if (published) published(FromCore(service));
+    };
+    core.unpublished = [unpublished = events.unpublished](const win::Service &service) {
+      if (unpublished) unpublished(FromCore(service));
+    };
+    core.error = [error = events.error](const std::string &scanId, const win::Error &value) {
+      if (error) error(scanId, FromCore(value));
+    };
+    return core;
+  }
+
+  std::unique_ptr<win::Zeroconf> core_;
+};
+
+} // namespace
+
+std::shared_ptr<Backend> CreateWindowsBackend(Events events) {
+  return std::make_shared<WindowsBackend>(std::move(events));
+}
+
+} // namespace rnzeroconf

package/windows/RNZeroconf/WindowsBackend.h

@@ -0,0 +1,13 @@
+// The Windows backend of the C++ module: ZeroconfCore (windns.h) behind cpp/Backend.h.
+// Declared without windows.h, which stays in WindowsBackend.cpp and ZeroconfCore.
+#pragma once
+
+#include "../../cpp/Backend.h"
+
+#include <memory>
+
+namespace rnzeroconf {
+
+std::shared_ptr<Backend> CreateWindowsBackend(Events events);
+
+} // namespace rnzeroconf

package/windows/RNZeroconf/ZeroconfCore.cpp

@@ -13,7 +13,7 @@
 #pragma comment(lib, "iphlpapi.lib")
 #pragma comment(lib, "ws2_32.lib")
 
-namespace rnzeroconf {
+namespace rnzeroconf::win {
 
 using After = std::vector<std::function<void()>>;
 
@@ -1092,4 +1092,4 @@ void Zeroconf::UnpublishAll() {
   }
 }
 
-} // namespace rnzeroconf
+} // namespace rnzeroconf::win

package/windows/RNZeroconf/ZeroconfCore.h

@@ -31,7 +31,7 @@
 #include <utility>
 #include <vector>
 
-namespace rnzeroconf {
+namespace rnzeroconf::win {
 
 using TxtPairs = std::vector<std::pair<std::wstring, std::wstring>>;
 
@@ -164,4 +164,4 @@ std::wstring Widen(const std::string &value);
 std::string Narrow(const std::wstring &value);
 std::wstring DescribeStatus(DWORD status);
 
-} // namespace rnzeroconf
+} // namespace rnzeroconf::win

package/windows/RNZeroconf/ZeroconfWindowsModule.cpp

@@ -0,0 +1,22 @@
+#include "ZeroconfWindowsModule.h"
+
+#include "WindowsBackend.h"
+
+namespace facebook::react {
+
+namespace {
+
+ZeroconfPlatform WindowsPlatform() {
+  ZeroconfPlatform platform;
+  // One mDNS stack on Windows, implType is Android's
+  platform.backendKey = [](const std::string &) { return std::string("windns"); };
+  platform.createBackend = [](const std::string &, rnzeroconf::Events events) { return rnzeroconf::CreateWindowsBackend(std::move(events)); };
+  return platform;
+}
+
+} // namespace
+
+ZeroconfWindowsModule::ZeroconfWindowsModule(std::shared_ptr<CallInvoker> jsInvoker)
+    : ZeroconfModule(std::move(jsInvoker), WindowsPlatform()) {}
+
+} // namespace facebook::react

package/windows/RNZeroconf/ZeroconfWindowsModule.h

@@ -0,0 +1,14 @@
+// The C++ module on Windows, registered with AddTurboModuleProvider in ReactPackageProvider.cpp:
+// the windns.h backend (ZeroconfCore). Windows has no Local Network permission to grant.
+#pragma once
+
+#include "../../cpp/ZeroconfModule.h"
+
+namespace facebook::react {
+
+class ZeroconfWindowsModule : public ZeroconfModule {
+ public:
+  explicit ZeroconfWindowsModule(std::shared_ptr<CallInvoker> jsInvoker);
+};
+
+} // namespace facebook::react

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

@@ -1,56 +0,0 @@
-package com.balthazargronon.RCTZeroconf;
-
-import com.balthazargronon.RCTZeroconf.nsd.NsdServiceImpl;
-import com.balthazargronon.RCTZeroconf.dnssd.DnssdImpl;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class ZeroConfImplFactory {
-    public static final String NSD_IMPL = "NSD";
-    public static final String DNSSD_IMPL = "DNSSD";
-
-    private Map<String, Zeroconf> zeroconfMap = new HashMap<>();
-
-    private ZeroconfModule zeroconfModule;
-    private ReactApplicationContext context;
-
-    public ZeroConfImplFactory(ZeroconfModule zeroconfModule, ReactApplicationContext context) {
-        this.zeroconfModule = zeroconfModule;
-        this.context = context;
-    }
-
-    public Zeroconf getZeroconf(String implType) {
-        if (implType == null || implType.trim().isEmpty()) implType = ZeroConfImplFactory.NSD_IMPL;
-        return getOrCreateImpl(implType);
-    }
-
-    private Zeroconf getOrCreateImpl(String implType) {
-        if (!zeroconfMap.containsKey(implType)) {
-            switch (implType) {
-                case NSD_IMPL:
-                    zeroconfMap.put(NSD_IMPL, new NsdServiceImpl(zeroconfModule, context));
-                    break;
-                case DNSSD_IMPL:
-                    zeroconfMap.put(DNSSD_IMPL, new DnssdImpl(zeroconfModule, context));
-                    break;
-                default:
-                    throw new IllegalArgumentException(String.format("%s implType is not supported. Only %s and %s are supported", implType, NSD_IMPL, DNSSD_IMPL));
-            }
-        }
-
-        return zeroconfMap.get(implType);
-    }
-
-    /**
-     * Implementations that have already been created, without instantiating new ones
-     */
-    public List<Zeroconf> getCreatedImpls() {
-        return new ArrayList<>(zeroconfMap.values());
-    }
-
-}