| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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. |
| */ |
| |
| /* |
| * References: |
| * org.eclipse.jdt.internal.ui.wizards.JavaProjectWizard |
| * org.eclipse.jdt.internal.ui.wizards.JavaProjectWizardFirstPage |
| */ |
| |
| package com.android.ide.eclipse.adt.wizards.newproject; |
| |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.sdk.Sdk; |
| import com.android.ide.eclipse.adt.sdk.Sdk.ITargetChangeListener; |
| import com.android.ide.eclipse.common.AndroidConstants; |
| import com.android.ide.eclipse.common.project.AndroidManifestParser; |
| import com.android.ide.eclipse.common.project.AndroidManifestParser.Activity; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.SdkConstants; |
| import com.android.sdklib.project.ProjectProperties; |
| import com.android.sdklib.project.ProjectProperties.PropertyType; |
| import com.android.sdkuilib.SdkTargetSelector; |
| |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.jdt.core.JavaConventions; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.osgi.util.TextProcessor; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| 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.DirectoryDialog; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Text; |
| |
| import java.io.File; |
| import java.io.FileFilter; |
| import java.net.URI; |
| import java.util.regex.Pattern; |
| |
| /** |
| * NewAndroidProjectCreationPage is a project creation page that provides the |
| * following fields: |
| * <ul> |
| * <li> Project name |
| * <li> SDK Target |
| * <li> Application name |
| * <li> Package name |
| * <li> Activity name |
| * </ul> |
| * Note: this class is public so that it can be accessed from unit tests. |
| * It is however an internal class. Its API may change without notice. |
| * It should semantically be considered as a private final class. |
| * Do not derive from this class. |
| */ |
| public class NewProjectCreationPage extends WizardPage { |
| |
| // constants |
| /** Initial value for all name fields (project, activity, application, package). Used |
| * whenever a value is requested before controls are created. */ |
| private static final String INITIAL_NAME = ""; //$NON-NLS-1$ |
| /** Initial value for the Create New Project radio; False means Create From Existing would be |
| * the default.*/ |
| private static final boolean INITIAL_CREATE_NEW_PROJECT = true; |
| /** Initial value for the Use Default Location check box. */ |
| private static final boolean INITIAL_USE_DEFAULT_LOCATION = true; |
| /** Initial value for the Create Activity check box. */ |
| private static final boolean INITIAL_CREATE_ACTIVITY = true; |
| |
| |
| /** Pattern for characters accepted in a project name. Since this will be used as a |
| * directory name, we're being a bit conservative on purpose. It cannot start with a space. */ |
| private static final Pattern sProjectNamePattern = Pattern.compile("^[\\w][\\w. -]*$"); //$NON-NLS-1$ |
| /** Last user-browsed location, static so that it be remembered for the whole session */ |
| private static String sCustomLocationOsPath = ""; //$NON-NLS-1$ |
| private static boolean sAutoComputeCustomLocation = true; |
| |
| private final int MSG_NONE = 0; |
| private final int MSG_WARNING = 1; |
| private final int MSG_ERROR = 2; |
| |
| private String mUserPackageName = ""; //$NON-NLS-1$ |
| private String mUserActivityName = ""; //$NON-NLS-1$ |
| private boolean mUserCreateActivityCheck = INITIAL_CREATE_ACTIVITY; |
| private String mSourceFolder = ""; //$NON-NLS-1$ |
| |
| // widgets |
| private Text mProjectNameField; |
| private Text mPackageNameField; |
| private Text mActivityNameField; |
| private Text mApplicationNameField; |
| private Button mCreateNewProjectRadio; |
| private Button mUseDefaultLocation; |
| private Label mLocationLabel; |
| private Text mLocationPathField; |
| private Button mBrowseButton; |
| private Button mCreateActivityCheck; |
| private Text mMinSdkVersionField; |
| private SdkTargetSelector mSdkTargetSelector; |
| private ITargetChangeListener mSdkTargetChangeListener; |
| |
| private boolean mInternalLocationPathUpdate; |
| protected boolean mInternalProjectNameUpdate; |
| protected boolean mInternalApplicationNameUpdate; |
| private boolean mInternalCreateActivityUpdate; |
| private boolean mInternalActivityNameUpdate; |
| protected boolean mProjectNameModifiedByUser; |
| protected boolean mApplicationNameModifiedByUser; |
| private boolean mInternalMinSdkVersionUpdate; |
| private boolean mMinSdkVersionModifiedByUser; |
| |
| |
| /** |
| * Creates a new project creation wizard page. |
| * |
| * @param pageName the name of this page |
| */ |
| public NewProjectCreationPage(String pageName) { |
| super(pageName); |
| setPageComplete(false); |
| } |
| |
| // --- Getters used by NewProjectWizard --- |
| |
| /** |
| * Returns the current project location path as entered by the user, or its |
| * anticipated initial value. Note that if the default has been returned the |
| * path in a project description used to create a project should not be set. |
| * |
| * @return the project location path or its anticipated initial value. |
| */ |
| public IPath getLocationPath() { |
| return new Path(getProjectLocation()); |
| } |
| |
| /** Returns the value of the project name field with leading and trailing spaces removed. */ |
| public String getProjectName() { |
| return mProjectNameField == null ? INITIAL_NAME : mProjectNameField.getText().trim(); |
| } |
| |
| /** Returns the value of the package name field with spaces trimmed. */ |
| public String getPackageName() { |
| return mPackageNameField == null ? INITIAL_NAME : mPackageNameField.getText().trim(); |
| } |
| |
| /** Returns the value of the activity name field with spaces trimmed. */ |
| public String getActivityName() { |
| return mActivityNameField == null ? INITIAL_NAME : mActivityNameField.getText().trim(); |
| } |
| |
| /** Returns the value of the min sdk version field with spaces trimmed. */ |
| public String getMinSdkVersion() { |
| return mMinSdkVersionField == null ? "" : mMinSdkVersionField.getText().trim(); |
| } |
| |
| /** Returns the value of the application name field with spaces trimmed. */ |
| public String getApplicationName() { |
| // Return the name of the activity as default application name. |
| return mApplicationNameField == null ? getActivityName() |
| : mApplicationNameField.getText().trim(); |
| |
| } |
| |
| /** Returns the value of the "Create New Project" radio. */ |
| public boolean isNewProject() { |
| return mCreateNewProjectRadio == null ? INITIAL_CREATE_NEW_PROJECT |
| : mCreateNewProjectRadio.getSelection(); |
| } |
| |
| /** Returns the value of the "Create Activity" checkbox. */ |
| public boolean isCreateActivity() { |
| return mCreateActivityCheck == null ? INITIAL_CREATE_ACTIVITY |
| : mCreateActivityCheck.getSelection(); |
| } |
| |
| /** Returns the value of the Use Default Location field. */ |
| public boolean useDefaultLocation() { |
| return mUseDefaultLocation == null ? INITIAL_USE_DEFAULT_LOCATION |
| : mUseDefaultLocation.getSelection(); |
| } |
| |
| /** Returns the internal source folder (for the "existing project" mode) or the default |
| * "src" constant. */ |
| public String getSourceFolder() { |
| if (isNewProject() || mSourceFolder == null || mSourceFolder.length() == 0) { |
| return SdkConstants.FD_SOURCES; |
| } else { |
| return mSourceFolder; |
| } |
| } |
| |
| /** Returns the current sdk target or null if none has been selected yet. */ |
| public IAndroidTarget getSdkTarget() { |
| return mSdkTargetSelector == null ? null : mSdkTargetSelector.getSelected(); |
| } |
| |
| /** |
| * Overrides @DialogPage.setVisible(boolean) to put the focus in the project name when |
| * the dialog is made visible. |
| */ |
| @Override |
| public void setVisible(boolean visible) { |
| super.setVisible(visible); |
| if (visible) { |
| mProjectNameField.setFocus(); |
| } |
| } |
| |
| // --- UI creation --- |
| |
| /** |
| * Creates the top level control for this dialog page under the given parent |
| * composite. |
| * |
| * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite) |
| */ |
| public void createControl(Composite parent) { |
| Composite composite = new Composite(parent, SWT.NULL); |
| composite.setFont(parent.getFont()); |
| |
| initializeDialogUnits(parent); |
| |
| composite.setLayout(new GridLayout()); |
| composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| createProjectNameGroup(composite); |
| createLocationGroup(composite); |
| createTargetGroup(composite); |
| createPropertiesGroup(composite); |
| |
| // Update state the first time |
| enableLocationWidgets(); |
| |
| // Show description the first time |
| setErrorMessage(null); |
| setMessage(null); |
| setControl(composite); |
| |
| // Validate. This will complain about the first empty field. |
| setPageComplete(validatePage()); |
| } |
| |
| @Override |
| public void dispose() { |
| |
| if (mSdkTargetChangeListener != null) { |
| AdtPlugin.getDefault().removeTargetListener(mSdkTargetChangeListener); |
| mSdkTargetChangeListener = null; |
| } |
| |
| super.dispose(); |
| } |
| |
| /** |
| * Creates the group for the project name: |
| * [label: "Project Name"] [text field] |
| * |
| * @param parent the parent composite |
| */ |
| private final void createProjectNameGroup(Composite parent) { |
| Composite group = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| // new project label |
| Label label = new Label(group, SWT.NONE); |
| label.setText("Project name:"); |
| label.setFont(parent.getFont()); |
| label.setToolTipText("Name of the Eclipse project to create. It cannot be empty."); |
| |
| // new project name entry field |
| mProjectNameField = new Text(group, SWT.BORDER); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| mProjectNameField.setToolTipText("Name of the Eclipse project to create. It cannot be empty."); |
| mProjectNameField.setLayoutData(data); |
| mProjectNameField.setFont(parent.getFont()); |
| mProjectNameField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| if (!mInternalProjectNameUpdate) { |
| mProjectNameModifiedByUser = true; |
| } |
| updateLocationPathField(null); |
| } |
| }); |
| } |
| |
| |
| /** |
| * Creates the group for the Project options: |
| * [radio] Create new project |
| * [radio] Create project from existing sources |
| * [check] Use default location |
| * Location [text field] [browse button] |
| * |
| * @param parent the parent composite |
| */ |
| private final void createLocationGroup(Composite parent) { |
| Group group = new Group(parent, SWT.SHADOW_ETCHED_IN); |
| // Layout has 4 columns of non-equal size |
| group.setLayout(new GridLayout()); |
| group.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| group.setFont(parent.getFont()); |
| group.setText("Contents"); |
| |
| mCreateNewProjectRadio = new Button(group, SWT.RADIO); |
| mCreateNewProjectRadio.setText("Create new project in workspace"); |
| mCreateNewProjectRadio.setSelection(INITIAL_CREATE_NEW_PROJECT); |
| Button existing_project_radio = new Button(group, SWT.RADIO); |
| existing_project_radio.setText("Create project from existing source"); |
| existing_project_radio.setSelection(!INITIAL_CREATE_NEW_PROJECT); |
| |
| mUseDefaultLocation = new Button(group, SWT.CHECK); |
| mUseDefaultLocation.setText("Use default location"); |
| mUseDefaultLocation.setSelection(INITIAL_USE_DEFAULT_LOCATION); |
| |
| SelectionListener location_listener = new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| super.widgetSelected(e); |
| enableLocationWidgets(); |
| extractNamesFromAndroidManifest(); |
| setPageComplete(validatePage()); |
| } |
| }; |
| |
| mCreateNewProjectRadio.addSelectionListener(location_listener); |
| existing_project_radio.addSelectionListener(location_listener); |
| mUseDefaultLocation.addSelectionListener(location_listener); |
| |
| Composite location_group = new Composite(group, SWT.NONE); |
| location_group.setLayout(new GridLayout(4, /* num columns */ |
| false /* columns of not equal size */)); |
| location_group.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| location_group.setFont(parent.getFont()); |
| |
| mLocationLabel = new Label(location_group, SWT.NONE); |
| mLocationLabel.setText("Location:"); |
| |
| mLocationPathField = new Text(location_group, SWT.BORDER); |
| GridData data = new GridData(GridData.FILL, /* horizontal alignment */ |
| GridData.BEGINNING, /* vertical alignment */ |
| true, /* grabExcessHorizontalSpace */ |
| false, /* grabExcessVerticalSpace */ |
| 2, /* horizontalSpan */ |
| 1); /* verticalSpan */ |
| mLocationPathField.setLayoutData(data); |
| mLocationPathField.setFont(parent.getFont()); |
| mLocationPathField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| onLocationPathFieldModified(); |
| } |
| }); |
| |
| mBrowseButton = new Button(location_group, SWT.PUSH); |
| mBrowseButton.setText("Browse..."); |
| setButtonLayoutData(mBrowseButton); |
| mBrowseButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| openDirectoryBrowser(); |
| } |
| }); |
| } |
| |
| /** |
| * Creates the target group. |
| * It only contains an SdkTargetSelector. |
| */ |
| private void createTargetGroup(Composite parent) { |
| Group group = new Group(parent, SWT.SHADOW_ETCHED_IN); |
| // Layout has 1 column |
| group.setLayout(new GridLayout()); |
| group.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| group.setFont(parent.getFont()); |
| group.setText("Build Target"); |
| |
| // The selector is created without targets. They are added below in the change listener. |
| mSdkTargetSelector = new SdkTargetSelector(group, null); |
| |
| mSdkTargetChangeListener = new ITargetChangeListener() { |
| public void onProjectTargetChange(IProject changedProject) { |
| // Ignore |
| } |
| |
| public void onTargetsLoaded() { |
| // Update the sdk target selector with the new targets |
| |
| // get the targets from the sdk |
| IAndroidTarget[] targets = null; |
| if (Sdk.getCurrent() != null) { |
| targets = Sdk.getCurrent().getTargets(); |
| } |
| mSdkTargetSelector.setTargets(targets); |
| |
| // If there's only one target, select it |
| if (targets != null && targets.length == 1) { |
| mSdkTargetSelector.setSelection(targets[0]); |
| } |
| } |
| }; |
| |
| AdtPlugin.getDefault().addTargetListener(mSdkTargetChangeListener); |
| |
| // Invoke it once to initialize the targets |
| mSdkTargetChangeListener.onTargetsLoaded(); |
| |
| mSdkTargetSelector.setSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onSdkTargetModified(); |
| updateLocationPathField(null); |
| setPageComplete(validatePage()); |
| } |
| }); |
| } |
| |
| /** |
| * Display a directory browser and update the location path field with the selected path |
| */ |
| private void openDirectoryBrowser() { |
| |
| String existing_dir = getLocationPathFieldValue(); |
| |
| // Disable the path if it doesn't exist |
| if (existing_dir.length() == 0) { |
| existing_dir = null; |
| } else { |
| File f = new File(existing_dir); |
| if (!f.exists()) { |
| existing_dir = null; |
| } |
| } |
| |
| DirectoryDialog dd = new DirectoryDialog(mLocationPathField.getShell()); |
| dd.setMessage("Browse for folder"); |
| dd.setFilterPath(existing_dir); |
| String abs_dir = dd.open(); |
| |
| if (abs_dir != null) { |
| updateLocationPathField(abs_dir); |
| extractNamesFromAndroidManifest(); |
| setPageComplete(validatePage()); |
| } |
| } |
| |
| /** |
| * Creates the group for the project properties: |
| * - Package name [text field] |
| * - Activity name [text field] |
| * - Application name [text field] |
| * |
| * @param parent the parent composite |
| */ |
| private final void createPropertiesGroup(Composite parent) { |
| // package specification group |
| Group group = new Group(parent, SWT.SHADOW_ETCHED_IN); |
| GridLayout layout = new GridLayout(); |
| layout.numColumns = 2; |
| group.setLayout(layout); |
| group.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| group.setFont(parent.getFont()); |
| group.setText("Properties"); |
| |
| // new application label |
| Label label = new Label(group, SWT.NONE); |
| label.setText("Application name:"); |
| label.setFont(parent.getFont()); |
| label.setToolTipText("Name of the Application. This is a free string. It can be empty."); |
| |
| // new application name entry field |
| mApplicationNameField = new Text(group, SWT.BORDER); |
| GridData data = new GridData(GridData.FILL_HORIZONTAL); |
| mApplicationNameField.setToolTipText("Name of the Application. This is a free string. It can be empty."); |
| mApplicationNameField.setLayoutData(data); |
| mApplicationNameField.setFont(parent.getFont()); |
| mApplicationNameField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| if (!mInternalApplicationNameUpdate) { |
| mApplicationNameModifiedByUser = true; |
| } |
| } |
| }); |
| |
| // new package label |
| label = new Label(group, SWT.NONE); |
| label.setText("Package name:"); |
| label.setFont(parent.getFont()); |
| label.setToolTipText("Namespace of the Package to create. This must be a Java namespace with at least two components."); |
| |
| // new package name entry field |
| mPackageNameField = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| mPackageNameField.setToolTipText("Namespace of the Package to create. This must be a Java namespace with at least two components."); |
| mPackageNameField.setLayoutData(data); |
| mPackageNameField.setFont(parent.getFont()); |
| mPackageNameField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| onPackageNameFieldModified(); |
| } |
| }); |
| |
| // new activity label |
| mCreateActivityCheck = new Button(group, SWT.CHECK); |
| mCreateActivityCheck.setText("Create Activity:"); |
| mCreateActivityCheck.setToolTipText("Specifies if you want to create a default Activity."); |
| mCreateActivityCheck.setFont(parent.getFont()); |
| mCreateActivityCheck.setSelection(INITIAL_CREATE_ACTIVITY); |
| mCreateActivityCheck.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event event) { |
| onCreateActivityCheckModified(); |
| enableLocationWidgets(); |
| } |
| }); |
| |
| // new activity name entry field |
| mActivityNameField = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| mActivityNameField.setToolTipText("Name of the Activity class to create. Must be a valid Java identifier."); |
| mActivityNameField.setLayoutData(data); |
| mActivityNameField.setFont(parent.getFont()); |
| mActivityNameField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| onActivityNameFieldModified(); |
| } |
| }); |
| |
| // min sdk version label |
| label = new Label(group, SWT.NONE); |
| label.setText("Min SDK Version:"); |
| label.setFont(parent.getFont()); |
| label.setToolTipText("The minimum SDK version number that the application requires. Must be an integer > 0. It can be empty."); |
| |
| // min sdk version entry field |
| mMinSdkVersionField = new Text(group, SWT.BORDER); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| label.setToolTipText("The minimum SDK version number that the application requires. Must be an integer > 0. It can be empty."); |
| mMinSdkVersionField.setLayoutData(data); |
| mMinSdkVersionField.setFont(parent.getFont()); |
| mMinSdkVersionField.addListener(SWT.Modify, new Listener() { |
| public void handleEvent(Event event) { |
| onMinSdkVersionFieldModified(); |
| setPageComplete(validatePage()); |
| } |
| }); |
| } |
| |
| |
| //--- Internal getters & setters ------------------ |
| |
| /** Returns the location path field value with spaces trimmed. */ |
| private String getLocationPathFieldValue() { |
| return mLocationPathField == null ? "" : mLocationPathField.getText().trim(); |
| } |
| |
| /** Returns the current project location, depending on the Use Default Location check box. */ |
| public String getProjectLocation() { |
| if (isNewProject() && useDefaultLocation()) { |
| return Platform.getLocation().toString(); |
| } else { |
| return getLocationPathFieldValue(); |
| } |
| } |
| |
| /** |
| * Creates a project resource handle for the current project name field |
| * value. |
| * <p> |
| * This method does not create the project resource; this is the |
| * responsibility of <code>IProject::create</code> invoked by the new |
| * project resource wizard. |
| * </p> |
| * |
| * @return the new project resource handle |
| */ |
| private IProject getProjectHandle() { |
| return ResourcesPlugin.getWorkspace().getRoot().getProject(getProjectName()); |
| } |
| |
| // --- UI Callbacks ---- |
| |
| /** |
| * Enables or disable the location widgets depending on the user selection: |
| * the location path is enabled when using the "existing source" mode (i.e. not new project) |
| * or in new project mode with the "use default location" turned off. |
| */ |
| private void enableLocationWidgets() { |
| boolean is_new_project = isNewProject(); |
| boolean use_default = useDefaultLocation(); |
| boolean location_enabled = !is_new_project || !use_default; |
| boolean create_activity = isCreateActivity(); |
| |
| mUseDefaultLocation.setEnabled(is_new_project); |
| |
| mLocationLabel.setEnabled(location_enabled); |
| mLocationPathField.setEnabled(location_enabled); |
| mBrowseButton.setEnabled(location_enabled); |
| |
| mPackageNameField.setEnabled(is_new_project); |
| mCreateActivityCheck.setEnabled(is_new_project); |
| mActivityNameField.setEnabled(is_new_project & create_activity); |
| |
| updateLocationPathField(null); |
| updatePackageAndActivityFields(); |
| } |
| |
| /** |
| * Updates the location directory path field. |
| * <br/> |
| * When custom user selection is enabled, use the abs_dir argument if not null and also |
| * save it internally. If abs_dir is null, restore the last saved abs_dir. This allows the |
| * user selection to be remembered when the user switches from default to custom. |
| * <br/> |
| * When custom user selection is disabled, use the workspace default location with the |
| * current project name. This does not change the internally cached abs_dir. |
| * |
| * @param abs_dir A new absolute directory path or null to use the default. |
| */ |
| private void updateLocationPathField(String abs_dir) { |
| boolean is_new_project = isNewProject(); |
| boolean use_default = useDefaultLocation(); |
| boolean custom_location = !is_new_project || !use_default; |
| |
| if (!mInternalLocationPathUpdate) { |
| mInternalLocationPathUpdate = true; |
| if (custom_location) { |
| if (abs_dir != null) { |
| // We get here if the user selected a directory with the "Browse" button. |
| // Disable auto-compute of the custom location unless the user selected |
| // the exact same path. |
| sAutoComputeCustomLocation = sAutoComputeCustomLocation && |
| abs_dir.equals(sCustomLocationOsPath); |
| sCustomLocationOsPath = TextProcessor.process(abs_dir); |
| } else if (sAutoComputeCustomLocation || |
| (!is_new_project && !new File(sCustomLocationOsPath).isDirectory())) { |
| // By default select the samples directory of the current target |
| IAndroidTarget target = getSdkTarget(); |
| if (target != null) { |
| sCustomLocationOsPath = target.getPath(IAndroidTarget.SAMPLES); |
| } |
| |
| // If we don't have a target, select the base directory of the |
| // "universal sdk". If we don't even have that, use a root drive. |
| if (sCustomLocationOsPath == null || sCustomLocationOsPath.length() == 0) { |
| if (Sdk.getCurrent() != null) { |
| sCustomLocationOsPath = Sdk.getCurrent().getSdkLocation(); |
| } else { |
| sCustomLocationOsPath = File.listRoots()[0].getAbsolutePath(); |
| } |
| } |
| } |
| if (!mLocationPathField.getText().equals(sCustomLocationOsPath)) { |
| mLocationPathField.setText(sCustomLocationOsPath); |
| } |
| } else { |
| String value = Platform.getLocation().append(getProjectName()).toString(); |
| value = TextProcessor.process(value); |
| if (!mLocationPathField.getText().equals(value)) { |
| mLocationPathField.setText(value); |
| } |
| } |
| setPageComplete(validatePage()); |
| mInternalLocationPathUpdate = false; |
| } |
| } |
| |
| /** |
| * The location path field is either modified internally (from updateLocationPathField) |
| * or manually by the user when the custom_location mode is not set. |
| * |
| * Ignore the internal modification. When modified by the user, memorize the choice and |
| * validate the page. |
| */ |
| private void onLocationPathFieldModified() { |
| if (!mInternalLocationPathUpdate) { |
| // When the updates doesn't come from updateLocationPathField, it must be the user |
| // editing the field manually, in which case we want to save the value internally |
| // and we disable auto-compute of the custom location (to avoid overriding the user |
| // value) |
| String newPath = getLocationPathFieldValue(); |
| sAutoComputeCustomLocation = sAutoComputeCustomLocation && |
| newPath.equals(sCustomLocationOsPath); |
| sCustomLocationOsPath = newPath; |
| extractNamesFromAndroidManifest(); |
| setPageComplete(validatePage()); |
| } |
| } |
| |
| /** |
| * The package name field is either modified internally (from extractNamesFromAndroidManifest) |
| * or manually by the user when the custom_location mode is not set. |
| * |
| * Ignore the internal modification. When modified by the user, memorize the choice and |
| * validate the page. |
| */ |
| private void onPackageNameFieldModified() { |
| if (isNewProject()) { |
| mUserPackageName = getPackageName(); |
| setPageComplete(validatePage()); |
| } |
| } |
| |
| /** |
| * The create activity checkbox is either modified internally (from |
| * extractNamesFromAndroidManifest) or manually by the user. |
| * |
| * Ignore the internal modification. When modified by the user, memorize the choice and |
| * validate the page. |
| */ |
| private void onCreateActivityCheckModified() { |
| if (isNewProject() && !mInternalCreateActivityUpdate) { |
| mUserCreateActivityCheck = isCreateActivity(); |
| } |
| setPageComplete(validatePage()); |
| } |
| |
| /** |
| * The activity name field is either modified internally (from extractNamesFromAndroidManifest) |
| * or manually by the user when the custom_location mode is not set. |
| * |
| * Ignore the internal modification. When modified by the user, memorize the choice and |
| * validate the page. |
| */ |
| private void onActivityNameFieldModified() { |
| if (isNewProject() && !mInternalActivityNameUpdate) { |
| mUserActivityName = getActivityName(); |
| setPageComplete(validatePage()); |
| } |
| } |
| |
| /** |
| * Called when the min sdk version field has been modified. |
| * |
| * Ignore the internal modifications. When modified by the user, try to match |
| * a target with the same API level. |
| */ |
| private void onMinSdkVersionFieldModified() { |
| if (mInternalMinSdkVersionUpdate) { |
| return; |
| } |
| |
| try { |
| int version = Integer.parseInt(getMinSdkVersion()); |
| |
| // Before changing, compare with the currently selected one, if any. |
| // There can be multiple targets with the same sdk api version, so don't change |
| // it if it's already at the right version. |
| IAndroidTarget curr_target = getSdkTarget(); |
| if (curr_target != null && curr_target.getApiVersionNumber() == version) { |
| return; |
| } |
| |
| for (IAndroidTarget target : mSdkTargetSelector.getTargets()) { |
| if (target.getApiVersionNumber() == version) { |
| mSdkTargetSelector.setSelection(target); |
| break; |
| } |
| } |
| } catch (NumberFormatException e) { |
| // ignore |
| } |
| |
| mMinSdkVersionModifiedByUser = true; |
| } |
| |
| /** |
| * Called when an SDK target is modified. |
| * |
| * If the minSdkVersion field hasn't been modified by the user yet, we change it |
| * to reflect the sdk api level that has just been selected. |
| */ |
| private void onSdkTargetModified() { |
| IAndroidTarget target = getSdkTarget(); |
| |
| if (target != null && !mMinSdkVersionModifiedByUser) { |
| mInternalMinSdkVersionUpdate = true; |
| mMinSdkVersionField.setText(Integer.toString(target.getApiVersionNumber())); |
| mInternalMinSdkVersionUpdate = false; |
| } |
| } |
| |
| /** |
| * Called when the radio buttons are changed between the "create new project" and the |
| * "use existing source" mode. This reverts the fields to whatever the user manually |
| * entered before. |
| */ |
| private void updatePackageAndActivityFields() { |
| if (isNewProject()) { |
| if (mUserPackageName.length() > 0 && |
| !mPackageNameField.getText().equals(mUserPackageName)) { |
| mPackageNameField.setText(mUserPackageName); |
| } |
| |
| if (mUserActivityName.length() > 0 && |
| !mActivityNameField.getText().equals(mUserActivityName)) { |
| mInternalActivityNameUpdate = true; |
| mActivityNameField.setText(mUserActivityName); |
| mInternalActivityNameUpdate = false; |
| } |
| |
| if (mUserCreateActivityCheck != mCreateActivityCheck.getSelection()) { |
| mInternalCreateActivityUpdate = true; |
| mCreateActivityCheck.setSelection(mUserCreateActivityCheck); |
| mInternalCreateActivityUpdate = false; |
| } |
| } |
| } |
| |
| /** |
| * Extract names from an android manifest. |
| * This is done only if the user selected the "use existing source" and a manifest xml file |
| * can actually be found in the custom user directory. |
| */ |
| private void extractNamesFromAndroidManifest() { |
| if (isNewProject()) { |
| return; |
| } |
| |
| String projectLocation = getProjectLocation(); |
| File f = new File(projectLocation); |
| if (!f.isDirectory()) { |
| return; |
| } |
| |
| Path path = new Path(f.getPath()); |
| String osPath = path.append(AndroidConstants.FN_ANDROID_MANIFEST).toOSString(); |
| |
| AndroidManifestParser manifestData = AndroidManifestParser.parseForData(osPath); |
| if (manifestData == null) { |
| return; |
| } |
| |
| String packageName = null; |
| Activity activity = null; |
| String activityName = null; |
| int minSdkVersion = AndroidManifestParser.INVALID_MIN_SDK; |
| try { |
| packageName = manifestData.getPackage(); |
| minSdkVersion = manifestData.getApiLevelRequirement(); |
| |
| // try to get the first launcher activity. If none, just take the first activity. |
| activity = manifestData.getLauncherActivity(); |
| if (activity == null) { |
| Activity[] activities = manifestData.getActivities(); |
| if (activities != null && activities.length > 0) { |
| activity = activities[0]; |
| } |
| } |
| } catch (Exception e) { |
| // ignore exceptions |
| } |
| |
| if (packageName != null && packageName.length() > 0) { |
| mPackageNameField.setText(packageName); |
| } |
| |
| if (activity != null) { |
| activityName = AndroidManifestParser.extractActivityName(activity.getName(), |
| packageName); |
| } |
| |
| if (activityName != null && activityName.length() > 0) { |
| mInternalActivityNameUpdate = true; |
| mInternalCreateActivityUpdate = true; |
| mActivityNameField.setText(activityName); |
| mCreateActivityCheck.setSelection(true); |
| mInternalCreateActivityUpdate = false; |
| mInternalActivityNameUpdate = false; |
| |
| // If project name and application names are empty, use the activity |
| // name as a default. If the activity name has dots, it's a part of a |
| // package specification and only the last identifier must be used. |
| if (activityName.indexOf('.') != -1) { |
| String[] ids = activityName.split(AndroidConstants.RE_DOT); |
| activityName = ids[ids.length - 1]; |
| } |
| if (mProjectNameField.getText().length() == 0 || |
| !mProjectNameModifiedByUser) { |
| mInternalProjectNameUpdate = true; |
| mProjectNameField.setText(activityName); |
| mInternalProjectNameUpdate = false; |
| } |
| if (mApplicationNameField.getText().length() == 0 || |
| !mApplicationNameModifiedByUser) { |
| mInternalApplicationNameUpdate = true; |
| mApplicationNameField.setText(activityName); |
| mInternalApplicationNameUpdate = false; |
| } |
| } else { |
| mInternalActivityNameUpdate = true; |
| mInternalCreateActivityUpdate = true; |
| mActivityNameField.setText(""); //$NON-NLS-1$ |
| mCreateActivityCheck.setSelection(false); |
| mInternalCreateActivityUpdate = false; |
| mInternalActivityNameUpdate = false; |
| |
| // There is no activity name to use to fill in the project and application |
| // name. However if there's a package name, we can use this as a base. |
| if (packageName != null && packageName.length() > 0) { |
| // Package name is a java identifier, so it's most suitable for |
| // an application name. |
| |
| if (mApplicationNameField.getText().length() == 0 || |
| !mApplicationNameModifiedByUser) { |
| mInternalApplicationNameUpdate = true; |
| mApplicationNameField.setText(packageName); |
| mInternalApplicationNameUpdate = false; |
| } |
| |
| // For the project name, remove any dots |
| packageName = packageName.replace('.', '_'); |
| if (mProjectNameField.getText().length() == 0 || |
| !mProjectNameModifiedByUser) { |
| mInternalProjectNameUpdate = true; |
| mProjectNameField.setText(packageName); |
| mInternalProjectNameUpdate = false; |
| } |
| |
| } |
| } |
| |
| // Select the target matching the manifest's sdk or build properties, if any |
| boolean foundTarget = false; |
| |
| ProjectProperties p = ProjectProperties.create(projectLocation, null); |
| if (p != null) { |
| // Check the {build|default}.properties files if present |
| p.merge(PropertyType.BUILD).merge(PropertyType.DEFAULT); |
| String v = p.getProperty(ProjectProperties.PROPERTY_TARGET); |
| IAndroidTarget target = Sdk.getCurrent().getTargetFromHashString(v); |
| if (target != null) { |
| mSdkTargetSelector.setSelection(target); |
| foundTarget = true; |
| } |
| } |
| |
| if (!foundTarget && minSdkVersion != AndroidManifestParser.INVALID_MIN_SDK) { |
| try { |
| for (IAndroidTarget target : mSdkTargetSelector.getTargets()) { |
| if (target.getApiVersionNumber() == minSdkVersion) { |
| mSdkTargetSelector.setSelection(target); |
| foundTarget = true; |
| break; |
| } |
| } |
| } catch(NumberFormatException e) { |
| // ignore |
| } |
| } |
| |
| if (!foundTarget) { |
| for (IAndroidTarget target : mSdkTargetSelector.getTargets()) { |
| if (projectLocation.startsWith(target.getLocation())) { |
| mSdkTargetSelector.setSelection(target); |
| foundTarget = true; |
| break; |
| } |
| } |
| } |
| |
| if (!foundTarget) { |
| mInternalMinSdkVersionUpdate = true; |
| mMinSdkVersionField.setText( |
| minSdkVersion == AndroidManifestParser.INVALID_MIN_SDK ? "" : |
| Integer.toString(minSdkVersion)); //$NON-NLS-1$ |
| mInternalMinSdkVersionUpdate = false; |
| } |
| } |
| |
| /** |
| * Returns whether this page's controls currently all contain valid values. |
| * |
| * @return <code>true</code> if all controls are valid, and |
| * <code>false</code> if at least one is invalid |
| */ |
| protected boolean validatePage() { |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| |
| int status = validateProjectField(workspace); |
| if ((status & MSG_ERROR) == 0) { |
| status |= validateLocationPath(workspace); |
| } |
| if ((status & MSG_ERROR) == 0) { |
| status |= validateSdkTarget(); |
| } |
| if ((status & MSG_ERROR) == 0) { |
| status |= validatePackageField(); |
| } |
| if ((status & MSG_ERROR) == 0) { |
| status |= validateActivityField(); |
| } |
| if ((status & MSG_ERROR) == 0) { |
| status |= validateMinSdkVersionField(); |
| } |
| if ((status & MSG_ERROR) == 0) { |
| status |= validateSourceFolder(); |
| } |
| if (status == MSG_NONE) { |
| setStatus(null, MSG_NONE); |
| } |
| |
| // Return false if there's an error so that the finish button be disabled. |
| return (status & MSG_ERROR) == 0; |
| } |
| |
| /** |
| * Validates the project name field. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateProjectField(IWorkspace workspace) { |
| // Validate project field |
| String projectFieldContents = getProjectName(); |
| if (projectFieldContents.length() == 0) { |
| return setStatus("Project name must be specified", MSG_ERROR); |
| } |
| |
| // Limit the project name to shell-agnostic characters since it will be used to |
| // generate the final package |
| if (!sProjectNamePattern.matcher(projectFieldContents).matches()) { |
| return setStatus("The project name must start with an alphanumeric characters, followed by one or more alphanumerics, digits, dots, dashes, underscores or spaces.", |
| MSG_ERROR); |
| } |
| |
| IStatus nameStatus = workspace.validateName(projectFieldContents, IResource.PROJECT); |
| if (!nameStatus.isOK()) { |
| return setStatus(nameStatus.getMessage(), MSG_ERROR); |
| } |
| |
| if (getProjectHandle().exists()) { |
| return setStatus("A project with that name already exists in the workspace", |
| MSG_ERROR); |
| } |
| |
| return MSG_NONE; |
| } |
| |
| /** |
| * Validates the location path field. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateLocationPath(IWorkspace workspace) { |
| Path path = new Path(getProjectLocation()); |
| if (isNewProject()) { |
| if (!useDefaultLocation()) { |
| // If not using the default value validate the location. |
| URI uri = URIUtil.toURI(path.toOSString()); |
| IStatus locationStatus = workspace.validateProjectLocationURI(getProjectHandle(), |
| uri); |
| if (!locationStatus.isOK()) { |
| return setStatus(locationStatus.getMessage(), MSG_ERROR); |
| } else { |
| // The location is valid as far as Eclipse is concerned (i.e. mostly not |
| // an existing workspace project.) Check it either doesn't exist or is |
| // a directory that is empty. |
| File f = path.toFile(); |
| if (f.exists() && !f.isDirectory()) { |
| return setStatus("A directory name must be specified.", MSG_ERROR); |
| } else if (f.isDirectory()) { |
| // However if the directory exists, we should put a warning if it is not |
| // empty. We don't put an error (we'll ask the user again for confirmation |
| // before using the directory.) |
| String[] l = f.list(); |
| if (l.length != 0) { |
| return setStatus("The selected output directory is not empty.", |
| MSG_WARNING); |
| } |
| } |
| } |
| } else { |
| // Otherwise validate the path string is not empty |
| if (getProjectLocation().length() == 0) { |
| return setStatus("A directory name must be specified.", MSG_ERROR); |
| } |
| |
| File dest = path.append(getProjectName()).toFile(); |
| if (dest.exists()) { |
| return setStatus(String.format("There is already a file or directory named \"%1$s\" in the selected location.", |
| getProjectName()), MSG_ERROR); |
| } |
| } |
| } else { |
| // Must be an existing directory |
| File f = path.toFile(); |
| if (!f.isDirectory()) { |
| return setStatus("An existing directory name must be specified.", MSG_ERROR); |
| } |
| |
| // Check there's an android manifest in the directory |
| String osPath = path.append(AndroidConstants.FN_ANDROID_MANIFEST).toOSString(); |
| File manifestFile = new File(osPath); |
| if (!manifestFile.isFile()) { |
| return setStatus( |
| String.format("File %1$s not found in %2$s.", |
| AndroidConstants.FN_ANDROID_MANIFEST, f.getName()), |
| MSG_ERROR); |
| } |
| |
| // Parse it and check the important fields. |
| AndroidManifestParser manifestData = AndroidManifestParser.parseForData(osPath); |
| if (manifestData == null) { |
| return setStatus( |
| String.format("File %1$s could not be parsed.", osPath), |
| MSG_ERROR); |
| } |
| |
| String packageName = manifestData.getPackage(); |
| if (packageName == null || packageName.length() == 0) { |
| return setStatus( |
| String.format("No package name defined in %1$s.", osPath), |
| MSG_ERROR); |
| } |
| |
| Activity[] activities = manifestData.getActivities(); |
| if (activities == null || activities.length == 0) { |
| // This is acceptable now as long as no activity needs to be created |
| if (isCreateActivity()) { |
| return setStatus( |
| String.format("No activity name defined in %1$s.", osPath), |
| MSG_ERROR); |
| } |
| } |
| |
| // If there's already a .project, tell the user to use import instead. |
| if (path.append(".project").toFile().exists()) { //$NON-NLS-1$ |
| return setStatus("An Eclipse project already exists in this directory. Consider using File > Import > Existing Project instead.", |
| MSG_WARNING); |
| } |
| } |
| |
| return MSG_NONE; |
| } |
| |
| /** |
| * Validates the sdk target choice. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateSdkTarget() { |
| if (getSdkTarget() == null) { |
| return setStatus("An SDK Target must be specified.", MSG_ERROR); |
| } |
| return MSG_NONE; |
| } |
| |
| /** |
| * Validates the sdk target choice. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateMinSdkVersionField() { |
| |
| // If the min sdk version is empty, it is always accepted. |
| if (getMinSdkVersion().length() == 0) { |
| return MSG_NONE; |
| } |
| |
| int version = AndroidManifestParser.INVALID_MIN_SDK; |
| try { |
| // If not empty, it must be a valid integer > 0 |
| version = Integer.parseInt(getMinSdkVersion()); |
| } catch (NumberFormatException e) { |
| // ignore |
| } |
| |
| if (version < 1) { |
| return setStatus("Min SDK Version must be an integer > 0.", MSG_ERROR); |
| } |
| |
| if (getSdkTarget() != null && getSdkTarget().getApiVersionNumber() != version) { |
| return setStatus("The API level for the selected SDK target does not match the Min SDK version.", |
| MSG_WARNING); |
| } |
| |
| return MSG_NONE; |
| } |
| |
| /** |
| * Validates the activity name field. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateActivityField() { |
| // Disregard if not creating an activity |
| if (!isCreateActivity()) { |
| return MSG_NONE; |
| } |
| |
| // Validate activity field |
| String activityFieldContents = getActivityName(); |
| if (activityFieldContents.length() == 0) { |
| return setStatus("Activity name must be specified.", MSG_ERROR); |
| } |
| |
| // The activity field can actually contain part of a sub-package name |
| // or it can start with a dot "." to indicates it comes from the parent package name. |
| String packageName = ""; |
| int pos = activityFieldContents.lastIndexOf('.'); |
| if (pos >= 0) { |
| packageName = activityFieldContents.substring(0, pos); |
| if (packageName.startsWith(".")) { //$NON-NLS-1$ |
| packageName = packageName.substring(1); |
| } |
| |
| activityFieldContents = activityFieldContents.substring(pos + 1); |
| } |
| |
| // the activity field can contain a simple java identifier, or a |
| // package name or one that starts with a dot. So if it starts with a dot, |
| // ignore this dot -- the rest must look like a package name. |
| if (activityFieldContents.charAt(0) == '.') { |
| activityFieldContents = activityFieldContents.substring(1); |
| } |
| |
| // Check it's a valid activity string |
| int result = MSG_NONE; |
| IStatus status = JavaConventions.validateTypeVariableName(activityFieldContents, |
| "1.5", "1.5"); //$NON-NLS-1$ $NON-NLS-2$ |
| if (!status.isOK()) { |
| result = setStatus(status.getMessage(), |
| status.getSeverity() == IStatus.ERROR ? MSG_ERROR : MSG_WARNING); |
| } |
| |
| // Check it's a valid package string |
| if (result != MSG_ERROR && packageName.length() > 0) { |
| status = JavaConventions.validatePackageName(packageName, |
| "1.5", "1.5"); //$NON-NLS-1$ $NON-NLS-2$ |
| if (!status.isOK()) { |
| result = setStatus(status.getMessage() + " (in the activity name)", |
| status.getSeverity() == IStatus.ERROR ? MSG_ERROR : MSG_WARNING); |
| } |
| } |
| |
| |
| return result; |
| } |
| |
| /** |
| * Validates the package name field. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validatePackageField() { |
| // Validate package field |
| String packageFieldContents = getPackageName(); |
| if (packageFieldContents.length() == 0) { |
| return setStatus("Package name must be specified.", MSG_ERROR); |
| } |
| |
| // Check it's a valid package string |
| int result = MSG_NONE; |
| IStatus status = JavaConventions.validatePackageName(packageFieldContents, "1.5", "1.5"); //$NON-NLS-1$ $NON-NLS-2$ |
| if (!status.isOK()) { |
| result = setStatus(status.getMessage(), |
| status.getSeverity() == IStatus.ERROR ? MSG_ERROR : MSG_WARNING); |
| } |
| |
| // The Android Activity Manager does not accept packages names with only one |
| // identifier. Check the package name has at least one dot in them (the previous rule |
| // validated that if such a dot exist, it's not the first nor last characters of the |
| // string.) |
| if (result != MSG_ERROR && packageFieldContents.indexOf('.') == -1) { |
| return setStatus("Package name must have at least two identifiers.", MSG_ERROR); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Validates that an existing project actually has a source folder. |
| * |
| * For project in "use existing source" mode, this tries to find the source folder. |
| * A source folder should be just under the project directory and it should have all |
| * the directories composing the package+activity name. |
| * |
| * As a side effect, it memorizes the source folder in mSourceFolder. |
| * |
| * TODO: support multiple source folders for multiple activities. |
| * |
| * @return The wizard message type, one of MSG_ERROR, MSG_WARNING or MSG_NONE. |
| */ |
| private int validateSourceFolder() { |
| // This check does nothing when creating a new project. |
| // This check is also useless when no activity is present or created. |
| if (isNewProject() || !isCreateActivity()) { |
| return MSG_NONE; |
| } |
| |
| String osTarget = getActivityName(); |
| |
| if (osTarget.indexOf('.') == -1) { |
| osTarget = getPackageName() + File.separator + osTarget; |
| } else if (osTarget.indexOf('.') == 0) { |
| osTarget = getPackageName() + osTarget; |
| } |
| osTarget = osTarget.replace('.', File.separatorChar) + AndroidConstants.DOT_JAVA; |
| |
| String projectPath = getProjectLocation(); |
| File projectDir = new File(projectPath); |
| File[] all_dirs = projectDir.listFiles(new FileFilter() { |
| public boolean accept(File pathname) { |
| return pathname.isDirectory(); |
| } |
| }); |
| for (File f : all_dirs) { |
| Path path = new Path(f.getAbsolutePath()); |
| File java_activity = path.append(osTarget).toFile(); |
| if (java_activity.isFile()) { |
| mSourceFolder = f.getName(); |
| return MSG_NONE; |
| } |
| } |
| |
| if (all_dirs.length > 0) { |
| return setStatus( |
| String.format("%1$s can not be found under %2$s.", osTarget, projectPath), |
| MSG_ERROR); |
| } else { |
| return setStatus( |
| String.format("No source folders can be found in %1$s.", projectPath), |
| MSG_ERROR); |
| } |
| } |
| |
| /** |
| * Sets the error message for the wizard with the given message icon. |
| * |
| * @param message The wizard message type, one of MSG_ERROR or MSG_WARNING. |
| * @return As a convenience, always returns messageType so that the caller can return |
| * immediately. |
| */ |
| private int setStatus(String message, int messageType) { |
| if (message == null) { |
| setErrorMessage(null); |
| setMessage(null); |
| } else if (!message.equals(getMessage())) { |
| setMessage(message, messageType == MSG_WARNING ? WizardPage.WARNING : WizardPage.ERROR); |
| } |
| return messageType; |
| } |
| |
| } |
