react-native-zeroconf 0.13.8 → 0.15.0

package/android/build.gradle

@@ -1,14 +1,3 @@
-buildscript {
-  repositories {
-      google()
-      mavenCentral()
-  }
-
-  dependencies {
-    classpath 'com.android.tools.build:gradle:3.5.1'
-  }
-}
-
 apply plugin: 'com.android.library'
 
 def safeExtGet(prop, fallback) {
@@ -16,34 +5,44 @@ def safeExtGet(prop, fallback) {
 }
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 28)
-    buildToolsVersion "23.0.1"
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+    ndkVersion safeExtGet('ndkVersion', '27.1.12297006')
 
     defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 16)
-        targetSdkVersion safeExtGet('targetSdkVersion', 28)
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
         versionCode 1
         versionName "1.0"
+
         ndk {
-            abiFilters "armeabi-v7a", "x86"
+            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+        }
+
+    }
+
+    externalNativeBuild {
+        ndkBuild {
+            path "src/main/jni/Android.mk"
         }
     }
 
     compileOptions {
-        sourceCompatibility = 1.8
-        targetCompatibility = 1.8
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
     }
+
+    // Namespace for Android Gradle Plugin 8.0+
+    namespace 'com.balthazargronon.RCTZeroconf'
 }
 
 repositories {
-  google()
-  mavenCentral()
+    google()
+    mavenCentral()
 }
 
 dependencies {
     implementation "com.facebook.react:react-native:${safeExtGet('reactNativeVersion', '+')}"
-    // https://mvnrepository.com/artifact/com.github.andriydruk/rx2dnssd
-    api group: 'com.github.andriydruk', name: 'rx2dnssd', version: '0.9.16'
-    // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3
-    api group: 'org.apache.commons', name: 'commons-lang3', version: '3.11'
+    // RxJava2 for Rx2Dnssd (bundled from Discord's RxDNSSD fork)
+    api 'io.reactivex.rxjava2:rxjava:2.2.21'
+    api 'io.reactivex.rxjava2:rxandroid:2.1.1'
 }

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,6 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.balthazargronon.RCTZeroconf">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
 </manifest>

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

@@ -5,9 +5,9 @@ import com.balthazargronon.RCTZeroconf.rx2dnssd.DnssdImpl;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 
-import org.apache.commons.lang3.StringUtils;
-
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class ZeroConfImplFactory {
@@ -25,7 +25,7 @@ public class ZeroConfImplFactory {
     }
 
     public Zeroconf getZeroconf(String implType) {
-        if (StringUtils.isBlank(implType)) implType = ZeroConfImplFactory.NSD_IMPL;
+        if (implType == null || implType.trim().isEmpty()) implType = ZeroConfImplFactory.NSD_IMPL;
         return getOrCreateImpl(implType);
     }
 
@@ -46,4 +46,11 @@ public class ZeroConfImplFactory {
         return zeroconfMap.get(implType);
     }
 
+    /**
+     * Implementations that have already been created, without instantiating new ones
+     */
+    public List<Zeroconf> getCreatedImpls() {
+        return new ArrayList<>(zeroconfMap.values());
+    }
+
 }

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

