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.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import org.eclipse.core.resources.IFile; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.MultiStatus; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Platform; import org.eclipse.core.runtime.Status; import org.eclipse.debug.core.DebugPlugin; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationType; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; import org.eclipse.debug.core.ILaunchManager; import org.eclipse.debug.ui.DebugUITools; import org.eclipse.debug.ui.ILaunchGroup; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.StructuredSelection; import org.eclipse.jface.wizard.WizardDialog; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.console.IOConsoleOutputStream; import com.android.ddmlib.FileListingService; import com.android.ddmlib.FileListingService.FileEntry; import com.android.ddmlib.IDevice; import com.android.ddmuilib.ScreenShotDialog; import com.android.sdklib.IAndroidTarget; import com.motorola.studio.android.AndroidPlugin; import com.motorola.studio.android.adt.StudioAndroidEventManager.EventType; import com.motorola.studio.android.common.log.StudioLogger; import com.motorola.studio.android.common.log.UsageDataConstants; import com.motorola.studio.android.common.utilities.EclipseUtils; import com.motorola.studio.android.common.utilities.FileUtil; import com.motorola.studio.android.i18n.AndroidNLS; import com.motorola.studio.android.wizards.installapp.DeployWizard; import com.motorola.studio.android.wizards.installapp.DeployWizard.INSTALL_TYPE; import com.motorola.studio.android.wizards.installapp.UninstallAppWizard; import com.motorola.studio.android.wizards.mat.DumpHPROFWizard; import com.motorola.studio.android.wizards.monkey.IMonkeyConfigurationConstants; public class DDMSUtils { private static final Map<String, FileListingService> deviceFileListingServiceMap = new HashMap<String, FileListingService>(); /** * The APK extension */ private static final String APK_FILE_EXTENSION = "apk"; /** * Parameter for overwriting existing applications, if any */ private static final String ADB_INSTALL_OVERWRITE = "-r"; /** * Options to be used with adb to indicate package manager application */ private static final String PM_CMD = "pm"; /** * Options to be used with adb to run monkey application */ private static final String MONKEY_CMD = "monkey"; /** * Uninstall directive to the package manager */ private static final String PM_UNINSTALL_DIRECTIVE = "uninstall"; /** * List packages directive */ private static final String PM_LIST_DIRECTIVE = "list"; /** * List packages directive */ private static final String PM_PACKAGES_DIRECTIVE = "packages"; /** * List packages force directive */ private static final String PM_PACKAGES_DIRECTIVE_FORCE = "-f"; /** * Monkey packages directive */ private static final String MONKEY_PACKAGES_DIRECTIVE = " -p "; /** * Options to be used with adb to indicate install operation */ private static final String INSTALL_CMD = "install"; /** * This word must exist in the adb install commmand answer to indicate * succefull installation */ private static final String SUCCESS_CONSTANT = "Success"; private static final DdmsRunnable disconnectedListener = new DdmsRunnable() { public void run(String serialNumber) { synchronized (deviceFileListingServiceMap) { deviceFileListingServiceMap.remove(serialNumber); } } }; static { StudioAndroidEventManager.asyncAddDeviceChangeListeners(null, disconnectedListener); } public static void takeScreenshot(final String serialNumber) { Display.getDefault().asyncExec(new Runnable() { public void run() { Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); ScreenShotDialog sshot = new ScreenShotDialog(new Shell(shell)); sshot.open(DDMSFacade.getDeviceBySerialNumber(serialNumber)); } }); } public static void getApplicationDatabases(String serialNumber, String applicationName, IDatabaseListingListener listener) { LinkedList<String> pathSegments = new LinkedList<String>(); pathSegments.add("data"); pathSegments.add("data"); pathSegments.add(applicationName); pathSegments.add("databases"); FileListingService fileListing = getFileListingService(serialNumber); if (fileListing != null) { FileEntry root = fileListing.getRoot(); FileEntry[] children = null; children = fileListing.getChildren(root, true, new FileListingReceiver(pathSegments, fileListing, listener)); /* * If children isn't null means that file listing service found the * files in it cache to speed up the operation */ if (children != null) { List<String> databases = new ArrayList<String>(); FileEntry temp1 = null, temp2 = root; // start from root while ((children != null)) { // if we have something to search for if (pathSegments.size() > 0) { String theSegment = pathSegments.remove(0); temp1 = temp2.findChild(theSegment); if (temp1 != null) { temp2 = temp1; children = fileListing.getChildren(temp2, true, new FileListingReceiver(pathSegments, fileListing, listener)); } else { children = null; listener.databasesFound(databases); } } // else just notify the listener else { if (children != null) { for (FileEntry child : children) { if (child.getName().endsWith(".db")) { databases.add(child.getName()); } } children = null; } listener.databasesFound(databases); } } } } } public static List<String> getApplicationDatabases(String serialNumber, String applicationName) throws IOException { List<String> dbs = new ArrayList<String>(); String appDbPath = "/data/data/" + applicationName + "/databases/"; Collection<String> commandOutput = DDMSFacade.execRemoteApp(serialNumber, "ls " + appDbPath, new NullProgressMonitor()); List<String> dbPathCandidates = new ArrayList(commandOutput.size() + 10); for (String commandOutline : commandOutput) { String[] strings = commandOutline.split(" "); for (String string : strings) { if (string.trim().endsWith(".db")) { dbPathCandidates.add(string); } } } return dbPathCandidates; } /** * @param serialNumber * @return */ private static FileListingService getFileListingService(String serialNumber) { FileListingService fileListing = null; IDevice dev = DDMSFacade.getDeviceBySerialNumber(serialNumber); if (dev != null) { synchronized (dev) { fileListing = deviceFileListingServiceMap.get(serialNumber); } if (fileListing == null) { fileListing = dev.getFileListingService(); synchronized (deviceFileListingServiceMap) { deviceFileListingServiceMap.put(serialNumber, fileListing); } } } return fileListing; } /** * This method returns the current language and country in use by given * emulation instance. * * @param serialNumber The serial number of emulation instance * @return An array of Strings containing the command results. */ public static String[] getCurrentEmulatorLanguageAndCountry(final String serialNumber) { ArrayList<String[]> commands = createCurrentEmulatorLanguageAndCountryCommand(serialNumber); String[] responses = new String[2]; String[] languageCommand = commands.get(0); String[] countryCommand = commands.get(1); String languageCommandResult = null; String countryCommandResult = null; try { // Do not write the command output to the console languageCommandResult = DDMSFacade.executeCommand(languageCommand, null); countryCommandResult = DDMSFacade.executeCommand(countryCommand, null); responses[0] = languageCommandResult.replaceAll("\\n$", ""); responses[1] = countryCommandResult.replaceAll("\\n$", ""); } catch (IOException e) { StudioLogger.error("Deploy: Could not execute adb current language command."); } return responses; } public static InstallPackageBean installPackageWizard() { final InstallPackageBean bean = new InstallPackageBean(); final Display display = PlatformUI.getWorkbench().getDisplay(); display.syncExec(new Runnable() { public void run() { try { String defaultPath = null; DeployWizard wizard; IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); if (window != null) { ISelection selection = window.getSelectionService().getSelection(); if (selection instanceof IStructuredSelection) { IStructuredSelection workbenchSSelection = (IStructuredSelection) selection; for (Object o : workbenchSSelection.toList()) { if (o instanceof IFile) { IFile file = (IFile) o; if (file.getFileExtension().equalsIgnoreCase(APK_FILE_EXTENSION)) { defaultPath = file.getLocation().toOSString(); } } } } } wizard = new DeployWizard(defaultPath); wizard.init(PlatformUI.getWorkbench(), new StructuredSelection()); WizardDialog dialog = new WizardDialog( PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard); dialog.setPageSize(500, 200); if (dialog.open() == IDialogConstants.OK_ID) { bean.setPackagePath(wizard.getPackagePath()); bean.setCanOverwrite(wizard.canOverwrite()); } } catch (Throwable e) { StudioLogger.error(DDMSFacade.class, "Error executing deploy wizard", e); } } }); return bean; } public static IStatus installPackage(final String serialNumber, InstallPackageBean bean) { IStatus status = Status.CANCEL_STATUS; if ((bean.getPackagePath() != null) && (bean.getCanOverwrite() != null)) { OutputStream consoleOut = null; try { consoleOut = EclipseUtils.getStudioConsoleOutputStream(true); status = installPackage(serialNumber, bean.getPackagePath(), bean.getCanOverwrite(), consoleOut); } finally { try { if (consoleOut != null) { consoleOut.close(); } } catch (IOException e) { StudioLogger.error("Install App: could not close console stream" + e.getMessage()); } } } if (status.isOK()) { StudioAndroidEventManager.fireEvent(EventType.PACKAGE_INSTALLED, serialNumber); } return status; } /** * Install an application on an emulator instance * * @param serialNumber * The serial number of the device where the application will be * installed * @param path * Path of the package containing the application to be installed * @param installationType * one of the {@link INSTALL_TYPE} install types available * @param force * Perform the operation without asking for user intervention * * @return the status of the operation (OK, Cancel or Error+ErrorMessage) */ public static IStatus installPackage(String serialNumber, String path, INSTALL_TYPE installationType, OutputStream processOut) { IStatus status = null; if (installationType.equals(INSTALL_TYPE.UNINSTALL)) { status = uninstallPackage(new File(path), serialNumber, processOut); } boolean overwrite = installationType.equals(INSTALL_TYPE.OVERWRITE); status = installPackage(serialNumber, path, overwrite, processOut); return status; } /** * Uninstall the given package (if installed) in the given serialNumber * device * * @param path * the package path * @param serialNumber * the device serial number */ public static IStatus uninstallPackage(File path, String serialNumber, OutputStream processOut) { IStatus returnStatus = null; if ((path != null) && path.exists() && path.isFile()) { IDevice dev = DDMSFacade.getDeviceBySerialNumber(serialNumber); String apiLevel = dev.getProperty("ro.build.version.sdk"); IAndroidTarget target = SdkUtils.getTargetByAPILevel(Integer.parseInt(apiLevel)); String aaptPath = SdkUtils.getTargetAAPTPath(target); if (aaptPath != null) { // resolve package name String[] aaptComm = new String[] { aaptPath, "d", "badging", path.toString() }; InputStreamReader reader = null; BufferedReader bufferedReader = null; try { Process aapt = Runtime.getRuntime().exec(aaptComm); reader = new InputStreamReader(aapt.getInputStream()); bufferedReader = new BufferedReader(reader); String infoLine = bufferedReader.readLine(); infoLine = infoLine.split(" ")[1].split("=")[1].replaceAll("'", ""); returnStatus = uninstallPackage(serialNumber, infoLine, processOut); } catch (Exception e) { returnStatus = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_UninstallPackageException, e); } finally { try { if (reader != null) { reader.close(); } if (bufferedReader != null) { bufferedReader.close(); } } catch (IOException e) { StudioLogger.error("Uninstall app could not close stream. " + e.getMessage()); } } } else { StudioLogger.error(DDMSFacade.class, "Impossible to check APK package name. No android targets found inside SDK"); } } else { returnStatus = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_UninstallPackage); } return returnStatus; } /** * Uninstall the given package within device with given serial number * * @param serialNumber * @param packageName * @param processOutput * outputStream to write output of the process */ public static IStatus uninstallPackage(String serialNumber, String packageName, OutputStream processOutput) { IStatus status = Status.OK_STATUS; String command[] = createUninstallCommand(serialNumber, packageName); try { String commandResult = DDMSFacade.executeCommand(command, processOutput); if (!commandResult.toLowerCase().contains(SUCCESS_CONSTANT.toLowerCase())) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_UninstallPackageError + ": " + packageName); } } catch (Exception e) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_UninstallPackageException, e); StudioLogger.error(DDMSFacade.class, "Failed to remove package: " + packageName + ". " + e.getMessage()); } return status; } /** * Run the Monkey command for the given package within device with given serial number * * @param serialNumber * @param packageName * @param processOutput * @param otherCmd * @return the status of the monkey process */ public static IStatus runMonkey(String serialNumber, String allPackages, OutputStream processOutput, String otherCmd) { IStatus status = Status.OK_STATUS; String command[] = createMonkeyCommand(serialNumber, allPackages, otherCmd); try { DDMSFacade.executeCommand(command, processOutput); } catch (Exception e) { EclipseUtils.showErrorDialog(AndroidNLS.UI_MonkeyError_Title, AndroidNLS.UI_MonkeyError_Msg); StudioLogger.error(DDMSFacade.class, "Failed to run monkey command: " + command + " " + e.getMessage()); } return status; } /** * Uninstall packages from the given serialNumber device * * @param serialNumber * @param packagesToUninstall * @param outputStream * @return the status of the uninstall process or null if no packages were * uninstalled */ private static IStatus uninstallPackages(String serialNumber, ArrayList<String> packagesToUninstall, OutputStream outputStream) { IStatus returnStatus = null; for (String packageToUninstall : packagesToUninstall) { StudioLogger.info(DDMSUtils.class, "Removing package: " + packageToUninstall); IStatus temp = uninstallPackage(serialNumber, packageToUninstall, outputStream); if (!temp.isOK()) { if (returnStatus == null) { returnStatus = new MultiStatus(AndroidPlugin.PLUGIN_ID, 0, AndroidNLS.ERR_DDMSFacade_UninstallPackageError, null); } ((MultiStatus) returnStatus).add(temp); } } return returnStatus == null ? Status.OK_STATUS : returnStatus; } /** * Run monkey command on the given packages with the specified commands. * * @param serialNumber * @param packagesToRunMonkey * @param outputStream * @param otherCmds * @return the status of the monkey process or null if the process was not successful */ private static IStatus runMonkey(String serialNumber, ArrayList<String> packagesToRunMonkey, OutputStream outputStream, String otherCmds) { IStatus returnStatus = null; String allPackages = ""; for (String packageToRunMonkey : packagesToRunMonkey) { allPackages += MONKEY_PACKAGES_DIRECTIVE + packageToRunMonkey; } StudioLogger.info(DDMSUtils.class, "Running monkey for: " + allPackages); IStatus temp = runMonkey(serialNumber, allPackages, outputStream, otherCmds); if (!temp.isOK()) { if (returnStatus == null) { returnStatus = new MultiStatus(AndroidPlugin.PLUGIN_ID, 0, AndroidNLS.ERR_DDMSFacade_MonkeyError, null); } ((MultiStatus) returnStatus).add(temp); } return returnStatus == null ? Status.OK_STATUS : returnStatus; } /** * Uninstall packages from the given device. A Wizard will be opened asking * the user which packages to uninstall * * @param serialNumber * @return the status of the operation */ public static IStatus uninstallPackage(final String serialNumber) { final ArrayList<String> packagesToUninstall = new ArrayList<String>(); IStatus status = null; //wrap the dialog within a final variable final UninstallAppWizard[] wizard = new UninstallAppWizard[1]; // do package listing async Thread listingThread = new Thread("listPackages") { @Override public void run() { Map<String, String> installedPackages = null; try { installedPackages = listInstalledPackages(serialNumber); } catch (IOException e1) { installedPackages = new HashMap<String, String>(0); } while (wizard[0] == null) { try { sleep(100); } catch (InterruptedException e) { //do nothing } } wizard[0].setAvailablePackages(installedPackages); }; }; listingThread.start(); PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() { public void run() { UninstallAppWizard unAppWiz = new UninstallAppWizard(); WizardDialog dialog = new WizardDialog( new Shell(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell()), unAppWiz); wizard[0] = unAppWiz; dialog.open(); List<String> selectedPackages = wizard[0].getSelectedPackages(); if (selectedPackages != null) { for (String aPackage : selectedPackages) { packagesToUninstall.add(aPackage); } } } }); if (packagesToUninstall.size() > 0) { OutputStream consoleOut = null; try { consoleOut = EclipseUtils.getStudioConsoleOutputStream(true); status = uninstallPackages(serialNumber, packagesToUninstall, consoleOut); } finally { try { if (consoleOut != null) { consoleOut.close(); } } catch (IOException e) { StudioLogger.error("Uninstall App: could not close console stream" + e.getMessage()); } } } if (status != null) { if (status.isOK()) { Display.getDefault().asyncExec(new Runnable() { public void run() { MessageDialog.openInformation( PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), AndroidNLS.UI_UninstallApp_SucessDialogTitle, AndroidNLS.UI_UninstallApp_Message); } }); StudioAndroidEventManager.fireEvent(EventType.PACKAGE_UNINSTALLED, serialNumber); } else { EclipseUtils.showErrorDialog(AndroidNLS.UI_UninstallApp_ERRDialogTitle, AndroidNLS.UI_UninstallApp_ERRUninstallApp, status); } } // all return is successful since operations are async return Status.OK_STATUS; } /** * If there is no Monkey Launch configuration for the given deviceName, it is created. * @param deviceName */ private static ILaunchConfiguration createLaunchConfiguration(String deviceName) { ILaunchConfiguration config = null; ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager(); ILaunchConfigurationType motodevLaunchType = launchManager .getLaunchConfigurationType(IMonkeyConfigurationConstants.LAUNCH_CONFIGURATION_TYPE_EXTENSION_ID); String launchConfigurationName = launchManager .generateUniqueLaunchConfigurationNameFrom(IMonkeyConfigurationConstants.NEW_CONFIGURATION_NAME); try { ILaunchConfigurationWorkingCopy workingCopy = motodevLaunchType.newInstance(null, launchConfigurationName); workingCopy.setAttribute(IMonkeyConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, deviceName); config = workingCopy.doSave(); } catch (CoreException e) { EclipseUtils.showErrorDialog(AndroidNLS.UI_MonkeyError_Title, e.getMessage()); } return config; } /** * Run adb monkey. * * @param serialNumber * @param deviceName * @return the status of the operation */ public static IStatus runMonkey(final String serialNumber, final String deviceName) { ILaunchConfigurationType type = DebugPlugin.getDefault().getLaunchManager() .getLaunchConfigurationType(IMonkeyConfigurationConstants.LAUNCH_CONFIGURATION_TYPE_EXTENSION_ID); ILaunchConfiguration[] launchs; try { launchs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations(type); ILaunchConfiguration launchConfig = null; for (int i = 0; i < launchs.length; i++) { launchConfig = launchs[i]; String configDeviceName = launchConfig .getAttribute(IMonkeyConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, ""); if (configDeviceName.equals(deviceName)) { break; } else { launchConfig = null; } } if (launchConfig == null) { launchConfig = createLaunchConfiguration(deviceName); } final ILaunchGroup lc = DebugUITools.getLaunchGroup(launchConfig, ILaunchManager.RUN_MODE); final IStructuredSelection selection = new StructuredSelection(launchConfig); PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() { public void run() { DebugUITools.openLaunchConfigurationDialogOnGroup( new Shell(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell()), selection, lc.getIdentifier(), null); } }); } catch (CoreException e) { StudioLogger.error("Monkey: could not open the launch configuration dialog " + e.getMessage()); } // UDC log for monkey execution StudioLogger.collectUsageData(UsageDataConstants.WHAT_MONKEY_EXEC, //$NON-NLS-1$ UsageDataConstants.KIND_MONKEY_EXEC, "Monkey executed", //$NON-NLS-1$ AndroidPlugin.PLUGIN_ID, AndroidPlugin.getDefault().getBundle().getBundleContext().getBundle().getVersion().toString()); // all return is successful since operations are async return Status.OK_STATUS; } /** * Run adb monkey. * * @param serialNumber * @param packagesToRunMonkey * @param otherCmds * @return the status of the operation */ public static IStatus runMonkey(final String serialNumber, ArrayList<String> packagesToRunMonkey, String otherCmds) { if (packagesToRunMonkey.size() > 0) { OutputStream consoleOut = null; try { consoleOut = EclipseUtils.getStudioConsoleOutputStream(true); runMonkey(serialNumber, packagesToRunMonkey, consoleOut, otherCmds); } finally { try { if (consoleOut != null) { consoleOut.close(); } } catch (IOException e) { StudioLogger.error("Monkey: could not close console stream" + e.getMessage()); } } } // all return is successful since operations are async return Status.OK_STATUS; } /** * List the installed packages in the device with the serial number Each * package entry carries their package location * * @param serialNumber * @return a HashMap where keys are the package names and values are package * location * @throws IOException */ public static Map<String, String> listInstalledPackages(String serialNumber) throws IOException { Map<String, String> packages = new LinkedHashMap<String, String>(); String sdkPath = SdkUtils.getSdkPath(); String command[] = new String[] { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, DDMSFacade.SHELL_CMD, PM_CMD, PM_LIST_DIRECTIVE, PM_PACKAGES_DIRECTIVE, PM_PACKAGES_DIRECTIVE_FORCE }; String commResult = DDMSFacade.executeCommand(command, null); String[] packageList = null; if ((commResult != null) && (commResult.length() > 0) && !commResult.contains("system running?")) { packageList = commResult.trim().replaceAll("\n\n", "\n").split("\n"); int i = 0; String aPackage = null; String[] packageUnit = null; while (i < packageList.length) { if (packageList[i].toLowerCase().contains("package:")) { String[] splittedPackage = packageList[i].split(":"); if (splittedPackage.length >= 2) { aPackage = splittedPackage[1].trim(); packageUnit = aPackage.split("="); if (packageUnit.length > 1) { packages.put(packageUnit[1], packageUnit[0]); } } } i++; } } return packages; } /** * Install an application on an emulator instance * * @param serialNumber * The serial number of the device where the application will be * installed * @param path * Path of the package containing the application to be installed * @param canOverwrite * If the application will be installed even if there is a * previous installation * @param force * Perform the operation without asking for user intervention * * @return the status of the operation (OK, Cancel or Error+ErrorMessage) */ public static IStatus installPackage(String serialNumber, String path, boolean canOverwrite, OutputStream processOut) { IStatus status = Status.OK_STATUS; // Return if no instance is selected if (serialNumber == null) { StudioLogger.error("Abort deploy operation. Serial number is null."); status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, AndroidNLS.ERR_DDMSFacade_SerialNumberNullPointer); } // Return if instance is not started if (status.isOK() && !DDMSFacade.isDeviceOnline(serialNumber)) { StudioLogger.error("Abort deploy operation. Device is not online."); status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, ""); } String command_results = ""; if (status.isOK()) { try { String[] cmd = createInstallCommand(canOverwrite, path, serialNumber); command_results = DDMSFacade.executeCommand(cmd, processOut, serialNumber); // Check if the result has a success message if (!command_results.contains(SUCCESS_CONSTANT)) { status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, "Error executing the operation. Execution results: " + command_results); } } catch (IOException e) { StudioLogger.error("Deploy: Could not execute adb install command."); status = new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, e.getMessage()); } } return status; } /** * Change the emulator language * * @param serialNumber * The serial number of the device * @param language * the language id * @param country * the country id * @return the status of the operation (OK, Error+ErrorMessage) */ public static void changeLanguage(final String serialNumber, final String language, final String country) { if ((language != null) || (country != null)) { /* * A new thread is used since this command takes too long to be executed */ Thread thead = new Thread(new Runnable() { public void run() { String[] cmd = createChangeLanguageCommand(serialNumber, language, country); try { IOConsoleOutputStream consoleOut = EclipseUtils.getStudioConsoleOutputStream(true); if (language != null) { consoleOut.write(AndroidNLS.UI_ChangeLang_Language + " " + language + "\n"); } if (country != null) { consoleOut.write(AndroidNLS.UI_ChangeLang_Country + " " + country + "\n"); } DDMSFacade.executeCommand(cmd, consoleOut); consoleOut.write("\n " + serialNumber + ":" + AndroidNLS.UI_ChangeLang_Restart_Device_Manually + "\n\n"); StudioAndroidEventManager.fireEvent(EventType.LANGUAGE_CHANGED, serialNumber); } catch (IOException e) { StudioLogger.error("Language: Could not execute adb change language command."); } } }); thead.start(); } } /** * Creates a string with the command that should be called in order to * change the device language * * @param serialNumber * The serial number of the device * @param language * the language id * @param country * the country id * @return the command to be used to change the device language */ private static String[] createChangeLanguageCommand(String serialNumber, String language, String country) { String cmd[]; String sdkPath = SdkUtils.getSdkPath(); String CHANGE_LANGUAGE_CMD = ""; if (language != null) { CHANGE_LANGUAGE_CMD += "setprop persist.sys.language " + language; } if (country != null) { CHANGE_LANGUAGE_CMD += ((CHANGE_LANGUAGE_CMD.length() > 0) ? ";" : "") + "setprop persist.sys.country " + country; } // The tools folder should exist and be here, but double-checking // once more wont kill File f = new File(sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Language: Could not find tools folder on " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error("Language: Invalid tools folder " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } } String cmdTemp[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, "shell", CHANGE_LANGUAGE_CMD }; cmd = cmdTemp; return cmd; } /** * Creates strings with the command that should be called in order to * retrieve the current language and country in use by given emulator instance. * * @param serialNumber The serial number of the device * @return An ArrayList with command strings to be used to get the * current emulator language and country. */ private static ArrayList<String[]> createCurrentEmulatorLanguageAndCountryCommand(String serialNumber) { String languageCommand[]; String countryCommand[]; String sdkPath = SdkUtils.getSdkPath(); String GET_LANGUAGE_CMD = "getprop persist.sys.language"; String GET_COUNTRY_CMD = "getprop persist.sys.country"; // The tools folder should exist and be here, but double-cheking // once more wont kill File f = new File(sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Language: Could not find tools folder on " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error("Language: Invalid tools folder " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } } String langCmdTemp[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, "shell", GET_LANGUAGE_CMD }; String countryCmdTemp[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, "shell", GET_COUNTRY_CMD }; languageCommand = langCmdTemp; countryCommand = countryCmdTemp; ArrayList<String[]> commands = new ArrayList<String[]>(); commands.add(0, languageCommand); commands.add(1, countryCommand); return commands; } /** * Creates a string with the command that should be called in order to * install the application * * @param canOverwrite * If true, than existent application will be overwritten * @param path * Location of the package containing the application * @param serialNumber * The serial number of the device to be targeted * * @return */ private static String[] createInstallCommand(boolean canOverwrite, String path, String serialNumber) { String cmd[]; String sdkPath = SdkUtils.getSdkPath(); // The tools folder should exist and be here, but double-checking // once more wont kill File f = new File(sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Deploy: Could not find tools folder on " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error("Deploy: Invalid tools folder " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } } if (canOverwrite) { // If overwrite option is checked, create command with the -r // paramater String cmdTemp[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, INSTALL_CMD, ADB_INSTALL_OVERWRITE, path }; cmd = cmdTemp; } else { // If overwrite option is unchecked, create command without the -r // paramater String cmdTemp[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, INSTALL_CMD, path }; cmd = cmdTemp; } return cmd; } private static String[] createUninstallCommand(String serialNumber, String packageName) { String sdkPath = SdkUtils.getSdkPath(); // The tools folder should exist and be here, but double-checking // once more wont kill File f = new File(sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Run: Could not find tools folder on " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error( "Run: Invalid tools folder " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } } String cmd[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, DDMSFacade.SHELL_CMD, PM_CMD, PM_UNINSTALL_DIRECTIVE, packageName }; return cmd; } /** * Mount the adb monkey command based on the given parameters. * @param serialNumber * @param packagesName * @param otherCmd * @return the array of strings containing the monkey command to be executed. */ private static String[] createMonkeyCommand(String serialNumber, String packagesName, String otherCmd) { String sdkPath = SdkUtils.getSdkPath(); // The tools folder should exist and be here, but double-checking // once more wont kill File f = new File(sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); if (!f.exists()) { StudioLogger.error("Run: Could not find tools folder on " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } else { if (!f.isDirectory()) { StudioLogger.error( "Run: Invalid tools folder " + sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator); } } String cmd[] = { sdkPath + DDMSFacade.PLATFORM_TOOLS_FOLDER + File.separator + DDMSFacade.ADB_COMMAND, DDMSFacade.ADB_INSTANCE_PARAMETER, serialNumber, DDMSFacade.SHELL_CMD, MONKEY_CMD, packagesName, otherCmd }; return cmd; } /** * Dump HPROF service implementation * @param serialNumber The device serial number * @param monitor * @return A IStatus describing if the service was successful or not */ public static IStatus dumpHPROF(final String serialNumber, IProgressMonitor monitor) { IStatus status; // Selected app. The array should have only 1 element final String[] selectedAppSet = new String[1]; // Instantiate the wizard and populate it with the retrieved process list PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() { public void run() { DumpHPROFWizard dumpHPROFWizard = new DumpHPROFWizard(serialNumber); WizardDialog dialog = new WizardDialog( new Shell(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell()), dumpHPROFWizard); dialog.open(); // Get the selected application selectedAppSet[0] = dumpHPROFWizard.getSelectedApp(); } }); if (selectedAppSet[0] != null) { // Dump HPROF file based on the selected application status = DDMSFacade.dumpHprofFile(selectedAppSet[0], serialNumber, monitor); } else { status = Status.CANCEL_STATUS; } return status; } public static int getDeviceApiVersion(String serialNumber) { int deviceSdkVersion = -1; String deviceProperty = DDMSFacade.getDeviceProperty(serialNumber, "ro.build.version.sdk"); if (deviceProperty != null) { deviceSdkVersion = Integer.parseInt(deviceProperty); } return deviceSdkVersion; } public static boolean remoteFileExists(String serialNumber, String remotePath) throws IOException { boolean found = false; Collection<String> results = DDMSFacade.execRemoteApp(serialNumber, "ls " + FileUtil.getEscapedPath(remotePath, Platform.OS_LINUX), new NullProgressMonitor()); for (String result : results) { if (result.equals(remotePath)) { found = true; break; } } return found; } }