| /* |
| * 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.annotations.Nullable; |
| import com.android.ide.common.xml.ManifestData; |
| import com.android.ide.common.xml.ManifestData.Activity; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.internal.project.AndroidManifestHelper; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.internal.project.ProjectProperties; |
| import com.android.sdklib.internal.project.ProjectProperties.PropertyType; |
| import com.android.utils.Pair; |
| import com.android.xml.AndroidManifest; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.ui.IWorkingSet; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * The {@link NewProjectWizardState} holds the state used by the various pages |
| * in the {@link NewProjectWizard} and its variations, and it can also be used |
| * to pass project information to the {@link NewProjectCreator}. |
| */ |
| public class NewProjectWizardState { |
| /** The mode to run the wizard in: creating test, or sample, or plain project */ |
| public Mode mode; |
| |
| /** |
| * If true, the project should be created from an existing codebase (pointed |
| * to by the {@link #projectLocation} or in the case of sample projects, the |
| * {@link #chosenSample}. Otherwise, create a brand new project from scratch. |
| */ |
| public boolean useExisting; |
| |
| /** |
| * Whether new projects should be created into the default project location |
| * (e.g. in the Eclipse workspace) or not |
| */ |
| public boolean useDefaultLocation = true; |
| |
| /** The build target SDK */ |
| public IAndroidTarget target; |
| /** True if the user has manually modified the target */ |
| public boolean targetModifiedByUser; |
| |
| /** The location to store projects into */ |
| public File projectLocation = new File(Platform.getLocation().toOSString()); |
| /** True if the project location name has been manually edited by the user */ |
| public boolean projectLocationModifiedByUser; |
| |
| /** The name of the project */ |
| public String projectName = ""; //$NON-NLS-1$ |
| /** True if the project name has been manually edited by the user */ |
| public boolean projectNameModifiedByUser; |
| |
| /** The application name */ |
| public String applicationName; |
| /** True if the application name has been manually edited by the user */ |
| public boolean applicationNameModifiedByUser; |
| |
| /** The package path */ |
| public String packageName; |
| /** True if the package name has been manually edited by the user */ |
| public boolean packageNameModifiedByUser; |
| |
| /** True if a new activity should be created */ |
| public boolean createActivity; |
| |
| /** The name of the new activity to be created */ |
| public String activityName; |
| /** True if the activity name has been manually edited by the user */ |
| public boolean activityNameModifiedByUser; |
| |
| /** The minimum SDK version to use with the project (may be null or blank) */ |
| public String minSdk; |
| /** True if the minimum SDK version has been manually edited by the user */ |
| public boolean minSdkModifiedByUser; |
| /** |
| * A list of paths to each of the available samples for the current SDK. |
| * The pair is (String: sample display name => File: sample directory). |
| * Note we want a list, not a map since we might have duplicates. |
| * */ |
| public List<Pair<String, File>> samples = new ArrayList<Pair<String, File>>(); |
| /** Path to the currently chosen sample */ |
| public File chosenSample; |
| |
| /** The name of the source folder, relative to the project root */ |
| public String sourceFolder = SdkConstants.FD_SOURCES; |
| /** The set of chosen working sets to use when creating the project */ |
| public IWorkingSet[] workingSets = new IWorkingSet[0]; |
| |
| /** |
| * A reference to a different project that the current test project will be |
| * testing. |
| */ |
| public IProject testedProject; |
| /** |
| * If true, this test project should be testing itself, otherwise it will be |
| * testing the project pointed to by {@link #testedProject}. |
| */ |
| public boolean testingSelf; |
| |
| // NOTE: These apply only to creating paired projects; when isTest is true |
| // we're using |
| // the normal fields above |
| /** |
| * If true, create a test project along with this plain project which will |
| * be testing the plain project. (This flag only applies when creating |
| * normal projects.) |
| */ |
| public boolean createPairProject; |
| /** |
| * The application name of the test application (only applies when |
| * {@link #createPairProject} is true) |
| */ |
| public String testApplicationName; |
| /** |
| * True if the testing application name has been modified by the user (only |
| * applies when {@link #createPairProject} is true) |
| */ |
| public boolean testApplicationNameModified; |
| /** |
| * The package name of the test application (only applies when |
| * {@link #createPairProject} is true) |
| */ |
| public String testPackageName; |
| /** |
| * True if the testing package name has been modified by the user (only |
| * applies when {@link #createPairProject} is true) |
| */ |
| public boolean testPackageModified; |
| /** |
| * The project name of the test project (only applies when |
| * {@link #createPairProject} is true) |
| */ |
| public String testProjectName; |
| /** |
| * True if the testing project name has been modified by the user (only |
| * applies when {@link #createPairProject} is true) |
| */ |
| public boolean testProjectModified; |
| /** Package name of the tested app */ |
| public String testTargetPackageName; |
| |
| /** |
| * Copy project into workspace? This flag only applies when importing |
| * projects (creating projects from existing source) |
| */ |
| public boolean copyIntoWorkspace; |
| |
| /** |
| * List of projects to be imported. Null if not importing projects. |
| */ |
| @Nullable |
| public List<ImportedProject> importProjects; |
| |
| /** |
| * Creates a new {@link NewProjectWizardState} |
| * |
| * @param mode the mode to run the wizard in |
| */ |
| public NewProjectWizardState(Mode mode) { |
| this.mode = mode; |
| if (mode == Mode.SAMPLE) { |
| useExisting = true; |
| } else if (mode == Mode.TEST) { |
| createActivity = false; |
| } |
| } |
| |
| /** |
| * Extract information (package name, application name, minimum SDK etc) from |
| * the given Android project. |
| * |
| * @param path the path to the project to extract information from |
| */ |
| public void extractFromAndroidManifest(Path path) { |
| String osPath = path.append(SdkConstants.FN_ANDROID_MANIFEST_XML).toOSString(); |
| if (!(new File(osPath).exists())) { |
| return; |
| } |
| |
| ManifestData manifestData = AndroidManifestHelper.parseForData(osPath); |
| if (manifestData == null) { |
| return; |
| } |
| |
| String newPackageName = null; |
| Activity activity = null; |
| String newActivityName = null; |
| String minSdkVersion = null; |
| try { |
| newPackageName = manifestData.getPackage(); |
| minSdkVersion = manifestData.getMinSdkVersionString(); |
| |
| // 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 (newPackageName != null && newPackageName.length() > 0) { |
| packageName = newPackageName; |
| } |
| |
| if (activity != null) { |
| newActivityName = AndroidManifest.extractActivityName(activity.getName(), |
| newPackageName); |
| } |
| |
| if (newActivityName != null && newActivityName.length() > 0) { |
| activityName = newActivityName; |
| // we are "importing" an existing activity, not creating a new one |
| createActivity = 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 (newActivityName.indexOf('.') != -1) { |
| String[] ids = newActivityName.split(AdtConstants.RE_DOT); |
| newActivityName = ids[ids.length - 1]; |
| } |
| if (projectName == null || projectName.length() == 0 || |
| !projectNameModifiedByUser) { |
| projectName = newActivityName; |
| projectNameModifiedByUser = false; |
| } |
| if (applicationName == null || applicationName.length() == 0 || |
| !applicationNameModifiedByUser) { |
| applicationNameModifiedByUser = false; |
| applicationName = newActivityName; |
| } |
| } else { |
| activityName = ""; //$NON-NLS-1$ |
| |
| // 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 (newPackageName != null && newPackageName.length() > 0) { |
| // Package name is a java identifier, so it's most suitable for |
| // an application name. |
| |
| if (applicationName == null || applicationName.length() == 0 || |
| !applicationNameModifiedByUser) { |
| applicationName = newPackageName; |
| } |
| |
| // For the project name, remove any dots |
| newPackageName = newPackageName.replace('.', '_'); |
| if (projectName == null || projectName.length() == 0 || |
| !projectNameModifiedByUser) { |
| projectName = newPackageName; |
| } |
| |
| } |
| } |
| |
| if (mode == Mode.ANY && useExisting) { |
| updateSdkTargetToMatchProject(path.toFile()); |
| } |
| |
| minSdk = minSdkVersion; |
| minSdkModifiedByUser = false; |
| } |
| |
| /** |
| * Try to find an SDK Target that matches the current MinSdkVersion. |
| * |
| * There can be multiple targets with the same sdk api version, so don't change |
| * it if it's already at the right version. Otherwise pick the first target |
| * that matches. |
| */ |
| public void updateSdkTargetToMatchMinSdkVersion() { |
| IAndroidTarget currentTarget = target; |
| if (currentTarget != null && currentTarget.getVersion().equals(minSdk)) { |
| return; |
| } |
| |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk != null) { |
| IAndroidTarget[] targets = sdk.getTargets(); |
| for (IAndroidTarget t : targets) { |
| if (t.getVersion().equals(minSdk)) { |
| target = t; |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Updates the SDK to reflect the SDK required by the project at the given |
| * location |
| * |
| * @param location the location of the project |
| */ |
| public void updateSdkTargetToMatchProject(File location) { |
| // Select the target matching the manifest's sdk or build properties, if any |
| IAndroidTarget foundTarget = null; |
| // This is the target currently in the UI |
| IAndroidTarget currentTarget = target; |
| String projectPath = location.getPath(); |
| |
| // If there's a current target defined, we do not allow to change it when |
| // operating in the create-from-sample mode -- since the available sample list |
| // is tied to the current target, so changing it would invalidate the project we're |
| // trying to load in the first place. |
| if (!targetModifiedByUser) { |
| ProjectProperties p = ProjectProperties.load(projectPath, |
| PropertyType.PROJECT); |
| if (p != null) { |
| String v = p.getProperty(ProjectProperties.PROPERTY_TARGET); |
| IAndroidTarget desiredTarget = Sdk.getCurrent().getTargetFromHashString(v); |
| // We can change the current target if: |
| // - we found a new desired target |
| // - there is no current target |
| // - or the current target can't run the desired target |
| if (desiredTarget != null && |
| (currentTarget == null || !desiredTarget.canRunOn(currentTarget))) { |
| foundTarget = desiredTarget; |
| } |
| } |
| |
| Sdk sdk = Sdk.getCurrent(); |
| IAndroidTarget[] targets = null; |
| if (sdk != null) { |
| targets = sdk.getTargets(); |
| } |
| if (targets == null) { |
| targets = new IAndroidTarget[0]; |
| } |
| |
| if (foundTarget == null && minSdk != null) { |
| // Otherwise try to match the requested min-sdk-version if we find an |
| // exact match, regardless of the currently selected target. |
| for (IAndroidTarget existingTarget : targets) { |
| if (existingTarget != null && |
| existingTarget.getVersion().equals(minSdk)) { |
| foundTarget = existingTarget; |
| break; |
| } |
| } |
| } |
| |
| if (foundTarget == null) { |
| // Or last attempt, try to match a sample project location and use it |
| // if we find an exact match, regardless of the currently selected target. |
| for (IAndroidTarget existingTarget : targets) { |
| if (existingTarget != null && |
| projectPath.startsWith(existingTarget.getLocation())) { |
| foundTarget = existingTarget; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (foundTarget != null) { |
| target = foundTarget; |
| } |
| } |
| |
| /** |
| * Type of project being offered/created by the wizard |
| */ |
| public enum Mode { |
| /** Create a sample project. Testing options are not presented. */ |
| SAMPLE, |
| |
| /** |
| * Create a test project, either testing itself or some other project. |
| * Note that even if in the {@link #ANY} mode, a test project can be |
| * created as a *paired* project with the main project, so this flag |
| * only means that we are creating *just* a test project |
| */ |
| TEST, |
| |
| /** |
| * Create an Android project, which can be a plain project, optionally |
| * with a paired test project, or a sample project (the first page |
| * contains toggles for choosing which |
| */ |
| ANY; |
| } |
| } |