@@ -104,8 +104,9 @@ public class ZeroconfModule extends ReactContextBaseJavaModule {
     public void onCatalystInstanceDestroy() {
         super.onCatalystInstanceDestroy();
         try {
-            stop(ZeroConfImplFactory.NSD_IMPL);
-            stop(ZeroConfImplFactory.DNSSD_IMPL);
+            for (Zeroconf impl : zeroConfFactory.getCreatedImpls()) {
+                impl.stop();
+            }
         } catch (Throwable e) {
             Log.e(getClass().getName(), e.getMessage(), e);
             sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Exception During Catalyst Destroy: " + e.getMessage());

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

@@ -6,6 +6,9 @@ import android.net.nsd.NsdManager;
 import android.net.nsd.NsdServiceInfo;
 import android.net.wifi.WifiManager;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
 
 import com.balthazargronon.RCTZeroconf.Zeroconf;
 import com.balthazargronon.RCTZeroconf.ZeroconfModule;
@@ -18,13 +21,17 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 
-import java.io.UnsupportedEncodingException;
 import java.net.InetAddress;
-import java.util.HashMap;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class NsdServiceImpl implements Zeroconf {
+    private static final String TAG = "NsdServiceImpl";
+    private static final long RESOLVE_RETRY_DELAY_MS = 100;
+
     private NsdManager mNsdManager;
     private NsdManager.DiscoveryListener mDiscoveryListener;
     private WifiManager.MulticastLock multicastLock;
@@ -32,10 +39,15 @@ public class NsdServiceImpl implements Zeroconf {
     private ZeroconfModule zeroconfModule;
     private ReactApplicationContext reactApplicationContext;
 
+    // NsdManager can only resolve one service at a time before API 34, so resolves are queued
+    private final ArrayDeque<NsdServiceInfo> mResolveQueue = new ArrayDeque<>();
+    private boolean mIsResolving = false;
+    private final Handler mHandler = new Handler(Looper.getMainLooper());
+
     public NsdServiceImpl(ZeroconfModule zeroconfModule, ReactApplicationContext reactApplicationContext) {
         this.zeroconfModule = zeroconfModule;
         this.reactApplicationContext = reactApplicationContext;
-        mPublishedServices = new HashMap<String, NsdManager.RegistrationListener>();
+        mPublishedServices = new ConcurrentHashMap<String, NsdManager.RegistrationListener>();
     }
 
     @Override
@@ -68,29 +80,29 @@ public class NsdServiceImpl implements Zeroconf {
 
             @Override
             public void onDiscoveryStarted(String serviceType) {
-                System.out.println("On Discovery Started");
+                Log.d(TAG, "Discovery started");
                 zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_START, null);
             }
 
             @Override
             public void onDiscoveryStopped(String serviceType) {
-                System.out.println("On Discovery Stopped");
+                Log.d(TAG, "Discovery stopped");
                 zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_STOP, null);
             }
 
             @Override
             public void onServiceFound(NsdServiceInfo serviceInfo) {
-                System.out.println("On Service Found");
+                Log.d(TAG, "Service found");
                 WritableMap service = new WritableNativeMap();
                 service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
 
                 zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_FOUND, service);
-                mNsdManager.resolveService(serviceInfo, new NsdServiceImpl.ZeroResolveListener());
+                enqueueResolve(serviceInfo);
             }
 
             @Override
             public void onServiceLost(NsdServiceInfo serviceInfo) {
-                System.out.println("On Service Lost");
+                Log.d(TAG, "Service lost");
                 WritableMap service = new WritableNativeMap();
                 service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
                 zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_REMOVE, service);
@@ -103,8 +115,19 @@ public class NsdServiceImpl implements Zeroconf {
 
     @Override
     public void stop() {
-        if (mDiscoveryListener != null) {
-            mNsdManager.stopServiceDiscovery(mDiscoveryListener);
+        if (mDiscoveryListener != null && mNsdManager != null) {
+            try {
+                mNsdManager.stopServiceDiscovery(mDiscoveryListener);
+            } catch (IllegalArgumentException e) {
+                // Listener was never registered or already unregistered (e.g. discovery failed to start)
+                Log.w(TAG, "stopServiceDiscovery failed", e);
+            }
+        }
+
+        mHandler.removeCallbacksAndMessages(null);
+        synchronized (mResolveQueue) {
+            mResolveQueue.clear();
+            mIsResolving = false;
         }
 
         if (multicastLock != null) {
@@ -159,21 +182,60 @@ public class NsdServiceImpl implements Zeroconf {
         return reactApplicationContext;
     }
 
+    private void enqueueResolve(NsdServiceInfo serviceInfo) {
+        synchronized (mResolveQueue) {
+            mResolveQueue.add(serviceInfo);
+        }
+        resolveNext();
+    }
+
+    private void resolveNext() {
+        NsdServiceInfo next;
+        synchronized (mResolveQueue) {
+            if (mIsResolving || mResolveQueue.isEmpty()) {
+                return;
+            }
+            next = mResolveQueue.poll();
+            mIsResolving = true;
+        }
+        try {
+            getNsdManager().resolveService(next, new ZeroResolveListener());
+        } catch (Throwable e) {
+            Log.e(TAG, "resolveService failed", e);
+            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, "Resolving service failed: " + e.getMessage());
+            onResolveDone();
+        }
+    }
+
+    private void onResolveDone() {
+        synchronized (mResolveQueue) {
+            mIsResolving = false;
+        }
+        resolveNext();
+    }
+
     private class ZeroResolveListener implements NsdManager.ResolveListener {
         @Override
         public void onResolveFailed(NsdServiceInfo serviceInfo, int errorCode) {
             if (errorCode == NsdManager.FAILURE_ALREADY_ACTIVE) {
-                mNsdManager.resolveService(serviceInfo, this);
-            } else {
-                String error = "Resolving service failed with code: " + errorCode;
-                zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+                // Another resolve (possibly from another app or listener) is in flight: retry shortly
+                synchronized (mResolveQueue) {
+                    mResolveQueue.addFirst(serviceInfo);
+                    mIsResolving = false;
+                }
+                mHandler.postDelayed(NsdServiceImpl.this::resolveNext, RESOLVE_RETRY_DELAY_MS);
+                return;
             }
+            String error = "Resolving service failed with code: " + errorCode;
+            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+            onResolveDone();
         }
 
         @Override
         public void onServiceResolved(NsdServiceInfo serviceInfo) {
             WritableMap service = serviceInfoToMap(serviceInfo);
             zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_RESOLVE, service);
+            onResolveDone();
         }
     }
 
@@ -194,7 +256,8 @@ public class NsdServiceImpl implements Zeroconf {
 
         @Override
         public void onRegistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
-            // Registration failed!  Put debugging code here to determine why.
+            String error = "Registering service " + serviceInfo.getServiceName() + " failed with code: " + errorCode;
+            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
         }
 
         @Override
@@ -207,7 +270,8 @@ public class NsdServiceImpl implements Zeroconf {
 
         @Override
         public void onUnregistrationFailed(NsdServiceInfo serviceInfo, int errorCode) {
-            // Unregistration failed.  Put debugging code here to determine why.
+            String error = "Unregistering service " + serviceInfo.getServiceName() + " failed with code: " + errorCode;
+            zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
         }
     }
 
@@ -234,13 +298,10 @@ public class NsdServiceImpl implements Zeroconf {
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             Map<String, byte[]> attributes = serviceInfo.getAttributes();
-            for (String key : attributes.keySet()) {
-                try {
+            if (attributes != null) {
+                for (String key : attributes.keySet()) {
                     byte[] recordValue = attributes.get(key);
-                    txtRecords.putString(String.format(Locale.getDefault(), "%s", key), String.format(Locale.getDefault(), "%s", recordValue != null ? new String(recordValue, "UTF_8") : ""));
-                } catch (UnsupportedEncodingException e) {
-                    String error = "Failed to encode txtRecord: " + e;
-                    zeroconfModule.sendEvent(getReactApplicationContext(), ZeroconfModule.EVENT_ERROR, error);
+                    txtRecords.putString(String.format(Locale.getDefault(), "%s", key), recordValue != null ? new String(recordValue, StandardCharsets.UTF_8) : "");
                 }
             }
         }

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

@@ -16,7 +16,7 @@ import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.github.druk.rx2dnssd.BonjourService;
 import com.github.druk.rx2dnssd.Rx2Dnssd;
-import com.github.druk.rx2dnssd.Rx2DnssdBindable;
+import com.github.druk.rx2dnssd.Rx2DnssdEmbedded;
 
 import java.net.InetAddress;
 import java.util.HashMap;
@@ -26,11 +26,14 @@ 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;
 
     @Nullable
@@ -49,7 +52,17 @@ public class DnssdImpl implements Zeroconf {
         this.reactApplicationContext = reactApplicationContext;
         mPublishedServices = new HashMap<String, BonjourService>();
         mRegisteredDisposables = new HashMap<String, Disposable>();
-        rxDnssd = new Rx2DnssdBindable(reactApplicationContext);
+        rxDnssd = createDnssd(reactApplicationContext);
+    }
+
+    /**
+     * 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
+     * system daemon at /dev/socket/mdnsd doesn't exist on most devices.
+     */
+    private Rx2Dnssd createDnssd(Context context) {
+        return new Rx2DnssdEmbedded(context);
     }
 
     @Override
@@ -63,21 +76,50 @@ public class DnssdImpl implements Zeroconf {
             multicastLock.acquire();
         }
 
-        browseDisposable = rxDnssd.browse(getServiceType(type, protocol), "local.")
-                .compose(rxDnssd.resolve())
-                .compose(rxDnssd.queryRecords())
+        String serviceType = getServiceType(type, protocol);
+        Log.d(TAG, "Starting DNSSD scan for: " + serviceType);
+
+        // Emit start event
+        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_START, null);
+
+        browseDisposable = rxDnssd.browse(serviceType, "local.")
+                .doOnNext(bonjourService -> {
+                    if (!bonjourService.isLost()) {
+                        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_FOUND, serviceNameToMap(bonjourService));
+                    }
+                })
+                // Resolve each service independently so a single failure doesn't end the whole browse
+                .flatMap(bonjourService -> bonjourService.isLost()
+                        ? Flowable.just(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());
+                                    return Flowable.empty();
+                                }))
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(bonjourService -> {
-                    WritableMap service = serviceInfoToMap(bonjourService);
-                    Log.d(getClass().getName(), service.toString());
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_RESOLVE, service);
+                    if (bonjourService.isLost()) {
+                        zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_REMOVE, serviceNameToMap(bonjourService));
+                        return;
+                    }
+                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_RESOLVE, serviceInfoToMap(bonjourService));
                 }, throwable -> {
-                    Log.e(getClass().getName(), "Error resolving service: ", throwable);
-                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_ERROR, throwable.getMessage());
+                    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);
                 });
     }
 
