| /* |
| * 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.ui; |
| |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| import org.eclipse.core.commands.ExecutionEvent; |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.ui.AbstractLaunchConfigurationTab; |
| import org.eclipse.debug.ui.ILaunchConfigurationTab; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.dialogs.IDialogConstants; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.sequoyah.device.framework.events.IInstanceListener; |
| import org.eclipse.sequoyah.device.framework.events.InstanceEvent; |
| import org.eclipse.sequoyah.device.framework.events.InstanceEventManager; |
| import org.eclipse.sequoyah.device.framework.model.IInstance; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Link; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.dialogs.ElementListSelectionDialog; |
| import org.eclipse.ui.dialogs.ISelectionStatusValidator; |
| import org.eclipse.ui.plugin.AbstractUIPlugin; |
| |
| 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.ISerialNumbered; |
| import com.motorola.studio.android.adt.SdkUtils; |
| import com.motorola.studio.android.common.log.StudioLogger; |
| import com.motorola.studio.android.emulator.device.handlers.OpenNewDeviceWizardHandler; |
| import com.motorola.studio.android.emulator.device.refresh.InstancesListRefresh; |
| import com.motorola.studio.android.launch.ILaunchConfigurationConstants; |
| import com.motorola.studio.android.launch.LaunchPlugin; |
| import com.motorola.studio.android.launch.LaunchUtils; |
| import com.motorola.studio.android.launch.i18n.LaunchNLS; |
| |
| /** |
| * DESCRIPTION: This class implements the tab that is shown when the user is |
| * editing the configuration to run a MOTODEV Studio for Android application |
| * |
| * RESPONSIBILITY: User interface to allow the user to enter information to |
| * launch the application. |
| * |
| * COLABORATORS: This class is one of the tabs of the |
| * LaunchConfigurationTabGroup |
| * |
| * USAGE: This class should be created/used by the LaunchConfigurationTabGroup |
| * only. |
| */ |
| @SuppressWarnings("restriction") |
| public class LaunchConfigurationTab extends AbstractLaunchConfigurationTab |
| { |
| private static final String NAME = LaunchNLS.UI_LaunchConfigurationTab_Tab_Name; |
| |
| private static final Object UPDATE_WIDGETS_EVENT = new Object(); |
| |
| private Composite mainComposite; |
| |
| private String projectName = ""; //$NON-NLS-1$ |
| |
| private String activityName = ""; //$NON-NLS-1$ |
| |
| private String deviceName = ""; //$NON-NLS-1$ |
| |
| private boolean activitySpecified = false; |
| |
| private boolean runDefaultActivity = true; |
| |
| private final String LAUNCH_DIALOG_HELP = LaunchPlugin.PLUGIN_ID + ".mainLaunchTab"; //$NON-NLS-1$ |
| |
| private Button defaultLauncherButton = null; |
| |
| private Button vdlLauncherButton = null; |
| |
| private Button deviceNameBrowseButton = null; |
| |
| private final IInstanceListener instanceListener = new IInstanceListener() |
| { |
| |
| private void fireUpdate() |
| { |
| Display currentDisplay = PlatformUI.getWorkbench().getDisplay(); |
| if (!currentDisplay.isDisposed()) |
| { |
| currentDisplay.syncExec(new Runnable() |
| { |
| |
| public void run() |
| { |
| updateDeviceChooserButton(); |
| updateLaunchConfigurationDialog(); |
| } |
| }); |
| } |
| } |
| |
| public void instanceUpdated(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceUnloaded(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceTransitioned(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceLoaded(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceDeleted(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceCreated(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| |
| public void instanceAboutToTransition(InstanceEvent instanceevent) |
| { |
| fireUpdate(); |
| } |
| }; |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createControl(Composite parent) |
| { |
| Composite main = new Composite(parent, SWT.NONE); |
| |
| GridLayout layout = new GridLayout(1, false); |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true); |
| gd.widthHint = 430; |
| gd.heightHint = 130; |
| main.setLayout(layout); |
| main.setLayoutData(gd); |
| |
| createMainInfoGroup(main); |
| setControl(main); |
| } |
| |
| private void updateDeviceChooserButton() |
| { |
| // button is always enabled |
| if (!deviceNameBrowseButton.isDisposed()) |
| { |
| deviceNameBrowseButton.setEnabled(true); |
| } |
| } |
| |
| /** |
| * Create the main information selection group |
| * @param mainComposite: the parent composite |
| */ |
| private void createMainInfoGroup(Composite mainComposite) |
| { |
| this.mainComposite = mainComposite; |
| |
| // create destination group |
| Group destinationGroup = new Group(mainComposite, SWT.NONE); |
| GridLayout layout = new GridLayout(3, false); |
| destinationGroup.setLayout(layout); |
| GridData defaultDestGridData = new GridData(SWT.FILL, SWT.CENTER, true, false, 3, 1); |
| destinationGroup.setLayoutData(defaultDestGridData); |
| destinationGroup.setText(LaunchNLS.LaunchComposite_UI_LaunchComposite_DestinationGroupText); |
| |
| // Project Name Label |
| Label projectNameLabel = new Label(destinationGroup, SWT.NONE); |
| projectNameLabel.setText(LaunchNLS.UI_LaunchComposite_ProjectNameLabel); |
| GridData folderGridData = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| projectNameLabel.setLayoutData(folderGridData); |
| |
| // Project Name Text |
| final Text projectNameText = new Text(destinationGroup, SWT.SINGLE | SWT.BORDER); |
| projectNameText.setText(projectName); |
| folderGridData = new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1); |
| projectNameText.setLayoutData(folderGridData); |
| projectNameText.addModifyListener(new ModifyListener() |
| { |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent) |
| */ |
| public void modifyText(ModifyEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| projectNameText.setText(projectName); |
| } |
| else |
| { |
| projectName = projectNameText.getText(); |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| }); |
| |
| // Project Name Browse Button |
| Button projectNameBrowseButton = new Button(destinationGroup, SWT.PUSH); |
| folderGridData = new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1); |
| projectNameBrowseButton.setLayoutData(folderGridData); |
| projectNameBrowseButton.setText(LaunchNLS.UI_LaunchComposite_BrowseButton); |
| projectNameBrowseButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| AndroidProjectsSelectionDialog dialog = |
| new AndroidProjectsSelectionDialog(getShell()); |
| int result = dialog.open(); |
| if (result == Dialog.OK) |
| { |
| Object resultProject = dialog.getFirstResult(); |
| if (resultProject instanceof IProject) |
| { |
| IProject project = (IProject) resultProject; |
| projectNameText.setText(project.getName()); |
| } |
| } |
| } |
| |
| }); |
| |
| Group activityGroup = new Group(mainComposite, SWT.NONE); |
| GridLayout activityLayout = new GridLayout(3, false); |
| activityGroup.setLayout(activityLayout); |
| GridData activityGrid = new GridData(SWT.FILL, SWT.CENTER, true, false, 3, 1); |
| activityGroup.setLayoutData(activityGrid); |
| activityGroup.setText(LaunchNLS.UI_LaunchComposite_ActivityGroupLabel); |
| |
| final Button defaultActivityButton = new Button(activityGroup, SWT.RADIO); |
| defaultActivityButton.setText(LaunchNLS.UI_LaunchComposite_ActivityDefaultButton); |
| GridData gridData = new GridData(GridData.FILL_HORIZONTAL); |
| gridData.horizontalSpan = 3; |
| defaultActivityButton.setLayoutData(gridData); |
| |
| // Activity Name Button |
| final Button specificActivityButton = new Button(activityGroup, SWT.RADIO); |
| specificActivityButton.setText(LaunchNLS.LaunchConfigurationTab_LaunchButton); |
| GridData activityData = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| specificActivityButton.setLayoutData(activityData); |
| |
| // Activity Name Text |
| final Text activityNameText = new Text(activityGroup, SWT.SINGLE | SWT.BORDER); |
| activityNameText.setText(activityName); |
| activityData = new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1); |
| activityNameText.setLayoutData(activityData); |
| activityNameText.addModifyListener(new ModifyListener() |
| { |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent) |
| */ |
| public void modifyText(ModifyEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| activityNameText.setText(activityName); |
| } |
| else |
| { |
| activityName = activityNameText.getText(); |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| }); |
| |
| // Activity Name Browse Button |
| final Button activityNameBrowseButton = new Button(activityGroup, SWT.PUSH); |
| activityData = new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1); |
| activityNameBrowseButton.setLayoutData(activityData); |
| activityNameBrowseButton.setText(LaunchNLS.UI_LaunchComposite_BrowseButton); |
| activityNameBrowseButton.addSelectionListener(new SelectionAdapter() |
| { |
| /** |
| * Retrieve all activities of a given project |
| * @return All the activities of a given project |
| */ |
| private Set<String> getAllActivities(String projectName) |
| { |
| String[] tempActivities = null; |
| Set<String> activities = new HashSet<String>(); |
| |
| if (projectName.length() != 0) |
| { |
| IProject selectedProject = LaunchUtils.getProject(projectName); |
| |
| tempActivities = LaunchUtils.getProjectActivities(selectedProject); |
| for (String s : tempActivities) |
| { |
| activities.add(s); |
| } |
| } |
| return activities; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (projectName.length() == 0) |
| { |
| IWorkbenchWindow ww = PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| MessageDialog.openInformation(ww.getShell(), |
| LaunchNLS.UI_LaunchComposite_ProjectRequiredTitle, |
| LaunchNLS.UI_LaunchComposite_ProjectRequiredMessage); |
| } |
| else |
| { |
| |
| ElementListSelectionDialog dialog = |
| new ElementListSelectionDialog(getShell(), new LabelProvider() |
| { |
| @Override |
| public String getText(Object element) |
| { |
| String activity = (String) element; |
| return activity; |
| } |
| }) |
| { |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.dialogs.ElementListSelectionDialog#createDialogArea(org.eclipse.swt.widgets.Composite) |
| */ |
| @Override |
| protected Control createDialogArea(Composite parent) |
| { |
| PlatformUI.getWorkbench().getHelpSystem() |
| .setHelp(parent, ACTIVITY_SELECTION_DIALOG_HELPID); |
| return super.createDialogArea(parent); |
| } |
| |
| }; |
| |
| dialog.setTitle(LaunchNLS.UI_LaunchComposite_SelectActivityScreenTitle); |
| dialog.setMessage(LaunchNLS.UI_LaunchComposite_SelectActivityScreenMessage); |
| |
| Object[] allActivities = getAllActivities(projectNameText.getText()).toArray(); |
| if (allActivities.length == 0) |
| { |
| activityNameText.setText(""); //$NON-NLS-1$ |
| } |
| else |
| { |
| dialog.setElements(getAllActivities(projectNameText.getText()).toArray()); |
| |
| int buttonId = dialog.open(); |
| if (buttonId == IDialogConstants.OK_ID) |
| { |
| String activity = (String) dialog.getFirstResult(); |
| activityNameText.setText(activity); |
| |
| } |
| } |
| } |
| } |
| |
| protected static final String ACTIVITY_SELECTION_DIALOG_HELPID = |
| "com.motorola.studio.android.launch.activitySelectionDialog"; //$NON-NLS-1$ |
| }); |
| |
| final Button noActivityButton = new Button(activityGroup, SWT.RADIO); |
| noActivityButton.setText(LaunchNLS.LaunchConfigurationTab_DoNothingButton); |
| gridData = new GridData(GridData.FILL_HORIZONTAL); |
| gridData.horizontalSpan = 3; |
| noActivityButton.setLayoutData(gridData); |
| |
| defaultActivityButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| defaultActivityButton.setSelection(!activitySpecified && runDefaultActivity); |
| activityNameText.setEnabled(activitySpecified); |
| activityNameBrowseButton.setEnabled(activitySpecified); |
| } |
| else |
| { |
| // handle variables |
| handleActivityLauncherTypeVariables(defaultActivityButton, |
| specificActivityButton, activityNameText, activityNameBrowseButton); |
| } |
| } |
| }); |
| |
| specificActivityButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| specificActivityButton.setSelection(activitySpecified && !runDefaultActivity); |
| activityNameText.setEnabled(activitySpecified); |
| activityNameBrowseButton.setEnabled(activitySpecified); |
| } |
| else |
| { |
| // handle variables |
| handleActivityLauncherTypeVariables(defaultActivityButton, |
| specificActivityButton, activityNameText, activityNameBrowseButton); |
| } |
| } |
| }); |
| |
| noActivityButton.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| noActivityButton.setSelection(!activitySpecified && !runDefaultActivity); |
| activityNameText.setEnabled(activitySpecified); |
| activityNameBrowseButton.setEnabled(activitySpecified); |
| } |
| else |
| { |
| // handle variables |
| handleActivityLauncherTypeVariables(defaultActivityButton, |
| specificActivityButton, activityNameText, activityNameBrowseButton); |
| } |
| } |
| }); |
| |
| // Device Name Label |
| Label deviceNameLabel = new Label(destinationGroup, SWT.NONE); |
| deviceNameLabel.setText(LaunchNLS.UI_LaunchComposite_DeviceNameLabel); |
| GridData deviceGridData = new GridData(SWT.LEFT, SWT.CENTER, false, false); |
| deviceNameLabel.setLayoutData(deviceGridData); |
| |
| // Device Name Text |
| final Text deviceNameText = new Text(destinationGroup, SWT.SINGLE | SWT.BORDER); |
| deviceNameText.setText(deviceName); |
| deviceGridData = new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1); |
| deviceNameText.setLayoutData(deviceGridData); |
| deviceNameText.addModifyListener(new ModifyListener() |
| { |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent) |
| */ |
| public void modifyText(ModifyEvent e) |
| { |
| if (e.data == UPDATE_WIDGETS_EVENT) |
| { |
| deviceNameText.setText(deviceName); |
| } |
| else |
| { |
| deviceName = deviceNameText.getText(); |
| updateLaunchConfigurationDialog(); |
| } |
| } |
| }); |
| |
| // Device Name Browse Button |
| deviceNameBrowseButton = new Button(destinationGroup, SWT.PUSH); |
| deviceGridData = new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1); |
| deviceNameBrowseButton.setLayoutData(deviceGridData); |
| deviceNameBrowseButton.setText(LaunchNLS.UI_LaunchComposite_BrowseButton); |
| deviceNameBrowseButton.addSelectionListener(new SelectionAdapter() |
| { |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent) |
| */ |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| IProject selectedProject = LaunchUtils.getProject(projectNameText.getText()); |
| DeviceSelectionDialog dialog = |
| new DeviceSelectionDialog(getShell(), |
| LaunchNLS.UI_LaunchComposite_SelectDeviceScreenMessage, |
| selectedProject); |
| dialog.setTitle(LaunchNLS.UI_LaunchComposite_SelectDeviceScreenTitle); |
| dialog.setMultipleSelection(false); |
| dialog.setValidator(new ISelectionStatusValidator() |
| { |
| |
| public IStatus validate(Object[] selection) |
| { |
| IStatus status = new Status(IStatus.OK, LaunchPlugin.PLUGIN_ID, ""); //$NON-NLS-1$ |
| if (selection.length == 0) |
| { |
| status = |
| new Status(IStatus.ERROR, LaunchPlugin.PLUGIN_ID, |
| "No selected instance"); //$NON-NLS-1$ |
| } |
| return status; |
| } |
| }); |
| int res = dialog.open(); |
| if (res == IDialogConstants.OK_ID) |
| { |
| ISerialNumbered serialNumbered = (ISerialNumbered) dialog.getFirstResult(); |
| String selectedDevice = ((IInstance) serialNumbered).getName(); |
| deviceNameText.setText(selectedDevice); |
| } |
| } |
| |
| }); |
| |
| InstanceEventManager.getInstance().addInstanceListener(instanceListener); |
| |
| Link createNewAvdLink = new Link(destinationGroup, SWT.NONE); |
| deviceGridData = new GridData(SWT.RIGHT, SWT.CENTER, true, false, 3, 1); |
| createNewAvdLink.setLayoutData(deviceGridData); |
| createNewAvdLink.setText(LaunchNLS.LaunchConfigurationTab_CreateNewAVDLink); |
| createNewAvdLink.addSelectionListener(new SelectionAdapter() |
| { |
| @Override |
| public void widgetSelected(SelectionEvent e) |
| { |
| OpenNewDeviceWizardHandler handler = new OpenNewDeviceWizardHandler(); |
| try |
| { |
| handler.execute(new ExecutionEvent()); |
| } |
| catch (ExecutionException exception) |
| { |
| //do nothing |
| } |
| } |
| }); |
| |
| mainComposite.addListener(SWT.Modify, new Listener() |
| { |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event) |
| */ |
| public void handleEvent(Event e) |
| { |
| projectNameText.notifyListeners(SWT.Modify, e); |
| activityNameText.notifyListeners(SWT.Modify, e); |
| deviceNameText.notifyListeners(SWT.Modify, e); |
| defaultActivityButton.notifyListeners(SWT.Selection, e); |
| specificActivityButton.notifyListeners(SWT.Selection, e); |
| noActivityButton.notifyListeners(SWT.Selection, e); |
| |
| if (defaultLauncherButton != null) |
| { |
| defaultLauncherButton.notifyListeners(SWT.Selection, e); |
| } |
| if (vdlLauncherButton != null) |
| { |
| vdlLauncherButton.notifyListeners(SWT.Selection, e); |
| } |
| } |
| }); |
| |
| PlatformUI.getWorkbench().getHelpSystem().setHelp(mainComposite, LAUNCH_DIALOG_HELP); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Handle the variables regarding Activity Launcher options. |
| * |
| * @param defaultActivityButton {@link Button} for Default Activity. |
| * @param specificActivityButton {@link Button} for Specific Activity. |
| * @param activityNameText {@link Text} holding the Activity to be launched name. |
| * @param activityNameBrowseButton Activity browser {@link Button}. |
| */ |
| private void handleActivityLauncherTypeVariables(final Button defaultActivityButton, |
| final Button specificActivityButton, final Text activityNameText, |
| final Button activityNameBrowseButton) |
| { |
| activitySpecified = specificActivityButton.getSelection(); |
| runDefaultActivity = defaultActivityButton.getSelection(); |
| activityNameText.setEnabled(activitySpecified); |
| activityNameBrowseButton.setEnabled(activitySpecified); |
| updateLaunchConfigurationDialog(); |
| } |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName() |
| */ |
| public String getName() |
| { |
| return LaunchConfigurationTab.NAME; |
| } |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getImage() |
| */ |
| @Override |
| public Image getImage() |
| { |
| return AbstractUIPlugin.imageDescriptorFromPlugin(LaunchPlugin.PLUGIN_ID, |
| ILaunchConfigurationConstants.MOTODEV_APP_ICO).createImage(); |
| } |
| |
| @Override |
| public void dispose() |
| { |
| InstanceEventManager.getInstance().removeInstanceListener(instanceListener); |
| super.dispose(); |
| } |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration) |
| */ |
| public void initializeFrom(ILaunchConfiguration configuration) |
| { |
| // Assure that when loading the configuration, the TmL devices are in sync with the |
| // AVD available at the SDK |
| InstancesListRefresh.refresh(); |
| |
| try |
| { |
| projectName = |
| configuration.getAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| |
| activityName = |
| configuration.getAttribute(ILaunchConfigurationConstants.ATTR_ACTIVITY, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| |
| activitySpecified = |
| (configuration.getAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_ACTIVITY)) == ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_ACTIVITY; |
| |
| runDefaultActivity = |
| (configuration.getAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_ACTIVITY)) == ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DEFAULT; |
| |
| deviceName = |
| configuration.getAttribute( |
| ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| |
| Event e = new Event(); |
| e.type = SWT.Modify; |
| e.data = UPDATE_WIDGETS_EVENT; |
| mainComposite.notifyListeners(SWT.Modify, e); |
| } |
| catch (CoreException e) |
| { |
| // Do nothing for now |
| } |
| } |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy) |
| */ |
| public void performApply(ILaunchConfigurationWorkingCopy configuration) |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, projectName); |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_ACTIVITY, activityName); |
| |
| // For now we are not preventing the device chooser dialog to appear if the user choose a |
| // handset in the device field. However, if the user chooses an AVD, we set the preferred |
| // AVD field so that we force the launch to happen in the selected AVD without asking the |
| // user. |
| Collection<String> validAvds = SdkUtils.getAllValidVmNames(); |
| if (validAvds.contains(deviceName)) |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, |
| deviceName); |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_ADT_DEVICE_INSTANCE_NAME, |
| deviceName); |
| } |
| else |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, |
| deviceName); |
| configuration |
| .removeAttribute(ILaunchConfigurationConstants.ATTR_ADT_DEVICE_INSTANCE_NAME); |
| } |
| |
| if (activitySpecified) |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_ACTIVITY); |
| } |
| else if (runDefaultActivity) |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DEFAULT); |
| } |
| else |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DO_NOTHING); |
| } |
| |
| LaunchUtils.updateLaunchConfigurationDefaults(configuration); |
| |
| IProject project = LaunchUtils.getProject(projectName); |
| IResource[] mappedResources = null; |
| if (project != null) |
| { |
| mappedResources = new IResource[] |
| { |
| project |
| }; |
| } |
| |
| configuration.setMappedResources(mappedResources); |
| } |
| |
| /** |
| * @see org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy) |
| */ |
| public void setDefaults(ILaunchConfigurationWorkingCopy configuration) |
| { |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_ACTIVITY, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION, |
| ILaunchConfigurationConstants.ATTR_LAUNCH_ACTION_DEFAULT); |
| // It is default not to exist Preferred AVD attribute, so we just set the Studio's |
| // device instance name attribute here |
| configuration.setAttribute(ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| |
| LaunchUtils.setADTLaunchConfigurationDefaults(configuration); |
| |
| projectName = ILaunchConfigurationConstants.DEFAULT_VALUE; //$NON-NLS-1$ |
| activityName = ILaunchConfigurationConstants.DEFAULT_VALUE; //$NON-NLS-1$ |
| deviceName = ILaunchConfigurationConstants.DEFAULT_VALUE; //$NON-NLS-1$ |
| activitySpecified = ILaunchConfigurationConstants.DEFAULT_BOOL_VALUE; |
| runDefaultActivity = !ILaunchConfigurationConstants.DEFAULT_BOOL_VALUE; |
| |
| if (mainComposite != null) |
| { |
| Event e = new Event(); |
| e.type = SWT.Modify; |
| e.data = UPDATE_WIDGETS_EVENT; |
| mainComposite.notifyListeners(SWT.Modify, e); |
| } |
| } |
| |
| /** |
| * @see ILaunchConfigurationTab#isValid(ILaunchConfiguration) |
| */ |
| @Override |
| public boolean isValid(ILaunchConfiguration launchConfig) |
| { |
| boolean isValid = true; |
| boolean hasWarning = false; |
| |
| String projectName = ""; //$NON-NLS-1$ |
| String instanceName = ""; //$NON-NLS-1$ |
| String activityName = ""; //$NON-NLS-1$ |
| |
| try |
| { |
| projectName = |
| launchConfig.getAttribute(ILaunchConfigurationConstants.ATTR_PROJECT_NAME, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| instanceName = |
| launchConfig.getAttribute( |
| ILaunchConfigurationConstants.ATTR_DEVICE_INSTANCE_NAME, (String) null); |
| activityName = |
| launchConfig.getAttribute(ILaunchConfigurationConstants.ATTR_ACTIVITY, |
| ILaunchConfigurationConstants.DEFAULT_VALUE); |
| } |
| catch (CoreException e) |
| { |
| StudioLogger.error(LaunchConfigurationTab.class, |
| "Error validating launch configuration " + launchConfig.getName(), e); //$NON-NLS-1$ |
| } |
| |
| /* Validate current project */ |
| |
| IProject project = null; |
| |
| if (isValid && (projectName.length() > 0)) |
| { |
| Path projectPath = new Path(projectName); |
| if (!projectPath.isValidSegment(projectName)) |
| { |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_PROJECT_NOT_EXIST); |
| } |
| project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName); |
| if ((project != null) && !project.exists()) |
| { |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_PROJECT_NOT_EXIST); |
| } |
| else if ((project != null) && SdkUtils.isLibraryProject(project)) |
| { |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_PROJECT_IS_LIBRARY); |
| } |
| else if (project == null) |
| { |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_PROJECT_NOT_EXIST); |
| } |
| } |
| else if (isValid && (projectName.length() == 0)) |
| { |
| setErrorMessage(null); |
| } |
| |
| // if we have a chosen project, enable/disable the device selection |
| if (project != null) |
| { |
| updateDeviceChooserButton(); |
| } |
| |
| /* Validate current device instance */ |
| if (isValid && (instanceName != null) && (instanceName.length() > 0)) |
| { |
| IStatus compatible = LaunchUtils.isCompatible(project, instanceName); |
| if (compatible == null) |
| { |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_DEVICE_INEXISTENT); |
| isValid = false; |
| } |
| else if (compatible.getSeverity() == IStatus.ERROR) |
| { |
| setErrorMessage(compatible.getMessage()); |
| isValid = false; |
| } |
| else if (compatible.getSeverity() == IStatus.WARNING) |
| { |
| setMessage(compatible.getMessage()); |
| hasWarning = true; |
| } |
| } |
| else if (isValid && (instanceName != null) && (instanceName.length() == 0)) |
| { |
| setErrorMessage(null); |
| } |
| |
| /* Validate current activity */ |
| if (isValid && (activityName.length() > 0) && activitySpecified) |
| { |
| /* |
| * Check if the activity is valid in the current METAINF project |
| * file |
| */ |
| |
| Activity[] currentActivities = null; |
| boolean activityValid = false; |
| |
| ManifestData manifestParser = null; |
| try |
| { |
| manifestParser = AndroidManifestParser.parse(new IFolderWrapper(project)); |
| } |
| catch (Exception e) |
| { |
| StudioLogger.error(LaunchUtils.class, |
| "An error occurred trying to parse AndroidManifest", e); //$NON-NLS-1$ |
| } |
| if (manifestParser != null) |
| { |
| currentActivities = manifestParser.getActivities(); |
| } |
| else |
| { |
| // There's a problem with the manifest file / parser. Invalidate |
| // current settings. |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_INVALID_ACTIVITY); |
| } |
| |
| /* See if the chosen activity is there */ |
| |
| for (Activity s : currentActivities) |
| { |
| if (s.getName().equals(activityName)) |
| { |
| activityValid = true; |
| } |
| } |
| |
| if (!activityValid) |
| { |
| isValid = false; |
| setErrorMessage(LaunchNLS.UI_LaunchConfigurationTab_ERR_ACTIVITY_NOT_EXIST); |
| } |
| |
| } |
| else if (isValid && ((activityName.length() == 0) && activitySpecified)) |
| { |
| setErrorMessage(null); |
| } |
| |
| /* Wrap up validation */ |
| if (isValid |
| && ((projectName.length() == 0) |
| || ((activitySpecified) && (activityName.length() == 0)) || (instanceName |
| .length() == 0))) |
| { |
| isValid = false; |
| |
| if (projectName.length() == 0) |
| { |
| setMessage(LaunchNLS.UI_LaunchConfigurationTab_InfoSelectProject); |
| } |
| else if (instanceName.length() == 0) |
| { |
| setMessage(LaunchNLS.UI_LaunchConfigurationTab_InfoSelectInstance); |
| } |
| else if (activityName.length() == 0) |
| { |
| setMessage(LaunchNLS.UI_LaunchConfigurationTab_InfoSelectActivity); |
| } |
| |
| } |
| |
| if (isValid) |
| { |
| setErrorMessage(null); |
| if (!hasWarning) |
| { |
| setMessage(null); |
| } |
| } |
| |
| return isValid; |
| } |
| } |
