react-native-zeroconf 0.15.2 → 0.16.0

package/android/src/main/java/com/balthazargronon/RCTZeroconf/nsd/ServiceInfoCallbacks.java

@@ -0,0 +1,89 @@
+package com.balthazargronon.RCTZeroconf.nsd;
+
+import android.annotation.TargetApi;
+import android.net.nsd.NsdManager;
+import android.net.nsd.NsdServiceInfo;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+
+/**
+ * Follows found services with NsdManager.registerServiceInfoCallback (Android 14+) instead of one-shot resolves:
+ * services can be followed concurrently, updates (addresses, TXT records) are delivered as they change.
+ * Only loaded on API 34+, so older devices never touch these APIs.
+ */
+@TargetApi(34)
+class ServiceInfoCallbacks {
+    private static final String TAG = "ServiceInfoCallbacks";
+
+    interface Listener {
+        void onServiceUpdated(NsdServiceInfo serviceInfo);
+
+        void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode);
+    }
+
+    private final NsdManager nsdManager;
+    private final Executor executor;
+    private final Listener listener;
+    private final Map<String, NsdManager.ServiceInfoCallback> callbacks = new ConcurrentHashMap<>();
+
+    ServiceInfoCallbacks(NsdManager nsdManager, Executor executor, Listener listener) {
+        this.nsdManager = nsdManager;
+        this.executor = executor;
+        this.listener = listener;
+    }
+
+    void register(final NsdServiceInfo serviceInfo) {
+        final String name = serviceInfo.getServiceName();
+        if (callbacks.containsKey(name)) {
+            return;
+        }
+
+        NsdManager.ServiceInfoCallback callback = new NsdManager.ServiceInfoCallback() {
+            @Override
+            public void onServiceInfoCallbackRegistrationFailed(int errorCode) {
+                callbacks.remove(name);
+                listener.onRegistrationFailed(serviceInfo, errorCode);
+            }
+
+            @Override
+            public void onServiceUpdated(NsdServiceInfo updated) {
+                listener.onServiceUpdated(updated);
+            }
+
+            @Override
+            public void onServiceLost() {
+                // Reported by the discovery listener
+            }
+
+            @Override
+            public void onServiceInfoCallbackUnregistered() {
+            }
+        };
+        callbacks.put(name, callback);
+        Log.d(TAG, "Following " + name + " with registerServiceInfoCallback");
+        nsdManager.registerServiceInfoCallback(serviceInfo, executor, callback);
+    }
+
+    void unregister(String name) {
+        NsdManager.ServiceInfoCallback callback = callbacks.remove(name);
+        if (callback == null) {
+            return;
+        }
+        try {
+            nsdManager.unregisterServiceInfoCallback(callback);
+        } catch (IllegalArgumentException e) {
+            // Registration failed or was already unregistered
+            Log.w(TAG, "unregisterServiceInfoCallback failed", e);
+        }
+    }
+
+    void unregisterAll() {
+        for (String name : new ArrayList<>(callbacks.keySet())) {
+            unregister(name);
+        }
+    }
+}

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

