react-native-zeroconf 0.16.1 → 0.17.1

package/windows/RNZeroconf/ZeroconfCore.h

@@ -0,0 +1,167 @@
+// Zeroconf on Windows with the DNS-SD functions of windns.h (Windows 10 1809 and later).
+// No React Native dependency: RNZeroconf.cpp bridges it to JavaScript, test/windows/harness.cpp tests it.
+#pragma once
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <windns.h>
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rnzeroconf {
+
+using TxtPairs = std::vector<std::pair<std::wstring, std::wstring>>;
+
+struct Service {
+  std::wstring name;
+  std::wstring fullName;
+  std::wstring host;
+  uint16_t port = 0;
+  std::vector<std::wstring> addresses;
+  TxtPairs txt;
+};
+
+// { message, code, domain, serviceName } as on the other platforms.
+// domain "Windows": code is a Win32 / DNS_STATUS number. domain "RNZeroconf": stringCode is set.
+struct Error {
+  std::wstring domain;
+  int64_t code = 0;
+  std::wstring stringCode;
+  std::wstring message;
+  std::wstring serviceName;
+};
+
+using ServiceCallback = std::function<void(const Service &)>;
+using ErrorCallback = std::function<void(const Error &)>;
+
+// Called from DNS-SD threads. scanId is empty for errors that are 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::wstring &name)> found;
+  std::function<void(const std::string &scanId, const std::wstring &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 Operation;
+struct Browse;
+struct Resolve;
+struct Publication;
+
+class Zeroconf {
+ public:
+  explicit Zeroconf(Events events);
+  ~Zeroconf();
+
+  Zeroconf(const Zeroconf &) = delete;
+  Zeroconf &operator=(const Zeroconf &) = delete;
+
+  // type and protocol without underscore ("http", "tcp"). "services._dns-sd" / "udp" lists service types
+  void Scan(
+      const std::string &scanId,
+      const std::wstring &type,
+      const std::wstring &protocol,
+      const std::wstring &domain,
+      const std::wstring &subtype,
+      const std::wstring &networkInterface,
+      double resolveTimeoutSeconds = 5);
+  void Stop(const std::string &scanId);
+  void StopAll();
+
+  void Publish(
+      const std::wstring &type,
+      const std::wstring &protocol,
+      const std::wstring &domain,
+      const std::wstring &name,
+      uint16_t port,
+      const TxtPairs &txt,
+      const std::wstring &networkInterface,
+      ServiceCallback resolve,
+      ErrorCallback reject);
+  void Unpublish(const std::wstring &name, ServiceCallback resolve, ErrorCallback reject);
+  // windns.h has no update: unpublishes and publishes again under the same name
+  void Update(const std::wstring &name, const TxtPairs &txt, ServiceCallback resolve, ErrorCallback reject);
+  void UnpublishAll();
+
+  void ResolveService(
+      const std::wstring &name,
+      const std::wstring &type,
+      const std::wstring &protocol,
+      const std::wstring &domain,
+      const std::wstring &networkInterface,
+      double timeoutSeconds,
+      ServiceCallback resolve,
+      ErrorCallback reject);
+
+  // Callbacks of windns.h, routed through a registry of live operations
+  void OnBrowse(const std::shared_ptr<Browse> &browse, DWORD status, PDNS_RECORD records);
+  void OnResolve(const std::shared_ptr<Resolve> &resolve, DWORD status, PDNS_SERVICE_INSTANCE instance);
+  void OnRegister(const std::shared_ptr<Publication> &publication, DWORD status, PDNS_SERVICE_INSTANCE instance);
+
+ private:
+  using After = std::vector<std::function<void()>>;
+
+  void StopLocked(const std::string &scanId, After &after);
+  void StartResolve(const std::shared_ptr<Resolve> &resolve, After &after);
+  void StartScanResolve(const std::shared_ptr<Browse> &browse, const std::shared_ptr<Resolve> &resolve, After &after);
+  void CancelResolve(const std::shared_ptr<Resolve> &resolve, After &after);
+  void PublishAs(
+      const std::wstring &regType,
+      const std::wstring &domain,
+      const std::wstring &requestedName,
+      uint16_t port,
+      const TxtPairs &txt,
+      ULONG interfaceIndex,
+      bool announce,
+      ServiceCallback resolve,
+      ErrorCallback reject);
+  void UnpublishWith(const std::wstring &name, bool announce, ServiceCallback resolve, ErrorCallback reject);
+  Service PublishedService(const Publication &publication) const;
+  // Service type scans also list the types this app publishes, the network doesn't answer them back
+  void SyncLocalType(const std::wstring &regType, const std::wstring &domain, After &after);
+  bool LocallyPublished(const std::wstring &typeKey) const;
+  bool InterfaceIndex(const std::wstring &networkInterface, ULONG &index, Error &error) const;
+
+  Events events_;
+  // False once destroyed, for the resolveService() timeout threads
+  std::shared_ptr<std::atomic<bool>> alive_;
+  std::recursive_mutex mutex_;
+  std::map<std::string, std::shared_ptr<Browse>> browses_;
+  // Keyed by the published name, which can differ from the requested one
+  std::map<std::wstring, std::shared_ptr<Publication>> publications_;
+  std::vector<std::shared_ptr<Resolve>> singleResolves_;
+  std::wstring hostName_;
+};
+
+// Helpers shared with the bridge and the harness
+std::wstring Widen(const std::string &value);
+std::string Narrow(const std::wstring &value);
+std::wstring DescribeStatus(DWORD status);
+
+} // namespace rnzeroconf

package/windows/RNZeroconf/pch.cpp

@@ -0,0 +1 @@
+#include "pch.h"

package/windows/RNZeroconf/pch.h

@@ -0,0 +1,30 @@
+// pch.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#define NOMINMAX 1
+#define WIN32_LEAN_AND_MEAN 1
+#define WINRT_LEAN_AND_MEAN 1
+
+// Windows Header Files
+#include <windows.h>
+#undef GetCurrentTime
+#include <unknwn.h>
+
+// WinRT Header Files
+#include <winrt/base.h>
+#include <CppWinRTIncludes.h>
+#include <winrt/Microsoft.ReactNative.h>
+
+// C RunTime Header Files
+#include <malloc.h>
+#include <memory.h>
+#include <stdlib.h>
+#include <tchar.h>
+
+// Reference additional headers your project requires here

package/windows/RNZeroconf/resource.h

@@ -0,0 +1,5 @@
+//
+// Microsoft Visual C++ generated include file.
+// Used by RNZeroconf.rc
+
+#pragma once

package/windows/RNZeroconf/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

package/windows/RNZeroconf.sln

@@ -0,0 +1,43 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.3.32929.385
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "RNZeroconf", "RNZeroconf\RNZeroconf.vcxproj", "{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Debug|ARM64 = Debug|ARM64
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+		Release|ARM64 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x64.ActiveCfg = Debug|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x64.Build.0 = Debug|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x64.Deploy.0 = Debug|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x86.ActiveCfg = Debug|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x86.Build.0 = Debug|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|x86.Deploy.0 = Debug|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|ARM64.Build.0 = Debug|ARM64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x64.ActiveCfg = Release|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x64.Build.0 = Release|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x64.Deploy.0 = Release|x64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x86.ActiveCfg = Release|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x86.Build.0 = Release|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|x86.Deploy.0 = Release|Win32
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|ARM64.ActiveCfg = Release|ARM64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|ARM64.Build.0 = Release|ARM64
+		{9C9B6A6C-3DC5-494E-BABF-9C841E7F0176}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {D43FAD39-F619-437D-BB40-04A3982ACB6A}
+	EndGlobalSection
+EndGlobal

package/android/src/main/java/com/balthazargronon/RCTZeroconf/rx2dnssd/DnssdImpl.java

@@ -1,305 +0,0 @@
-package com.balthazargronon.RCTZeroconf.rx2dnssd;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.net.wifi.WifiManager;
-import android.util.Log;
-
-import com.balthazargronon.RCTZeroconf.Zeroconf;
-import com.balthazargronon.RCTZeroconf.ZeroconfModule;
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeArray;
-import com.facebook.react.bridge.WritableNativeMap;
-import com.github.druk.dnssd.DNSSDException;
-import com.github.druk.rx2dnssd.BonjourService;
-import com.github.druk.rx2dnssd.Rx2Dnssd;
-import com.github.druk.rx2dnssd.Rx2DnssdEmbedded;
-
-import java.net.InetAddress;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-import io.reactivex.Flowable;
-import io.reactivex.android.schedulers.AndroidSchedulers;
-import io.reactivex.disposables.Disposable;
-import io.reactivex.schedulers.Schedulers;
-
-public class DnssdImpl implements Zeroconf {
-    private static final String TAG = "DnssdImpl";
-
-    private Rx2Dnssd rxDnssd;
-
-
-    private Map<String, BonjourService> mPublishedServices;
-    private Map<String, Disposable> mRegisteredDisposables;
-
-    // Running browses, keyed by the id of the JS instance that started them
-    private final Map<String, Disposable> mBrowses = new ConcurrentHashMap<>();
-
-    private ZeroconfModule zeroconfModule;
-
-    private ReactApplicationContext reactApplicationContext;
-    private WifiManager.MulticastLock multicastLock;
-
-    public DnssdImpl(ZeroconfModule zeroconfModule, ReactApplicationContext reactApplicationContext) {
-        this.zeroconfModule = zeroconfModule;
-        this.reactApplicationContext = reactApplicationContext;
-        mPublishedServices = new HashMap<String, BonjourService>();
-        mRegisteredDisposables = new HashMap<String, Disposable>();
-        rxDnssd = createDnssd(reactApplicationContext);
-    }
-
-    /**
-     * Creates the Rx2Dnssd implementation.
-     * Always uses embedded mDNSResponder since it works across all Android versions.
-     * The daemonic version (not bundled) is unreliable on Android as the
-     * system daemon at /dev/socket/mdnsd doesn't exist on most devices.
-     */
-    private Rx2Dnssd createDnssd(Context context) {
-        return new Rx2DnssdEmbedded(context);
-    }
-
-    @Override
-    public void scan(final String scanId, String type, String protocol, String domain) {
-        this.stop(scanId);
-        acquireMulticastLock();
-
-        String serviceType = getServiceType(type, protocol);
-        Log.d(TAG, "Starting DNSSD scan " + scanId + " for: " + serviceType);
-
-        sendScanEvent(ZeroconfModule.EVENT_START, new WritableNativeMap(), scanId);
-
-        // A service is reported once per network interface, count them so found/remove are emitted once
-        final Map<String, Integer> foundInterfaces = new HashMap<>();
-        Disposable browse = rxDnssd.browse(serviceType, "local.")
-                .doOnNext(bonjourService -> {
-                    String name = bonjourService.getServiceName();
-                    Integer count = foundInterfaces.get(name);
-                    int interfaces = count == null ? 0 : count;
-                    if (!bonjourService.isLost()) {
-                        foundInterfaces.put(name, interfaces + 1);
-                        if (interfaces == 0) {
-                            sendScanEvent(ZeroconfModule.EVENT_FOUND, serviceNameToMap(bonjourService), scanId);
-                        }
-                    } else if (interfaces <= 1) {
-                        foundInterfaces.remove(name);
-                        sendScanEvent(ZeroconfModule.EVENT_REMOVE, serviceNameToMap(bonjourService), scanId);
-                    } else {
-                        foundInterfaces.put(name, interfaces - 1);
-                    }
-                })
-                .filter(bonjourService -> !bonjourService.isLost())
-                // Resolve each service independently so a single failure doesn't end the whole browse
-                .flatMap(bonjourService -> Flowable.just(bonjourService)
-                                .compose(rxDnssd.resolve())
-                                .compose(rxDnssd.queryRecords())
-                                .onErrorResumeNext((Throwable throwable) -> {
-                                    Log.e(TAG, "Error resolving service: ", throwable);
-                                    sendError(throwable, "Resolving service " + bonjourService.getServiceName() + " failed: ", bonjourService.getServiceName(), scanId);
-                                    return Flowable.empty();
-                                }))
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(bonjourService -> {
-                    // Lost services were filtered out above, a lost service could still come back from resolve
-                    if (bonjourService.isLost()) {
-                        return;
-                    }
-                    sendScanEvent(ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(bonjourService), scanId);
-                }, throwable -> {
-                    Log.e(TAG, "Error browsing services: ", throwable);
-                    sendError(throwable, "Browsing services failed: ", null, scanId);
-                    if (mBrowses.remove(scanId) != null) {
-                        releaseMulticastLock();
-                    }
-                    sendScanEvent(ZeroconfModule.EVENT_STOP, new WritableNativeMap(), scanId);
-                });
-        mBrowses.put(scanId, browse);
-    }
-
-    private void sendScanEvent(String eventName, WritableMap body, String scanId) {
-        body.putString(ZeroconfModule.KEY_SCAN_ID, scanId);
-        zeroconfModule.sendEvent(reactApplicationContext, eventName, body);
-    }
-
-    private void acquireMulticastLock() {
-        if (multicastLock == null) {
-            @SuppressLint("WifiManagerLeak") WifiManager wifi = (WifiManager) reactApplicationContext.getSystemService(Context.WIFI_SERVICE);
-            multicastLock = wifi.createMulticastLock("multicastLock");
-            multicastLock.setReferenceCounted(true);
-        }
-        multicastLock.acquire();
-    }
-
-    private void releaseMulticastLock() {
-        if (multicastLock != null && multicastLock.isHeld()) {
-            multicastLock.release();
-        }
-    }
-
-    /**
-     * DNSSD errors carry their DNSServiceErrorType code, anything else is reported as an exception
-     */
-    private void sendError(Throwable throwable, String prefix, @Nullable String serviceName, @Nullable String scanId) {
-        if (throwable instanceof DNSSDException) {
-            DNSSDException dnssdException = (DNSSDException) throwable;
-            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_DNSSD, dnssdException.getErrorCode(), prefix + throwable.getMessage(), serviceName, scanId);
-        } else {
-            zeroconfModule.sendError(ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_EXCEPTION, prefix + throwable.getMessage(), serviceName, scanId);
-        }
-    }
-
-    private void rejectWith(@Nullable Promise promise, Throwable throwable, String prefix, @Nullable String serviceName) {
-        if (throwable instanceof DNSSDException) {
-            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_DNSSD, ((DNSSDException) throwable).getErrorCode(), prefix + throwable.getMessage(), serviceName);
-        } else {
-            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_EXCEPTION, prefix + throwable.getMessage(), serviceName);
-        }
-    }
-
-    private WritableMap serviceNameToMap(BonjourService serviceInfo) {
-        WritableMap service = new WritableNativeMap();
-        service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
-        return service;
-    }
-
-    private String getServiceType(String type, String protocol) {
-        return String.format("_%s._%s", type, protocol);
-    }
-
-    private WritableMap serviceInfoToMap(BonjourService serviceInfo) {
-        WritableMap service = new WritableNativeMap();
-        service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
-        final List<InetAddress> hostList = serviceInfo.getInetAddresses();
-        final String hostname = serviceInfo.getHostname();
-        final String fullServiceName = hostname != null
-                ? hostname + serviceInfo.getRegType()
-                : serviceInfo.getServiceName();
-        service.putString(ZeroconfModule.KEY_SERVICE_HOST, hostname != null ? hostname : serviceInfo.getServiceName());
-
-        WritableArray addresses = new WritableNativeArray();
-        for (InetAddress host : hostList) {
-            addresses.pushString(host.getHostAddress());
-        }
-
-        service.putArray(ZeroconfModule.KEY_SERVICE_ADDRESSES, addresses);
-        service.putString(ZeroconfModule.KEY_SERVICE_FULL_NAME, fullServiceName);
-        service.putInt(ZeroconfModule.KEY_SERVICE_PORT, serviceInfo.getPort());
-
-        WritableMap txtRecords = new WritableNativeMap();
-
-        Map<String, String> attributes = serviceInfo.getTxtRecords();
-        for (String key : attributes.keySet()) {
-            String recordValue = attributes.get(key);
-            txtRecords.putString(String.format(Locale.getDefault(), "%s", key), String.format(Locale.getDefault(), "%s", recordValue != null ? recordValue : ""));
-        }
-
-        service.putMap(ZeroconfModule.KEY_SERVICE_TXT, txtRecords);
-
-        return service;
-    }
-
-    @Override
-    public void stop(String scanId) {
-        Disposable browse = mBrowses.remove(scanId);
-        if (browse == null) {
-            return;
-        }
-        browse.dispose();
-        releaseMulticastLock();
-        sendScanEvent(ZeroconfModule.EVENT_STOP, new WritableNativeMap(), scanId);
-    }
-
-    @Override
-    public void stopAll() {
-        for (String scanId : new ArrayList<>(mBrowses.keySet())) {
-            stop(scanId);
-        }
-    }
-
-    @Override
-    public void unregisterService(String serviceName, @Nullable Promise promise) {
-
-        BonjourService bs = mPublishedServices.get(serviceName);
-        Disposable registerDisposable = mRegisteredDisposables.get(serviceName);
-        if (bs == null && registerDisposable == null) {
-            ZeroconfModule.reject(promise, ZeroconfModule.ERROR_DOMAIN_LIBRARY, ZeroconfModule.ERROR_CODE_NOT_PUBLISHED, "Service " + serviceName + " is not published", serviceName);
-            return;
-        }
-
-        if (bs != null) {
-            zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_UNREGISTERED, serviceInfoToMap(bs));
-            mPublishedServices.remove(serviceName);
-        }
-
-        if (registerDisposable != null && !registerDisposable.isDisposed()) {
-            registerDisposable.dispose();
-        }
-        mRegisteredDisposables.remove(serviceName);
-
-        // Disposing unregisters synchronously
-        if (promise != null) {
-            promise.resolve(bs != null ? serviceInfoToMap(bs) : null);
-        }
-    }
-
-    @Override
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, Promise promise) {
-        BonjourService bs = new BonjourService.Builder(0, 0, name, getServiceType(type, protocol), null)
-                .port(port)
-                .dnsRecords(getTxtRecordMap(txt))
-                .build();
-
-        // Resolved once, the registration stream can emit again later
-        final Promise[] registerPromise = { promise };
-        Disposable registerDisposable = rxDnssd.register(bs)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribe(bonjourService -> {
-                    Log.i(TAG, "Registered service " + bonjourService.toString());
-
-                    mPublishedServices.put(bs.getServiceName(), bs);
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_PUBLISHED, serviceInfoToMap(bonjourService));
-                    if (registerPromise[0] != null) {
-                        registerPromise[0].resolve(serviceInfoToMap(bonjourService));
-                        registerPromise[0] = null;
-                    }
-                }, throwable -> {
-                    Log.e(TAG, "Error registering service: ", throwable);
-                    sendError(throwable, "Registering service " + name + " failed: ", name, null);
-                    rejectWith(registerPromise[0], throwable, "Registering service " + name + " failed: ", name);
-                    registerPromise[0] = null;
-                    mRegisteredDisposables.remove(name);
-                });
-
-        mRegisteredDisposables.put(name, registerDisposable);
-    }
-
-    @Override
-    public void unregisterAllServices() {
-        for (String serviceName : new ArrayList<>(mRegisteredDisposables.keySet())) {
-            unregisterService(serviceName, null);
-        }
-    }
-
-    private Map<String, String> getTxtRecordMap(ReadableArray txt) {
-        // LinkedHashMap keeps the TXT record order
-        Map<String, String> txtMap = new LinkedHashMap<>();
-        for (int i = 0; i < txt.size(); i++) {
-            ReadableArray pair = txt.getArray(i);
-            txtMap.put(pair.getString(0), pair.getString(1));
-        }
-        return txtMap;
-    }
-}