/*
* Copyright (C) 2007 The Android Open Source Project
*
* 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.android.ddmlib;
import com.android.annotations.NonNull;
import com.android.ddmlib.Log.LogLevel;
import com.google.common.base.Joiner;
import com.google.common.base.Throwables;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.Thread.State;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
/**
* A connection to the host-side android debug bridge (adb)
* <p/>This is the central point to communicate with any devices, emulators, or the applications
* running on them.
* <p/><b>{@link #init(boolean)} must be called before anything is done.</b>
*/
public final class AndroidDebugBridge {
/*
* Minimum and maximum version of adb supported. This correspond to
* ADB_SERVER_VERSION found in //device/tools/adb/adb.h
*/
private static final AdbVersion MIN_ADB_VERSION = AdbVersion.parseFrom("1.0.20");
private static final String ADB = "adb"; //$NON-NLS-1$
private static final String DDMS = "ddms"; //$NON-NLS-1$
private static final String SERVER_PORT_ENV_VAR = "ANDROID_ADB_SERVER_PORT"; //$NON-NLS-1$
// Where to find the ADB bridge.
static final String DEFAULT_ADB_HOST = "127.0.0.1"; //$NON-NLS-1$
static final int DEFAULT_ADB_PORT = 5037;
/** Port where adb server will be started **/
private static int sAdbServerPort = 0;
private static InetAddress sHostAddr;
private static InetSocketAddress sSocketAddr;
private static AndroidDebugBridge sThis;
private static boolean sInitialized = false;
private static boolean sClientSupport;
/** Full path to adb. */
private String mAdbOsLocation = null;
private boolean mVersionCheck;
private boolean mStarted = false;
private DeviceMonitor mDeviceMonitor;
private static final ArrayList<IDebugBridgeChangeListener> sBridgeListeners =
new ArrayList<IDebugBridgeChangeListener>();
private static final ArrayList<IDeviceChangeListener> sDeviceListeners =
new ArrayList<IDeviceChangeListener>();
private static final ArrayList<IClientChangeListener> sClientListeners =
new ArrayList<IClientChangeListener>();
// lock object for synchronization
private static final Object sLock = sBridgeListeners;
/**
* Classes which implement this interface provide a method that deals
* with {@link AndroidDebugBridge} changes.
*/
public interface IDebugBridgeChangeListener {
/**
* Sent when a new {@link AndroidDebugBridge} is connected.
* <p/>
* This is sent from a non UI thread.
* @param bridge the new {@link AndroidDebugBridge} object.
*/
void bridgeChanged(AndroidDebugBridge bridge);
}
/**
* Classes which implement this interface provide methods that deal
* with {@link IDevice} addition, deletion, and changes.
*/
public interface IDeviceChangeListener {
/**
* Sent when the a device is connected to the {@link AndroidDebugBridge}.
* <p/>
* This is sent from a non UI thread.
* @param device the new device.
*/
void deviceConnected(IDevice device);
/**
* Sent when the a device is connected to the {@link AndroidDebugBridge}.
* <p/>
* This is sent from a non UI thread.
* @param device the new device.
*/
void deviceDisconnected(IDevice device);
/**
* Sent when a device data changed, or when clients are started/terminated on the device.
* <p/>
* This is sent from a non UI thread.
* @param device the device that was updated.
* @param changeMask the mask describing what changed. It can contain any of the following
* values: {@link IDevice#CHANGE_BUILD_INFO}, {@link IDevice#CHANGE_STATE},
* {@link IDevice#CHANGE_CLIENT_LIST}
*/
void deviceChanged(IDevice device, int changeMask);
}
/**
* Classes which implement this interface provide methods that deal
* with {@link Client} changes.
*/
public interface IClientChangeListener {
/**
* Sent when an existing client information changed.
* <p/>
* This is sent from a non UI thread.
* @param client the updated client.
* @param changeMask the bit mask describing the changed properties. It can contain
* any of the following values: {@link Client#CHANGE_INFO},
* {@link Client#CHANGE_DEBUGGER_STATUS}, {@link Client#CHANGE_THREAD_MODE},
* {@link Client#CHANGE_THREAD_DATA}, {@link Client#CHANGE_HEAP_MODE},
* {@link Client#CHANGE_HEAP_DATA}, {@link Client#CHANGE_NATIVE_HEAP_DATA}
*/
void clientChanged(Client client, int changeMask);
}
/**
* Initialized the library only if needed.
*
* @param clientSupport Indicates whether the library should enable the monitoring and
* interaction with applications running on the devices.
*
* @see #init(boolean)
*/
public static synchronized void initIfNeeded(boolean clientSupport) {
if (sInitialized) {
return;
}
init(clientSupport);
}
/**
* Initializes the <code>ddm</code> library.
* <p/>This must be called once <b>before</b> any call to
* {@link #createBridge(String, boolean)}.
* <p>The library can be initialized in 2 ways:
* <ul>
* <li>Mode 1: <var>clientSupport</var> == <code>true</code>.<br>The library monitors the
* devices and the applications running on them. It will connect to each application, as a
* debugger of sort, to be able to interact with them through JDWP packets.</li>
* <li>Mode 2: <var>clientSupport</var> == <code>false</code>.<br>The library only monitors
* devices. The applications are left untouched, letting other tools built on
* <code>ddmlib</code> to connect a debugger to them.</li>
* </ul>
* <p/><b>Only one tool can run in mode 1 at the same time.</b>
* <p/>Note that mode 1 does not prevent debugging of applications running on devices. Mode 1
* lets debuggers connect to <code>ddmlib</code> which acts as a proxy between the debuggers and
* the applications to debug. See {@link Client#getDebuggerListenPort()}.
* <p/>The preferences of <code>ddmlib</code> should also be initialized with whatever default
* values were changed from the default values.
* <p/>When the application quits, {@link #terminate()} should be called.
* @param clientSupport Indicates whether the library should enable the monitoring and
* interaction with applications running on the devices.
* @see AndroidDebugBridge#createBridge(String, boolean)
* @see DdmPreferences
*/
public static synchronized void init(boolean clientSupport) {
if (sInitialized) {
throw new IllegalStateException("AndroidDebugBridge.init() has already been called.");
}
sInitialized = true;
sClientSupport = clientSupport;
// Determine port and instantiate socket address.
initAdbSocketAddr();
MonitorThread monitorThread = MonitorThread.createInstance();
monitorThread.start();
HandleHello.register(monitorThread);
HandleAppName.register(monitorThread);
HandleTest.register(monitorThread);
HandleThread.register(monitorThread);
HandleHeap.register(monitorThread);
HandleWait.register(monitorThread);
HandleProfiling.register(monitorThread);
HandleNativeHeap.register(monitorThread);
HandleViewDebug.register(monitorThread);
}
/**
* Terminates the ddm library. This must be called upon application termination.
*/
public static synchronized void terminate() {
// kill the monitoring services
if (sThis != null && sThis.mDeviceMonitor != null) {
sThis.mDeviceMonitor.stop();
sThis.mDeviceMonitor = null;
}
MonitorThread monitorThread = MonitorThread.getInstance();
if (monitorThread != null) {
monitorThread.quit();
}
sInitialized = false;
}
/**
* Returns whether the ddmlib is setup to support monitoring and interacting with
* {@link Client}s running on the {@link IDevice}s.
*/
static boolean getClientSupport() {
return sClientSupport;
}
/**
* Returns the socket address of the ADB server on the host.
*/
public static InetSocketAddress getSocketAddress() {
return sSocketAddr;
}
/**
* Creates a {@link AndroidDebugBridge} that is not linked to any particular executable.
* <p/>This bridge will expect adb to be running. It will not be able to start/stop/restart
* adb.
* <p/>If a bridge has already been started, it is directly returned with no changes (similar
* to calling {@link #getBridge()}).
* @return a connected bridge.
*/
public static AndroidDebugBridge createBridge() {
synchronized (sLock) {
if (sThis != null) {
return sThis;
}
try {
sThis = new AndroidDebugBridge();
sThis.start();
} catch (InvalidParameterException e) {
sThis = null;
}
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDebugBridgeChangeListener[] listenersCopy = sBridgeListeners.toArray(
new IDebugBridgeChangeListener[sBridgeListeners.size()]);
// notify the listeners of the change
for (IDebugBridgeChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.bridgeChanged(sThis);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
return sThis;
}
}
/**
* Creates a new debug bridge from the location of the command line tool.
* <p/>
* Any existing server will be disconnected, unless the location is the same and
* <code>forceNewBridge</code> is set to false.
* @param osLocation the location of the command line tool 'adb'
* @param forceNewBridge force creation of a new bridge even if one with the same location
* already exists.
* @return a connected bridge.
*/
public static AndroidDebugBridge createBridge(String osLocation, boolean forceNewBridge) {
synchronized (sLock) {
if (sThis != null) {
if (sThis.mAdbOsLocation != null && sThis.mAdbOsLocation.equals(osLocation) &&
!forceNewBridge) {
return sThis;
} else {
// stop the current server
sThis.stop();
}
}
try {
sThis = new AndroidDebugBridge(osLocation);
sThis.start();
} catch (InvalidParameterException e) {
sThis = null;
}
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDebugBridgeChangeListener[] listenersCopy = sBridgeListeners.toArray(
new IDebugBridgeChangeListener[sBridgeListeners.size()]);
// notify the listeners of the change
for (IDebugBridgeChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.bridgeChanged(sThis);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
return sThis;
}
}
/**
* Returns the current debug bridge. Can be <code>null</code> if none were created.
*/
public static AndroidDebugBridge getBridge() {
return sThis;
}
/**
* Disconnects the current debug bridge, and destroy the object.
* <p/>This also stops the current adb host server.
* <p/>
* A new object will have to be created with {@link #createBridge(String, boolean)}.
*/
public static void disconnectBridge() {
synchronized (sLock) {
if (sThis != null) {
sThis.stop();
sThis = null;
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDebugBridgeChangeListener[] listenersCopy = sBridgeListeners.toArray(
new IDebugBridgeChangeListener[sBridgeListeners.size()]);
// notify the listeners.
for (IDebugBridgeChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.bridgeChanged(sThis);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
}
}
/**
* Adds the listener to the collection of listeners who will be notified when a new
* {@link AndroidDebugBridge} is connected, by sending it one of the messages defined
* in the {@link IDebugBridgeChangeListener} interface.
* @param listener The listener which should be notified.
*/
public static void addDebugBridgeChangeListener(IDebugBridgeChangeListener listener) {
synchronized (sLock) {
if (!sBridgeListeners.contains(listener)) {
sBridgeListeners.add(listener);
if (sThis != null) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.bridgeChanged(sThis);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
}
}
/**
* Removes the listener from the collection of listeners who will be notified when a new
* {@link AndroidDebugBridge} is started.
* @param listener The listener which should no longer be notified.
*/
public static void removeDebugBridgeChangeListener(IDebugBridgeChangeListener listener) {
synchronized (sLock) {
sBridgeListeners.remove(listener);
}
}
/**
* Adds the listener to the collection of listeners who will be notified when a {@link IDevice}
* is connected, disconnected, or when its properties or its {@link Client} list changed,
* by sending it one of the messages defined in the {@link IDeviceChangeListener} interface.
* @param listener The listener which should be notified.
*/
public static void addDeviceChangeListener(IDeviceChangeListener listener) {
synchronized (sLock) {
if (!sDeviceListeners.contains(listener)) {
sDeviceListeners.add(listener);
}
}
}
/**
* Removes the listener from the collection of listeners who will be notified when a
* {@link IDevice} is connected, disconnected, or when its properties or its {@link Client}
* list changed.
* @param listener The listener which should no longer be notified.
*/
public static void removeDeviceChangeListener(IDeviceChangeListener listener) {
synchronized (sLock) {
sDeviceListeners.remove(listener);
}
}
/**
* Adds the listener to the collection of listeners who will be notified when a {@link Client}
* property changed, by sending it one of the messages defined in the
* {@link IClientChangeListener} interface.
* @param listener The listener which should be notified.
*/
public static void addClientChangeListener(IClientChangeListener listener) {
synchronized (sLock) {
if (!sClientListeners.contains(listener)) {
sClientListeners.add(listener);
}
}
}
/**
* Removes the listener from the collection of listeners who will be notified when a
* {@link Client} property changed.
* @param listener The listener which should no longer be notified.
*/
public static void removeClientChangeListener(IClientChangeListener listener) {
synchronized (sLock) {
sClientListeners.remove(listener);
}
}
/**
* Returns the devices.
* @see #hasInitialDeviceList()
*/
@NonNull
public IDevice[] getDevices() {
synchronized (sLock) {
if (mDeviceMonitor != null) {
return mDeviceMonitor.getDevices();
}
}
return new IDevice[0];
}
/**
* Returns whether the bridge has acquired the initial list from adb after being created.
* <p/>Calling {@link #getDevices()} right after {@link #createBridge(String, boolean)} will
* generally result in an empty list. This is due to the internal asynchronous communication
* mechanism with <code>adb</code> that does not guarantee that the {@link IDevice} list has been
* built before the call to {@link #getDevices()}.
* <p/>The recommended way to get the list of {@link IDevice} objects is to create a
* {@link IDeviceChangeListener} object.
*/
public boolean hasInitialDeviceList() {
if (mDeviceMonitor != null) {
return mDeviceMonitor.hasInitialDeviceList();
}
return false;
}
/**
* Sets the client to accept debugger connection on the custom "Selected debug port".
* @param selectedClient the client. Can be null.
*/
public void setSelectedClient(Client selectedClient) {
MonitorThread monitorThread = MonitorThread.getInstance();
if (monitorThread != null) {
monitorThread.setSelectedClient(selectedClient);
}
}
/**
* Returns whether the {@link AndroidDebugBridge} object is still connected to the adb daemon.
*/
public boolean isConnected() {
MonitorThread monitorThread = MonitorThread.getInstance();
if (mDeviceMonitor != null && monitorThread != null) {
return mDeviceMonitor.isMonitoring() && monitorThread.getState() != State.TERMINATED;
}
return false;
}
/**
* Returns the number of times the {@link AndroidDebugBridge} object attempted to connect
* to the adb daemon.
*/
public int getConnectionAttemptCount() {
if (mDeviceMonitor != null) {
return mDeviceMonitor.getConnectionAttemptCount();
}
return -1;
}
/**
* Returns the number of times the {@link AndroidDebugBridge} object attempted to restart
* the adb daemon.
*/
public int getRestartAttemptCount() {
if (mDeviceMonitor != null) {
return mDeviceMonitor.getRestartAttemptCount();
}
return -1;
}
/**
* Creates a new bridge.
* @param osLocation the location of the command line tool
* @throws InvalidParameterException
*/
private AndroidDebugBridge(String osLocation) throws InvalidParameterException {
if (osLocation == null || osLocation.isEmpty()) {
throw new InvalidParameterException();
}
mAdbOsLocation = osLocation;
try {
checkAdbVersion();
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
}
/**
* Creates a new bridge not linked to any particular adb executable.
*/
private AndroidDebugBridge() {
}
/**
* Queries adb for its version number and checks that it is atleast {@link #MIN_ADB_VERSION}.
*/
private void checkAdbVersion() throws IOException {
// default is bad check
mVersionCheck = false;
if (mAdbOsLocation == null) {
return;
}
File adb = new File(mAdbOsLocation);
ListenableFuture<AdbVersion> future = getAdbVersion(adb);
AdbVersion version;
try {
version = future.get(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
return;
} catch (java.util.concurrent.TimeoutException e) {
String msg = "Unable to obtain result of 'adb version'";
Log.logAndDisplay(LogLevel.ERROR, ADB, msg);
return;
} catch (ExecutionException e) {
Log.logAndDisplay(LogLevel.ERROR, ADB, e.getCause().getMessage());
Throwables.propagateIfInstanceOf(e.getCause(), IOException.class);
return;
}
if (version.compareTo(MIN_ADB_VERSION) > 0) {
mVersionCheck = true;
} else {
String message = String.format(
"Required minimum version of adb: %1$s."
+ "Current version is %2$s", MIN_ADB_VERSION, version);
Log.logAndDisplay(LogLevel.ERROR, ADB, message);
}
}
public static ListenableFuture<AdbVersion> getAdbVersion(@NonNull final File adb) {
final SettableFuture<AdbVersion> future = SettableFuture.create();
new Thread(new Runnable() {
@Override
public void run() {
ProcessBuilder pb = new ProcessBuilder(adb.getPath(), "version");
pb.redirectErrorStream(true);
Process p = null;
try {
p = pb.start();
} catch (IOException e) {
future.setException(e);
return;
}
StringBuilder sb = new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
try {
String line;
while ((line = br.readLine()) != null) {
AdbVersion version = AdbVersion.parseFrom(line);
if (version != AdbVersion.UNKNOWN) {
future.set(version);
return;
}
sb.append(line);
sb.append('\n');
}
} catch (IOException e) {
future.setException(e);
return;
} finally {
try {
br.close();
} catch (IOException e) {
future.setException(e);
}
}
future.setException(new RuntimeException(
"Unable to detect adb version, adb output: " + sb.toString()));
}
}, "Obtaining adb version").start();
return future;
}
/**
* Starts the debug bridge.
*
* @return true if success.
*/
boolean start() {
if (mAdbOsLocation != null && sAdbServerPort != 0 && (!mVersionCheck || !startAdb())) {
return false;
}
mStarted = true;
// now that the bridge is connected, we start the underlying services.
mDeviceMonitor = new DeviceMonitor(this);
mDeviceMonitor.start();
return true;
}
/**
* Kills the debug bridge, and the adb host server.
* @return true if success
*/
boolean stop() {
// if we haven't started we return false;
if (!mStarted) {
return false;
}
// kill the monitoring services
if (mDeviceMonitor != null) {
mDeviceMonitor.stop();
mDeviceMonitor = null;
}
if (!stopAdb()) {
return false;
}
mStarted = false;
return true;
}
/**
* Restarts adb, but not the services around it.
* @return true if success.
*/
public boolean restart() {
if (mAdbOsLocation == null) {
Log.e(ADB,
"Cannot restart adb when AndroidDebugBridge is created without the location of adb."); //$NON-NLS-1$
return false;
}
if (sAdbServerPort == 0) {
Log.e(ADB, "ADB server port for restarting AndroidDebugBridge is not set."); //$NON-NLS-1$
return false;
}
if (!mVersionCheck) {
Log.logAndDisplay(LogLevel.ERROR, ADB,
"Attempting to restart adb, but version check failed!"); //$NON-NLS-1$
return false;
}
synchronized (this) {
stopAdb();
boolean restart = startAdb();
if (restart && mDeviceMonitor == null) {
mDeviceMonitor = new DeviceMonitor(this);
mDeviceMonitor.start();
}
return restart;
}
}
/**
* Notify the listener of a new {@link IDevice}.
* <p/>
* The notification of the listeners is done in a synchronized block. It is important to
* expect the listeners to potentially access various methods of {@link IDevice} as well as
* {@link #getDevices()} which use internal locks.
* <p/>
* For this reason, any call to this method from a method of {@link DeviceMonitor},
* {@link IDevice} which is also inside a synchronized block, should first synchronize on
* the {@link AndroidDebugBridge} lock. Access to this lock is done through {@link #getLock()}.
* @param device the new <code>IDevice</code>.
* @see #getLock()
*/
void deviceConnected(IDevice device) {
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDeviceChangeListener[] listenersCopy = null;
synchronized (sLock) {
listenersCopy = sDeviceListeners.toArray(
new IDeviceChangeListener[sDeviceListeners.size()]);
}
// Notify the listeners
for (IDeviceChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.deviceConnected(device);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
/**
* Notify the listener of a disconnected {@link IDevice}.
* <p/>
* The notification of the listeners is done in a synchronized block. It is important to
* expect the listeners to potentially access various methods of {@link IDevice} as well as
* {@link #getDevices()} which use internal locks.
* <p/>
* For this reason, any call to this method from a method of {@link DeviceMonitor},
* {@link IDevice} which is also inside a synchronized block, should first synchronize on
* the {@link AndroidDebugBridge} lock. Access to this lock is done through {@link #getLock()}.
* @param device the disconnected <code>IDevice</code>.
* @see #getLock()
*/
void deviceDisconnected(IDevice device) {
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDeviceChangeListener[] listenersCopy = null;
synchronized (sLock) {
listenersCopy = sDeviceListeners.toArray(
new IDeviceChangeListener[sDeviceListeners.size()]);
}
// Notify the listeners
for (IDeviceChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.deviceDisconnected(device);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
/**
* Notify the listener of a modified {@link IDevice}.
* <p/>
* The notification of the listeners is done in a synchronized block. It is important to
* expect the listeners to potentially access various methods of {@link IDevice} as well as
* {@link #getDevices()} which use internal locks.
* <p/>
* For this reason, any call to this method from a method of {@link DeviceMonitor},
* {@link IDevice} which is also inside a synchronized block, should first synchronize on
* the {@link AndroidDebugBridge} lock. Access to this lock is done through {@link #getLock()}.
* @param device the modified <code>IDevice</code>.
* @see #getLock()
*/
void deviceChanged(IDevice device, int changeMask) {
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IDeviceChangeListener[] listenersCopy = null;
synchronized (sLock) {
listenersCopy = sDeviceListeners.toArray(
new IDeviceChangeListener[sDeviceListeners.size()]);
}
// Notify the listeners
for (IDeviceChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.deviceChanged(device, changeMask);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
/**
* Notify the listener of a modified {@link Client}.
* <p/>
* The notification of the listeners is done in a synchronized block. It is important to
* expect the listeners to potentially access various methods of {@link IDevice} as well as
* {@link #getDevices()} which use internal locks.
* <p/>
* For this reason, any call to this method from a method of {@link DeviceMonitor},
* {@link IDevice} which is also inside a synchronized block, should first synchronize on
* the {@link AndroidDebugBridge} lock. Access to this lock is done through {@link #getLock()}.
* @param client the modified <code>Client</code>.
* @param changeMask the mask indicating what changed in the <code>Client</code>
* @see #getLock()
*/
void clientChanged(Client client, int changeMask) {
// because the listeners could remove themselves from the list while processing
// their event callback, we make a copy of the list and iterate on it instead of
// the main list.
// This mostly happens when the application quits.
IClientChangeListener[] listenersCopy = null;
synchronized (sLock) {
listenersCopy = sClientListeners.toArray(
new IClientChangeListener[sClientListeners.size()]);
}
// Notify the listeners
for (IClientChangeListener listener : listenersCopy) {
// we attempt to catch any exception so that a bad listener doesn't kill our
// thread
try {
listener.clientChanged(client, changeMask);
} catch (Exception e) {
Log.e(DDMS, e);
}
}
}
/**
* Returns the {@link DeviceMonitor} object.
*/
DeviceMonitor getDeviceMonitor() {
return mDeviceMonitor;
}
/**
* Starts the adb host side server.
* @return true if success
*/
synchronized boolean startAdb() {
if (mAdbOsLocation == null) {
Log.e(ADB,
"Cannot start adb when AndroidDebugBridge is created without the location of adb."); //$NON-NLS-1$
return false;
}
if (sAdbServerPort == 0) {
Log.w(ADB, "ADB server port for starting AndroidDebugBridge is not set."); //$NON-NLS-1$
return false;
}
Process proc;
int status = -1;
String[] command = getAdbLaunchCommand("start-server");
String commandString = Joiner.on(',').join(command);
try {
Log.d(DDMS, String.format("Launching '%1$s' to ensure ADB is running.", commandString));
ProcessBuilder processBuilder = new ProcessBuilder(command);
if (DdmPreferences.getUseAdbHost()) {
String adbHostValue = DdmPreferences.getAdbHostValue();
if (adbHostValue != null && !adbHostValue.isEmpty()) {
//TODO : check that the String is a valid IP address
Map<String, String> env = processBuilder.environment();
env.put("ADBHOST", adbHostValue);
}
}
proc = processBuilder.start();
ArrayList<String> errorOutput = new ArrayList<String>();
ArrayList<String> stdOutput = new ArrayList<String>();
status = grabProcessOutput(proc, errorOutput, stdOutput, false /* waitForReaders */);
} catch (IOException ioe) {
Log.e(DDMS, "Unable to run 'adb': " + ioe.getMessage()); //$NON-NLS-1$
// we'll return false;
} catch (InterruptedException ie) {
Log.e(DDMS, "Unable to run 'adb': " + ie.getMessage()); //$NON-NLS-1$
// we'll return false;
}
if (status != 0) {
Log.e(DDMS,
String.format("'%1$s' failed -- run manually if necessary", commandString)); //$NON-NLS-1$
return false;
} else {
Log.d(DDMS, String.format("'%1$s' succeeded", commandString)); //$NON-NLS-1$
return true;
}
}
private String[] getAdbLaunchCommand(String option) {
List<String> command = new ArrayList<String>(4);
command.add(mAdbOsLocation);
if (sAdbServerPort != DEFAULT_ADB_PORT) {
command.add("-P"); //$NON-NLS-1$
command.add(Integer.toString(sAdbServerPort));
}
command.add(option);
return command.toArray(new String[command.size()]);
}
/**
* Stops the adb host side server.
*
* @return true if success
*/
private synchronized boolean stopAdb() {
if (mAdbOsLocation == null) {
Log.e(ADB,
"Cannot stop adb when AndroidDebugBridge is created without the location of adb.");
return false;
}
if (sAdbServerPort == 0) {
Log.e(ADB, "ADB server port for restarting AndroidDebugBridge is not set");
return false;
}
Process proc;
int status = -1;
String[] command = getAdbLaunchCommand("kill-server"); //$NON-NLS-1$
try {
proc = Runtime.getRuntime().exec(command);
status = proc.waitFor();
}
catch (IOException ioe) {
// we'll return false;
}
catch (InterruptedException ie) {
// we'll return false;
}
String commandString = Joiner.on(',').join(command);
if (status != 0) {
Log.w(DDMS, String.format("'%1$s' failed -- run manually if necessary", commandString));
return false;
} else {
Log.d(DDMS, String.format("'%1$s' succeeded", commandString));
return true;
}
}
/**
* Get the stderr/stdout outputs of a process and return when the process is done.
* Both <b>must</b> be read or the process will block on windows.
* @param process The process to get the output from
* @param errorOutput The array to store the stderr output. cannot be null.
* @param stdOutput The array to store the stdout output. cannot be null.
* @param waitForReaders if true, this will wait for the reader threads.
* @return the process return code.
* @throws InterruptedException
*/
private int grabProcessOutput(final Process process, final ArrayList<String> errorOutput,
final ArrayList<String> stdOutput, boolean waitForReaders)
throws InterruptedException {
assert errorOutput != null;
assert stdOutput != null;
// read the lines as they come. if null is returned, it's
// because the process finished
Thread t1 = new Thread("") { //$NON-NLS-1$
@Override
public void run() {
// create a buffer to read the stderr output
InputStreamReader is = new InputStreamReader(process.getErrorStream());
BufferedReader errReader = new BufferedReader(is);
try {
while (true) {
String line = errReader.readLine();
if (line != null) {
Log.e(ADB, line);
errorOutput.add(line);
} else {
break;
}
}
} catch (IOException e) {
// do nothing.
}
}
};
Thread t2 = new Thread("") { //$NON-NLS-1$
@Override
public void run() {
InputStreamReader is = new InputStreamReader(process.getInputStream());
BufferedReader outReader = new BufferedReader(is);
try {
while (true) {
String line = outReader.readLine();
if (line != null) {
Log.d(ADB, line);
stdOutput.add(line);
} else {
break;
}
}
} catch (IOException e) {
// do nothing.
}
}
};
t1.start();
t2.start();
// it looks like on windows process#waitFor() can return
// before the thread have filled the arrays, so we wait for both threads and the
// process itself.
if (waitForReaders) {
try {
t1.join();
} catch (InterruptedException e) {
}
try {
t2.join();
} catch (InterruptedException e) {
}
}
// get the return code from the process
return process.waitFor();
}
/**
* Returns the singleton lock used by this class to protect any access to the listener.
* <p/>
* This includes adding/removing listeners, but also notifying listeners of new bridges,
* devices, and clients.
*/
private static Object getLock() {
return sLock;
}
/**
* Instantiates sSocketAddr with the address of the host's adb process.
*/
private static void initAdbSocketAddr() {
try {
sAdbServerPort = getAdbServerPort();
sHostAddr = InetAddress.getByName(DEFAULT_ADB_HOST);
sSocketAddr = new InetSocketAddress(sHostAddr, sAdbServerPort);
} catch (UnknownHostException e) {
// localhost should always be known.
}
}
/**
* Returns the port where adb server should be launched. This looks at:
* <ol>
* <li>The system property ANDROID_ADB_SERVER_PORT</li>
* <li>The environment variable ANDROID_ADB_SERVER_PORT</li>
* <li>Defaults to {@link #DEFAULT_ADB_PORT} if neither the system property nor the env var
* are set.</li>
* </ol>
*
* @return The port number where the host's adb should be expected or started.
*/
private static int getAdbServerPort() {
// check system property
Integer prop = Integer.getInteger(SERVER_PORT_ENV_VAR);
if (prop != null) {
try {
return validateAdbServerPort(prop.toString());
} catch (IllegalArgumentException e) {
String msg = String.format(
"Invalid value (%1$s) for ANDROID_ADB_SERVER_PORT system property.",
prop);
Log.w(DDMS, msg);
}
}
// when system property is not set or is invalid, parse environment property
try {
String env = System.getenv(SERVER_PORT_ENV_VAR);
if (env != null) {
return validateAdbServerPort(env);
}
} catch (SecurityException ex) {
// A security manager has been installed that doesn't allow access to env vars.
// So an environment variable might have been set, but we can't tell.
// Let's log a warning and continue with ADB's default port.
// The issue is that adb would be started (by the forked process having access
// to the env vars) on the desired port, but within this process, we can't figure out
// what that port is. However, a security manager not granting access to env vars
// but allowing to fork is a rare and interesting configuration, so the right
// thing seems to be to continue using the default port, as forking is likely to
// fail later on in the scenario of the security manager.
Log.w(DDMS,
"No access to env variables allowed by current security manager. "
+ "If you've set ANDROID_ADB_SERVER_PORT: it's being ignored.");
} catch (IllegalArgumentException e) {
String msg = String.format(
"Invalid value (%1$s) for ANDROID_ADB_SERVER_PORT environment variable (%2$s).",
prop, e.getMessage());
Log.w(DDMS, msg);
}
// use default port if neither are set
return DEFAULT_ADB_PORT;
}
/**
* Returns the integer port value if it is a valid value for adb server port
* @param adbServerPort adb server port to validate
* @return {@code adbServerPort} as a parsed integer
* @throws IllegalArgumentException when {@code adbServerPort} is not bigger than 0 or it is
* not a number at all
*/
private static int validateAdbServerPort(@NonNull String adbServerPort)
throws IllegalArgumentException {
try {
// C tools (adb, emulator) accept hex and octal port numbers, so need to accept them too
int port = Integer.decode(adbServerPort);
if (port <= 0 || port >= 65535) {
throw new IllegalArgumentException("Should be > 0 and < 65535");
}
return port;
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Not a valid port number");
}
}
}