path: root/src/plugins/android/src/com/motorola/studio/android/model/AndroidProject.java

/*
 * 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;
    }
}