react-native-zeroconf 0.16.1 → 0.17.0

package/src/index.js

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
-import { Platform, NativeModules, DeviceEventEmitter } from 'react-native'
+import { Platform, NativeModules, DeviceEventEmitter, PermissionsAndroid } from 'react-native'
 import { EventEmitter } from 'events'
 
 const RNZeroconf = NativeModules.RNZeroconf
@@ -38,6 +38,13 @@ const withDefaults = (defaults, options) => {
 
 const isOptionsObject = value => value !== null && typeof value === 'object'
 
+// Options passed to native code, without the undefined ones
+const nativeOptions = options =>
+  Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
+
+// Android 17 (API 37) runtime permission, enforced for apps targeting API 37 or declaring it
+const ACCESS_LOCAL_NETWORK = 'android.permission.ACCESS_LOCAL_NETWORK'
+
 // Each instance runs its own scan, identified by this id in native events
 let instanceCount = 0
 
@@ -90,6 +97,15 @@ const withAddressFamilies = service => {
 /**
  * TXT records as ordered [key, value] pairs, from an object or an array of pairs
  */
+// Browsing this type lists the service types on the network instead of services
+const SERVICE_TYPES = { type: 'services._dns-sd', protocol: 'udp' }
+
+// "_http._tcp" -> { type: 'http', protocol: 'tcp' }
+const parseServiceType = name => {
+  const match = /^_([^.]+)\._(tcp|udp)$/.exec(name)
+  return match ? { type: match[1], protocol: match[2] } : null
+}
+
 const toTxtPairs = txt => {
   const entries = Array.isArray(txt) ? txt : Object.entries(txt || {})
   return entries.map(([key, value]) => [String(key), String(value)])
@@ -106,6 +122,8 @@ export default class Zeroconf extends EventEmitter {
     }
 
     this._services = {}
+    this._serviceTypes = {}
+    this._scanningTypes = false
     this._publishedServices = {}
     this._publishedImplTypes = {}
     this._scanImplType = null
@@ -148,6 +166,16 @@ export default class Zeroconf extends EventEmitter {
       }
       const { name } = service
 
+      if (this._scanningTypes) {
+        const serviceType = parseServiceType(name)
+        if (serviceType && !this._serviceTypes[name]) {
+          this._serviceTypes[name] = serviceType
+          this.emit('typeFound', serviceType)
+          this.emit('update')
+        }
+        return
+      }
+
       this._services[name] = { name }
       this.emit('found', name)
       this.emit('update')
@@ -159,6 +187,16 @@ export default class Zeroconf extends EventEmitter {
       }
       const { name } = service
 
+      if (this._scanningTypes) {
+        const serviceType = this._serviceTypes[name]
+        if (serviceType) {
+          delete this._serviceTypes[name]
+          this.emit('typeRemove', serviceType)
+          this.emit('update')
+        }
+        return
+      }
+
       delete this._services[name]
 
       this.emit('remove', name)
@@ -237,6 +275,24 @@ export default class Zeroconf extends EventEmitter {
     return this._services
   }
 
+  /**
+   * Get the service types found by scanServiceTypes, as [{ type, protocol }]
+   */
+  getServiceTypes() {
+    return Object.values(this._serviceTypes)
+  }
+
+  /**
+   * Scan for the service types advertised on the network (_http._tcp, _ipp._tcp...), emits typeFound and typeRemove.
+   * On iOS, only types declared in NSBonjourServices can then be scanned.
+   * On iOS it requires the multicast entitlement. On Android with NSD and on Windows, services other apps publish on the same device are left out.
+   *
+   * scanServiceTypes({ domain, implType })
+   */
+  scanServiceTypes({ domain, implType, networkInterface } = {}) {
+    this._startScan({ ...SERVICE_TYPES, domain, implType, networkInterface }, true)
+  }
+
   /**
    * Scan for Zeroconf services, defaults to _http._tcp. on the local. domain
    *
@@ -244,14 +300,21 @@ export default class Zeroconf extends EventEmitter {
    * scan(type, protocol, domain, implType) is deprecated
    */
   scan(options, protocolArg, domainArg, implTypeArg) {
-    const { type, protocol, domain, implType, resolveTimeout } = withDefaults(
-      SCAN_DEFAULTS,
+    this._startScan(
       isOptionsObject(options)
         ? options
         : { type: options, protocol: protocolArg, domain: domainArg, implType: implTypeArg },
+      false,
     )
+  }
+
+  _startScan(options, scanningTypes) {
+    const { type, protocol, domain, implType, resolveTimeout, subtype, networkInterface } =
+      withDefaults(SCAN_DEFAULTS, options)
 
     this._services = {}
+    this._serviceTypes = {}
+    this._scanningTypes = scanningTypes
     this._hasScanned = true
     this.emit('update')
     if (Platform.OS === 'android') {
@@ -260,9 +323,22 @@ export default class Zeroconf extends EventEmitter {
         RNZeroconf.stop(this._scanId, this._scanImplType)
       }
       this._scanImplType = implType
-      RNZeroconf.scan(this._scanId, type, protocol, domain, implType)
+      RNZeroconf.scan(
+        this._scanId,
+        type,
+        protocol,
+        domain,
+        implType,
+        nativeOptions({ subtype, networkInterface }),
+      )
     } else {
-      RNZeroconf.scan(this._scanId, type, protocol, domain, resolveTimeout)
+      RNZeroconf.scan(
+        this._scanId,
+        type,
+        protocol,
+        domain,
+        nativeOptions({ resolveTimeout, subtype, networkInterface }),
+      )
     }
   }
 
@@ -279,13 +355,22 @@ export default class Zeroconf extends EventEmitter {
   }
 
   /**
-   * Checks the iOS Local Network permission, resolves 'granted', 'denied' or 'unknown'.
-   * Uses a service type from NSBonjourServices (the first one by default) and can show the permission prompt.
-   * Android has no equivalent permission to check and resolves 'unknown'.
+   * Checks the Local Network permission, resolves 'granted', 'denied' or 'unknown'.
+   * iOS: uses a service type from NSBonjourServices (the first one by default) and can show the permission prompt.
+   * Android: apps targeting Android 17 (API 37) need ACCESS_LOCAL_NETWORK on Android 17 devices, it is requested
+   * when missing unless request is false. 'granted' when there is nothing to grant.
    */
-  checkLocalNetworkAccess({ type, protocol = 'tcp', timeout = 5 } = {}) {
+  async checkLocalNetworkAccess({ type, protocol = 'tcp', timeout = 5, request = true } = {}) {
     if (Platform.OS === 'android') {
-      return Promise.resolve('unknown')
+      if (!RNZeroconf.checkLocalNetworkAccess) {
+        return 'unknown'
+      }
+      const status = await asPromise(RNZeroconf.checkLocalNetworkAccess())
+      if (status !== 'denied' || !request) {
+        return status
+      }
+      const result = await PermissionsAndroid.request(ACCESS_LOCAL_NETWORK)
+      return result === PermissionsAndroid.RESULTS.GRANTED ? 'granted' : 'denied'
     }
     const serviceType = type ? `_${type}._${protocol}` : null
     return asPromise(RNZeroconf.checkLocalNetworkAccess(serviceType, timeout))
@@ -299,28 +384,68 @@ export default class Zeroconf extends EventEmitter {
    * publishService(type, protocol, domain, name, port, txt, implType) is deprecated
    */
   publishService(options, protocolArg, domainArg, nameArg, portArg, txtArg, implTypeArg) {
-    const { type, protocol, domain, name, port, txt, implType } = withDefaults(
-      PUBLISH_DEFAULTS,
-      isOptionsObject(options)
-        ? options
-        : {
-            type: options,
-            protocol: protocolArg,
-            domain: domainArg,
-            name: nameArg,
-            port: portArg,
-            txt: txtArg,
-            implType: implTypeArg,
-          },
-    )
+    const { type, protocol, domain, name, port, txt, implType, subtypes, networkInterface } =
+      withDefaults(
+        PUBLISH_DEFAULTS,
+        isOptionsObject(options)
+          ? options
+          : {
+              type: options,
+              protocol: protocolArg,
+              domain: domainArg,
+              name: nameArg,
+              port: portArg,
+              txt: txtArg,
+              implType: implTypeArg,
+            },
+      )
     const txtRecord = toTxtPairs(txt)
+    const native = nativeOptions({ subtypes, networkInterface })
     if (Platform.OS === 'android') {
       this._publishedImplTypes[name] = implType
       return asPromise(
-        RNZeroconf.registerService(type, protocol, domain, name, port, txtRecord, implType),
+        RNZeroconf.registerService(type, protocol, domain, name, port, txtRecord, implType, native),
       )
     }
-    return asPromise(RNZeroconf.registerService(type, protocol, domain, name, port, txtRecord))
+    return asPromise(
+      RNZeroconf.registerService(type, protocol, domain, name, port, txtRecord, native),
+    )
+  }
+
+  /**
+   * 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, { txt })
+   */
+  updateService(
+    name,
+    { txt = {}, implType = this._publishedImplTypes[name] || ImplType.NSD } = {},
+  ) {
+    const txtRecord = toTxtPairs(txt)
+    if (Platform.OS === 'android') {
+      return asPromise(RNZeroconf.updateService(name, txtRecord, implType))
+    }
+    return asPromise(RNZeroconf.updateService(name, txtRecord))
+  }
+
+  /**
+   * Resolve one service by name without scanning, for a device found before.
+   * Resolves with the service, rejects with code 'TIMEOUT' when it doesn't answer in time.
+   *
+   * resolveService({ name, type, protocol, domain, implType, timeout, networkInterface })
+   */
+  resolveService(options) {
+    const { name, type, protocol, domain, implType, timeout, networkInterface } = withDefaults(
+      { ...SCAN_DEFAULTS, timeout: 5 },
+      options,
+    )
+    const native = nativeOptions({ timeout, networkInterface })
+    const promise =
+      Platform.OS === 'android'
+        ? RNZeroconf.resolveService(name, type, protocol, domain, implType, native)
+        : RNZeroconf.resolveService(name, type, protocol, domain, native)
+    return asPromise(asPromise(promise).then(service => service && withAddressFamilies(service)))
   }
 
   /**
@@ -336,31 +461,23 @@ export default class Zeroconf extends EventEmitter {
   }
 }
 
-/**
- * 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.
- *
- * const { services, isScanning, error, stop, restart } = useZeroconf({ type: 'http' })
- */
-export function useZeroconf(options = {}) {
-  const { type, protocol, domain, implType, resolveTimeout, enabled = true } = options
+// Runs a scan while mounted and enabled, and again when deps change or on restart
+function useScan(enabled, startScan, read, deps) {
   const zeroconfRef = useRef(null)
-  const [services, setServices] = useState([])
+  const [items, setItems] = useState([])
   const [isScanning, setIsScanning] = useState(false)
   const [error, setError] = useState(null)
   const [scanCount, setScanCount] = useState(0)
+  const readRef = useRef(read)
+  readRef.current = read
 
   useEffect(() => {
     const zeroconf = new Zeroconf()
     zeroconfRef.current = zeroconf
-    // Found services only have a name until they are resolved
-    const updateServices = () =>
-      setServices(Object.values(zeroconf.getServices()).filter(service => service.addresses))
     const unsubscribes = [
       zeroconf.subscribe('start', () => setIsScanning(true)),
       zeroconf.subscribe('stop', () => setIsScanning(false)),
-      zeroconf.subscribe('update', updateServices),
+      zeroconf.subscribe('update', () => setItems(readRef.current(zeroconf))),
       zeroconf.subscribe('error', setError),
     ]
     return () => {
@@ -376,11 +493,11 @@ export function useZeroconf(options = {}) {
     if (!zeroconf || !enabled) {
       return undefined
     }
-    setServices([])
+    setItems([])
     setError(null)
-    zeroconf.scan({ type, protocol, domain, implType, resolveTimeout })
+    startScan(zeroconf)
     return () => zeroconf.stop()
-  }, [enabled, type, protocol, domain, implType, resolveTimeout, scanCount])
+  }, [enabled, scanCount, ...deps])
 
   const stop = useCallback(() => {
     if (zeroconfRef.current) {
@@ -389,5 +506,58 @@ export function useZeroconf(options = {}) {
   }, [])
   const restart = useCallback(() => setScanCount(count => count + 1), [])
 
-  return { services, isScanning, error, stop, restart }
+  return { items, isScanning, error, stop, restart }
+}
+
+/**
+ * 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.
+ *
+ * const { services, isScanning, error, stop, restart } = useZeroconf({ type: 'http' })
+ */
+export function useZeroconf(options = {}) {
+  const {
+    type,
+    protocol,
+    domain,
+    implType,
+    resolveTimeout,
+    subtype,
+    networkInterface,
+    enabled = true,
+  } = options
+  const { items, ...scan } = useScan(
+    enabled,
+    zeroconf =>
+      zeroconf.scan({
+        type,
+        protocol,
+        domain,
+        implType,
+        resolveTimeout,
+        subtype,
+        networkInterface,
+      }),
+    // Found services only have a name until they are resolved
+    zeroconf => Object.values(zeroconf.getServices()).filter(service => service.addresses),
+    [type, protocol, domain, implType, resolveTimeout, subtype, networkInterface],
+  )
+  return { services: items, ...scan }
+}
+
+/**
+ * Lists the service types advertised on the network while mounted.
+ *
+ * const { serviceTypes, isScanning, error, stop, restart } = useServiceTypes()
+ */
+export function useServiceTypes(options = {}) {
+  const { domain, implType, networkInterface, enabled = true } = options
+  const { items, ...scan } = useScan(
+    enabled,
+    zeroconf => zeroconf.scanServiceTypes({ domain, implType, networkInterface }),
+    zeroconf => zeroconf.getServiceTypes(),
+    [domain, implType, networkInterface],
+  )
+  return { serviceTypes: items, ...scan }
 }

package/windows/ExperimentalFeatures.props

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup Label="Microsoft.ReactNative Experimental Features">
+    <!--
+      Required for building a New Architecture project.
+
+      Library projects can change this value to test against Old and New
+      Architectures when building the library project's local sln file.
+      
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/new-architecture
+    -->
+    <RnwNewArch>true</RnwNewArch>
+
+    <!--
+      Changes compilation to assume use of Microsoft.ReactNative NuGet packages
+      instead of building the framework from source. Defaults to true.
+
+      This is set during library project creation and is used when building
+      the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/nuget
+    -->
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+
+    <ReactExperimentalFeaturesSet>true</ReactExperimentalFeaturesSet>
+  </PropertyGroup>
+
+</Project>

package/windows/NuGet.config

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="react-native" value="https://pkgs.dev.azure.com/ms/react-native/_packaging/react-native-public/nuget/v3/index.json" />
+    <add key="Nuget.org" value="https://api.nuget.org/v3/index.json" />
+  </packageSources>
+  <disabledPackageSources>
+    <clear />
+  </disabledPackageSources>  
+</configuration>

package/windows/RNZeroconf/RNZeroconf.cpp

@@ -0,0 +1,227 @@
+#include "pch.h"
+
+#include "RNZeroconf.h"
+
+using namespace rnzeroconf;
+
+namespace winrt::RNZeroconf
+{
+
+namespace {
+
+std::wstring Wide(std::string const &value) {
+  return Widen(value);
+}
+
+std::wstring StringOption(React::JSValue const &options, char const *key) {
+  if (options.Type() != React::JSValueType::Object) {
+    return L"";
+  }
+  auto const &value = options.AsObject();
+  auto it = value.find(key);
+  return it != value.end() && it->second.Type() == React::JSValueType::String ? Wide(it->second.AsString()) : L"";
+}
+
+double NumberOption(React::JSValue const &options, char const *key) {
+  if (options.Type() != React::JSValueType::Object) {
+    return 0;
+  }
+  auto const &value = options.AsObject();
+  auto it = value.find(key);
+  return it != value.end() && (it->second.Type() == React::JSValueType::Double || it->second.Type() == React::JSValueType::Int64)
+      ? it->second.AsDouble()
+      : 0;
+}
+
+// [[key, value], ...] from JavaScript
+TxtPairs ReadTxt(React::JSValue const &txt) {
+  TxtPairs pairs;
+  if (txt.Type() != React::JSValueType::Array) {
+    return pairs;
+  }
+  for (auto const &pair : txt.AsArray()) {
+    if (pair.Type() == React::JSValueType::Array && pair.AsArray().size() == 2) {
+      pairs.emplace_back(Wide(pair.AsArray()[0].AsString()), Wide(pair.AsArray()[1].AsString()));
+    }
+  }
+  return pairs;
+}
+
+React::JSValueObject ServiceObject(Service const &service) {
+  React::JSValueArray addresses;
+  for (auto const &address : service.addresses) {
+    addresses.push_back(Narrow(address));
+  }
+  React::JSValueObject txt;
+  for (auto const &pair : service.txt) {
+    txt[Narrow(pair.first)] = Narrow(pair.second);
+  }
+  React::JSValueObject object;
+  object["name"] = Narrow(service.name);
+  object["fullName"] = Narrow(service.fullName);
+  object["host"] = Narrow(service.host);
+  object["port"] = static_cast<int64_t>(service.port);
+  object["addresses"] = std::move(addresses);
+  object["txt"] = std::move(txt);
+  return object;
+}
+
+React::JSValueObject ErrorObject(Error const &error) {
+  React::JSValueObject object;
+  object["message"] = Narrow(error.message);
+  if (error.stringCode.empty()) {
+    object["code"] = error.code;
+  } else {
+    object["code"] = Narrow(error.stringCode);
+  }
+  object["domain"] = Narrow(error.domain);
+  if (!error.serviceName.empty()) {
+    object["serviceName"] = Narrow(error.serviceName);
+  }
+  return object;
+}
+
+// Rejects with the same { message, code, domain, serviceName } in userInfo as iOS and Android
+void Reject(React::ReactPromise<React::JSValue> const &promise, Error const &error) {
+  React::ReactError reactError;
+  reactError.Code = error.stringCode.empty() ? std::to_string(error.code) : Narrow(error.stringCode);
+  reactError.Message = Narrow(error.message);
+  reactError.UserInfo = ErrorObject(error);
+  promise.Reject(std::move(reactError));
+}
+
+} // namespace
+
+void RNZeroconf::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+
+  Events events;
+  events.start = [this](std::string const &scanId) {
+    React::JSValueObject body;
+    body["scanId"] = scanId;
+    Emit(L"RNZeroconfStart", std::move(body));
+  };
+  events.stop = [this](std::string const &scanId) {
+    React::JSValueObject body;
+    body["scanId"] = scanId;
+    Emit(L"RNZeroconfStop", std::move(body));
+  };
+  events.found = [this](std::string const &scanId, std::wstring const &name) {
+    React::JSValueObject body;
+    body["name"] = Narrow(name);
+    body["scanId"] = scanId;
+    Emit(L"RNZeroconfFound", std::move(body));
+  };
+  events.remove = [this](std::string const &scanId, std::wstring const &name) {
+    React::JSValueObject body;
+    body["name"] = Narrow(name);
+    body["scanId"] = scanId;
+    Emit(L"RNZeroconfRemove", std::move(body));
+  };
+  events.resolved = [this](std::string const &scanId, Service const &service) {
+    React::JSValueObject body = ServiceObject(service);
+    body["scanId"] = scanId;
+    Emit(L"RNZeroconfResolved", std::move(body));
+  };
+  events.published = [this](Service const &service) { Emit(L"RNZeroconfServiceRegistered", ServiceObject(service)); };
+  events.unpublished = [this](Service const &service) { Emit(L"RNZeroconfServiceUnregistered", ServiceObject(service)); };
+  events.error = [this](std::string const &scanId, Error const &error) {
+    React::JSValueObject body = ErrorObject(error);
+    if (!scanId.empty()) {
+      body["scanId"] = scanId;
+    }
+    Emit(L"RNZeroconfError", std::move(body));
+  };
+  m_zeroconf = std::make_unique<Zeroconf>(std::move(events));
+}
+
+void RNZeroconf::Emit(std::wstring_view eventName, React::JSValueObject body) noexcept {
+  m_context.EmitJSEvent(L"RCTDeviceEventEmitter", eventName, std::move(body));
+}
+
+void RNZeroconf::scan(std::string scanId, std::string type, std::string protocol, std::string domain, React::JSValue options) noexcept {
+  m_zeroconf->Scan(scanId, Wide(type), Wide(protocol), Wide(domain), StringOption(options, "subtype"), StringOption(options, "networkInterface"));
+}
+
+void RNZeroconf::stop(React::JSValue scanId) noexcept {
+  if (scanId.Type() == React::JSValueType::String && !scanId.AsString().empty()) {
+    m_zeroconf->Stop(scanId.AsString());
+  } else {
+    m_zeroconf->StopAll();
+  }
+}
+
+void RNZeroconf::registerService(
+    std::string type,
+    std::string protocol,
+    std::string domain,
+    std::string name,
+    int port,
+    React::JSValue txt,
+    React::JSValue options,
+    React::ReactPromise<React::JSValue> promise) noexcept {
+  // windns.h can't register subtypes
+  if (options.Type() == React::JSValueType::Object) {
+    auto const &object = options.AsObject();
+    auto subtypes = object.find("subtypes");
+    if (subtypes != object.end() && subtypes->second.Type() == React::JSValueType::Array && !subtypes->second.AsArray().empty()) {
+      Error error;
+      error.domain = L"RNZeroconf";
+      error.stringCode = L"UNSUPPORTED";
+      error.message = L"Publishing subtypes is not supported on Windows";
+      error.serviceName = Wide(name);
+      Reject(promise, error);
+      return;
+    }
+  }
+  m_zeroconf->Publish(
+      Wide(type),
+      Wide(protocol),
+      Wide(domain),
+      Wide(name),
+      static_cast<uint16_t>(port),
+      ReadTxt(txt),
+      StringOption(options, "networkInterface"),
+      [promise](Service const &service) mutable { promise.Resolve(React::JSValue(ServiceObject(service))); },
+      [promise](Error const &error) mutable { Reject(promise, error); });
+}
+
+void RNZeroconf::unregisterService(std::string name, React::ReactPromise<React::JSValue> promise) noexcept {
+  m_zeroconf->Unpublish(
+      Wide(name),
+      [promise](Service const &service) mutable { promise.Resolve(React::JSValue(ServiceObject(service))); },
+      [promise](Error const &error) mutable { Reject(promise, error); });
+}
+
+void RNZeroconf::updateService(std::string name, React::JSValue txt, React::ReactPromise<React::JSValue> promise) noexcept {
+  m_zeroconf->Update(
+      Wide(name),
+      ReadTxt(txt),
+      [promise](Service const &service) mutable { promise.Resolve(React::JSValue(ServiceObject(service))); },
+      [promise](Error const &error) mutable { Reject(promise, error); });
+}
+
+void RNZeroconf::resolveService(
+    std::string name,
+    std::string type,
+    std::string protocol,
+    std::string domain,
+    React::JSValue options,
+    React::ReactPromise<React::JSValue> promise) noexcept {
+  m_zeroconf->ResolveService(
+      Wide(name),
+      Wide(type),
+      Wide(protocol),
+      Wide(domain),
+      StringOption(options, "networkInterface"),
+      NumberOption(options, "timeout"),
+      [promise](Service const &service) mutable { promise.Resolve(React::JSValue(ServiceObject(service))); },
+      [promise](Error const &error) mutable { Reject(promise, error); });
+}
+
+void RNZeroconf::checkLocalNetworkAccess(React::JSValue, React::JSValue, React::ReactPromise<React::JSValue> promise) noexcept {
+  // Nothing to grant on Windows, as on Android before Android 17
+  promise.Resolve(React::JSValue("granted"));
+}
+
+} // namespace winrt::RNZeroconf

package/windows/RNZeroconf/RNZeroconf.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE