| /* |
| * Copyright (C) 2011 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. |
| */ |
| package com.android.ide.eclipse.adt.internal.wizards.newproject; |
| |
| import com.android.SdkConstants; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk.ITargetChangeListener; |
| import com.android.ide.eclipse.adt.internal.wizards.newproject.NewProjectWizardState.Mode; |
| import com.android.sdklib.IAndroidTarget; |
| |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.resources.IProject; |
| 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.Status; |
| import org.eclipse.jdt.core.JavaConventions; |
| import org.eclipse.jface.dialogs.IMessageProvider; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| 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.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| |
| import java.io.File; |
| import java.io.FileFilter; |
| import java.net.URI; |
| |
| /** Page where you choose the application name, activity name, and optional test project info */ |
| public class ApplicationInfoPage extends WizardPage implements SelectionListener, ModifyListener, |
| ITargetChangeListener { |
| private static final String JDK_15 = "1.5"; //$NON-NLS-1$ |
| private final static String DUMMY_PACKAGE = "your.package.namespace"; |
| |
| /** Suffix added by default to activity names */ |
| static final String ACTIVITY_NAME_SUFFIX = "Activity"; //$NON-NLS-1$ |
| |
| private final NewProjectWizardState mValues; |
| |
| private Text mApplicationText; |
| private Text mPackageText; |
| private Text mActivityText; |
| private Button mCreateActivityCheckbox; |
| private Combo mSdkCombo; |
| |
| private boolean mIgnore; |
| private Button mCreateTestCheckbox; |
| private Text mTestProjectNameText; |
| private Text mTestApplicationText; |
| private Text mTestPackageText; |
| private Label mTestProjectNameLabel; |
| private Label mTestApplicationLabel; |
| private Label mTestPackageLabel; |
| |
| /** |
| * Create the wizard. |
| */ |
| ApplicationInfoPage(NewProjectWizardState values) { |
| super("appInfo"); //$NON-NLS-1$ |
| mValues = values; |
| |
| setTitle("Application Info"); |
| setDescription("Configure the new Android Project"); |
| AdtPlugin.getDefault().addTargetListener(this); |
| } |
| |
| /** |
| * Create contents of the wizard. |
| */ |
| @Override |
| @SuppressWarnings("unused") // Eclipse marks SWT constructors with side effects as unused |
| public void createControl(Composite parent) { |
| Composite container = new Composite(parent, SWT.NULL); |
| container.setLayout(new GridLayout(2, false)); |
| |
| Label applicationLabel = new Label(container, SWT.NONE); |
| applicationLabel.setText("Application Name:"); |
| |
| mApplicationText = new Text(container, SWT.BORDER); |
| mApplicationText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mApplicationText.addModifyListener(this); |
| |
| Label packageLabel = new Label(container, SWT.NONE); |
| packageLabel.setText("Package Name:"); |
| |
| mPackageText = new Text(container, SWT.BORDER); |
| mPackageText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mPackageText.addModifyListener(this); |
| |
| if (mValues.mode != Mode.TEST) { |
| mCreateActivityCheckbox = new Button(container, SWT.CHECK); |
| mCreateActivityCheckbox.setText("Create Activity:"); |
| mCreateActivityCheckbox.addSelectionListener(this); |
| |
| mActivityText = new Text(container, SWT.BORDER); |
| mActivityText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mActivityText.addModifyListener(this); |
| } |
| |
| Label minSdkLabel = new Label(container, SWT.NONE); |
| minSdkLabel.setText("Minimum SDK:"); |
| |
| mSdkCombo = new Combo(container, SWT.NONE); |
| GridData gdSdkCombo = new GridData(SWT.LEFT, SWT.CENTER, true, false, 1, 1); |
| gdSdkCombo.widthHint = 200; |
| mSdkCombo.setLayoutData(gdSdkCombo); |
| mSdkCombo.addSelectionListener(this); |
| mSdkCombo.addModifyListener(this); |
| |
| onSdkLoaded(); |
| |
| setControl(container); |
| new Label(container, SWT.NONE); |
| new Label(container, SWT.NONE); |
| |
| mCreateTestCheckbox = new Button(container, SWT.CHECK); |
| mCreateTestCheckbox.setLayoutData(new GridData(SWT.LEFT, SWT.CENTER, false, false, 2, 1)); |
| mCreateTestCheckbox.setText("Create a Test Project"); |
| mCreateTestCheckbox.addSelectionListener(this); |
| |
| mTestProjectNameLabel = new Label(container, SWT.NONE); |
| mTestProjectNameLabel.setText("Test Project Name:"); |
| |
| mTestProjectNameText = new Text(container, SWT.BORDER); |
| mTestProjectNameText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mTestProjectNameText.addModifyListener(this); |
| |
| mTestApplicationLabel = new Label(container, SWT.NONE); |
| mTestApplicationLabel.setText("Test Application:"); |
| |
| mTestApplicationText = new Text(container, SWT.BORDER); |
| mTestApplicationText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mTestApplicationText.addModifyListener(this); |
| |
| mTestPackageLabel = new Label(container, SWT.NONE); |
| mTestPackageLabel.setText("Test Package:"); |
| |
| mTestPackageText = new Text(container, SWT.BORDER); |
| mTestPackageText.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); |
| mTestPackageText.addModifyListener(this); |
| } |
| |
| /** Controls whether the options for creating a paired test project should be shown */ |
| private void showTestOptions(boolean visible) { |
| if (mValues.mode == Mode.SAMPLE) { |
| visible = false; |
| } |
| |
| mCreateTestCheckbox.setVisible(visible); |
| mTestProjectNameLabel.setVisible(visible); |
| mTestProjectNameText.setVisible(visible); |
| mTestApplicationLabel.setVisible(visible); |
| mTestApplicationText.setVisible(visible); |
| mTestPackageLabel.setVisible(visible); |
| mTestPackageText.setVisible(visible); |
| } |
| |
| /** Controls whether the options for creating a paired test project should be enabled */ |
| private void enableTestOptions(boolean enabled) { |
| mTestProjectNameLabel.setEnabled(enabled); |
| mTestProjectNameText.setEnabled(enabled); |
| mTestApplicationLabel.setEnabled(enabled); |
| mTestApplicationText.setEnabled(enabled); |
| mTestPackageLabel.setEnabled(enabled); |
| mTestPackageText.setEnabled(enabled); |
| } |
| |
| @Override |
| public void setVisible(boolean visible) { |
| super.setVisible(visible); |
| |
| if (visible) { |
| try { |
| mIgnore = true; |
| if (mValues.applicationName != null) { |
| mApplicationText.setText(mValues.applicationName); |
| } |
| if (mValues.packageName != null) { |
| mPackageText.setText(mValues.packageName); |
| } else { |
| mPackageText.setText(DUMMY_PACKAGE); |
| } |
| |
| if (mValues.mode != Mode.TEST) { |
| mCreateActivityCheckbox.setSelection(mValues.createActivity); |
| mActivityText.setEnabled(mValues.createActivity); |
| if (mValues.activityName != null) { |
| mActivityText.setText(mValues.activityName); |
| } |
| } |
| if (mValues.minSdk != null && mValues.minSdk.length() > 0) { |
| mSdkCombo.setText(mValues.minSdk); |
| } |
| |
| showTestOptions(mValues.mode == Mode.ANY); |
| enableTestOptions(mCreateTestCheckbox.getSelection()); |
| |
| if (mValues.testProjectName != null) { |
| mTestProjectNameText.setText(mValues.testProjectName); |
| } |
| if (mValues.testApplicationName != null) { |
| mTestApplicationText.setText(mValues.testApplicationName); |
| } |
| if (mValues.testProjectName != null) { |
| mTestPackageText.setText(mValues.testProjectName); |
| } |
| } finally { |
| mIgnore = false; |
| } |
| } |
| |
| // Start focus with the package name, since the other fields are typically assigned |
| // reasonable defaults |
| mPackageText.setFocus(); |
| mPackageText.selectAll(); |
| |
| validatePage(); |
| } |
| |
| protected void setSdkTargets(IAndroidTarget[] targets, IAndroidTarget target) { |
| if (targets == null) { |
| targets = new IAndroidTarget[0]; |
| } |
| int selectionIndex = -1; |
| String[] items = new String[targets.length]; |
| for (int i = 0, n = targets.length; i < n; i++) { |
| items[i] = targetLabel(targets[i]); |
| if (targets[i] == target) { |
| selectionIndex = i; |
| } |
| } |
| try { |
| mIgnore = true; |
| mSdkCombo.setItems(items); |
| mSdkCombo.setData(targets); |
| if (selectionIndex != -1) { |
| mSdkCombo.select(selectionIndex); |
| } |
| } finally { |
| mIgnore = false; |
| } |
| } |
| |
| private String targetLabel(IAndroidTarget target) { |
| // In the minimum SDK chooser, show the targets with api number and description, |
| // such as "11 (Android 3.0)" |
| return String.format("%1$s (%2$s)", target.getVersion().getApiString(), |
| target.getFullName()); |
| } |
| |
| @Override |
| public void dispose() { |
| AdtPlugin.getDefault().removeTargetListener(this); |
| super.dispose(); |
| } |
| |
| @Override |
| public boolean isPageComplete() { |
| // This page is only needed when creating new projects |
| if (mValues.useExisting || mValues.mode != Mode.ANY) { |
| return true; |
| } |
| |
| // Ensure that we reach this page |
| if (mValues.packageName == null) { |
| return false; |
| } |
| |
| return super.isPageComplete(); |
| } |
| |
| @Override |
| public void modifyText(ModifyEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| if (source == mSdkCombo) { |
| mValues.minSdk = mSdkCombo.getText().trim(); |
| IAndroidTarget[] targets = (IAndroidTarget[]) mSdkCombo.getData(); |
| // An editable combo will treat item selection the same way as a user edit, |
| // so we need to see if the string looks like a labeled version |
| int index = mSdkCombo.getSelectionIndex(); |
| if (index != -1) { |
| if (index >= 0 && index < targets.length) { |
| IAndroidTarget target = targets[index]; |
| if (targetLabel(target).equals(mValues.minSdk)) { |
| mValues.minSdk = target.getVersion().getApiString(); |
| } |
| } |
| } |
| |
| // Ensure that we never pick up the (Android x.y) suffix shown in combobox |
| // for readability |
| int separator = mValues.minSdk.indexOf(' '); |
| if (separator != -1) { |
| mValues.minSdk = mValues.minSdk.substring(0, separator); |
| } |
| mValues.minSdkModifiedByUser = true; |
| mValues.updateSdkTargetToMatchMinSdkVersion(); |
| } else if (source == mApplicationText) { |
| mValues.applicationName = mApplicationText.getText().trim(); |
| mValues.applicationNameModifiedByUser = true; |
| |
| if (!mValues.testApplicationNameModified) { |
| mValues.testApplicationName = suggestTestApplicationName(mValues.applicationName); |
| try { |
| mIgnore = true; |
| mTestApplicationText.setText(mValues.testApplicationName); |
| } finally { |
| mIgnore = false; |
| } |
| } |
| |
| } else if (source == mPackageText) { |
| mValues.packageName = mPackageText.getText().trim(); |
| mValues.packageNameModifiedByUser = true; |
| |
| if (!mValues.testPackageModified) { |
| mValues.testPackageName = suggestTestPackage(mValues.packageName); |
| try { |
| mIgnore = true; |
| mTestPackageText.setText(mValues.testPackageName); |
| } finally { |
| mIgnore = false; |
| } |
| } |
| } else if (source == mActivityText) { |
| mValues.activityName = mActivityText.getText().trim(); |
| mValues.activityNameModifiedByUser = true; |
| } else if (source == mTestApplicationText) { |
| mValues.testApplicationName = mTestApplicationText.getText().trim(); |
| mValues.testApplicationNameModified = true; |
| } else if (source == mTestPackageText) { |
| mValues.testPackageName = mTestPackageText.getText().trim(); |
| mValues.testPackageModified = true; |
| } else if (source == mTestProjectNameText) { |
| mValues.testProjectName = mTestProjectNameText.getText().trim(); |
| mValues.testProjectModified = true; |
| } |
| |
| validatePage(); |
| } |
| |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| if (mIgnore) { |
| return; |
| } |
| |
| Object source = e.getSource(); |
| |
| if (source == mCreateActivityCheckbox) { |
| mValues.createActivity = mCreateActivityCheckbox.getSelection(); |
| mActivityText.setEnabled(mValues.createActivity); |
| } else if (source == mSdkCombo) { |
| int index = mSdkCombo.getSelectionIndex(); |
| IAndroidTarget[] targets = (IAndroidTarget[]) mSdkCombo.getData(); |
| if (index != -1) { |
| if (index >= 0 && index < targets.length) { |
| IAndroidTarget target = targets[index]; |
| // Even though we are showing the logical version name, we place the |
| // actual api number as the minimum SDK |
| mValues.minSdk = target.getVersion().getApiString(); |
| } |
| } else { |
| String text = mSdkCombo.getText(); |
| boolean found = false; |
| for (IAndroidTarget target : targets) { |
| if (targetLabel(target).equals(text)) { |
| mValues.minSdk = target.getVersion().getApiString(); |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| mValues.minSdk = text; |
| } |
| } |
| } else if (source == mCreateTestCheckbox) { |
| mValues.createPairProject = mCreateTestCheckbox.getSelection(); |
| enableTestOptions(mValues.createPairProject); |
| if (mValues.createPairProject) { |
| if (mValues.testProjectName == null || mValues.testProjectName.length() == 0) { |
| mValues.testProjectName = suggestTestProjectName(mValues.projectName); |
| } |
| if (mValues.testApplicationName == null || |
| mValues.testApplicationName.length() == 0) { |
| mValues.testApplicationName = |
| suggestTestApplicationName(mValues.applicationName); |
| } |
| if (mValues.testPackageName == null || mValues.testPackageName.length() == 0) { |
| mValues.testPackageName = suggestTestPackage(mValues.packageName); |
| } |
| |
| try { |
| mIgnore = true; |
| mTestProjectNameText.setText(mValues.testProjectName); |
| mTestApplicationText.setText(mValues.testApplicationName); |
| mTestPackageText.setText(mValues.testPackageName); |
| } finally { |
| mIgnore = false; |
| } |
| } |
| } |
| |
| validatePage(); |
| } |
| |
| @Override |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| |
| private void validatePage() { |
| IStatus status = validatePackage(mValues.packageName); |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| IStatus validActivity = validateActivity(); |
| if (validActivity != null) { |
| status = validActivity; |
| } |
| } |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| IStatus validMinSdk = validateMinSdk(); |
| if (validMinSdk != null) { |
| status = validMinSdk; |
| } |
| } |
| |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| IStatus validSourceFolder = validateSourceFolder(); |
| if (validSourceFolder != null) { |
| status = validSourceFolder; |
| } |
| } |
| |
| // If creating a test project to go along with the main project, also validate |
| // the additional test project parameters |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| if (mValues.createPairProject) { |
| IStatus validTestProject = ProjectNamePage.validateProjectName( |
| mValues.testProjectName); |
| if (validTestProject != null) { |
| status = validTestProject; |
| } |
| |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| IStatus validTestLocation = validateTestProjectLocation(); |
| if (validTestLocation != null) { |
| status = validTestLocation; |
| } |
| } |
| |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| IStatus validTestPackage = validatePackage(mValues.testPackageName); |
| if (validTestPackage != null) { |
| status = new Status(validTestPackage.getSeverity(), |
| AdtPlugin.PLUGIN_ID, |
| validTestPackage.getMessage() + " (in test package)"); |
| } |
| } |
| |
| if (status == null || status.getSeverity() != IStatus.ERROR) { |
| if (mValues.projectName.equals(mValues.testProjectName)) { |
| status = new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "The main project name and the test project name must be different."); |
| } |
| } |
| } |
| } |
| |
| // -- update UI & enable finish if there's no error |
| setPageComplete(status == null || status.getSeverity() != IStatus.ERROR); |
| if (status != null) { |
| setMessage(status.getMessage(), |
| status.getSeverity() == IStatus.ERROR |
| ? IMessageProvider.ERROR : IMessageProvider.WARNING); |
| } else { |
| setErrorMessage(null); |
| setMessage(null); |
| } |
| } |
| |
| private IStatus validateTestProjectLocation() { |
| assert mValues.createPairProject; |
| |
| // Validate location |
| Path path = new Path(mValues.projectLocation.getPath()); |
| if (!mValues.useExisting) { |
| if (!mValues.useDefaultLocation) { |
| // If not using the default value validate the location. |
| URI uri = URIUtil.toURI(path.toOSString()); |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IProject handle = workspace.getRoot().getProject(mValues.testProjectName); |
| IStatus locationStatus = workspace.validateProjectLocationURI(handle, uri); |
| if (!locationStatus.isOK()) { |
| return locationStatus; |
| } |
| // 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 new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "A directory name must be specified."); |
| } 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 != null && l.length != 0) { |
| return new Status(IStatus.WARNING, AdtPlugin.PLUGIN_ID, |
| "The selected output directory is not empty."); |
| } |
| } |
| } else { |
| IPath destPath = path.removeLastSegments(1).append(mValues.testProjectName); |
| File dest = destPath.toFile(); |
| if (dest.exists()) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format( |
| "There is already a file or directory named \"%1$s\" in the selected location.", |
| mValues.testProjectName)); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private IStatus validateSourceFolder() { |
| // This check does nothing when creating a new project. |
| // This check is also useless when no activity is present or created. |
| mValues.sourceFolder = SdkConstants.FD_SOURCES; |
| if (!mValues.useExisting || !mValues.createActivity) { |
| return null; |
| } |
| |
| String osTarget = mValues.activityName; |
| if (osTarget.indexOf('.') == -1) { |
| osTarget = mValues.packageName + File.separator + osTarget; |
| } else if (osTarget.indexOf('.') == 0) { |
| osTarget = mValues.packageName + osTarget; |
| } |
| osTarget = osTarget.replace('.', File.separatorChar) + SdkConstants.DOT_JAVA; |
| |
| File projectDir = mValues.projectLocation; |
| File[] allDirs = projectDir.listFiles(new FileFilter() { |
| @Override |
| public boolean accept(File pathname) { |
| return pathname.isDirectory(); |
| } |
| }); |
| if (allDirs != null) { |
| boolean found = false; |
| for (File f : allDirs) { |
| Path path = new Path(f.getAbsolutePath()); |
| File java_activity = path.append(osTarget).toFile(); |
| if (java_activity.isFile()) { |
| mValues.sourceFolder = f.getName(); |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| String projectPath = projectDir.getPath(); |
| if (allDirs.length > 0) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format("%1$s can not be found under %2$s.", osTarget, |
| projectPath)); |
| } else { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format("No source folders can be found in %1$s.", |
| projectPath)); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private IStatus validateMinSdk() { |
| // Validate min SDK field |
| // If the min sdk version is empty, it is always accepted. |
| if (mValues.minSdk == null || mValues.minSdk.length() == 0) { |
| return null; |
| } |
| |
| IAndroidTarget target = mValues.target; |
| if (target == null) { |
| return null; |
| } |
| |
| // If the current target is a preview, explicitly indicate minSdkVersion |
| // must be set to this target name. |
| if (target.getVersion().isPreview() && !target.getVersion().equals(mValues.minSdk)) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| String.format( |
| "The SDK target is a preview. Min SDK Version must be set to '%s'.", |
| target.getVersion().getCodename())); |
| } |
| |
| if (!target.getVersion().equals(mValues.minSdk)) { |
| return new Status(target.getVersion().isPreview() ? IStatus.ERROR : IStatus.WARNING, |
| AdtPlugin.PLUGIN_ID, |
| "The API level for the selected SDK target does not match the Min SDK Version." |
| ); |
| } |
| |
| return null; |
| } |
| |
| public static IStatus validatePackage(String packageFieldContents) { |
| // Validate package |
| if (packageFieldContents == null || packageFieldContents.length() == 0) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Package name must be specified."); |
| } else if (packageFieldContents.equals(DUMMY_PACKAGE)) { |
| // The dummy package name is just a placeholder package (which isn't even valid |
| // because it contains the reserved Java keyword "package") but we want to |
| // make the error message say that a proper package should be entered rather than |
| // what's wrong with this specific package. (And the reason we provide a dummy |
| // package rather than a blank line is to make it more clear to beginners what |
| // we're looking for. |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Package name must be specified."); |
| } |
| // Check it's a valid package string |
| IStatus status = JavaConventions.validatePackageName(packageFieldContents, JDK_15, |
| JDK_15); |
| if (!status.isOK()) { |
| return status; |
| } |
| |
| // 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 (packageFieldContents.indexOf('.') == -1) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Package name must have at least two identifiers."); |
| } |
| |
| return null; |
| } |
| |
| public static IStatus validateClass(String className) { |
| if (className == null || className.length() == 0) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Class name must be specified."); |
| } |
| if (className.indexOf('.') != -1) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Enter just a class name, not a full package name"); |
| } |
| return JavaConventions.validateJavaTypeName(className, JDK_15, JDK_15); |
| } |
| |
| private IStatus validateActivity() { |
| // Validate activity (if creating an activity) |
| if (!mValues.createActivity) { |
| return null; |
| } |
| |
| return validateActivity(mValues.activityName); |
| } |
| |
| /** |
| * Validates the given activity name |
| * |
| * @param activityFieldContents the activity name to validate |
| * @return a status for whether the activity name is valid |
| */ |
| public static IStatus validateActivity(String activityFieldContents) { |
| // Validate activity field |
| if (activityFieldContents == null || activityFieldContents.length() == 0) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Activity name must be specified."); |
| } else if (ACTIVITY_NAME_SUFFIX.equals(activityFieldContents)) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, "Enter a valid activity name"); |
| } else if (activityFieldContents.contains("..")) { //$NON-NLS-1$ |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| "Package segments in activity name cannot be empty (..)"); |
| } |
| // 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 = ""; //$NON-NLS-1$ |
| 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.length() > 0 && activityFieldContents.charAt(0) == '.') { |
| activityFieldContents = activityFieldContents.substring(1); |
| } |
| |
| // Check it's a valid activity string |
| IStatus status = JavaConventions.validateTypeVariableName(activityFieldContents, JDK_15, |
| JDK_15); |
| if (!status.isOK()) { |
| return status; |
| } |
| |
| // Check it's a valid package string |
| if (packageName.length() > 0) { |
| status = JavaConventions.validatePackageName(packageName, JDK_15, JDK_15); |
| if (!status.isOK()) { |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| status.getMessage() + " (in the activity name)"); |
| } |
| } |
| |
| return null; |
| } |
| |
| // ---- Implement ITargetChangeListener ---- |
| |
| @Override |
| public void onSdkLoaded() { |
| if (mSdkCombo == null) { |
| return; |
| } |
| |
| // 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(); |
| } |
| setSdkTargets(targets, mValues.target); |
| } |
| |
| @Override |
| public void onProjectTargetChange(IProject changedProject) { |
| // Ignore |
| } |
| |
| @Override |
| public void onTargetLoaded(IAndroidTarget target) { |
| // Ignore |
| } |
| |
| public static String suggestTestApplicationName(String applicationName) { |
| if (applicationName == null) { |
| applicationName = ""; //$NON-NLS-1$ |
| } |
| if (applicationName.indexOf(' ') != -1) { |
| return applicationName + " Test"; //$NON-NLS-1$ |
| } else { |
| return applicationName + "Test"; //$NON-NLS-1$ |
| } |
| } |
| |
| public static String suggestTestProjectName(String projectName) { |
| if (projectName == null) { |
| projectName = ""; //$NON-NLS-1$ |
| } |
| if (projectName.length() > 0 && Character.isUpperCase(projectName.charAt(0))) { |
| return projectName + "Test"; //$NON-NLS-1$ |
| } else { |
| return projectName + "-test"; //$NON-NLS-1$ |
| } |
| } |
| |
| |
| public static String suggestTestPackage(String packagePath) { |
| if (packagePath == null) { |
| packagePath = ""; //$NON-NLS-1$ |
| } |
| return packagePath + ".test"; //$NON-NLS-1$ |
| } |
| } |
