Java tutorial
/* * Copyright (C) 2012 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.motorola.studio.android.adt; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.concurrent.TimeoutException; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubMonitor; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.osgi.util.NLS; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.PlatformUI; import com.android.ddmlib.AdbCommandRejectedException; import com.android.ddmlib.AndroidDebugBridge; import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener; import com.android.ddmlib.Client; import com.android.ddmlib.ClientData; import com.android.ddmlib.EmulatorConsole; import com.android.ddmlib.FileListingService; import com.android.ddmlib.FileListingService.FileEntry; import com.android.ddmlib.IDevice; import com.android.ddmlib.IDevice.DeviceState; import com.android.ddmlib.MultiLineReceiver; import com.android.ddmlib.SyncException; import com.android.ddmlib.SyncService; import com.android.ddmlib.SyncService.ISyncProgressMonitor; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; import com.android.ide.eclipse.ddms.DdmsPlugin; import com.motorola.studio.android.AndroidPlugin; import com.motorola.studio.android.adt.StudioAndroidEventManager.EventType; import com.motorola.studio.android.common.IAndroidConstants; import com.motorola.studio.android.common.exception.AndroidException; import com.motorola.studio.android.common.log.StudioLogger; import com.motorola.studio.android.i18n.AndroidNLS; import com.motorola.studio.android.utilities.TelnetFrameworkAndroid; /** * DESCRIPTION: * This class is the common interface to functionalities from DDMS * * RESPONSIBILITY: * Centralizes the access to DDMS. * * COLABORATORS: * None. * * USAGE: * Use the public methods to use DDMS */ public class DDMSFacade { /** * Command for switching back to USB connection mode. */ private static final String USB_SWITCH_BACK_COMMAND = "usb"; //$NON-NLS-1$ /** * Argument which indicates the device to apply a certain command. */ private static final String DEVICE_ID_INDICATOR = "-s"; //$NON-NLS-1$ private static final String DEFAULT_WIRELESS_DEVICE_PROPERTY = "tiwlan0"; //$NON-NLS-1$ /** * Map containing all connected devices. * It is being kept for us not to depend on ADT every time we need one, preventing * deadlocks. */ private static final Map<String, IDevice> connectedDevices = new HashMap<String, IDevice>(); /** * Set containing the serial numbers of the devices completely loaded. * A device is considered completely loaded if it has already loaded the HOME application. */ private static final Set<String> completelyUpDevices = new HashSet<String>(); /** * Folder located inside the SDK folder containing some sdk tools. */ static final String TOOLS_FOLDER = IAndroidConstants.FD_TOOLS; /** * Folder located inside the SDK folder and containing the ADB. */ static final String PLATFORM_TOOLS_FOLDER = IAndroidConstants.FD_PLATFORM_TOOLS; /** * adb (android debug bridge) command. */ static final String ADB_COMMAND = "adb"; //$NON-NLS-1$ /** * Command to concatenate with "adb" to have the device shell. */ static final String SHELL_CMD = "shell"; //$NON-NLS-1$ /** * Options to be used with adb to indicate run operation. */ private static final String AM_CMD = "am"; //$NON-NLS-1$ /** * Command to concatenate with "am" to have an activity executed at the device. */ private static final String START_CMD = "start"; //$NON-NLS-1$ /** * Parameter for running in debug mode. */ private static final String ADB_AM_DEBUG = "-D"; //$NON-NLS-1$ /** * Parameter provided before the application package/name. */ private static final String ADB_AM_NAME = "-n"; //$NON-NLS-1$ /** * Parameter for selecting emulator instance. */ static final String ADB_INSTANCE_PARAMETER = DEVICE_ID_INDICATOR; //$NON-NLS-1$ /** * Folder for the SDK. */ private static final String SDCARD_FOLDER = "sdcard"; //$NON-NLS-1$ /** * Folder for the SDK. */ private static final String MNT_SDCARD_FOLDER = "mnt/sdcard"; //$NON-NLS-1$ /* * TCP/IP */ private static final String CONNECT_TCPIP_CMD = "connect"; //$NON-NLS-1$ private static final String DISCONNECT_TCPIP_CMD = "disconnect"; //$NON-NLS-1$ private static final String TCPIP_CMD = "tcpip"; //$NON-NLS-1$ private static final String IFCONFIG_CMD = "ifconfig"; //$NON-NLS-1$ static Object consoleLock = new Object(); private static Map<String, String> avdNameMap = new HashMap<String, String>(); /** * Property from device which represents the wi-fi value to use ipconfig command. */ private static final String WIFI_INTERFACE_DEVICE_PROPERTY = "wifi.interface"; //$NON-NLS-1$ // IP validation private static final String ZERO_TO_255_PATTERN = "((\\d)|(\\d\\d)|([0-1]\\d\\d)|(2[0-4]\\d)|(25[0-5]))"; //$NON-NLS-1$ private static final String IP_PATTERN = "(" + ZERO_TO_255_PATTERN + "\\." //$NON-NLS-1$ //$NON-NLS-2$ + ZERO_TO_255_PATTERN + "\\." + ZERO_TO_255_PATTERN + "\\." + ZERO_TO_255_PATTERN //$NON-NLS-1$ //$NON-NLS-2$ + ")+"; //$NON-NLS-1$ /** * Must be called only once, during AndroidPlugin start-up. * This method configures all necessary device listeners. */ public static void setup() { AndroidPlugin.getDefault().addSDKLoaderListener(new Runnable() { public void run() { AndroidDebugBridge adb = AndroidDebugBridge.getBridge(); if (adb == null) { AndroidDebugBridge.disconnectBridge(); DdmsPlugin.setToolsLocation(AdtPlugin.getOsAbsoluteAdb(), true, AdtPlugin.getOsAbsoluteHprofConv(), AdtPlugin.getOsAbsoluteTraceview()); } if (adb != null) { IDevice[] x = adb.getDevices(); IDevice[] newDevices = x; List<IDevice> oldDevList = new ArrayList<IDevice>(connectedDevices.values()); for (IDevice newDev : newDevices) { String serialNum = newDev.getSerialNumber(); if (connectedDevices.containsKey(serialNum)) { IDevice oldDev = connectedDevices.get(serialNum); oldDevList.remove(oldDev); if (oldDev.getState().compareTo((newDev).getState()) != 0) { if ((newDev).getState() == DeviceState.OFFLINE) { deviceDisconnected(newDev); } else if ((newDev).getState() == DeviceState.ONLINE) { deviceConnected(newDev); } } } else { deviceConnected(newDev); } } for (IDevice oldDev : oldDevList) { deviceDisconnected(oldDev); } } } }); // Adds listener for the HOME application. It adds the serial number of the // device to a collection when it identifies that the HOME application has // loaded AndroidDebugBridge.addClientChangeListener(new IClientChangeListener() { public void clientChanged(Client client, int changeMask) { if ((changeMask & Client.CHANGE_NAME) == Client.CHANGE_NAME) { final Client finalClient = client; Thread t = new Thread() { @Override public void run() { String applicationName = finalClient.getClientData().getClientDescription(); if (applicationName != null) { IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); String home = store.getString(AdtPrefs.PREFS_HOME_PACKAGE); if (home.equals(applicationName)) { String serialNum = finalClient.getDevice().getSerialNumber(); synchronized (completelyUpDevices) { StudioLogger.debug("Completely Up Device: " + serialNum); //$NON-NLS-1$ completelyUpDevices.add(serialNum); } } } } }; t.start(); } } }); } static void deviceStatusChanged(IDevice device) { StudioLogger.debug("Device changed: " + device.getSerialNumber()); //$NON-NLS-1$ synchronized (connectedDevices) { connectedDevices.put(device.getSerialNumber(), device); } if ((device).getState() == DeviceState.ONLINE) { IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); String home = store.getString(AdtPrefs.PREFS_HOME_PACKAGE); if (device.getClient(home) != null) { synchronized (completelyUpDevices) { StudioLogger.debug("Completely Up Device: " + device.getSerialNumber()); //$NON-NLS-1$ if (!completelyUpDevices.contains(device.getSerialNumber())) { completelyUpDevices.add(device.getSerialNumber()); } } } } } /** * Registers a device as connected * * @param device */ static void deviceConnected(IDevice device) { final String serialNumber = device.getSerialNumber(); StudioLogger.debug("Device connected: " + serialNumber); //$NON-NLS-1$ synchronized (connectedDevices) { connectedDevices.put(serialNumber, device); } if (!device.isEmulator() && !device.hasClients()) { boolean timeout = false; long startTime = System.currentTimeMillis(); int maxInterval = 10000; do { try { Thread.sleep(250); } catch (InterruptedException e) { //do nothing } long currentTime = System.currentTimeMillis(); timeout = ((startTime + maxInterval) < currentTime); } while (!device.hasClients() && !timeout); if (timeout) { synchronized (completelyUpDevices) { //put the device up anyway. completelyUpDevices.add(serialNumber); } } } if (device.hasClients()) { // When a device is connected, look for the HOME application and add // the device serial number to a collection if it is already running. IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); String home = store.getString(AdtPrefs.PREFS_HOME_PACKAGE); if (device.getClient(home) != null) { StudioLogger.debug("Completely Up Device: " + serialNumber); //$NON-NLS-1$ synchronized (completelyUpDevices) { completelyUpDevices.add(serialNumber); } } } StudioAndroidEventManager.fireEvent(EventType.DEVICE_CONNECTED, serialNumber); } /** * Unregisters a device as connected * * @param device */ static void deviceDisconnected(IDevice device) { final String serialNumber = device.getSerialNumber(); StudioLogger.debug("Device disconnected: " + serialNumber); //$NON-NLS-1$ synchronized (completelyUpDevices) { completelyUpDevices.remove(serialNumber); } synchronized (connectedDevices) { connectedDevices.remove(serialNumber); } StudioAndroidEventManager.fireEvent(EventType.DEVICE_DISCONNECTED, serialNumber); avdNameMap.remove(device.getSerialNumber()); } /** * Get all connected device serial numbers * * @return */ public static Collection<String> getConnectedSerialNumbers() { return connectedDevices.keySet(); } /** * Get the Device associated with the given serial number * * @param serialNumber Serial number of the device to retrieve * @return Device associated with the given serial number */ public static IDevice getDeviceBySerialNumber(String serialNumber) { return connectedDevices.get(serialNumber); } /** * Runs an activity at the given device * * @param serialNumber The serial number of the device to have the activity executed * @param activityName The activity to execute * @param debugMode Whether the activity shall be run in debug mode or not * @param processOut The output stream of the process running "adb" * * @return An IStatus object with the result of the operation */ public static IStatus runActivity(String serialNumber, String activityName, boolean debugMode, OutputStream processOut) { IStatus status = Status.OK_STATUS; // Return if no instance is selected if (serialNumber == null) { StudioLogger.error("Abort run operation. Serial number is null."); //$NON-NLS-1$ return new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_SerialNumberNullPointer); } // Return if instance is not started if (!isDeviceOnline(serialNumber)) { StudioLogger.error("Abort run operation. Device is not online."); //$NON-NLS-1$ return new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, ""); //$NON-NLS-1$ } try { String[] cmd = createRunCommand(serialNumber, activityName, debugMode); executeCommand(cmd, processOut); } catch (IOException e) { StudioLogger.error("Deploy: Could not execute adb install command."); //$NON-NLS-1$ status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, e.getMessage()); } return status; } static String executeCommand(String[] cmd, OutputStream out) throws IOException { return executeCommand(cmd, out, null); } /** * DOCUMENT ME!! * @param cmd * @param out * @param serialNumber * @return * @throws IOException */ static String executeCommand(String[] cmd, OutputStream out, String serialNumber) throws IOException { String fullCmd = ""; //$NON-NLS-1$ if (out != null) { for (String cmdArg : cmd) { fullCmd += cmdArg + " "; //$NON-NLS-1$ } out.write(fullCmd.getBytes()); out.write("\n".getBytes()); //$NON-NLS-1$ } Runtime r = Runtime.getRuntime(); Process p = r.exec(cmd); String command_results = ""; //$NON-NLS-1$ InputStream processIn = p.getInputStream(); final BufferedReader br = new BufferedReader(new InputStreamReader(processIn)); String line; try { while ((line = br.readLine()) != null) { command_results += line; command_results += "\n"; //$NON-NLS-1$ if (out != null) { if (serialNumber != null) { out.write((serialNumber + ": ").getBytes()); //$NON-NLS-1$ } out.write(line.getBytes()); out.write("\n".getBytes()); //$NON-NLS-1$ } } } finally { br.close(); } return command_results; } /** * See http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-traps.html * to understand how Process.exec works and its problems * * @param cmd Command to be executed. * @param out Output Stream. * @param timeout Timeout (secs.) * @param monitor {@link IProgressMonitor} * * @return the {@link IStatus} of this process execution. * * @throws IOException Exception thrown in case there is any problem * executing the command. */ private static IStatus executeRemoteDevicesCommand(String[] cmd, OutputStream out, int timeout, String timeoutMsg, IStopCondition stopCondition, IProgressMonitor monitor) throws IOException { IStatus status = Status.OK_STATUS; long timeoutLimit = -1; if (timeout != 0) { timeoutLimit = System.currentTimeMillis() + (timeout * 1000); } String fullCmd = ""; //$NON-NLS-1$ for (String cmdArg : cmd) { fullCmd += cmdArg + " "; //$NON-NLS-1$ } if (out != null) { out.write(fullCmd.getBytes()); out.write("\n".getBytes()); //$NON-NLS-1$ } Runtime r = Runtime.getRuntime(); Process p = r.exec(cmd); int errorCode = 0; // inputStream / errorStream; String[] commandResults = new String[] { "", "" //$NON-NLS-1$ //$NON-NLS-2$ }; commandResults = readCmdOutputFromStreams(commandResults[0], commandResults[1], p.getInputStream(), p.getErrorStream(), out); while (!stopCondition.canStop()) { if ((monitor != null) && (monitor.isCanceled())) { p.destroy(); return Status.CANCEL_STATUS; } try { errorCode = p.exitValue(); if (errorCode != 0) { break; } } catch (IllegalThreadStateException e) { // Process is still running... Proceed with loop } try { Thread.sleep(1000); } catch (InterruptedException e) { StudioLogger.error("Execute command: thread has been interrupted"); //$NON-NLS-1$ } if (timeout > 0) { try { testTimeout(timeoutLimit, ((timeoutMsg != null) ? timeoutMsg : AndroidNLS.ERR_GenericTimeout)); } catch (TimeoutException e) { p.destroy(); StudioLogger.debug("The timeout " + timeout //$NON-NLS-1$ + " has been reached when executing the command " + fullCmd); //$NON-NLS-1$ return new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, e.getMessage(), e); } } } commandResults = readCmdOutputFromStreams(commandResults[0], commandResults[1], p.getInputStream(), p.getErrorStream(), out); if (errorCode != 0) { StudioLogger.debug("Command " + cmd + " returned an error code: " + errorCode); //$NON-NLS-1$ //$NON-NLS-2$ status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, NLS.bind(AndroidNLS.ERR_CommandError, errorCode) + "\n" //$NON-NLS-1$ + ((!commandResults[1].equals("")) ? commandResults[1] //$NON-NLS-1$ : commandResults[0])); } else { status = new Status(IStatus.OK, AndroidPlugin.PLUGIN_ID, commandResults[0]); } return status; } /** * Defines a stop condition */ interface IStopCondition { public boolean canStop(); } /** * @param commandResults * @param errorResults * @param inputStream * @param errorStream * @param out */ private static String[] readCmdOutputFromStreams(String commandResults, String errorResults, InputStream inputStream, InputStream errorStream, OutputStream out) { String[] results = new String[2]; String line = ""; //$NON-NLS-1$ BufferedReader brInput = new BufferedReader(new InputStreamReader(inputStream)); BufferedReader brError = new BufferedReader(new InputStreamReader(errorStream)); try { // input stream if (brInput.ready()) { while ((line = brInput.readLine()) != null) { commandResults += line; commandResults += "\n"; //$NON-NLS-1$ if (out != null) { out.write(line.getBytes()); out.write("\n".getBytes()); //$NON-NLS-1$ } } } // error stream if (brError.ready()) { while ((line = brError.readLine()) != null) { errorResults += "\n"; //$NON-NLS-1$ if (out != null) { out.write(line.getBytes()); out.write("\n".getBytes()); //$NON-NLS-1$ } } } } catch (IOException e) { StudioLogger.error("Cannot read command outputs"); //$NON-NLS-1$ } finally { try { brInput.close(); brError.close(); } catch (IOException e) { StudioLogger.error("Could not close console stream: " + e.getMessage()); } } results[0] = commandResults; results[1] = errorResults; return results; } /** * Checks if the timeout limit has reached. * * @param timeoutLimit The system time limit that cannot be overtaken, in milliseconds. * @throws StartTimeoutException When the system time limit is overtaken. */ private static void testTimeout(long timeoutLimit, String timeoutErrorMessage) throws TimeoutException { if (System.currentTimeMillis() > timeoutLimit) { throw new TimeoutException(timeoutErrorMessage); } } /** * Creates a string with the command that should * be called in order to run the application. */ private static String[] createRunCommand(String serialNumber, String activityName, boolean debugMode) { String cmd[]; String sdkPath = SdkUtils.getSdkPath(); // The tools folder should exist and be here, but double-cheking // once more wont kill File f = new File(sdkPath + PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Run: Could not find tools folder on " + sdkPath + PLATFORM_TOOLS_FOLDER //$NON-NLS-1$ + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error("Run: Invalid tools folder " + sdkPath + PLATFORM_TOOLS_FOLDER //$NON-NLS-1$ + File.separator); } } String completeAppPath = activityName.substring(0, activityName.lastIndexOf(".")) + "/" + activityName; //$NON-NLS-1$ //$NON-NLS-2$ if (debugMode) { // If debugMode option is checked, create command with the -D paramater String cmdTemp[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, ADB_INSTANCE_PARAMETER, serialNumber, SHELL_CMD, AM_CMD, START_CMD, ADB_AM_DEBUG, ADB_AM_NAME, completeAppPath }; cmd = cmdTemp; } else { // If debugMode option is unchecked, create command without the -D paramater String cmdTemp[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, ADB_INSTANCE_PARAMETER, serialNumber, SHELL_CMD, AM_CMD, START_CMD, ADB_AM_NAME, completeAppPath }; cmd = cmdTemp; } return cmd; } /** * Check if the device is Online (i.e. if it's possible to communicate with it) * Notice it is a verification of the status of the Device which may be different than the status of the Tml Instance. * * @param serialNumber * @return true if the Device is online, false otherwise */ public static boolean isDeviceOnline(String serialNumber) { IDevice device = getDeviceBySerialNumber(serialNumber); if ((device == null) || !device.isOnline()) { return false; } return true; } /** * Return true if the Device is being shown on the OFFLINE state. * * @param serialNumber Devices serial number. * * @return <code>true</code> in case the Device if offline, * <code>false</code> otherwise. */ public static boolean isDeviceOffline(String serialNumber) { IDevice device = getDeviceBySerialNumber(serialNumber); return ((device == null) || ((device != null) && device.isOffline())); } /** * Check if the device is completely loaded * A device is completely loaded when it loads the HOME application * * @param serialNumber * @return true if the Device has completely loaded; false otherwise */ public static boolean isDeviceCompletelyLoaded(String serialNumber) { return completelyUpDevices.contains(serialNumber); } /** * Tests if the device represented by the serial number (if it exists) is an emulator * * @param serialNumber * @return true if it is an emulator, false if not or non existent */ public static boolean isEmulator(String serialNumber) { IDevice device = getDeviceBySerialNumber(serialNumber); if ((device != null) && device.isEmulator()) { return true; } return false; } public static boolean isRemote(String serialNumber) { // firstly, test if the serial number has the format "anything:digits" Pattern p = Pattern.compile("(.)+:(\\d)+"); //$NON-NLS-1$ Matcher m = p.matcher(serialNumber); if (m.matches()) { IDevice device = getDeviceBySerialNumber(serialNumber); if ((device != null) && !device.isEmulator()) { return true; } } return false; } /** * Execute an app in the Device * * @param serialNumber Serial number of the device where to execute the command * @param remoteCommand command to be executed remotely on the Device * @param monitor monitor associated with the operation * * @return The lines read from the command output * * @throws IOException */ public static Collection<String> execRemoteApp(String serialNumber, String remoteCommand, final IProgressMonitor monitor) throws IOException { return executeShellCmd(serialNumber, remoteCommand, monitor); } /** * Execute an app in the Device * * @param serialNumber Serial number of the device where to execute the command * @param remoteCommands commands to be executed remotely on the Device * @param monitor monitor associated with the operation * * @throws IOException */ public static Map<String, Collection<String>> execRemoteApp(String serialNumber, Collection<String> remoteCommands, final IProgressMonitor monitor) throws IOException { Map<String, Collection<String>> cmdAnswers = new LinkedHashMap<String, Collection<String>>(); for (String remoteCommand : remoteCommands) { StudioLogger.debug(remoteCommand); Collection<String> answers = executeShellCmd(serialNumber, remoteCommand, monitor); cmdAnswers.put(remoteCommand, answers); } return cmdAnswers; } private static Collection<String> executeShellCmd(String serialNumber, final String cmd, final IProgressMonitor monitor) { final Collection<String> results = new ArrayList<String>(); IDevice d = getDeviceBySerialNumber(serialNumber); if (d != null) { try { d.executeShellCommand(cmd, new MultiLineReceiver() { public boolean isCancelled() { return monitor.isCanceled(); } @Override public void processNewLines(String[] lines) { for (String line : lines) { if ((!line.equals("")) && (!line.equals(cmd))) //$NON-NLS-1$ { results.add(line); } } } }, 0); } catch (Exception e) { StudioLogger.error(DDMSFacade.class, "Error executing shell command " + cmd //$NON-NLS-1$ + " at device " + serialNumber, e); //$NON-NLS-1$ } } return results; } /** * Retrieves all properties from the device with provided serial number. * @param serialNumber * @return */ public static Properties getDeviceProperties(String serialNumber) { Properties instanceProperties = new Properties(); if (serialNumber != null) { String key = ""; //$NON-NLS-1$ String value = ""; //$NON-NLS-1$ Collection<String> lines; try { lines = execRemoteApp(serialNumber, "getprop", new NullProgressMonitor()); //$NON-NLS-1$ for (String line : lines) { String[] split = line.split("]:"); //$NON-NLS-1$ if (split.length >= 2) { if (!split[0].equals("")) //$NON-NLS-1$ { key = split[0].substring(1, split[0].length()); if (!split[1].equals("")) //$NON-NLS-1$ { value = split[1].substring(2, split[1].length() - 1); instanceProperties.setProperty(key, value); } } } } } catch (IOException e) { StudioLogger.error("IOException while executing an app on device. " + e.getMessage()); } } return instanceProperties; } /** * Retrieves a given property from the device with provided serial number. * * @param serialNumber * @param propertyName * * @return */ public static String getDeviceProperty(String serialNumber, String propertyName) { String result = null; IDevice device = DDMSFacade.getDeviceBySerialNumber(serialNumber); if (device != null) { result = device.getProperty(propertyName); } return result; } /** * Get the name of the VM associated to the emulator running in the given deviceSerial identification. * * @param deviceSerial identification of the emulator whose vm name must be retrieved. * @return the name of the VM used by the emulator running with the given id, * or null if the vmname could be retrieved. */ public static String getVmName(final IDevice d) { String vmName = null; String serialNumber = d.getSerialNumber(); int MAX_TRIES = 120; int tries = 0; while ((vmName == null) && (tries < MAX_TRIES)) { synchronized (avdNameMap) { vmName = avdNameMap.get(serialNumber); } if (vmName == null) { vmName = d.getAvdName(); } if (vmName == null) { try { Thread.sleep(1000); } catch (InterruptedException e) { //do nothing } finally { tries++; } } //try to get vmname by telnet as last option if (vmName == null) { vmName = getVmNameByTelnet(serialNumber); } } if (vmName != null) { synchronized (avdNameMap) { if (avdNameMap.get(serialNumber) == null) { avdNameMap.put(serialNumber, vmName); } } } return vmName; } private static String getVmNameByTelnet(String serialNumber) { Pattern pattern = Pattern.compile("emulator-([0-9]+)"); //$NON-NLS-1$ TelnetFrameworkAndroid telnet = new TelnetFrameworkAndroid(); Matcher matcher = pattern.matcher(serialNumber); matcher.matches(); String avdName = null; try { Integer telnetPort = Integer.valueOf(matcher.group(1)); telnet.connect("localhost", telnetPort); //$NON-NLS-1$ String avdNameRaw = telnet.write("avd name\r\n", new String[] //$NON-NLS-1$ { "KO" //$NON-NLS-1$ }); String split = avdNameRaw.contains("\r\n") ? "\r\n" : "\n"; String[] outputArray = avdNameRaw.split(split); //$NON-NLS-1$ if (outputArray.length > 2) { avdName = outputArray[2]; } if (avdName != null) { avdNameMap.put(serialNumber, avdName); } } catch (NumberFormatException e) { avdName = serialNumber; } catch (IOException e) { avdName = serialNumber; } finally { try { telnet.disconnect(); } catch (IOException e) { //Do nothing. } } return avdName; } /** * Get the Device associated with the Android VM * * @param vmName Android VM name * @return Device associated with the given Android VM */ public static IDevice getDeviceWithVmName(String vmName) { IDevice toReturn = null; if (vmName != null) { Collection<IDevice> devices = connectedDevices.values(); for (IDevice d : devices) { if (d.isEmulator()) { String deviceVmName = DDMSFacade.getVmName(d); if (vmName.equals(deviceVmName)) { toReturn = d; break; } } } } return toReturn; } /** * Securely get the name of the AVD associated to the given device. * * @param serialNumber The serialNumber of the device that we want the AVD name for * @return the name of the AVD used by the emulator running with the given device, * or null if the vmname could be retrieved. */ public static String getNameBySerialNumber(String serialNumber) { String avdName = null; IDevice d = getDeviceBySerialNumber(serialNumber); avdName = getNameByDevice(d); return avdName; } /** * Securely get the serial number of the given instance. * * @param instanceName The name of the instance we want the serial number of * @return the serial number of the given instance, or <code>null</code> if no instance with the * given name is online */ public static String getSerialNumberByName(String instanceName) { String serialNumber = null; if (instanceName != null) { List<IDevice> devices = null; synchronized (connectedDevices) { devices = new ArrayList<IDevice>(connectedDevices.size()); devices.addAll(connectedDevices.values()); } if (devices != null) { for (IDevice dev : devices) { if (instanceName.equals(getNameByDevice(dev))) { serialNumber = dev.getSerialNumber(); break; } } } } return serialNumber; } public static Collection<String> getRunningApplications(String serialNumber) { Collection<String> apps = new ArrayList<String>(); if (serialNumber != null) { IDevice dev = getDeviceBySerialNumber(serialNumber); if (dev != null) { Client[] clients = dev.getClients(); if ((clients != null) && (clients.length > 0)) { for (Client c : clients) { apps.add(c.getClientData().getClientDescription()); } } } } return apps; } /** * Dumps a HPROF file based on a client description and a device serial number * @param clientDescription A client description of a running application */ public static IStatus dumpHprofFile(String clientDescription, String serialNumber, IProgressMonitor monitor) { IStatus status = Status.OK_STATUS; monitor.beginTask(AndroidNLS.DumpHprofFile_GeneratingMemoryAnalysisOutput, 100); // Retrive running apps monitor.setTaskName(AndroidNLS.DumpHprofFile_GettingRunningApplications); IDevice dev = getDeviceBySerialNumber(serialNumber); Client[] clients = dev.getClients(); monitor.worked(25); // Store the shell final Shell[] shell = new Shell[1]; PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() { public void run() { shell[0] = new Shell(PlatformUI.getWorkbench().getDisplay()); } }); MotodevHProfDumpHandler hprofHandler = new MotodevHProfDumpHandler(shell[0], monitor); monitor.setTaskName(AndroidNLS.DumpHprofFile_SettingApplicationToAnalyse); hprofHandler.setSelectedApp(clientDescription); monitor.worked(25); try { // Find a client with matching description and dum the HPROF file for (Client c : clients) { if (c.getClientData().getClientDescription().equals(clientDescription)) { // Set our handler as the HprofDumpHandler ClientData.setHprofDumpHandler(hprofHandler); monitor.setTaskName(AndroidNLS.DumpHprofFile_DumpingHprofFile); c.dumpHprof(); synchronized (DDMSFacade.class) { DDMSFacade.class.wait(); } monitor.worked(50); } } } catch (Exception e) { // Status not ok status = Status.CANCEL_STATUS; } finally { monitor.done(); } return status; } /** * Gets the AVD name of the device * * @param d The device to be searched for the AVD name * * @return The AVD name */ private static String getNameByDevice(final IDevice d) { String name = null; if (d != null) { if (d.isEmulator()) { name = getVmName(d); } else { name = d.getSerialNumber(); } } return name; } /** * Create port forward for a given VM * * @param serialNumber Android serial number * @param from port number from * @param to port number to * @return true is the port forward was successful, false otherwise */ public static boolean createForward(String serialNumber, int from, int to) { boolean ok = true; IDevice device = getDeviceBySerialNumber(serialNumber); try { device.createForward(from, to); } catch (Exception e) { StudioLogger.error(DDMSFacade.class, "Error creating forward of device: " //$NON-NLS-1$ + serialNumber + " from " + from + " to " + to, e); //$NON-NLS-1$ //$NON-NLS-2$ ok = false; } return ok; } /** * Kill the communication channel * * @param serialNumber The serial number of the device to kill */ public static void kill(String serialNumber) { if (isDeviceOnline(serialNumber)) { IDevice deviceToKill = getDeviceBySerialNumber(serialNumber); if (deviceToKill != null) { synchronized (consoleLock) { EmulatorConsole console = EmulatorConsole.getConsole(deviceToKill); if (console != null) { console.kill(); } } } } } /** * Push files to device * * @param serialNumber Android device serial number * @param localDir local folder path * @param fileNames files to transfer * @param remoteDir destination folder path * @param timeout timeout for the operation * @param monitor monitor associated with the operation */ public static IStatus pushFiles(String serialNumber, String localDir, Collection<String> fileNames, String remoteDir, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { return transferFiles(true, serialNumber, localDir, fileNames, remoteDir, timeout, monitor, outputStream); } /** * Push files to device * * @param serialNumber Android device serial number * @param localFiles destination local files * @param remoteFiles remote files to transfer as localFiles to desktop * @param timeout timeout for the operation * @param monitor monitor associated with the operation */ public static IStatus pushFiles(String serialNumber, List<File> localFiles, List<String> remoteFiles, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { return transferFiles(true, serialNumber, localFiles, remoteFiles, timeout, monitor, outputStream); } /** * Pull files from device * * @param serialNumber Android device serial number * @param localDir local folder path * @param fileNames files to transfer * @param remoteDir destination folder path * @param timeout timeout for the operation * @param monitor monitor associated with the operation */ public static IStatus pullFiles(String serialNumber, String localDir, Collection<String> fileNames, String remoteDir, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { return transferFiles(false, serialNumber, localDir, fileNames, remoteDir, timeout, monitor, outputStream); } /** * Pull files from device * * @param serialNumber Android device serial number * @param localFiles local files to transfer as remoteFiles to device * @param remoteFiles destination remote files * @param timeout timeout for the operation * @param monitor monitor associated with the operation */ public static IStatus pullFiles(String serialNumber, List<File> localFiles, List<String> remoteFiles, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { return transferFiles(false, serialNumber, localFiles, remoteFiles, timeout, monitor, outputStream); } /** * Get the service used to transfer files to the Device * * @param device Device * @param timeout timeout for the operation * @param monitor monitor associated with the operation * @return The service used to transfer files to the Device * * @throws AndroidException */ private static SyncService getSyncService(IDevice device, int timeout, final IProgressMonitor monitor) throws AndroidException { SyncService service = null; long timeoutLimit = System.currentTimeMillis() + timeout; do { if ((device != null) && (device.isOnline())) { try { service = device.getSyncService(); } catch (IOException e) { StudioLogger.debug("Couldn't get sync service; cause: " + e.getMessage()); //$NON-NLS-1$ } catch (com.android.ddmlib.TimeoutException e) { StudioLogger.debug("Couldn't get sync service; cause: " + e.getMessage()); //$NON-NLS-1$ } catch (AdbCommandRejectedException e) { StudioLogger.debug("Couldn't get sync service; cause: " + e.getMessage()); //$NON-NLS-1$ } } try { Thread.sleep(100); } catch (InterruptedException e) { //do nothing } if (monitor.isCanceled()) { StudioLogger.info("Operation canceled by the user"); //$NON-NLS-1$ return null; } if (System.currentTimeMillis() > timeoutLimit) { StudioLogger.error("The emulator was not up within the set timeout"); //$NON-NLS-1$ throw new AndroidException("Timeout while preparing to transfer files to the Device. " + device); //$NON-NLS-1$ } } while (service == null); return service; } private static IStatus transferFiles(boolean isPush, String serialNumber, String localDir, Collection<String> fileNames, String remoteDir, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { List<File> localList = new ArrayList<File>(); List<String> remoteList = new ArrayList<String>(); for (String name : fileNames) { localList.add(new File(localDir, name)); remoteList.add(remoteDir + "/" + name); //$NON-NLS-1$ } return transferFiles(isPush, serialNumber, localList, remoteList, timeout, monitor, outputStream); } private static IStatus transferFiles(boolean isPush, String serialNumber, List<File> localFiles, List<String> remoteFiles, int timeout, final IProgressMonitor monitor, OutputStream outputStream) { if (localFiles.size() != remoteFiles.size()) { return new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_IncompatibleFileLists); } IStatus status = Status.OK_STATUS; IDevice device = DDMSFacade.getDeviceBySerialNumber(serialNumber); SyncService service = null; try { service = getSyncService(device, timeout, monitor); if (service == null) { status = Status.CANCEL_STATUS; } else { final ISyncProgressMonitor syncMonitor = new ISyncProgressMonitor() { public void start(int i) { //do nothing } public void stop() { //do nothing } public void advance(int i) { //do nothing } public boolean isCanceled() { return monitor.isCanceled(); } public void startSubTask(String s) { //do nothing } }; FileListingService flService = device.getFileListingService(); for (int i = 0; i < localFiles.size(); i++) { File localFile = localFiles.get(i); String remotePath = remoteFiles.get(i); String absLocalFile = localFile.getAbsolutePath(); String resultMessage = null; if (isPush) { StudioLogger.debug("Push " + absLocalFile + " to " + remotePath); //$NON-NLS-1$ //$NON-NLS-2$ try { service.pushFile(absLocalFile, remotePath, syncMonitor); } catch (SyncException e1) { StudioLogger.debug("Push result: " + "SyncException occured " + e1.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$ resultMessage = NLS.bind(AndroidNLS.CON_ConsolePush, absLocalFile, remotePath) + ": " //$NON-NLS-1$ + e1.getLocalizedMessage(); } catch (FileNotFoundException e1) { StudioLogger.debug("Push result: " + "FileNotFoundException occured " //$NON-NLS-1$ //$NON-NLS-2$ + e1.getMessage()); resultMessage = NLS.bind(AndroidNLS.CON_ConsolePush, absLocalFile, remotePath) + ": " //$NON-NLS-1$ + e1.getLocalizedMessage(); } catch (IOException e1) { StudioLogger.debug("Push result: " + "IOException occured " + e1.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$ resultMessage = NLS.bind(AndroidNLS.CON_ConsolePush, absLocalFile, remotePath) + ": " //$NON-NLS-1$ + e1.getLocalizedMessage(); } catch (com.android.ddmlib.TimeoutException e1) { StudioLogger.debug("Push result: " + "TimeoutException occured " + e1.getMessage()); //$NON-NLS-1$ //$NON-NLS-2$ resultMessage = NLS.bind(AndroidNLS.CON_ConsolePush, absLocalFile, remotePath) + ": " //$NON-NLS-1$ + e1.getLocalizedMessage(); } if ((outputStream != null) && (resultMessage != null)) { try { outputStream.write(resultMessage.getBytes()); outputStream.write('\n'); outputStream.flush(); } catch (Exception e) { // Do nothing } } } else { FileEntry f1 = null; FileEntry f2 = null; f2 = flService.getRoot(); flService.getChildren(f2, false, null); String[] dirs = remotePath.split("/"); //$NON-NLS-1$ for (int j = 1; j < (dirs.length - 1); j++) { f1 = f2.findChild(dirs[j]); flService.getChildren(f1, false, null); f2 = f1; } final FileEntry fileToPull = f2.findChild(dirs[dirs.length - 1]); if (fileToPull != null) { try { service.pullFile(fileToPull, absLocalFile, syncMonitor); } catch (FileNotFoundException e) { resultMessage = e.getLocalizedMessage(); StudioLogger.debug("Pull result: " + e.getMessage()); //$NON-NLS-1$ } catch (SyncException e) { resultMessage = e.getLocalizedMessage(); StudioLogger.debug("Pull result: " + e.getMessage()); //$NON-NLS-1$ } catch (IOException e) { resultMessage = e.getLocalizedMessage(); StudioLogger.debug("Pull result: " + e.getMessage()); //$NON-NLS-1$ } catch (com.android.ddmlib.TimeoutException e) { resultMessage = e.getLocalizedMessage(); StudioLogger.debug("Pull result: " + e.getMessage()); //$NON-NLS-1$ } if ((outputStream != null) && (resultMessage != null)) { String message = NLS.bind(AndroidNLS.CON_ConsolePull, fileToPull.getFullPath(), absLocalFile) + ": " + resultMessage; //$NON-NLS-1$ try { outputStream.write(message.getBytes()); outputStream.write('\n'); outputStream.flush(); } catch (IOException e) { //do nothing } } } else { resultMessage = NLS.bind(AndroidNLS.DDMSFacade_Remote_File_Not_Found, remotePath); StudioLogger.debug("Pull result: File not found " + remotePath); //$NON-NLS-1$ } } if (resultMessage != null) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, resultMessage); } if (syncMonitor.isCanceled()) { status = Status.CANCEL_STATUS; break; } } } } catch (AndroidException e) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, e.getMessage()); } catch (NullPointerException e1) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_FileNotFound); } finally { if (service != null) { service.close(); } } return status; } /** * Check if the application is running in the device with specified serial number * @param serialNumber * @param applicationName * @return true if it is running, false otherwise */ public static boolean isApplicationRunning(String serialNumber, String applicationName) { IDevice dev = null; boolean running = false; dev = connectedDevices.get(serialNumber); if (dev != null) { running = dev.getClient(applicationName) != null; } return running; } /** * Connect to a Remote Device given its IP/Port * * @param device the Remote Device Instance * @param host device host (IP) * @param port device port * @param timeout the maximum time allowed to successfully connect to the device * @param monitor the monitor of the operation * @return the status of the operation * @throws IOException */ public static IStatus connectTcpIp(final ISerialNumbered device, String host, String port, int timeout, IProgressMonitor monitor) throws IOException { SubMonitor subMonitor = SubMonitor.convert(monitor, 1000); subMonitor.beginTask(AndroidNLS.DDMSFacade_MsgConnectingToDeviceViaTCPIP, 10); IStatus status = Status.OK_STATUS; String serialNumber = device.getSerialNumber(); if (!isDeviceOnline(serialNumber)) // check if it's already connected { String[] cmd = createConnectTcpIpCommand(host, port); status = executeRemoteDevicesCommand(cmd, null, timeout, NLS.bind(AndroidNLS.ERR_RemoteDevice_TimeoutWhileConnecting, device.getDeviceName()), new IStopCondition() { public boolean canStop() { String serialNumber = device.getSerialNumber(); if (serialNumber != null) { return isDeviceOnline(serialNumber); } else { return false; } } }, subMonitor.newChild(1000)); } subMonitor.worked(1000); return status; } /** * Method which switches the device connection mode from TCP/IP * to USB. * * @param device {@link ISerialNumbered} device to have its connection mode changed. * @param host The IP of the device. * @param port The port in which the TCP/IP connection is established. * @param timeout The maximum time which the switching operation is attempted. * @param monitor The {@link IProgressMonitor} which this operation is being computed. * * @return Returns the {@link IStatus} of this operation. * * @throws IOException Exception thrown in case something goes wrong while trying * to switch the device connection mode from TCP/IP to USB. */ public static IStatus switchFromTCPConnectionModeToUSBConnectionMode(final ISerialNumbered device, String host, String port, int timeout, IProgressMonitor monitor) throws IOException { SubMonitor subMonitor = SubMonitor.convert(monitor, 1000); subMonitor.beginTask(AndroidNLS.DDMSFacade_MsgSwitchingDeviceFromTCPIPToUSB, 10); IStatus status = Status.OK_STATUS; String serialNumber = device.getSerialNumber(); if (isDeviceOnline(serialNumber)) // check if it's already connected { String[] cmd = createSwitchToUSBConnectionModeCommand(host, port); status = executeRemoteDevicesCommand(cmd, null, timeout, NLS.bind(AndroidNLS.DDMSFacade_MsgTimeoutReachedSwitchingFromTCPToUSB, device.getDeviceName()), new IStopCondition() { public boolean canStop() { String serialNumber = device.getSerialNumber(); if (serialNumber != null) { return isDeviceOnline(serialNumber); } else { return false; } } }, subMonitor.newChild(1000)); } subMonitor.worked(1000); if (status.isOK()) { StudioLogger.collectUsageData(StudioLogger.WHAT_REMOTE_USB, StudioLogger.KIND_REMOTE_DEVICE, StudioLogger.DESCRIPTION_DEFAULT, AndroidPlugin.PLUGIN_ID, AndroidPlugin.getDefault().getBundle().getVersion().toString()); } return status; } /** * Get the wireless ip from the connected handset * @param serialNumber * @param monitor * @return the ip or null if not possible to retrieve it */ public static String getWirelessIPfromHandset(String serialNumber, IProgressMonitor monitor) { String handset_wireless_ip = null; IDevice device = null; device = connectedDevices.get(serialNumber); if (device != null) { // get the wi-fi name for executing the ipconfig command String wifiProperty = device.getProperty(WIFI_INTERFACE_DEVICE_PROPERTY); if (wifiProperty == null) { wifiProperty = DEFAULT_WIRELESS_DEVICE_PROPERTY; } // execute ipconfig command Collection<String> answers = executeShellCmd(serialNumber, IFCONFIG_CMD + " " + wifiProperty, monitor); //$NON-NLS-1$ // Success message - for example // [tiwlan0: ip 192.168.0.174 mask 255.255.255.0 flags [up broadcast running multicast]] if (answers != null) { String result = answers.toString(); if (result != null) { // splits the result of the shell command and gets the third position // that should be the IP number String[] result_splited = result.split(" "); //$NON-NLS-1$ if (result_splited.length >= 3) { // check whether there is an IP Pattern pattern = Pattern.compile(IP_PATTERN); Matcher matcher = pattern.matcher(result); if (matcher.find()) { handset_wireless_ip = result_splited[2]; } } } } } return handset_wireless_ip; } /** * Switch adb connection mode of an specific device to TCPIP * * @param deviceName name of the handset instance * @param host wireless ip of the handset instance * @param port number of the port to be using during the connection * @param timeout the maximum time allowed to successfully connect to the device * @param monitor the monitor of the operation * @return the status of the operation * * @throws IOException Exception thrown in case there are problems switching the device. */ public static IStatus switchUSBtoTcpIp(String deviceName, final String serialNumber, String port, int timeout, IProgressMonitor monitor) throws IOException { SubMonitor subMonitor = SubMonitor.convert(monitor, 1000); subMonitor.beginTask(AndroidNLS.DDMSFacade_MsgSwitchingFromUSBConnection, 10); IStatus status = Status.OK_STATUS; if (isDeviceOnline(serialNumber)) { String[] cmd = createSwitchToTcpIpCommand(serialNumber, port); status = executeRemoteDevicesCommand(cmd, null, timeout, NLS.bind(AndroidNLS.ERR_WirelessRemoteDevice_TimeoutWhileConnecting, deviceName), new IStopCondition() { public boolean canStop() { if (serialNumber != null) { return isDeviceOffline(serialNumber); } else { return false; } } }, subMonitor.newChild(1000)); } monitor.worked(1000); return status; } /** * Disconnect from a Remote Device given its IP/Port * * @param device the Remote Device Instance * @param host device host (IP) * @param port device port * @param timeout the maximum time allowed to successfully disconnect from the device * @param monitor the monitor of the operation * @return the status of the operation * @throws IOException */ public static IStatus disconnectTcpIp(final ISerialNumbered device, String host, String port, int timeout, IProgressMonitor monitor) throws IOException { IStatus status = Status.OK_STATUS; String serialNumber = device.getSerialNumber(); if (isDeviceOnline(serialNumber)) // check if it's already disconnected { String[] cmd = createDisconnectTcpIpCommand(host, port); status = executeRemoteDevicesCommand(cmd, null, timeout, NLS.bind(AndroidNLS.ERR_RemoteDevice_TimeoutWhileDisconnecting, device.getDeviceName()), new IStopCondition() { public boolean canStop() { String serialNumber = device.getSerialNumber(); return !isDeviceOnline(serialNumber); } }, monitor); } return status; } /** * Creates a string with the command that should * be called in order to connect to an IP/Port * * @param host device host (IP) * @param port device port * @return the command to be used to connect to an IP/Port */ private static String[] createConnectTcpIpCommand(String host, String port) { String hostPort = host + ":" + port; //$NON-NLS-1$ String sdkPath = SdkUtils.getSdkPath(); String cmd[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, CONNECT_TCPIP_CMD, hostPort }; return cmd; } /** * Creates a string with the command switches * a device from the TCP/IP connection mode * to the USB connection mode. * * @param host Device host (IP). * @param port Device port. * * @return The command to be used to switch back to USB connection mode. */ private static String[] createSwitchToUSBConnectionModeCommand(String host, String port) { String hostPort = host + ":" + port; //$NON-NLS-1$ String sdkPath = SdkUtils.getSdkPath(); String cmd[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, DEVICE_ID_INDICATOR, hostPort, USB_SWITCH_BACK_COMMAND }; return cmd; } /** * Creates a string with the command that should * be called in order to switch adb connection from USB to TPCIP mode * * @param serialNumber device serial number * @param port device port * @return the command to be used to switch adb connection to TCPIP mode */ private static String[] createSwitchToTcpIpCommand(String serialNumber, String port) { String sdkPath = SdkUtils.getSdkPath(); String cmd[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, ADB_INSTANCE_PARAMETER, serialNumber, TCPIP_CMD, port }; return cmd; } /** * Creates a string with the command that should * be called to delete a file from device * * @param serialNumber * @param file * @param folder * @return */ private static String[] createDeleteFileFromDeviceCommand(String serialNumber, String file, String folder) { String sdkPath = SdkUtils.getSdkPath(); // The tools folder should exist and be here, but double-cheking // once more wont kill File f = new File(sdkPath + PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Run: Could not find tools folder on " + sdkPath + PLATFORM_TOOLS_FOLDER //$NON-NLS-1$ + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error("Run: Invalid tools folder " + sdkPath + PLATFORM_TOOLS_FOLDER //$NON-NLS-1$ + File.separator); } } String cmd[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, ADB_INSTANCE_PARAMETER, serialNumber, SHELL_CMD, "rm /" + folder + "/" + file //$NON-NLS-1$ //$NON-NLS-2$ }; return cmd; } /** * Uses the ADB shell command to remove a file from the device * * @param serialNumber * @param fileName * @param sdCardFolder * @return * @throws IOException */ private static boolean deleteFileFromDevice(String serialNumber, String fileName, String folder) throws IOException { String command[] = createDeleteFileFromDeviceCommand(serialNumber, fileName, folder); IStatus status = executeRemoteDevicesCommand(command, null, 1000, "", new IStopCondition() //$NON-NLS-1$ { public boolean canStop() { return true; } }, null); return status.isOK(); } /** * Check if a device identified by the serial number has a mounted SDCard * @param serialNumber the serial number * @return true if the device has a SDCard * @throws IOException */ public static boolean hasSDCard(String serialNumber) throws IOException { boolean hasSdCard = false; File tempSdCardFile = File.createTempFile("SDcheck", ".tmp"); //$NON-NLS-1$ //$NON-NLS-2$ boolean tempCopiedOnSdCardFile = pushFileToDevice(serialNumber, SDCARD_FOLDER, tempSdCardFile); if (tempCopiedOnSdCardFile) { //trying to write on /sdcard folder (it works for phones previous from Platform 2.2) if (!deleteFileFromDevice(serialNumber, tempSdCardFile.getName(), SDCARD_FOLDER)) { StudioLogger.error( "DDMSFacade: Could not delete tempfile from /sdcard when checking if card is enabled"); //$NON-NLS-1$ } hasSdCard = true; tempSdCardFile.delete(); } else { File tempMntFile = File.createTempFile("SDcheck", ".tmp"); //$NON-NLS-1$ //$NON-NLS-2$ boolean tempCopiedOnMntFile = pushFileToDevice(serialNumber, MNT_SDCARD_FOLDER, tempSdCardFile); if (tempCopiedOnMntFile) { //trying to write on /mnt/sdcard folder (it works for phones since Platform 2.2) if (!deleteFileFromDevice(serialNumber, tempMntFile.getName(), MNT_SDCARD_FOLDER)) { StudioLogger.error( "DDMSFacade: Could not delete tempfile from /mnt/sdcard when checking if card is enabled"); //$NON-NLS-1$ } hasSdCard = true; tempMntFile.delete(); } } return hasSdCard; } /** * * @param serialNumber * @param sdCardFolder * @param tempFile * @return true if manages to push file into the folder specified on device */ private static boolean pushFileToDevice(String serialNumber, String folder, File file) { Collection<String> files = new ArrayList<String>(); files.add(file.getName()); Path path = new Path(file.getAbsolutePath()); IStatus status = pushFiles(serialNumber, path.removeLastSegments(1).toString(), files, folder, 2000, new NullProgressMonitor(), null); return status.isOK(); } /** * Creates a string with the command that should * be called in order to disconnect from an IP/Port * * @param host device host (IP) * @param port device port * @return the command to be used to disconnect from an IP/Port */ private static String[] createDisconnectTcpIpCommand(String host, String port) { String hostPort = host + ":" + port; //$NON-NLS-1$ String sdkPath = SdkUtils.getSdkPath(); String cmd[] = { sdkPath + PLATFORM_TOOLS_FOLDER + File.separator + ADB_COMMAND, DISCONNECT_TCPIP_CMD, hostPort }; return cmd; } public static void deleteFile(String serialNumber, String path) throws IOException { DDMSFacade.execRemoteApp(serialNumber, "rm " + path, //$NON-NLS-1$ new NullProgressMonitor()); } }