react-native-zeroconf 0.17.4 → 1.0.0-rc.2

package/android/src/main/java/com/balthazargronon/RCTZeroconf/{ZeroconfModule.java → NsdHost.java}

@@ -1,6 +1,5 @@
 package com.balthazargronon.RCTZeroconf;
 
-
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.net.ConnectivityManager;
@@ -9,25 +8,21 @@ import android.net.Network;
 import android.os.Build;
 import android.util.Log;
 
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeMap;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.balthazargronon.RCTZeroconf.nsd.NsdServiceImpl;
+import com.facebook.proguard.annotations.DoNotStrip;
 
-import javax.annotation.Nullable;
+import java.util.LinkedHashMap;
+import java.util.Map;
 
+import javax.annotation.Nullable;
 
 /**
- * Created by Jeremy White on 8/1/2016.
- * Copyright © 2016 Balthazar Gronon MIT
+ * Android NSD for the C++ module (cpp/android/NsdBackend): it calls these methods through JNI, events,
+ * errors and results come back through native methods. Also the constants and helpers of the NSD code.
  */
-public class ZeroconfModule extends ReactContextBaseJavaModule {
+@DoNotStrip
+public final class NsdHost {
+    private static final String TAG = "NsdHost";
 
     public static final String EVENT_START = "RNZeroconfStart";
     public static final String EVENT_STOP = "RNZeroconfStop";
@@ -50,7 +45,6 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
 
     // Where an error code comes from
     public static final String ERROR_DOMAIN_NSD = "NsdManager";
-    public static final String ERROR_DOMAIN_DNSSD = "DNSSD";
     public static final String ERROR_DOMAIN_LIBRARY = "RNZeroconf";
     public static final String ERROR_CODE_EXCEPTION = "EXCEPTION";
     public static final String ERROR_CODE_TIMEOUT = "TIMEOUT";
@@ -60,121 +54,137 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     public static final String PERMISSION_ACCESS_LOCAL_NETWORK = "android.permission.ACCESS_LOCAL_NETWORK";
     public static final String ERROR_CODE_NOT_PUBLISHED = "NOT_PUBLISHED";
 
-    private ZeroConfImplFactory zeroConfFactory;
+    // The C++ backend's id, 0 once it is gone
+    private volatile long handle;
+    private final Context context;
+    private final NsdServiceImpl nsd;
 
-    public ZeroconfModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-        zeroConfFactory = new ZeroConfImplFactory(this, getReactApplicationContext());
+    @DoNotStrip
+    public NsdHost(long handle) {
+        this.handle = handle;
+        this.context = ZeroconfNativeSupport.application();
+        this.nsd = new NsdServiceImpl(this, context);
     }
 
-    @Override
-    public String getName() {
-        return "RNZeroconf";
+    public Context getContext() {
+        return context;
     }
 
-    @ReactMethod
-    public void scan(String scanId, String type, String protocol, String domain, String implType, @Nullable ReadableMap options) {
+    @DoNotStrip
+    public void scan(String scanId, String type, String protocol, String domain, String subtype, String networkInterface, double resolveTimeout) {
         try {
-            getZeroconfImpl(implType).scan(scanId, type, protocol, domain, ZeroconfOptions.from(options));
+            nsd.scan(scanId, type, protocol, domain, new ZeroconfOptions(subtype, null, networkInterface, 5, resolveTimeout));
         } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
+            Log.e(TAG, e.getMessage(), e);
             sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception during scan: " + e.getMessage(), null, scanId);
         }
     }
 
-    /**
-     * Stops the scan with this id, or every scan of the implementation without one
-     */
-    @ReactMethod
-    public void stop(@Nullable String scanId, String implType) {
+    // Stops the scan with this id, or every scan without one
+    @DoNotStrip
+    public void stop(String scanId) {
         try {
-            Zeroconf impl = getZeroconfImpl(implType);
             if (scanId == null || scanId.isEmpty()) {
-                impl.stopAll();
+                nsd.stopAll();
             } else {
-                impl.stop(scanId);
+                nsd.stop(scanId);
             }
         } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
+            Log.e(TAG, e.getMessage(), e);
             sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception during stop: " + e.getMessage(), null, scanId);
         }
     }
 
-    private Zeroconf getZeroconfImpl(String implType) {
-        return zeroConfFactory.getZeroconf(implType);
-    }
-
-    @ReactMethod
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, String implType, @Nullable ReadableMap options, Promise promise) {
+    @DoNotStrip
+    public void registerService(String type, String protocol, String domain, String name, int port, String[] txtKeys, String[] txtValues,
+                                String[] subtypes, String networkInterface, NsdPromise promise) {
         try {
-            getZeroconfImpl(implType).registerService(type, protocol, domain, name, port, txt, ZeroconfOptions.from(options), promise);
+            nsd.registerService(type, protocol, domain, name, port, txt(txtKeys, txtValues),
+                    new ZeroconfOptions(null, subtypes, networkInterface, 5, 5), promise);
         } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
+            Log.e(TAG, e.getMessage(), e);
             String message = "Exception while registering service: " + e.getMessage();
             sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
             reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
         }
     }
 
-    @ReactMethod
-    public void updateService(String serviceName, ReadableArray txt, String implType, Promise promise) {
+    @DoNotStrip
+    public void updateService(String name, String[] txtKeys, String[] txtValues, NsdPromise promise) {
+        try {
+            nsd.updateService(name, txt(txtKeys, txtValues), promise);
+        } catch (Throwable e) {
+            Log.e(TAG, e.getMessage(), e);
+            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception while updating service: " + e.getMessage(), name);
+        }
+    }
+
+    @DoNotStrip
+    public void unregisterService(String name, NsdPromise promise) {
         try {
-            getZeroconfImpl(implType).updateService(serviceName, txt, promise);
+            nsd.unregisterService(name, promise);
         } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
-            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception while updating service: " + e.getMessage(), serviceName);
+            Log.e(TAG, e.getMessage(), e);
+            String message = "Exception while unregistering service: " + e.getMessage();
+            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
+            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, name);
         }
     }
 
-    @ReactMethod
-    public void resolveService(String name, String type, String protocol, String domain, String implType, @Nullable ReadableMap options, Promise promise) {
+    @DoNotStrip
+    public void resolveService(String name, String type, String protocol, String domain, String networkInterface, double timeout, NsdPromise promise) {
         try {
-            getZeroconfImpl(implType).resolveService(name, type, protocol, domain, ZeroconfOptions.from(options), promise);
+            nsd.resolveService(name, type, protocol, domain, new ZeroconfOptions(null, null, networkInterface, timeout, 5), promise);
         } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
+            Log.e(TAG, e.getMessage(), e);
             reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception while resolving service: " + e.getMessage(), name);
         }
     }
 
+    // Stops the scans and unpublishes the services, when the module goes away
+    @DoNotStrip
+    public void shutdown() {
+        try {
+            nsd.stopAll();
+            nsd.unregisterAllServices();
+        } catch (Throwable e) {
+            Log.e(TAG, e.getMessage(), e);
+        }
+        handle = 0;
+    }
+
     /**
-     * Resolves "granted" or "denied". On Android 17 (API 37) devices, the ACCESS_LOCAL_NETWORK runtime permission
+     * "granted" or "denied". On Android 17 (API 37) devices, the ACCESS_LOCAL_NETWORK runtime permission
      * is enforced for apps targeting API 37 and for apps declaring it in their manifest. Otherwise there is nothing to grant.
      */
-    @ReactMethod
-    public void checkLocalNetworkAccess(Promise promise) {
-        Context context = getReactApplicationContext();
+    @DoNotStrip
+    public static String checkLocalNetworkAccess() {
+        Context context = ZeroconfNativeSupport.application();
+        if (context == null) {
+            return "unknown";
+        }
         boolean required = Build.VERSION.SDK_INT >= 37
                 && (context.getApplicationInfo().targetSdkVersion >= 37 || declaresPermission(context, PERMISSION_ACCESS_LOCAL_NETWORK));
         if (!required) {
-            promise.resolve("granted");
-            return;
+            return "granted";
         }
         boolean granted = context.checkSelfPermission(PERMISSION_ACCESS_LOCAL_NETWORK) == PackageManager.PERMISSION_GRANTED;
-        promise.resolve(granted ? "granted" : "denied");
+        return granted ? "granted" : "denied";
     }
 
-    @ReactMethod
-    public void unregisterService(String serviceName, String implType, Promise promise) {
-        try {
-            getZeroconfImpl(implType).unregisterService(serviceName, promise);
-        } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
-            String message = "Exception while unregistering service: " + e.getMessage();
-            sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, serviceName);
-            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, message, serviceName);
+    private static Map<String, String> txt(String[] keys, String[] values) {
+        Map<String, String> txt = new LinkedHashMap<>();
+        for (int i = 0; i < keys.length && i < values.length; i++) {
+            txt.put(keys[i], values[i]);
         }
+        return txt;
     }
 
-    public void sendEvent(ReactContext reactContext,
-                          String eventName,
-                          @Nullable Object params) {
-        try {
-            reactContext
-                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                    .emit(eventName, params);
-        } catch (Throwable e) {
-            // The JS side may already be gone, e.g. callbacks arriving during teardown
-            Log.w(getClass().getName(), "Could not send " + eventName + ": " + e.getMessage());
+    // Events of the NSD code, with the scan id in the payload for scan events
+    public void sendEvent(String eventName, NsdPayload body) {
+        long current = handle;
+        if (current != 0) {
+            nativeEvent(current, eventName, body);
         }
     }
 
@@ -191,35 +201,17 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
      * @param scanId the scan the error belongs to, null for errors not related to a scan
      */
     public void sendError(String domain, Object code, String message, @Nullable String serviceName, @Nullable String scanId) {
-        WritableMap error = buildError(domain, code, message, serviceName);
-        if (scanId != null) {
-            error.putString(KEY_SCAN_ID, scanId);
+        long current = handle;
+        if (current != 0) {
+            nativeError(current, scanId == null ? "" : scanId, domain, String.valueOf(code), message, serviceName == null ? "" : serviceName);
         }
-        sendEvent(getReactApplicationContext(), EVENT_ERROR, error);
     }
 
-    /**
-     * Rejects a promise with the same { message, code, domain, serviceName } shape as error events, in userInfo
-     */
-    public static void reject(@Nullable Promise promise, String domain, Object code, String message, @Nullable String serviceName) {
+    // Rejects a call with the same { message, code, domain, serviceName } as error events
+    public static void reject(@Nullable NsdPromise promise, String domain, Object code, String message, @Nullable String serviceName) {
         if (promise != null) {
-            promise.reject(String.valueOf(code), message, buildError(domain, code, message, serviceName));
-        }
-    }
-
-    private static WritableMap buildError(String domain, Object code, String message, @Nullable String serviceName) {
-        WritableMap error = new WritableNativeMap();
-        error.putString("message", message);
-        error.putString("domain", domain);
-        if (code instanceof Integer) {
-            error.putInt("code", (Integer) code);
-        } else {
-            error.putString("code", String.valueOf(code));
-        }
-        if (serviceName != null) {
-            error.putString("serviceName", serviceName);
+            promise.reject(domain, String.valueOf(code), message, serviceName);
         }
-        return error;
     }
 
     public static final String SERVICE_TYPES_TYPE = "services._dns-sd";
@@ -296,42 +288,7 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
         }
     }
 
-    /**
-     * Readable description of a DNSServiceErrorType code, as on iOS
-     */
-    public static String describeDnssdError(int errorCode) {
-        switch (errorCode) {
-            case -65548: return "name already in use"; // kDNSServiceErr_NameConflict
-            case -65540: return "bad parameter"; // kDNSServiceErr_BadParam
-            case -65538: return "no such name"; // kDNSServiceErr_NoSuchName
-            case -65554: return "no such record"; // kDNSServiceErr_NoSuchRecord
-            case -65563: return "mDNSResponder is not running"; // kDNSServiceErr_ServiceNotRunning
-            case -65539: return "out of memory"; // kDNSServiceErr_NoMemory
-            case -65544: return "unsupported"; // kDNSServiceErr_Unsupported
-            default: return "error " + errorCode;
-        }
-    }
-
-    // Called on teardown by current React Native versions.
-    // No @Override so it still compiles against versions that don't declare it.
-    public void invalidate() {
-        teardown();
-    }
-
-    // Called on teardown by older React Native versions, deprecated in favor of invalidate().
-    // No @Override so it still compiles once it is removed.
-    public void onCatalystInstanceDestroy() {
-        teardown();
-    }
+    private static native void nativeEvent(long handle, String eventName, NsdPayload body);
 
-    private void teardown() {
-        try {
-            for (Zeroconf impl : zeroConfFactory.getCreatedImpls()) {
-                impl.stopAll();
-                impl.unregisterAllServices();
-            }
-        } catch (Throwable e) {
-            Log.e(getClass().getName(), e.getMessage(), e);
-        }
-    }
+    private static native void nativeError(long handle, String scanId, String domain, String code, String message, String serviceName);
 }

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

@@ -0,0 +1,87 @@
+package com.balthazargronon.RCTZeroconf;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * An event or result of the NSD implementation, read by the C++ module (cpp/android/NsdBackend) through JNI:
+ * a service's name, full name, host, port, addresses and TXT record.
+ */
+@DoNotStrip
+public final class NsdPayload {
+    private final Map<String, Object> values = new LinkedHashMap<>();
+
+    public void putString(String key, @Nullable String value) {
+        values.put(key, value);
+    }
+
+    public void putInt(String key, int value) {
+        values.put(key, value);
+    }
+
+    public void putArray(String key, List<String> value) {
+        values.put(key, new ArrayList<>(value));
+    }
+
+    public void putMap(String key, NsdPayload value) {
+        values.put(key, value);
+    }
+
+    @DoNotStrip
+    @Nullable
+    public String getString(String key) {
+        Object value = values.get(key);
+        return value instanceof String ? (String) value : null;
+    }
+
+    @DoNotStrip
+    public int getInt(String key) {
+        Object value = values.get(key);
+        return value instanceof Integer ? (Integer) value : 0;
+    }
+
+    @DoNotStrip
+    public String[] getStrings(String key) {
+        Object value = values.get(key);
+        if (!(value instanceof List)) {
+            return new String[0];
+        }
+        List<?> list = (List<?>) value;
+        String[] strings = new String[list.size()];
+        for (int i = 0; i < strings.length; i++) {
+            strings[i] = String.valueOf(list.get(i));
+        }
+        return strings;
+    }
+
+    // The keys, then the values, of a nested map of strings (the TXT record), in order
+    @DoNotStrip
+    public String[] getMapKeys(String key) {
+        Object value = values.get(key);
+        if (!(value instanceof NsdPayload)) {
+            return new String[0];
+        }
+        return ((NsdPayload) value).values.keySet().toArray(new String[0]);
+    }
+
+    @DoNotStrip
+    public String[] getMapValues(String key) {
+        Object value = values.get(key);
+        if (!(value instanceof NsdPayload)) {
+            return new String[0];
+        }
+        Map<String, Object> map = ((NsdPayload) value).values;
+        String[] strings = new String[map.size()];
+        int i = 0;
+        for (Object entry : map.values()) {
+            strings[i++] = entry == null ? "" : String.valueOf(entry);
+        }
+        return strings;
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.balthazargronon.RCTZeroconf;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+import javax.annotation.Nullable;
+
+/**
+ * Settles a call of the C++ module (cpp/android/NsdBackend) once: with a service, or with
+ * { domain, code, message, serviceName }.
+ */
+@DoNotStrip
+public final class NsdPromise {
+    private final long id;
+    private boolean settled = false;
+
+    @DoNotStrip
+    public NsdPromise(long id) {
+        this.id = id;
+    }
+
+    public synchronized void resolve(@Nullable NsdPayload service) {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        nativeResolve(id, service);
+    }
+
+    public synchronized void reject(String domain, String code, String message, @Nullable String serviceName) {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        nativeReject(id, domain, code, message, serviceName == null ? "" : serviceName);
+    }
+
+    private static native void nativeResolve(long id, @Nullable NsdPayload service);
+
+    private static native void nativeReject(long id, String domain, String code, String message, String serviceName);
+}

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

@@ -1,7 +1,5 @@
 package com.balthazargronon.RCTZeroconf;
 
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReadableArray;
 
 import javax.annotation.Nullable;
 
@@ -19,23 +17,23 @@ public interface Zeroconf {
     /**
      * @param promise resolved with the service once unregistered, null when nobody waits for it
      */
-    public void unregisterService(String serviceName, @Nullable Promise promise);
+    public void unregisterService(String serviceName, @Nullable NsdPromise promise);
 
     /**
      * @param txt TXT records as ordered [key, value] pairs
      * @param promise resolved with the service once registered
      */
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, ZeroconfOptions options, Promise promise);
+    public void registerService(String type, String protocol, String domain, String name, int port, java.util.Map<String, String> txt, ZeroconfOptions options, NsdPromise promise);
 
     /**
      * Replaces the TXT record of a published service
      */
-    void updateService(String serviceName, ReadableArray txt, Promise promise);
+    void updateService(String serviceName, java.util.Map<String, String> txt, NsdPromise promise);
 
     /**
      * Resolves one service by name, without scanning
      */
-    void resolveService(String name, String type, String protocol, String domain, ZeroconfOptions options, Promise promise);
+    void resolveService(String name, String type, String protocol, String domain, ZeroconfOptions options, NsdPromise promise);
 
     /**
      * Unregister every service published through this implementation

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

@@ -0,0 +1,60 @@
+package com.balthazargronon.RCTZeroconf;
+
+import android.annotation.SuppressLint;
+import android.app.Application;
+import android.content.Context;
+import android.net.wifi.WifiManager;
+import android.util.Log;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * Android services for the C++ module (cpp/android): it calls these through JNI.
+ */
+@DoNotStrip
+public final class ZeroconfNativeSupport {
+    private static final String TAG = "ZeroconfNativeSupport";
+
+    private static WifiManager.MulticastLock multicastLock;
+
+    private ZeroconfNativeSupport() {}
+
+    /**
+     * Android drops multicast packets unless an app holds a multicast lock: held while scans, resolves
+     * or published services are active, released when there are none.
+     */
+    @DoNotStrip
+    public static synchronized void setMulticastLock(boolean held) {
+        if (held) {
+            if (multicastLock == null) {
+                Context context = application();
+                if (context == null) {
+                    Log.w(TAG, "No application context, multicast stays filtered");
+                    return;
+                }
+                @SuppressLint("WifiManagerLeak")
+                WifiManager wifi = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+                if (wifi == null) {
+                    return;
+                }
+                multicastLock = wifi.createMulticastLock("react-native-zeroconf");
+                multicastLock.setReferenceCounted(false);
+            }
+            multicastLock.acquire();
+        } else if (multicastLock != null && multicastLock.isHeld()) {
+            multicastLock.release();
+        }
+    }
+
+    // The application, without a ReactContext: the C++ module has none
+    static Context application() {
+        try {
+            @SuppressLint("PrivateApi")
+            Class<?> activityThread = Class.forName("android.app.ActivityThread");
+            return (Application) activityThread.getMethod("currentApplication").invoke(null);
+        } catch (Exception e) {
+            Log.w(TAG, "Cannot get the application", e);
+            return null;
+        }
+    }
+}

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

@@ -1,8 +1,5 @@
 package com.balthazargronon.RCTZeroconf;
 
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.ReadableType;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -24,30 +21,27 @@ public class ZeroconfOptions {
     /** Scan: seconds to resolve each service, retried once before a TIMEOUT error */
     public double resolveTimeoutSeconds = 5;
 
-    public static ZeroconfOptions from(@Nullable ReadableMap map) {
-        ZeroconfOptions options = new ZeroconfOptions();
-        if (map == null) {
-            return options;
-        }
-        options.subtype = subtypeLabel(getString(map, "subtype"));
-        if (map.hasKey("subtypes") && map.getType("subtypes") == ReadableType.Array) {
-            ReadableArray subtypes = map.getArray("subtypes");
-            for (int i = 0; i < subtypes.size(); i++) {
-                String label = subtypes.getType(i) == ReadableType.String ? subtypeLabel(subtypes.getString(i)) : null;
+    /**
+     * @param timeout resolveService's timeout in seconds, ignored unless positive
+     * @param resolveTimeout scans' resolve timeout in seconds, ignored unless positive
+     */
+    public ZeroconfOptions(@Nullable String subtype, @Nullable String[] subtypes, @Nullable String networkInterface, double timeout, double resolveTimeout) {
+        this.subtype = subtypeLabel(subtype);
+        if (subtypes != null) {
+            for (String candidate : subtypes) {
+                String label = subtypeLabel(candidate);
                 if (label != null) {
-                    options.subtypes.add(label);
+                    this.subtypes.add(label);
                 }
             }
         }
-        String networkInterface = getString(map, "networkInterface");
-        options.networkInterface = networkInterface == null || networkInterface.isEmpty() ? null : networkInterface;
-        if (map.hasKey("timeout") && map.getType("timeout") == ReadableType.Number && map.getDouble("timeout") > 0) {
-            options.timeoutSeconds = map.getDouble("timeout");
+        this.networkInterface = networkInterface == null || networkInterface.isEmpty() ? null : networkInterface;
+        if (timeout > 0) {
+            this.timeoutSeconds = timeout;
         }
-        if (map.hasKey("resolveTimeout") && map.getType("resolveTimeout") == ReadableType.Number && map.getDouble("resolveTimeout") > 0) {
-            options.resolveTimeoutSeconds = map.getDouble("resolveTimeout");
+        if (resolveTimeout > 0) {
+            this.resolveTimeoutSeconds = resolveTimeout;
         }
-        return options;
     }
 
     /**
@@ -61,11 +55,6 @@ public class ZeroconfOptions {
         return type.toString();
     }
 
-    @Nullable
-    private static String getString(ReadableMap map, String key) {
-        return map.hasKey(key) && map.getType(key) == ReadableType.String ? map.getString(key) : null;
-    }
-
     // "printer" or "_printer" -> "_printer"
     @Nullable
     private static String subtypeLabel(@Nullable String subtype) {