+    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);
     }
@@ -86,10 +128,11 @@ public class DnssdImpl implements Zeroconf {
         WritableMap service = new WritableNativeMap();
         service.putString(ZeroconfModule.KEY_SERVICE_NAME, serviceInfo.getServiceName());
         final List<InetAddress> hostList = serviceInfo.getInetAddresses();
-        final String fullServiceName;
-        Log.d("TAG", serviceInfo.getServiceName());
-        fullServiceName = serviceInfo.getServiceName();
-        service.putString(ZeroconfModule.KEY_SERVICE_HOST, fullServiceName);
+        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) {
@@ -154,12 +197,14 @@ public class DnssdImpl implements Zeroconf {
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(bonjourService -> {
-                    Log.i("TAG", "Register successfully " + bonjourService.toString());
+                    Log.i(TAG, "Registered service " + bonjourService.toString());
 
                     mPublishedServices.put(bs.getServiceName(), bs);
                     zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_PUBLISHED, serviceInfoToMap(bonjourService));
                 }, throwable -> {
-                    Log.e("TAG", "error", throwable);
+                    Log.e(TAG, "Error registering service: ", throwable);
+                    zeroconfModule.sendEvent(reactApplicationContext, ZeroconfModule.EVENT_ERROR, "Registering service failed: " + throwable.getMessage());
+                    mRegisteredDisposables.remove(name);
                 });
 
         mRegisteredDisposables.put(name, registerDisposable);

package/android/src/main/java/com/github/druk/dnssd/BaseListener.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2016 Andriy Druk
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.druk.dnssd;
+
+
+/**	A base class for DNSSD listeners. */
+
+public interface BaseListener {
+	/** Called to report DNSSD operation failures.<P> 
+
+		@param	service
+					The service that encountered the failure.
+		<P>
+		@param	errorCode
+					Indicates the failure that occurred. See {@link DNSSDException} for error codes.
+	*/
+	void operationFailed(DNSSDService service, int errorCode);
+}
+

package/android/src/main/java/com/github/druk/dnssd/BrowseListener.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2016 Andriy Druk
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.druk.dnssd;
+
+/**	A listener that receives results from {@link InternalDNSSD#browse}. */
+
+public interface BrowseListener extends BaseListener {
+	/** Called to report discovered services.<P>
+
+		@param	browser
+					The active browse service.
+		<P>
+		@param	flags
+					Possible values are DNSSD.MORE_COMING.
+		<P>
+		@param	ifIndex
+					The interface on which the service is advertised. This index should be passed
+					to {@link InternalDNSSD#resolve} when resolving the service.
+		<P>
+		@param	serviceName
+					The service name discovered.
+		<P>
+		@param	regType
+					The registration type, as passed in to DNSSD.browse().
+		<P>
+		@param	domain
+					The domain in which the service was discovered.
+	*/
+	void serviceFound(DNSSDService browser, int flags, int ifIndex, String serviceName, String regType, String domain);
+
+	/** Called to report services which have been deregistered.<P> 
+
+		@param	browser
+					The active browse service.
+		<P>
+		@param	flags
+					Possible values are DNSSD.MORE_COMING.
+		<P>
+		@param	ifIndex
+					The interface on which the service is advertised.
+		<P>
+		@param	serviceName
+					The service name which has deregistered.
+		<P>
+		@param	regType
+					The registration type, as passed in to DNSSD.browse().
+		<P>
+		@param	domain
+					The domain in which the service was discovered.
+	*/
+	void serviceLost(DNSSDService browser, int flags, int ifIndex, String serviceName, String regType, String domain);
+}
+

package/android/src/main/java/com/github/druk/dnssd/DNSRecord.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2016 Andriy Druk
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.druk.dnssd;
+
+
+/**	
+	Reference to a record returned by {@link DNSSDRegistration#addRecord}.<P> 
+
+	Note: client is responsible for serializing access to these objects if 
+	they are shared between concurrent threads.
+*/
+
+public interface DNSRecord {
+	/** Update a registered resource record.<P> 
+		The record must either be the primary txt record of a service registered via DNSSD.register(), 
+		or a record added to a registered service via addRecord().<P>
+
+		@param	flags
+					Currently unused, reserved for future use.
+		<P>
+		@param	rData
+					The new rdata to be contained in the updated resource record.
+		<P>
+		@param	ttl
+					The time to live of the updated resource record, in seconds.
+	*/
+	void update(int flags, byte[] rData, int ttl) throws DNSSDException;
+
+	/** Remove a registered resource record.<P> 
+	*/
+	void remove() throws DNSSDException;
+}
+