react-native-zeroconf 0.16.1 → 0.17.0

package/NOTICE

@@ -35,9 +35,6 @@ android/src/main/jni/*
 android/src/main/java/com/github/druk/dnssd/*
   - Java DNS-SD API classes
 
-android/src/main/java/com/github/druk/rx2dnssd/*
-  - RxJava2 reactive wrappers for DNS-SD
-
 ================================================================================
 
 mDNSResponder

package/README.md

@@ -2,7 +2,7 @@
   <img src=".github/banner.png" alt="react-native-zeroconf: Bonjour / mDNS discovery and publishing for React Native, on iOS, Android, macOS, tvOS and Expo" width="100%">
 </p>
 
-Find the services other devices advertise on the local network (printers, speakers, cameras, your own servers) and advertise your own, on iOS, Android, macOS and tvOS.
+Find the services other devices advertise on the local network (printers, speakers, cameras, your own servers) and advertise your own, on iOS, Android, macOS, tvOS and Windows.
 
 **[Read the documentation](https://zeroconf.balthazar.dev)**
 

package/android/build.gradle

@@ -42,7 +42,4 @@ repositories {
 
 dependencies {
     implementation "com.facebook.react:react-native:${safeExtGet('reactNativeVersion', '+')}"
-    // RxJava2 for Rx2Dnssd (bundled from Discord's RxDNSSD fork)
-    implementation 'io.reactivex.rxjava2:rxjava:2.2.21'
-    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
 }

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

@@ -1,7 +1,7 @@
 package com.balthazargronon.RCTZeroconf;
 
 import com.balthazargronon.RCTZeroconf.nsd.NsdServiceImpl;
-import com.balthazargronon.RCTZeroconf.rx2dnssd.DnssdImpl;
+import com.balthazargronon.RCTZeroconf.dnssd.DnssdImpl;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 

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

@@ -10,7 +10,7 @@ public interface Zeroconf {
     /**
      * @param scanId id of the JS instance starting the scan, several scans can run at once
      */
-    void scan(String scanId, String type, String protocol, String domain);
+    void scan(String scanId, String type, String protocol, String domain, ZeroconfOptions options);
 
     void stop(String scanId);
 
@@ -25,7 +25,17 @@ public interface Zeroconf {
      * @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, Promise promise);
