/*
* 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.model;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
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.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.osgi.util.NLS;
import com.android.sdklib.IAndroidTarget;
import com.motorola.studio.android.AndroidPlugin;
import com.motorola.studio.android.adt.Sample;
import com.motorola.studio.android.adt.SdkUtils;
import com.motorola.studio.android.common.IAndroidConstants;
import com.motorola.studio.android.common.exception.AndroidException;
import com.motorola.studio.android.common.utilities.AndroidStatus;
import com.motorola.studio.android.common.utilities.EclipseUtils;
import com.motorola.studio.android.i18n.AndroidNLS;
/**
* Class that implements the model for the new project wizard
*/
public class AndroidProject implements IWizardModel
{
private static final IWorkspace WORKSPACE = ResourcesPlugin.getWorkspace();
private static final String SDK_VERSION = "1.5"; //$NON-NLS-1$
private static final String BIN_FOLDER = "bin"; //$NON-NLS-1$
private static final String CLASS_EXTENSION = ".class"; //$NON-NLS-1$
private static final String R_DRAWABLE_CLASS = "R$drawable" + CLASS_EXTENSION; //$NON-NLS-1$
private static final String SETTINGS_FOLDER = ".settings"; //$NON-NLS-1$
private static final String SETTINGS_FILE = "org.eclipse.core.resources.prefs"; //$NON-NLS-1$
public static final String ANDROID_NATURE = "com.android.ide.eclipse.adt.AndroidNature"; //$NON-NLS-1$
private static final int MAX_PATH_LENGTH = 255;
/**
* Represents the Type of new Projects
*/
public static enum SourceTypes
{
SAMPLE, EXISTING, NEW, WIDGET
};
/*
* (non-Javadoc)
*
* @see java.lang.Object#finalize()
*/
@Override
public void finalize() throws Throwable
{
if (listener != null)
{
AndroidPlugin.getDefault().removeSDKLoaderListener(listener);
}
super.finalize();
}
private SourceTypes sourceType = SourceTypes.NEW;
private Sample sample = null;
private String location = null;
private boolean useDefaultLocation = true;
private boolean addNativeSupport = false;
private boolean needToObfuscate = false;
/**
* Return the Type of the new Project
*
* @return
*/
public SourceTypes getSourceType()
{
return sourceType;
}
/**
* Change the Type of the new Project
*
* @param sourceType
*/
public void setSourceType(SourceTypes sourceType)
{
this.sourceType = sourceType;
}
/**
* Check if adding native support
*
* @return
*/
public boolean isAddingNativeSupport()
{
return addNativeSupport;
}
/**
* Set add native support property
*
* @param hasNativeSupport
*/
public void setAddNativeSupport(boolean addNativeSupport)
{
this.addNativeSupport = addNativeSupport;
}
public void setNeedToObfuscate(boolean needToObfuscate)
{
this.needToObfuscate = needToObfuscate;
}
public boolean needToObfuscate()
{
return needToObfuscate;
}
/**
* Returns the Project location.
*
* @see #isUsingDefaultLocation()
* @return
*/
public String getLocation()
{
return location;
}
/**
* Return the sample to use
*
* @see #getSourceType()
* @return
*/
public Sample getSample()
{
return sample;
}
/**
* Change the used sample
*
* @see #getSourceType()
* @param sample
*/
public void setSample(Sample sample)
{
this.sample = sample;
}
/**
* Change the Project Location
*
* @param location
*/
public void setLocation(String location)
{
this.location = location;
}
/**
* Check if using the default location
*
* @return
*/
public boolean isUsingDefaultLocation()
{
return useDefaultLocation;
}
/**
* Set use default location property
*
* @param useDefaultLocation
*/
public void setUseDefaultLocation(boolean useDefaultLocation)
{
this.useDefaultLocation = useDefaultLocation;
}
private String minSdkVersion = null;
private String name = ""; //$NON-NLS-1$
private String activityName = ""; //$NON-NLS-1$
private String packageName = ""; //$NON-NLS-1$
private IAndroidTarget sdkTarget = null;
private List<String> sourceFolders = null;
private boolean usingDefaultPackage = true;
private final String PACKAGE_ROOT = "com."; //$NON-NLS-1$
private Runnable listener = null;
private String appName;
/**
* Check if using the defaul package name
*
* @return
*/
public boolean isUsingDefaultPackage()
{
return usingDefaultPackage;
}
/**
* Set if using the Default package name
*
* @param usingDefaultPackage
*/
public void setUsingDefaultPackage(boolean usingDefaultPackage)
{
this.usingDefaultPackage = usingDefaultPackage;
}
/**
* Creates a new AndroidProject
*/
public AndroidProject()
{
// initialize SDK Targets
if (SdkUtils.getCurrentSdk() == null)
{
// this listener will be called when a SDK is configured
listener = new Runnable()
{
public void run()
{
IAndroidTarget[] targets = SdkUtils.getAllTargets();
if ((targets != null) && (targets.length > 0))
{
int maxApiVersion = -1;
for (IAndroidTarget aTarget : targets)
{
int apiVersion = aTarget.getVersion().getApiLevel();
if (maxApiVersion < apiVersion)
{
sdkTarget = aTarget;
maxApiVersion = apiVersion;
}
}
// set the API string as the min SDK version - this is the way ADT does
minSdkVersion = sdkTarget.getVersion().getApiString();
}
AndroidPlugin.getDefault().removeSDKLoaderListener(listener);
listener = null;
}
};
AndroidPlugin.getDefault().addSDKLoaderListener(listener);
}
else
{
IAndroidTarget[] targets = SdkUtils.getAllTargets();
if ((targets != null) && (targets.length > 0))
{
int maxApiVersion = -1;
for (IAndroidTarget aTarget : targets)
{
int apiVersion = aTarget.getVersion().getApiLevel();
if (maxApiVersion < apiVersion)
{
sdkTarget = aTarget;
maxApiVersion = apiVersion;
}
}
// set the API string as the min SDK version - this is the way ADT does
minSdkVersion = sdkTarget.getVersion().getApiString();
}
}
sourceFolders = new ArrayList(3);
sourceFolders.add(IAndroidConstants.FD_SOURCES);
sourceFolders.add(IAndroidConstants.FD_GEN_SOURCES);
}
/**
* Return the Default Package Name.
*
* @return
*/
private String getDefaultPackageName()
{
return PACKAGE_ROOT + name2package(name);
}
/**
* Return the default name for activities.
*
* @return
*/
public String getDefaultActivityName()
{
String activityName = name;
activityName = activityName.replaceAll("^[0-9]+", "_"); //$NON-NLS-1$ //$NON-NLS-2$
activityName = activityName.replaceAll("[\\.]+", "_"); //$NON-NLS-1$ //$NON-NLS-2$
return activityName;
}
/**
* Returns a valid package name from the Project Name
*
* @param name
* @return
*/
protected String name2package(String name)
{
String packageName = getDefaultActivityName().toLowerCase();
packageName = packageName.replaceAll("[^A-Za-z0-9_]+", "_"); //$NON-NLS-1$ //$NON-NLS-2$
if (packageName.endsWith("_") && (packageName.length() > 1)) //$NON-NLS-1$
{
packageName = packageName.substring(0, packageName.length() - 1);
}
return packageName;
}
/**
* Return the Minimum SDK Version
*
* @return
*/
public String getMinSdkVersion()
{
return minSdkVersion;
}
/**
* Returns <code>true</code> in case the SDK is a preview,
* <code>false</code> otherwise.
*
* @return Returns <code>true</code> in case the SDK is a preview,
* <code>false</code> otherwise.
*/
public boolean isSdkPreview()
{
return getSdkTarget().getVersion().isPreview();
}
/**
* Return the project Name
*
* @return
*/
public String getName()
{
return name;
}
/**
* Return the package name. Or the Default package name, if using it.
*
* @return
*/
public String getPackageName()
{
String packageName;
if (isUsingDefaultPackage())
{
packageName = getDefaultPackageName();
}
else
{
packageName = this.packageName;
}
return packageName;
}
/**
* Return the SDK target used by this project.
*
* @return
*/
public IAndroidTarget getSdkTarget()
{
return sdkTarget;
}
/**
* Return the Source Folder to be created in the project.
*
* @return
*/
public List<String> getSourceFolders()
{
return sourceFolders;
}
/*
* (non-Javadoc)
*
* @see com.motorola.studio.android.model.IWizardModel#getStatus()
*/
public IStatus getStatus()
{
IStatus status = Status.OK_STATUS;
// Validating Project Name
if ((name == null) || (name.length() == 0))
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_ProjectNameMustBeSpecified);
}
else
{
Pattern pattern = Pattern.compile("([A-Za-z0-9_\\.])+"); //$NON-NLS-1$
Matcher matcher = pattern.matcher(name);
if (!matcher.matches())
{
String errMsg = NLS.bind(AndroidNLS.ERR_AndroidProject_InvalidProjectName, name);
status = new AndroidStatus(IStatus.ERROR, errMsg);
}
else if (WORKSPACE.getRoot().getProject(name).exists())
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_DuplicatedProjectNameInWorkspace);
}
else
{
status = WORKSPACE.validateName(name, IResource.PROJECT);
}
}
if (status.isOK() && (sourceType == SourceTypes.EXISTING))
{
// Check first if the path is empty. If true, we show a info
// message to the user
if (getLocation().length() == 0)
{
status =
new AndroidStatus(IStatus.INFO,
AndroidNLS.ERR_AndroidProject_EmptySourceLocation);
}
else
{
// Check if the manifest exists
Path path = new Path(getLocation());
String osPath = path.append(IAndroidConstants.FN_ANDROID_MANIFEST).toOSString();
File manifest = new File(osPath);
if (!manifest.exists() || !manifest.isFile())
{
String errMsg =
NLS.bind(AndroidNLS.ERR_AndroidProject_FileNotFoundError,
IAndroidConstants.FN_ANDROID_MANIFEST, path.lastSegment());
status = new AndroidStatus(IStatus.ERROR, errMsg);
}
}
}
// Validating Project Location
if (status.isOK() && !isUsingDefaultLocation())
{
IProject handle = WORKSPACE.getRoot().getProject(name);
status = WORKSPACE.validateProjectLocation(handle, new Path(location));
if (status.isOK() && isNewProject() && (getLocation() != null))
{
boolean projectLocationIsEmpty =
ProjectCreationSupport.validateNewProjectLocationIsEmpty(new Path(
getLocation()));
if (!projectLocationIsEmpty)
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.UI_ProjectCreationSupport_NonEmptyFolder);
}
}
}
// Validating Project Location when adding Native Support on Windows
if (status.isOK() && isAddingNativeSupport() && Platform.getOS().equals(Platform.OS_WIN32))
{
if ((isUsingDefaultLocation() && ResourcesPlugin.getWorkspace().getRoot().getLocation()
.toOSString().contains(" ")) //$NON-NLS-1$
|| (!isUsingDefaultLocation() && location.contains(" "))) //$NON-NLS-1$
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_LocationContainsWhitespaces);
}
}
// Validating if the project could create a "file name too long"
// structure
if (status.isOK())
{
String basePath = isUsingDefaultLocation() ? getDefaultLocation() : getLocation();
String relativePackagePath = getPackageName().replace('.', File.separatorChar);
String binPath =
basePath + File.separatorChar + BIN_FOLDER + File.separatorChar
+ relativePackagePath;
String rDrawableBinClass = binPath + File.separatorChar + R_DRAWABLE_CLASS;
String settingsFilePath =
basePath + File.separatorChar + SETTINGS_FOLDER + File.separatorChar
+ SETTINGS_FILE;
String defaultClassBin =
binPath + File.separator + getDefaultActivityName() + CLASS_EXTENSION;
int maxFilenameLength = getMax(new int[]
{
rDrawableBinClass.length(), settingsFilePath.length(), defaultClassBin.length()
});
if (maxFilenameLength > MAX_PATH_LENGTH)
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_ProjectNameTooLong);
}
}
// Validating SDK Target
if (status.isOK() && (sdkTarget == null))
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_ASdkTargetMustBeSpecified);
}
// Validates the application name
if (status.isOK()
&& ((sourceType == SourceTypes.NEW) || (sourceType == SourceTypes.WIDGET)))
{
if (appName.trim().length() == 0)
{
status =
new AndroidStatus(IStatus.WARNING,
AndroidNLS.WARN_AndroidProject_ApplicationNameIsEmpty);
}
if (appName.contains("&")) //$NON-NLS-1$
{
status =
new AndroidStatus(IStatus.ERROR, NLS.bind(
AndroidNLS.ERR_AndroidProject_InvalidApplicationName, appName));
}
}
// Validating PackageName
if (status.isOK()
&& ((sourceType == SourceTypes.NEW) || (sourceType == SourceTypes.WIDGET))
&& !isUsingDefaultPackage())
{
if (getPackageName().length() == 0)
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_EmptyPackageName);
}
else if (status.isOK())
{
status =
JavaConventions.validatePackageName(getPackageName(), SDK_VERSION,
SDK_VERSION);
}
if (status.isOK() && (getPackageName().indexOf('.') == -1))
{
// 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.)
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_InvalidPackageName);
}
if (status.isOK())
{
Pattern pattern = Pattern.compile("[A-Za-z0-9_\\.]+"); //$NON-NLS-1$
Matcher matcher = pattern.matcher(getPackageName());
if (!matcher.matches())
{
String errMsg =
NLS.bind(AndroidNLS.ERR_AndroidProject_InvalidCharsInPackageName,
getPackageName());
status = new AndroidStatus(IStatus.ERROR, errMsg);
}
}
}
// validating activity name
if ((this.getSourceType() == SourceTypes.NEW)
|| (this.getSourceType() == SourceTypes.WIDGET))
{
if ((activityName == null) || (activityName.length() == 0))
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_ActivityNameMustBeSpecified);
}
else
{
String onlyChars = "[A-Za-z_]"; //$NON-NLS-1$
Pattern pattern = Pattern.compile("(" + onlyChars + ")(\\w)+"); //$NON-NLS-1$ //$NON-NLS-2$
Matcher matcher = pattern.matcher(activityName);
if (!matcher.matches())
{
String errMsg =
NLS.bind(AndroidNLS.ERR_AndroidProject_InvalidActivityName,
activityName);
status = new AndroidStatus(IStatus.ERROR, errMsg);
}
}
}
// Validating Min Sdk Version
if (status.isOK()
&& ((sourceType == SourceTypes.NEW) || (sourceType == SourceTypes.WIDGET)))
{
// validate in case the sdk is preview
if (isSdkPreview())
{
String sdkAPI = getSdkTarget().getVersion().getApiString();
if (!sdkAPI.equals(getMinSdkVersion()))
{
status =
new AndroidStatus(IStatus.ERROR, NLS.bind(
AndroidNLS.AndroidProject_MsgSDKVersionIsPreview, sdkAPI));
}
}
// since it is not a preview, validate it normally
else
{
int version = -1;
try
{
// If not empty, it must be a valid integer > 0
version = Integer.parseInt(getMinSdkVersion());
}
catch (NumberFormatException nfe)
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_InvalidSdkVersion);
}
if (status.isOK() && (version < 1))
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.ERR_AndroidProject_InvalidSdkVersion);
}
if (status.isOK() && (getSdkTarget() != null))
{
if (getSdkTarget().getVersion().getApiLevel() > version)
{
status =
new AndroidStatus(IStatus.WARNING,
AndroidNLS.ERR_AndroidProject_InvalidApiLevel);
}
else if (getSdkTarget().getVersion().getApiLevel() < version)
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.EXC_AndroidProject_InvalidMinimumSdkVersion);
}
}
}
}
//validate if there are available samples
if (status.isOK() && (sourceType == SourceTypes.SAMPLE) && (sdkTarget != null)
&& (SdkUtils.getSamples(sdkTarget).length == 0))
{
status =
new AndroidStatus(IStatus.ERROR,
AndroidNLS.EXC_AndroidProject_NoSamplesAvailable);
}
// Validating Project Location when adding Obfuscation Support
if (status.isOK() && needToObfuscate())
{
if ((isUsingDefaultLocation() && ResourcesPlugin.getWorkspace().getRoot().getLocation()
.toOSString().contains(" ")) //$NON-NLS-1$
|| (!isUsingDefaultLocation() && location.contains(" "))) //$NON-NLS-1$
{
status =
new AndroidStatus(IStatus.WARNING,
AndroidNLS.WRN_Obfuscation_ProjectLocationContainWhitespaces);
}
}
return status;
}
/*
* (non-Javadoc)
*
* @see com.motorola.studio.android.model.IWizardModel#needMoreInformation()
*/
public boolean needMoreInformation()
{
boolean needMoreInformation =
(name == null) || (name.length() == 0)
|| !WORKSPACE.validateName(name, IResource.PROJECT).isOK();
if (!needMoreInformation)
{
boolean projectPathInformation =
(location == null)
|| ((location.length() == 0) || !WORKSPACE.validateProjectLocation(
WORKSPACE.getRoot().getProject(name), new Path(location))
.isOK());
boolean newProjectInformation = !useDefaultLocation && projectPathInformation;
switch (sourceType)
{
case NEW:
needMoreInformation = newProjectInformation;
break;
case SAMPLE:
needMoreInformation = newProjectInformation || (sample == null);
break;
case EXISTING:
needMoreInformation = projectPathInformation;
break;
case WIDGET:
needMoreInformation = newProjectInformation;
}
}
if (!needMoreInformation)
{
if (((sourceType == SourceTypes.NEW) || (sourceType == SourceTypes.WIDGET))
&& !isUsingDefaultPackage())
{
needMoreInformation =
(getPackageName().length() == 0)
|| !JavaConventions.validatePackageName(getPackageName(),
SDK_VERSION, SDK_VERSION).isOK()
|| (getPackageName().indexOf('.') == -1);
}
}
if (!needMoreInformation)
{
needMoreInformation = sdkTarget == null;
}
return needMoreInformation;
}
/* (non-Javadoc)
* @see com.motorola.studio.android.model.IWizardModel#save(org.eclipse.jface.wizard.IWizardContainer, org.eclipse.core.runtime.IProgressMonitor)
*/
public boolean save(IWizardContainer container, IProgressMonitor monitor)
{
try
{
return ProjectCreationSupport.createProject(this, container);
}
catch (AndroidException e)
{
IStatus status =
new Status(IStatus.ERROR, AndroidPlugin.PLUGIN_ID, e.getLocalizedMessage());
EclipseUtils.showErrorDialog(AndroidNLS.GEN_Error,
AndroidNLS.EXC_AndroidProject_AnErrorHasOccurredWhenCreatingTheProject, status);
return false;
}
}
/**
* Change the SDK
*
* @param minSdkVersion
*/
public void setMinSdkVersion(String minSdkVersion)
{
this.minSdkVersion = minSdkVersion;
}
/**
* Change the project name
*
* @param name
*/
public void setName(String name)
{
this.name = name.trim();
}
/**
* Change the package name. If using default package name will throw an
* {@link IllegalStateException}
*
* @param packageName
*/
public void setPackageName(String packageName)
{
if (isUsingDefaultPackage())
{
throw new IllegalStateException();
}
this.packageName = packageName.trim();
}
/**
* Change the SDK Target
*
* @param sdkTarget
*/
public void setSdkTarget(IAndroidTarget sdkTarget)
{
this.sdkTarget = sdkTarget;
}
/**
* Change the Source Folder
*
* @param sourceFolder
*/
public void setSourceFolder(List<String> sourceFolders)
{
this.sourceFolders.clear();
this.sourceFolders.addAll(sourceFolders);
}
/**
* Return the Default location for this project
*
* @return
*/
public String getDefaultLocation()
{
return ResourcesPlugin.getWorkspace().getRoot().getLocation().toOSString() + File.separator
+ name;
}
/**
* Check if this project is a new project.
*
* @return
*/
public boolean isNewProject()
{
return getSourceType() != SourceTypes.EXISTING;
}
/**
* Set the name of the activity being created with the project
* This attribute is only valid for New Projects.
* Other kind of project will ignore this attribute.
*/
public void setActivityName(String activityName)
{
this.activityName = activityName;
}
/**
* Return this project default activity name
* @return an Activity name as string
*/
public String getActivityName()
{
return this.activityName;
}
/**
* Retrieves the maximum value from an int array
*
* @param values
* the int array
*
* @return the maximum value from the int array
*/
private int getMax(int[] values)
{
int max = values[0];
for (int i = 1; i < values.length; i++)
{
max = Math.max(max, values[i]);
}
return max;
}
/**
* Set the application name to be used
* The app name will be used only when the project is new
* @param app_name
*/
public void setApplicationName(String app_name)
{
this.appName = app_name;
}
/**
* get the user defined application name
* @return
*/
public String getApplicationName()
{
return this.appName;
}
}