/*
* 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;
}
}