| /* |
| * 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.launch; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.core.ILaunch; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.core.ILaunchManager; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.debug.ui.ILaunchGroup; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.sequoyah.device.framework.model.IInstance; |
| import org.eclipse.sequoyah.device.framework.model.handler.ServiceHandler; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.console.ConsolePlugin; |
| import org.eclipse.ui.console.IConsole; |
| |
| import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener; |
| import com.android.ddmlib.Client; |
| import com.android.ddmlib.ClientData; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.launch.AndroidLaunch; |
| import com.android.ide.eclipse.adt.internal.launch.AndroidLaunchController; |
| import com.android.ide.eclipse.adt.internal.launch.LaunchConfigDelegate; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.io.IFolderWrapper; |
| import com.android.sdklib.xml.AndroidManifestParser; |
| import com.android.sdklib.xml.ManifestData; |
| import com.android.sdklib.xml.ManifestData.Activity; |
| import com.motorola.studio.android.adt.DDMSFacade; |
| import com.motorola.studio.android.adt.SdkUtils; |
| import com.motorola.studio.android.adt.StudioAndroidEventManager; |
| import com.motorola.studio.android.common.log.StudioLogger; |
| import com.motorola.studio.android.common.preferences.DialogWithToggleUtils; |
| import com.motorola.studio.android.emulator.EmulatorPlugin; |
| import com.motorola.studio.android.emulator.core.devfrm.DeviceFrameworkManager; |
| import com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance; |
| import com.motorola.studio.android.launch.i18n.LaunchNLS; |
| import com.motorola.studio.android.launch.ui.StartedInstancesDialog; |
| |
| /** |
| * DESCRIPTION: This class is responsible to execute the launch process <br> |
| * RESPONSIBILITY: Perform application launch on a device. <br> |
| * COLABORATORS: none <br> |
| */ |
| @SuppressWarnings("restriction") |
| public class StudioAndroidConfigurationDelegate extends LaunchConfigDelegate |
| { |
| |
| private static final String ERRONEOUS_LAUNCH_CONFIGURATION = "erroneous.launch.config.dialog"; |
| |
| private static final String NO_COMPATIBLE_DEVICE = "no.compatible.device.dialog"; |
| |
| IAndroidEmulatorInstance compatibleInstance = null; |
| |
| IAndroidEmulatorInstance initialEmulatorInstance = null; |
| |
| public List<Client> waitingDebugger = new ArrayList<Client>(); |
| |
| private class RunAsClientListener implements IClientChangeListener |
| { |
| /** |
| * |
| */ |
| private final IAndroidEmulatorInstance instance; |
| |
| /** |
| * |
| */ |
| private final String appToLaunch; |
| |
| /** |
| * |
| * @param instance |
| */ |
| RunAsClientListener(IAndroidEmulatorInstance instance, String appToLaunch) |
| { |
| this.instance = instance; |
| this.appToLaunch = appToLaunch; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see com.android.ddmlib.AndroidDebugBridge.IClientChangeListener#clientChanged(com.android.ddmlib.Client, int) |
| */ |
| public void clientChanged(Client client, int changeMask) |
| { |
| if ((changeMask & Client.CHANGE_NAME) == Client.CHANGE_NAME) |
| { |
| String applicationName = client.getClientData().getClientDescription(); |
| if (applicationName != null) |
| { |
| IPreferenceStore store = AdtPlugin.getDefault().getPreferenceStore(); |
| String home = store.getString(AdtPrefs.PREFS_HOME_PACKAGE); |
| if (home.equals(applicationName)) |
| { |
| String serialNumber = client.getDevice().getSerialNumber(); |
| String avdName = DDMSFacade.getNameBySerialNumber(serialNumber); |
| if ((instance != null) && instance.getName().equals(avdName)) |
| { |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "Delegating launch session to ADT... "); |
| |
| synchronized (StudioAndroidConfigurationDelegate.this) |
| { |
| StudioAndroidConfigurationDelegate.this.notify(); |
| } |
| } |
| } |
| |
| Client removeClient = null; |
| for (Client waiting : waitingDebugger) |
| { |
| int pid = waiting.getClientData().getPid(); |
| if (pid == client.getClientData().getPid()) |
| { |
| client.getDebuggerListenPort(); |
| synchronized (StudioAndroidConfigurationDelegate.this) |
| { |
| StudioAndroidConfigurationDelegate.this.notify(); |
| } |
| removeClient = waiting; |
| break; |
| } |
| } |
| |
| if (removeClient != null) |
| { |
| waitingDebugger.remove(removeClient); |
| } |
| } |
| } |
| |
| if ((changeMask & Client.CHANGE_DEBUGGER_STATUS) == Client.CHANGE_DEBUGGER_STATUS) |
| { |
| ClientData clientData = client.getClientData(); |
| String applicationName = clientData.getClientDescription(); |
| if (clientData.getDebuggerConnectionStatus() == ClientData.DebuggerStatus.DEFAULT) |
| { |
| if (((appToLaunch != null) && (applicationName != null)) |
| && applicationName.equals(appToLaunch.substring(0, |
| appToLaunch.lastIndexOf(".")))) |
| { |
| client.getDebuggerListenPort(); |
| synchronized (StudioAndroidConfigurationDelegate.this) |
| { |
| StudioAndroidConfigurationDelegate.this.notify(); |
| } |
| } |
| else if (appToLaunch != null) |
| { |
| waitingDebugger.add(client); |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.debug.core.model.LaunchConfigurationDelegate#preLaunchCheck(org.eclipse.debug.core.ILaunchConfiguration, java.lang.String, org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public boolean preLaunchCheck(ILaunchConfiguration configuration, String mode, |
| IProgressMonitor monitor) throws CoreException |
| { |
| initialEmulatorInstance = null; |
| boolean isOk = super.preLaunchCheck(configuration, mode, monitor); |
| |
| if (isOk) |
| { |
| final String instanceName = |
| configuration.getAttribute( |
| ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, (String) null); |
| |
| // we found an instance |
| if ((instanceName != null) && (instanceName.length() > 0)) |
| { |
| IAndroidEmulatorInstance instance = |
| DeviceFrameworkManager.getInstance().getInstanceByName(instanceName); |
| if (instance == null) |
| { |
| String serialNumber = LaunchUtils.getSerialNumberForInstance(instanceName); |
| if (!DDMSFacade.isDeviceOnline(serialNumber)) |
| { |
| isOk = false; |
| handleErrorDuringLaunch(configuration, mode, instanceName); |
| } |
| } |
| else |
| { |
| if (!instance.isAvailable()) |
| { |
| isOk = false; |
| handleErrorDuringLaunch(configuration, mode, instanceName); |
| } |
| |
| if (!instance.isStarted()) |
| { |
| initialEmulatorInstance = instance; |
| //updates the compatible instance with user response |
| isOk = checkForCompatibleRunningInstances(configuration); |
| } |
| } |
| } |
| else |
| { |
| isOk = false; |
| handleErrorDuringLaunch(configuration, mode, null); |
| } |
| } |
| // validate if the project isn't a library project |
| if (isOk) |
| { |
| String projectName = |
| configuration.getAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| (String) null); |
| if (projectName != null) |
| { |
| IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| if ((project != null) && SdkUtils.isLibraryProject(project)) |
| { |
| handleProjectError(configuration, project, mode); |
| isOk = false; |
| } |
| } |
| } |
| |
| return isOk; |
| } |
| |
| private void handleProjectError(final ILaunchConfiguration config, final IProject project, |
| final String mode) |
| { |
| PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() |
| { |
| |
| public void run() |
| { |
| Shell shell = LaunchUtils.getActiveWorkbenchShell(); |
| |
| String message = LaunchNLS.UI_LaunchConfigurationTab_ERR_PROJECT_IS_LIBRARY; |
| |
| String prefKey = ERRONEOUS_LAUNCH_CONFIGURATION; |
| |
| DialogWithToggleUtils.showInformation(prefKey, |
| LaunchNLS.ERR_LaunchConfigurationShortcut_MsgTitle, message); |
| |
| StructuredSelection struturedSelection; |
| |
| String groupId = IDebugUIConstants.ID_RUN_LAUNCH_GROUP; |
| |
| ILaunchGroup group = DebugUITools.getLaunchGroup(config, mode); |
| groupId = group.getIdentifier(); |
| struturedSelection = new StructuredSelection(config); |
| |
| DebugUITools.openLaunchConfigurationDialogOnGroup(shell, struturedSelection, |
| groupId); |
| } |
| }); |
| } |
| |
| private void handleErrorDuringLaunch(final ILaunchConfiguration config, final String mode, |
| final String instanceName) |
| { |
| PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() |
| { |
| |
| public void run() |
| { |
| Shell shell = LaunchUtils.getActiveWorkbenchShell(); |
| |
| String message = |
| instanceName != null ? NLS.bind( |
| LaunchNLS.ERR_LaunchDelegate_InvalidDeviceInstance, instanceName) |
| : NLS.bind(LaunchNLS.ERR_LaunchDelegate_No_Compatible_Device, |
| config.getName()); |
| |
| String prefKey = |
| instanceName != null ? ERRONEOUS_LAUNCH_CONFIGURATION |
| : NO_COMPATIBLE_DEVICE; |
| |
| DialogWithToggleUtils.showInformation(prefKey, |
| LaunchNLS.ERR_LaunchConfigurationShortcut_MsgTitle, message); |
| |
| StructuredSelection struturedSelection; |
| |
| String groupId = IDebugUIConstants.ID_RUN_LAUNCH_GROUP; |
| |
| ILaunchGroup group = DebugUITools.getLaunchGroup(config, mode); |
| groupId = group.getIdentifier(); |
| struturedSelection = new StructuredSelection(config); |
| |
| DebugUITools.openLaunchConfigurationDialogOnGroup(shell, struturedSelection, |
| groupId); |
| } |
| }); |
| } |
| |
| /** |
| * Launches an Android application based on the given launch configuration. |
| */ |
| @Override |
| public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, |
| IProgressMonitor monitor) throws CoreException |
| |
| { |
| //use a working copy because it can be changed and these changes should not be propagated to the original copy |
| ILaunchConfigurationWorkingCopy configurationWorkingCopy = configuration.getWorkingCopy(); |
| |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "Launch Android Application using Studio for Android wizard. Configuration: " |
| + configurationWorkingCopy + " mode:" + mode + " launch: " + launch); |
| try |
| { |
| |
| String projectName = |
| configurationWorkingCopy.getAttribute( |
| ILaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) null); |
| int launchAction = |
| configurationWorkingCopy.getAttribute( |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DEFAULT); |
| |
| String instanceName = |
| configurationWorkingCopy.getAttribute( |
| ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, (String) null); |
| |
| if ((projectName != null) && (instanceName != null)) |
| { |
| IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| if (project == null) |
| { |
| IStatus status = |
| new Status(Status.ERROR, LaunchPlugin.PLUGIN_ID, |
| "Could not retrieve project: " + projectName); |
| throw new CoreException(status); |
| } |
| |
| String appToLaunch = null; |
| if (launchAction == ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DEFAULT) |
| { |
| ManifestData manifestParser = |
| AndroidManifestParser.parse(new IFolderWrapper(project)); |
| Activity launcherActivity = manifestParser.getLauncherActivity(); |
| String activityName = null; |
| if (launcherActivity != null) |
| { |
| activityName = launcherActivity.getName(); |
| } |
| |
| // if there's no default activity. Then there's nothing to be launched. |
| if (activityName != null) |
| { |
| appToLaunch = activityName; |
| } |
| } |
| // case for a specific activity |
| else if (launchAction == ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_ACTIVITY) |
| { |
| appToLaunch = |
| configurationWorkingCopy.getAttribute( |
| ILaunchConfigurationConstants.ATTR_ACTIVITY, (String) null); |
| |
| if ((appToLaunch == null) || "".equals(appToLaunch)) |
| { |
| IStatus status = |
| new Status( |
| Status.ERROR, |
| LaunchPlugin.PLUGIN_ID, |
| "Activity field cannot be empty. Specify an activity or use the default activity on launch configuration."); |
| throw new CoreException(status); |
| } |
| } |
| // for the do nothing case there is nothing to do |
| |
| IAndroidEmulatorInstance emuInstance = |
| DeviceFrameworkManager.getInstance().getInstanceByName(instanceName); |
| |
| RunAsClientListener list = null; |
| |
| //if initialEmulatorInstance is not null it means that it was offline and user has interacted with StartedInstancesDialog. |
| //The emuInstance variable should be overrided by the initialEmulatorInstance because the emuInstance can be the new |
| //user choice (in case he has selected the check box in dialog asking to update the run configuration) |
| if (initialEmulatorInstance != null) |
| { |
| emuInstance = initialEmulatorInstance; |
| } |
| |
| try |
| { |
| if (appToLaunch != null) |
| { |
| list = new RunAsClientListener(emuInstance, appToLaunch); |
| StudioAndroidEventManager.asyncAddClientChangeListener(list); |
| } |
| |
| // The instance from the launch configuration is an emulator (because the query returned |
| // something different from null) and is not started. |
| if ((emuInstance != null) && (!emuInstance.isStarted())) |
| { |
| if (compatibleInstance != null) |
| { |
| emuInstance = compatibleInstance; |
| instanceName = emuInstance.getName(); |
| configurationWorkingCopy.setAttribute( |
| ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, |
| emuInstance.getName()); |
| configurationWorkingCopy.setAttribute( |
| ILaunchConfigurationConstants.ATTR_ADT_DEVICE_INSTANCE_NAME, |
| emuInstance.getName()); |
| } |
| else |
| { |
| startEmuInstance(emuInstance); |
| } |
| } |
| |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "AVD where the application will be executed: " + instanceName); |
| |
| |
| String serialNumber = LaunchUtils.getSerialNumberForInstance(instanceName); |
| if (serialNumber == null) |
| { |
| IStatus status = |
| new Status(Status.ERROR, LaunchPlugin.PLUGIN_ID, |
| "Could not retrieve AVD instance: " + instanceName); |
| throw new CoreException(status); |
| } |
| |
| bringConsoleView(); |
| |
| // Determining if it is an emulator or handset and creating the description |
| //to be used for usage data collection |
| String descriptionToLog = ""; |
| if (emuInstance != null) |
| { |
| descriptionToLog = StudioLogger.VALUE_EMULATOR; |
| } |
| else |
| { |
| if ((serialNumber != null) && (!serialNumber.equals(""))) |
| { |
| descriptionToLog = StudioLogger.VALUE_HANDSET; |
| } |
| } |
| |
| if (!descriptionToLog.equals("")) |
| { |
| descriptionToLog = |
| StudioLogger.KEY_DEVICE_TYPE + descriptionToLog |
| + StudioLogger.SEPARATOR; |
| } |
| |
| descriptionToLog = descriptionToLog + StudioLogger.KEY_USE_VDL; |
| |
| descriptionToLog = descriptionToLog + StudioLogger.VALUE_NO; |
| super.launch(configurationWorkingCopy, mode, launch, monitor); |
| |
| // Collecting usage data for statistical purposes |
| try |
| { |
| String prjTarget = ""; |
| if (project != null) |
| { |
| prjTarget = Sdk.getCurrent().getTarget(project).getName(); |
| } |
| |
| if (!descriptionToLog.equals("")) |
| { |
| descriptionToLog = descriptionToLog + StudioLogger.SEPARATOR; |
| } |
| |
| descriptionToLog = |
| descriptionToLog + StudioLogger.KEY_PRJ_TARGET + prjTarget; |
| |
| if (emuInstance != null) |
| { |
| String emuTarget = emuInstance.getTarget(); |
| descriptionToLog = descriptionToLog + StudioLogger.SEPARATOR; |
| descriptionToLog = |
| descriptionToLog + StudioLogger.KEY_TARGET + emuTarget; |
| } |
| |
| StudioLogger.collectUsageData(mode, StudioLogger.KIND_APP_MANAGEMENT, |
| descriptionToLog, LaunchPlugin.PLUGIN_ID, LaunchPlugin.getDefault() |
| .getBundle().getVersion().toString()); |
| } |
| catch (Throwable e) |
| { |
| //Do nothing, but error on the log should never prevent app from working |
| } |
| |
| } |
| finally |
| { |
| if (list != null) |
| { |
| StudioAndroidEventManager.asyncRemoveClientChangeListener(list); |
| } |
| StudioAndroidEventManager.asyncAddClientChangeListener(AndroidLaunchController |
| .getInstance()); |
| } |
| } |
| else |
| { |
| throw new CoreException(new Status(IStatus.ERROR, LaunchPlugin.PLUGIN_ID, |
| "Missing parameters for launch")); |
| } |
| } |
| catch (CoreException e) |
| { |
| AndroidLaunch androidLaunch = (AndroidLaunch) launch; |
| androidLaunch.stopLaunch(); |
| StudioLogger.error(StudioAndroidConfigurationDelegate.class, "Error while lauching " |
| + configurationWorkingCopy.getName(), e); |
| throw e; |
| } |
| catch (Exception e) |
| { |
| StudioLogger.error(LaunchUtils.class, |
| "An error occurred trying to parse AndroidManifest", e); |
| } |
| finally |
| { |
| if (mode.equals(ILaunchManager.RUN_MODE)) |
| { |
| AndroidLaunch androidLaunch = (AndroidLaunch) launch; |
| androidLaunch.stopLaunch(); |
| } |
| } |
| } |
| |
| /** |
| * @param project |
| * @param emuInstance |
| * @throws CoreException |
| */ |
| private boolean checkForCompatibleRunningInstances(ILaunchConfiguration configuration) |
| throws CoreException |
| { |
| IProject project = null; |
| compatibleInstance = null; |
| |
| final String projectName = |
| configuration.getAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| (String) null); |
| |
| project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| if (project == null) |
| { |
| IStatus status = |
| new Status(Status.ERROR, LaunchPlugin.PLUGIN_ID, "Could not retrieve project: " |
| + projectName); |
| throw new CoreException(status); |
| } |
| |
| //Check if there is a compatible instance running to launch the app |
| Collection<IAndroidEmulatorInstance> startedInstances = |
| DeviceFrameworkManager.getInstance().getAllStartedInstances(); |
| |
| final Collection<IAndroidEmulatorInstance> compatibleStartedInstances = |
| new HashSet<IAndroidEmulatorInstance>(); |
| |
| boolean continueLaunch = true; |
| |
| for (IAndroidEmulatorInstance i : startedInstances) |
| { |
| IStatus resultStatus = LaunchUtils.isCompatible(project, i.getName()); |
| if ((resultStatus.getSeverity() == Status.OK) |
| || (resultStatus.getSeverity() == Status.WARNING)) |
| { |
| compatibleStartedInstances.add(i); |
| } |
| } |
| if (compatibleStartedInstances.size() > 0) |
| { |
| //show a dialog with compatible running instances so the user can |
| //choose one to run the app, or he can choose to run the preferred AVD |
| |
| StartedInstancesDialogProxy proxy = |
| new StartedInstancesDialogProxy(compatibleStartedInstances, configuration, |
| project); |
| PlatformUI.getWorkbench().getDisplay().syncExec(proxy); |
| |
| compatibleInstance = proxy.getSelectedInstance(); |
| continueLaunch = proxy.continueLaunch(); |
| } |
| return continueLaunch; |
| } |
| |
| private class StartedInstancesDialogProxy implements Runnable |
| { |
| private IAndroidEmulatorInstance selectedInstance = null; |
| |
| private boolean continueLaunch = true; |
| |
| private final ILaunchConfiguration configuration; |
| |
| Collection<IAndroidEmulatorInstance> compatibleStartedInstances = null; |
| |
| IProject project = null; |
| |
| /** |
| * |
| */ |
| public StartedInstancesDialogProxy( |
| Collection<IAndroidEmulatorInstance> compatibleStartedInstances, |
| ILaunchConfiguration configuration, IProject project) |
| { |
| this.compatibleStartedInstances = compatibleStartedInstances; |
| this.configuration = configuration; |
| this.project = project; |
| } |
| |
| public void run() |
| { |
| Shell aShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); |
| Shell shell = new Shell(aShell); |
| StartedInstancesDialog dialog; |
| try |
| { |
| dialog = |
| new StartedInstancesDialog(shell, compatibleStartedInstances, |
| configuration, project); |
| dialog.setBlockOnOpen(true); |
| dialog.open(); |
| |
| selectedInstance = null; |
| if (dialog.getReturnCode() == IDialogConstants.OK_ID) |
| { |
| selectedInstance = dialog.getSelectedInstance(); |
| } |
| else if (dialog.getReturnCode() == IDialogConstants.ABORT_ID) |
| { |
| continueLaunch = false; |
| } |
| } |
| catch (CoreException e) |
| { |
| StudioLogger.error(StudioAndroidConfigurationDelegate.class, |
| "It was not possible to open Started Instance Dialog", e); |
| } |
| } |
| |
| public IAndroidEmulatorInstance getSelectedInstance() |
| { |
| return selectedInstance; |
| } |
| |
| public boolean continueLaunch() |
| { |
| return continueLaunch; |
| } |
| } |
| |
| /** |
| * Bring Console View to the front and activate the appropriate stream |
| * |
| */ |
| private void bringConsoleView() |
| { |
| IConsole activeConsole = null; |
| |
| IConsole[] consoles = ConsolePlugin.getDefault().getConsoleManager().getConsoles(); |
| for (IConsole console : consoles) |
| { |
| if (console.getName().equals(ILaunchConfigurationConstants.ANDROID_CONSOLE_ID)) |
| { |
| activeConsole = console; |
| } |
| } |
| |
| // Bring Console View to the front |
| if (activeConsole != null) |
| { |
| ConsolePlugin.getDefault().getConsoleManager().showConsoleView(activeConsole); |
| } |
| |
| } |
| |
| /** |
| * |
| * @param instance |
| * @throws CoreException |
| */ |
| private void startEmuInstance(IAndroidEmulatorInstance instance) throws CoreException |
| { |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "Needs to Start the AVD instance before launching... "); |
| |
| ServiceHandler startHandler = EmulatorPlugin.getStartServiceHandler(); |
| IStatus status = startHandler.run((IInstance) instance, null, new NullProgressMonitor()); |
| |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "Status of the launch service: " + status); |
| |
| if (status.getSeverity() == Status.ERROR) |
| { |
| throw new CoreException(status); |
| } |
| else if (status.getSeverity() == Status.CANCEL) |
| { |
| StudioLogger.info(StudioAndroidConfigurationDelegate.class, |
| "Abort launch session because the AVD start was canceled. "); |
| return; |
| } |
| |
| if (!instance.isStarted()) |
| { |
| status = |
| new Status(Status.ERROR, LaunchPlugin.PLUGIN_ID, |
| "The Android Virtual Device is not started: " + instance.getName()); |
| throw new CoreException(status); |
| } |
| |
| synchronized (this) |
| { |
| try |
| { |
| wait(); |
| } |
| catch (InterruptedException e) |
| { |
| StudioLogger.info("Could not wait: ", e.getMessage()); |
| } |
| } |
| } |
| } |
