LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "NsdService: disentangle NativeDaemonConnector from ctor" am: fa97f11b20 am: 47748b754c am: 5d0bd13538

Browse Source 
am: f659a6775f

Change-Id: Ie0a42ede086cc480830c91e770eaf250bcd2f711
This commit is contained in:
Hugo Benichi
2017-04-27 13:14:10 +00:00
committed by android-build-merger
parent b1347c6287 f659a6775f
commit 4801469256
1 changed files with 81 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
services/core/java/com/android/server/NsdService.java
View File

@@ -39,6 +39,7 @@ import android.util.SparseArray;
import java.io.FileDescriptor; import java.io.FileDescriptor;
import java.io.PrintWriter; import java.io.PrintWriter;
import java.net.InetAddress; import java.net.InetAddress;
import java.util.Arrays;
import java.util.HashMap; import java.util.HashMap;
import java.util.concurrent.CountDownLatch; import java.util.concurrent.CountDownLatch;
@@ -65,8 +66,8 @@ public class NsdService extends INsdManager.Stub {
private final Context mContext; private final Context mContext;
private final NsdSettings mNsdSettings; private final NsdSettings mNsdSettings;
private final NsdStateMachine mNsdStateMachine; private final NsdStateMachine mNsdStateMachine;
private final NativeDaemonConnector mNativeConnector; private final DaemonConnection mDaemon;
private final CountDownLatch mNativeDaemonConnected = new CountDownLatch(1); private final NativeCallbackReceiver mDaemonCallback;
/** /**
* Clients receiving asynchronous messages * Clients receiving asynchronous messages
@@ -546,18 +547,13 @@ public class NsdService extends INsdManager.Stub {
} }
@VisibleForTesting @VisibleForTesting
NsdService(Context ctx, NsdSettings settings, Handler handler) { NsdService(Context ctx, NsdSettings settings, Handler handler, DaemonConnectionSupplier fn) {
mContext = ctx; mContext = ctx;
mNsdSettings = settings; mNsdSettings = settings;
NativeCallbackReceiver callback = new NativeCallbackReceiver();
mNativeConnector = new NativeDaemonConnector(callback, "mdns", 10, MDNS_TAG, 25, null);
mNsdStateMachine = new NsdStateMachine(TAG, handler); mNsdStateMachine = new NsdStateMachine(TAG, handler);
mNsdStateMachine.start(); mNsdStateMachine.start();
mDaemonCallback = new NativeCallbackReceiver();
Thread th = new Thread(mNativeConnector, MDNS_TAG); mDaemon = fn.get(mDaemonCallback);
th.start();
} }
public static NsdService create(Context context) throws InterruptedException { public static NsdService create(Context context) throws InterruptedException {
@@ -565,8 +561,8 @@ public class NsdService extends INsdManager.Stub {
HandlerThread thread = new HandlerThread(TAG); HandlerThread thread = new HandlerThread(TAG);
thread.start(); thread.start();
Handler handler = new Handler(thread.getLooper()); Handler handler = new Handler(thread.getLooper());
NsdService service = new NsdService(context, settings, handler); NsdService service = new NsdService(context, settings, handler, DaemonConnection::new);
service.mNativeDaemonConnected.await(); service.mDaemonCallback.awaitConnection();
return service; return service;
} }
@@ -665,14 +661,23 @@ public class NsdService extends INsdManager.Stub {
} }
class NativeCallbackReceiver implements INativeDaemonConnectorCallbacks { class NativeCallbackReceiver implements INativeDaemonConnectorCallbacks {
public void onDaemonConnected() { private final CountDownLatch connected = new CountDownLatch(1);
mNativeDaemonConnected.countDown();
public void awaitConnection() throws InterruptedException {
connected.await();
} }
@Override
public void onDaemonConnected() {
connected.countDown();
}
@Override
public boolean onCheckHoldWakeLock(int code) { public boolean onCheckHoldWakeLock(int code) {
return false; return false;
} }
@Override
public boolean onEvent(int code, String raw, String[] cooked) { public boolean onEvent(int code, String raw, String[] cooked) {
// TODO: NDC translates a message to a callback, we could enhance NDC to // TODO: NDC translates a message to a callback, we could enhance NDC to
// directly interact with a state machine through messages // directly interact with a state machine through messages
@@ -682,132 +687,102 @@ public class NsdService extends INsdManager.Stub {
} }
} }
private boolean startMDnsDaemon() { interface DaemonConnectionSupplier {
if (DBG) Slog.d(TAG, "startMDnsDaemon"); DaemonConnection get(NativeCallbackReceiver callback);
}
@VisibleForTesting
public static class DaemonConnection {
final NativeDaemonConnector mNativeConnector;
DaemonConnection(NativeCallbackReceiver callback) {
mNativeConnector = new NativeDaemonConnector(callback, "mdns", 10, MDNS_TAG, 25, null);
new Thread(mNativeConnector, MDNS_TAG).start();
}
public boolean execute(Object... args) {
if (DBG) {
Slog.d(TAG, "mdnssd " + Arrays.toString(args));
}
try { try {
mNativeConnector.execute("mdnssd", "start-service"); mNativeConnector.execute("mdnssd", args);
} catch (NativeDaemonConnectorException e) { } catch (NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to start daemon" + e); Slog.e(TAG, "Failed to execute mdnssd " + Arrays.toString(args), e);
return false; return false;
} }
return true; return true;
} }
public boolean execute(Command cmd) {
if (DBG) {
Slog.d(TAG, cmd.toString());
}
try {
mNativeConnector.execute(cmd);
} catch (NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to execute " + cmd, e);
return false;
}
return true;
}
}
private boolean startMDnsDaemon() {
return mDaemon.execute("start-service");
}
private boolean stopMDnsDaemon() { private boolean stopMDnsDaemon() {
if (DBG) Slog.d(TAG, "stopMDnsDaemon"); return mDaemon.execute("stop-service");
try {
mNativeConnector.execute("mdnssd", "stop-service");
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to start daemon" + e);
return false;
}
return true;
} }
private boolean registerService(int regId, NsdServiceInfo service) { private boolean registerService(int regId, NsdServiceInfo service) {
if (DBG) Slog.d(TAG, "registerService: " + regId + " " + service); if (DBG) {
try { Slog.d(TAG, "registerService: " + regId + " " + service);
Command cmd = new Command("mdnssd", "register", regId, service.getServiceName(),
service.getServiceType(), service.getPort(),
Base64.encodeToString(service.getTxtRecord(), Base64.DEFAULT)
.replace("\n", ""));
mNativeConnector.execute(cmd);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to execute registerService " + e);
return false;
} }
return true; String name = service.getServiceName();
String type = service.getServiceType();
int port = service.getPort();
byte[] textRecord = service.getTxtRecord();
String record = Base64.encodeToString(textRecord, Base64.DEFAULT).replace("\n", "");
Command cmd = new Command("mdnssd", "register", regId, name, type, port, record);
return mDaemon.execute(cmd);
} }
private boolean unregisterService(int regId) { private boolean unregisterService(int regId) {
if (DBG) Slog.d(TAG, "unregisterService: " + regId); return mDaemon.execute("stop-register", regId);
try {
mNativeConnector.execute("mdnssd", "stop-register", regId);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to execute unregisterService " + e);
return false;
}
return true;
} }
private boolean updateService(int regId, DnsSdTxtRecord t) { private boolean updateService(int regId, DnsSdTxtRecord t) {
if (DBG) Slog.d(TAG, "updateService: " + regId + " " + t); if (t == null) {
try {
if (t == null) return false;
mNativeConnector.execute("mdnssd", "update", regId, t.size(), t.getRawData());
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to updateServices " + e);
return false; return false;
} }
return true; return mDaemon.execute("update", regId, t.size(), t.getRawData());
} }
private boolean discoverServices(int discoveryId, String serviceType) { private boolean discoverServices(int discoveryId, String serviceType) {
if (DBG) Slog.d(TAG, "discoverServices: " + discoveryId + " " + serviceType); return mDaemon.execute("discover", discoveryId, serviceType);
try {
mNativeConnector.execute("mdnssd", "discover", discoveryId, serviceType);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to discoverServices " + e);
return false;
}
return true;
} }
private boolean stopServiceDiscovery(int discoveryId) { private boolean stopServiceDiscovery(int discoveryId) {
if (DBG) Slog.d(TAG, "stopServiceDiscovery: " + discoveryId); return mDaemon.execute("stop-discover", discoveryId);
try {
mNativeConnector.execute("mdnssd", "stop-discover", discoveryId);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to stopServiceDiscovery " + e);
return false;
}
return true;
} }
private boolean resolveService(int resolveId, NsdServiceInfo service) { private boolean resolveService(int resolveId, NsdServiceInfo service) {
if (DBG) Slog.d(TAG, "resolveService: " + resolveId + " " + service); String name = service.getServiceName();
try { String type = service.getServiceType();
mNativeConnector.execute("mdnssd", "resolve", resolveId, service.getServiceName(), return mDaemon.execute("resolve", resolveId, name, type, "local.");
service.getServiceType(), "local.");
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to resolveService " + e);
return false;
}
return true;
} }
private boolean stopResolveService(int resolveId) { private boolean stopResolveService(int resolveId) {
if (DBG) Slog.d(TAG, "stopResolveService: " + resolveId); return mDaemon.execute("stop-resolve", resolveId);
try {
mNativeConnector.execute("mdnssd", "stop-resolve", resolveId);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to stop resolve " + e);
return false;
}
return true;
} }
private boolean getAddrInfo(int resolveId, String hostname) { private boolean getAddrInfo(int resolveId, String hostname) {
if (DBG) Slog.d(TAG, "getAdddrInfo: " + resolveId); return mDaemon.execute("getaddrinfo", resolveId, hostname);
try {
mNativeConnector.execute("mdnssd", "getaddrinfo", resolveId, hostname);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to getAddrInfo " + e);
return false;
}
return true;
} }
private boolean stopGetAddrInfo(int resolveId) { private boolean stopGetAddrInfo(int resolveId) {
if (DBG) Slog.d(TAG, "stopGetAdddrInfo: " + resolveId); return mDaemon.execute("stop-getaddrinfo", resolveId);
try {
mNativeConnector.execute("mdnssd", "stop-getaddrinfo", resolveId);
} catch(NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to stopGetAddrInfo " + e);
return false;
}
return true;
} }
@Override @Override