+    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, ZeroconfOptions options, Promise promise);
+
+    /**
+     * Replaces the TXT record of a published service
+     */
+    void updateService(String serviceName, ReadableArray txt, Promise promise);
+
+    /**
+     * Resolves one service by name, without scanning
+     */
+    void resolveService(String name, String type, String protocol, String domain, ZeroconfOptions options, Promise promise);
 
     /**
      * Unregister every service published through this implementation

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

@@ -1,6 +1,12 @@
 package com.balthazargronon.RCTZeroconf;
 
 
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.net.ConnectivityManager;
+import android.net.LinkProperties;
+import android.net.Network;
+import android.os.Build;
 import android.util.Log;
 
 import com.facebook.react.bridge.Promise;
@@ -9,6 +15,7 @@ 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;
@@ -46,6 +53,11 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     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";
+    public static final String ERROR_CODE_UNKNOWN_INTERFACE = "UNKNOWN_INTERFACE";
+    public static final String ERROR_CODE_UNSUPPORTED = "UNSUPPORTED";
+    // Manifest.permission.ACCESS_LOCAL_NETWORK, API 37
+    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;
@@ -61,9 +73,9 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void scan(String scanId, String type, String protocol, String domain, String implType) {
+    public void scan(String scanId, String type, String protocol, String domain, String implType, @Nullable ReadableMap options) {
         try {
-            getZeroconfImpl(implType).scan(scanId, type, protocol, domain);
+            getZeroconfImpl(implType).scan(scanId, type, protocol, domain, ZeroconfOptions.from(options));
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
             sendError(ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception during scan: " + e.getMessage(), null, scanId);
@@ -93,9 +105,9 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, String implType, Promise promise) {
+    public void registerService(String type, String protocol, String domain, String name, int port, ReadableArray txt, String implType, @Nullable ReadableMap options, Promise promise) {
         try {
-            getZeroconfImpl(implType).registerService(type, protocol, domain, name, port, txt, promise);
+            getZeroconfImpl(implType).registerService(type, protocol, domain, name, port, txt, ZeroconfOptions.from(options), promise);
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
             String message = "Exception while registering service: " + e.getMessage();
@@ -104,6 +116,43 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
         }
     }
 
+    @ReactMethod
+    public void updateService(String serviceName, ReadableArray txt, String implType, Promise promise) {
+        try {
+            getZeroconfImpl(implType).updateService(serviceName, txt, 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);
+        }
+    }
+
+    @ReactMethod
+    public void resolveService(String name, String type, String protocol, String domain, String implType, @Nullable ReadableMap options, Promise promise) {
+        try {
+            getZeroconfImpl(implType).resolveService(name, type, protocol, domain, ZeroconfOptions.from(options), promise);
+        } catch (Throwable e) {
+            Log.e(getClass().getName(), e.getMessage(), e);
+            reject(promise, ERROR_DOMAIN_LIBRARY, ERROR_CODE_EXCEPTION, "Exception while resolving service: " + e.getMessage(), name);
+        }
+    }
+
+    /**
+     * Resolves "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();
+        boolean required = Build.VERSION.SDK_INT >= 37
+                && (context.getApplicationInfo().targetSdkVersion >= 37 || declaresPermission(context, PERMISSION_ACCESS_LOCAL_NETWORK));
+        if (!required) {
+            promise.resolve("granted");
+            return;
+        }
+        boolean granted = context.checkSelfPermission(PERMISSION_ACCESS_LOCAL_NETWORK) == PackageManager.PERMISSION_GRANTED;
+        promise.resolve(granted ? "granted" : "denied");
+    }
+
     @ReactMethod
     public void unregisterService(String serviceName, String implType, Promise promise) {
         try {
@@ -173,6 +222,65 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
         return error;
     }
 
+    public static final String SERVICE_TYPES_TYPE = "services._dns-sd";
+    public static final String SERVICE_TYPES_PROTOCOL = "udp";
+
+    /**
+     * Whether a scan browses _services._dns-sd._udp, whose results are service types
+     */
+    public static boolean isServiceTypesScan(String type, String protocol) {
+        return SERVICE_TYPES_TYPE.equals(type) && SERVICE_TYPES_PROTOCOL.equals(protocol);
+    }
+
+    /**
+     * Service type from a _services._dns-sd._udp result: "_http" and "_tcp.local." give "_http._tcp"
+     */
+    public static String serviceTypeFromResult(String name, @Nullable String regType) {
+        if (regType != null) {
+            for (String label : regType.split("\\.")) {
+                if (label.startsWith("_")) {
+                    return name + "." + label;
+                }
+            }
+        }
+        return name;
+    }
+
+    private static boolean declaresPermission(Context context, String permission) {
+        try {
+            String[] requested = context.getPackageManager()
+                    .getPackageInfo(context.getPackageName(), PackageManager.GET_PERMISSIONS).requestedPermissions;
+            if (requested != null) {
+                for (String declared : requested) {
+                    if (permission.equals(declared)) {
+                        return true;
+                    }
+                }
+            }
+        } catch (PackageManager.NameNotFoundException e) {
+            // Our own package is always found
+        }
+        return false;
+    }
+
+    /**
+     * The Android network of a network interface ("wlan0"), null when there is none
+     */
+    @Nullable
+    public static Network findNetwork(Context context, String interfaceName) {
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (connectivityManager == null) {
+            return null;
+        }
+        for (Network network : connectivityManager.getAllNetworks()) {
+            LinkProperties properties = connectivityManager.getLinkProperties(network);
+            if (properties != null && interfaceName.equals(properties.getInterfaceName())) {
+                return network;
+            }
+        }
+        return null;
+    }
+
     /**
      * Readable description of an NsdManager failure code
      */
@@ -183,6 +291,23 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
             case 4: return "maximum number of requests reached"; // FAILURE_MAX_LIMIT
             case 5: return "operation not running"; // FAILURE_OPERATION_NOT_RUNNING (API 34)
             case 6: return "bad parameters"; // FAILURE_BAD_PARAMETERS (API 34)
+            case 7: return "permission denied, the app needs the ACCESS_LOCAL_NETWORK permission"; // FAILURE_PERMISSION_DENIED (API 37)
+            default: return "error " + errorCode;
+        }
+    }
+
+    /**
+     * 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;
         }
     }

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

@@ -0,0 +1,72 @@
+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;
+
+import javax.annotation.Nullable;
+
+/**
+ * Options of scan, registerService and resolveService
+ */
+public class ZeroconfOptions {
+    /** Scan: subtype to browse, "_printer" */
+    @Nullable public String subtype;
+    /** Publish: subtypes to register, "_printer" */
+    public final List<String> subtypes = new ArrayList<>();
+    /** Network interface name, "wlan0" */
+    @Nullable public String networkInterface;
+    /** resolveService: seconds before giving up */
+    public double timeoutSeconds = 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;
+                if (label != null) {
+                    options.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");
+        }
+        return options;
+    }
+
+    /**
+     * "_ipp._tcp" with the subtypes: "_ipp._tcp,_printer", the syntax of mDNSResponder and NsdManager
+     */
+    public static String withSubtypes(String serviceType, List<String> subtypes) {
+        StringBuilder type = new StringBuilder(serviceType);
+        for (String subtype : subtypes) {
+            type.append(',').append(subtype);
+        }
+        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) {
+        if (subtype == null || subtype.isEmpty()) {
+            return null;
+        }
+        return subtype.startsWith("_") ? subtype : "_" + subtype;
+    }
+}