@@ -7,12 +7,14 @@ 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;
@@ -21,6 +23,7 @@ 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;
@@ -37,12 +40,13 @@ public class DnssdImpl implements Zeroconf {
 
     private Rx2Dnssd rxDnssd;
 
-    @Nullable
-    private Disposable browseDisposable;
 
     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;
@@ -59,7 +63,7 @@ public class DnssdImpl implements Zeroconf {
     /**
      * Creates the Rx2Dnssd implementation.
      * Always uses embedded mDNSResponder since it works across all Android versions.
-     * The daemonic version (Rx2DnssdBindable) is unreliable on Android as the
+     * 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) {
@@ -67,52 +71,101 @@ public class DnssdImpl implements Zeroconf {
     }
 
     @Override
-    public void scan(String type, String protocol, String domain) {
-        this.stop();
-
-        if (multicastLock == null) {
-            @SuppressLint("WifiManagerLeak") WifiManager wifi = (WifiManager) reactApplicationContext.getSystemService(Context.WIFI_SERVICE);
-            multicastLock = wifi.createMulticastLock("multicastLock");
-            multicastLock.setReferenceCounted(true);
-            multicastLock.acquire();
-        }
+    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 for: " + serviceType);
+        Log.d(TAG, "Starting DNSSD scan " + scanId + " for: " + serviceType);
 
-        // Emit start event
-        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_START, null);
+        sendScanEvent(ZeroconfModule.EVENT_START, new WritableNativeMap(), scanId);
 
-        browseDisposable = rxDnssd.browse(serviceType, "local.")
+        // 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()) {
-                        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_FOUND, serviceNameToMap(bonjourService));
+                        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 -> bonjourService.isLost()
-                        ? Flowable.just(bonjourService)
-                        : Flowable.just(bonjourService)
+                .flatMap(bonjourService -> Flowable.just(bonjourService)
                                 .compose(rxDnssd.resolve())
                                 .compose(rxDnssd.queryRecords())
                                 .onErrorResumeNext((Throwable throwable) -> {
                                     Log.e(TAG, "Error resolving service: ", throwable);
-                                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_ERROR, "Resolving service failed: " + throwable.getMessage());
+                                    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()) {
-                        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_REMOVE, serviceNameToMap(bonjourService));
                         return;
                     }
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(bonjourService));
+                    sendScanEvent(ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(bonjourService), scanId);
                 }, throwable -> {
                     Log.e(TAG, "Error browsing services: ", throwable);
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_ERROR, "Browsing services failed: " + throwable.getMessage());
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_STOP, null);
+                    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) {
@@ -158,42 +211,58 @@ public class DnssdImpl implements Zeroconf {
     }
 
     @Override
-    public void stop() {
-        if (browseDisposable != null) {
-            browseDisposable.dispose();
-            zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_STOP, null);
+    public void stop(String scanId) {
+        Disposable browse = mBrowses.remove(scanId);
+        if (browse == null) {
+            return;
         }
-        if (multicastLock != null) {
-            multicastLock.release();
+        browse.dispose();
+        releaseMulticastLock();
+        sendScanEvent(ZeroconfModule.EVENT_STOP, new WritableNativeMap(), scanId);
+    }
+
+    @Override
+    public void stopAll() {
+        for (String scanId : new ArrayList<>(mBrowses.keySet())) {
+            stop(scanId);
         }
-        browseDisposable = null;
-        multicastLock = null;
     }
 
     @Override
-    public void unregisterService(String serviceName) {
+    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);
         }
 
-        Disposable registerDisposable = mRegisteredDisposables.get(serviceName);
         if (registerDisposable != null && !registerDisposable.isDisposed()) {
             registerDisposable.dispose();
-            mRegisteredDisposables.remove(serviceName);
         }
+        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) {
+    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())
@@ -202,9 +271,15 @@ public class DnssdImpl implements Zeroconf {
 
                     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);
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_ERROR, "Registering service failed: " + throwable.getMessage());
+                    sendError(throwable, "Registering service " + name + " failed: ", name, null);
+                    rejectWith(registerPromise[0], throwable, "Registering service " + name + " failed: ", name);
+                    registerPromise[0] = null;
                     mRegisteredDisposables.remove(name);
                 });
 
@@ -214,7 +289,7 @@ public class DnssdImpl implements Zeroconf {
     @Override
     public void unregisterAllServices() {
         for (String serviceName : new ArrayList<>(mRegisteredDisposables.keySet())) {
-            unregisterService(serviceName);
+            unregisterService(serviceName, null);
         }
     }
 

package/android/src/main/jni/Android.mk

@@ -1,10 +1,5 @@
 LOCAL_PATH := $(call my-dir)
 
-commonSources := \
-    mdnsresponder/mDNSShared/dnssd_clientlib.c  \
-    mdnsresponder/mDNSShared/dnssd_clientstub.c \
-    mdnsresponder/mDNSShared/dnssd_ipc.c
-
 commonFlags := \
     -O2 -g \
     -fno-strict-aliasing \
@@ -73,23 +68,5 @@ LOCAL_LDLIBS := -llog
 LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
 include $(BUILD_SHARED_LIBRARY)
 
-### DAEMONIC LIB (for Android < 12) ###
-include $(CLEAR_VARS)
-
-LOCAL_SDK_VERSION := 8
-LOCAL_MODULE    := jdns_sd
-LOCAL_SRC_FILES := $(commonSources) JNISupport.c
-
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/mdnsresponder/mDNSShared \
-                    $(LOCAL_PATH)
-
-LOCAL_CFLAGS += $(commonFlags)
-LOCAL_LDLIBS := -llog
-LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
-include $(BUILD_SHARED_LIBRARY)
-
-# NOTE: Both libraries are built with 16KB page alignment for Android 15+ compatibility
-# However, only jdns_sd_embedded is used at runtime (see DnssdImpl.java)
-# - jdns_sd: Daemonic implementation (requires /dev/socket/mdnsd - not available on most devices)
-# - jdns_sd_embedded: Embedded mDNSResponder (used for all Android versions)
+# NOTE: Built with 16KB page alignment for Android 15+ compatibility
 # See: https://developer.android.com/guide/practices/page-sizes

package/android/src/main/jni/Application.mk

@@ -1,3 +1,3 @@
 APP_ABI := armeabi-v7a arm64-v8a x86 x86_64
 APP_PLATFORM := android-21
-APP_STL := c++_shared
+APP_STL := none