/**
* Checks if all source files are existing. If not, create them.
*
* @param javaProj
*/
private void checkSourceFolders(final IJavaProject javaProj) {
if (javaProj == null) return;
if (javaProj.exists()) {
try {
if (!javaProj.isOpen()) {
javaProj.open(new NullProgressMonitor());
}
IClasspathEntry[] entries = javaProj.getRawClasspath();
for (IClasspathEntry entry : entries) {
if (IClasspathEntry.CPE_SOURCE == entry.getEntryKind()) {
IPath path = entry.getPath();
final IPath folderPath = path.removeFirstSegments(1);
if (!folderPath.isEmpty()) {
Display.getDefault()
.asyncExec(
new Runnable() {
public void run() {
try {
ImportUtils.createFolders(
javaProj.getProject(), folderPath, IResource.FORCE);
} catch (CoreException e) {
_log.error(e.getMessage());
}
}
});
}
}
}
} catch (JavaModelException e) {
_log.error("findProjectSources: Could not retrieve project sources:", e); // $NON-NLS-1$
}
}
}
public void initFromSelection() {
IJavaElement je = getSelectedJavaElement(selection);
if (je instanceof IJavaProject) {
IJavaProject jp = (IJavaProject) je;
if (jp.isOpen()) {
// default to the first source dir
// we find in the selected project
try {
for (IPackageFragmentRoot pfr : jp.getAllPackageFragmentRoots()) {
if (!pfr.isExternal() && !pfr.isArchive()) {
je = pfr;
break;
}
}
} catch (JavaModelException e) {
}
}
}
if (je instanceof IPackageFragmentRoot) {
sourceDir = (IPackageFragmentRoot) je;
packageFragment = sourceDir.getPackageFragment("");
packageName = packageFragment.getElementName();
} else if (je instanceof IPackageFragment) {
packageFragment = (IPackageFragment) je;
packageName = packageFragment.getElementName();
sourceDir = (IPackageFragmentRoot) packageFragment.getAncestor(PACKAGE_FRAGMENT_ROOT);
}
}
protected void validateJavaAttribute(Element element, Attr attr) {
String value = attr.getValue();
IJavaProject javaProject = JavaCore.create(fFile.getProject());
// be careful: people have the option to use the format:
// fullqualifiedName:staticMethod
int index = value.indexOf(":"); // $NON-NLS-1$
if (index != -1) value = value.substring(0, index);
// assume we're on the classpath already
boolean onClasspath = true;
int severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_UNKNOWN_CLASS);
if (severity != CompilerFlags.IGNORE && javaProject.isOpen()) {
onClasspath = PDEJavaHelper.isOnClasspath(value, javaProject);
if (!onClasspath) {
report(
NLS.bind(
MDECoreMessages.Builders_Manifest_class, (new String[] {value, attr.getName()})),
getLine(element, attr.getName()),
severity,
MDEMarkerFactory.P_UNKNOWN_CLASS,
element,
attr.getName() + F_ATT_VALUE_PREFIX + attr.getValue(),
MDEMarkerFactory.CAT_FATAL);
}
}
severity = CompilerFlags.getFlag(fProject, CompilerFlags.P_DISCOURAGED_CLASS);
if (severity != CompilerFlags.IGNORE && javaProject.isOpen()) {
BundleDescription desc = fModel.getBundleDescription();
if (desc == null) return;
// only check if we're discouraged if there is something on the classpath
if (onClasspath && PDEJavaHelper.isDiscouraged(value, javaProject, desc)) {
report(
NLS.bind(
MDECoreMessages.Builders_Manifest_discouragedClass,
(new String[] {value, attr.getName()})),
getLine(element, attr.getName()),
severity,
MDEMarkerFactory.M_DISCOURAGED_CLASS,
element,
attr.getName() + F_ATT_VALUE_PREFIX + attr.getValue(),
MDEMarkerFactory.CAT_OTHER);
}
}
}
/** Handle browse package. */
private void handleBrowsePackage() {
IPackageFragment[] packages = null;
IJavaProject javaProject = JavaCore.create(project);
IJavaElement javaElementArray[] = null;
ArrayList<IJavaElement> javaElementsList = new ArrayList<IJavaElement>();
// Si el projecto no esta abierto se cancela el proceso
if (javaProject.isOpen() == false) {
MessageDialog.openError(
getShell(),
Messages.WizardPageChooseSourceFolderAndPackage_29,
Messages.WizardPageChooseSourceFolderAndPackage_30);
return;
}
// Lee los paquetes solo del proyecto
try {
packages = javaProject.getPackageFragments();
for (IPackageFragment iPackageFragment : packages) {
if (iPackageFragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
javaElementsList.add(iPackageFragment);
}
}
if (javaElementsList.size() > 0) {
javaElementArray = new IJavaElement[javaElementsList.size()];
javaElementArray = javaElementsList.toArray(javaElementArray);
}
} catch (JavaModelException e) {
MessageDialog.openError(
getShell(), Messages.WizardPageChooseSourceFolderAndPackage_31, e.getMessage());
}
Shell shell = getShell();
IJavaSearchScope iJavaSearchScope = SearchEngine.createJavaSearchScope(javaElementArray, false);
PackageSelectionDialog packageSelectionDialog =
new PackageSelectionDialog(
shell,
new ProgressMonitorDialog(shell),
PackageSelectionDialog.F_REMOVE_DUPLICATES | PackageSelectionDialog.F_HIDE_EMPTY_INNER,
iJavaSearchScope);
packageSelectionDialog.setTitle(Messages.WizardPageChooseSourceFolderAndPackage_32);
packageSelectionDialog.setMessage(Messages.WizardPageChooseSourceFolderAndPackage_33);
if (packageSelectionDialog.open() == Window.OK) {
Object results[] = packageSelectionDialog.getResult();
if (results != null && results.length > 0) {
PackageFragment packageFragment = (PackageFragment) results[0];
txtPackage.setText(packageFragment.getElementName());
EclipseGeneratorUtil.javaEntityPackage = packageFragment.getElementName();
}
}
}
/**
* Creates a JavaProject prom the given project
*
* @param project
* @return the created JavaProject
*/
public IJavaProject createJavaProject(IProject project) {
try {
// addJavaNature(project);
IJavaProject javaProject = JavaCore.create(project);
if (!javaProject.isOpen()) {
javaProject.open(null);
}
createBinFolder(project, javaProject);
clearSourcePath(javaProject);
IClasspathEntry sourceFolder = createSourceFolder("src", project);
addToClasspath(javaProject, sourceFolder);
addJREContainerToProject(javaProject);
return javaProject;
} catch (CoreException e) {
e.printStackTrace();
}
return null;
}
@Override
public void initializeDefaults(ILaunchConfiguration configuration) throws CoreException {
dispose();
setLaunchConfiguration(configuration);
String projectName =
configuration.getAttribute(
IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, ""); // $NON-NLS-1$
if (projectName != null && projectName.length() > 0) {
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
if (project != null && project.isOpen()) {
ProjectState state = Sdk.getProjectState(project);
if (state == null) {
initDefaults();
return;
}
IAndroidTarget target = state.getTarget();
if (target == null) {
initDefaults();
return;
}
// String path = target.getPath(IAndroidTarget.ANDROID_JAR);
String path = AdtPlugin.getAuidtJar();
if (path == null) {
initDefaults();
return;
}
IJavaProject javaProject = JavaCore.create(project);
if (javaProject != null && javaProject.isOpen()) {
IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
IClasspathEntry androidEntry = null;
for (int i = 0; i < entries.length; i++) {
IClasspathEntry entry = entries[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY
&& path.equals(entry.getPath().toString())) {
androidEntry = entry;
break;
}
}
if (androidEntry != null) {
IPath sourceAttachmentPath = androidEntry.getSourceAttachmentPath();
if (sourceAttachmentPath != null) {
String androidSrc = sourceAttachmentPath.toString();
if (androidSrc != null && androidSrc.trim().length() > 0) {
File srcFile = new File(androidSrc);
ISourceContainer adtContainer = null;
if (srcFile.isFile()) {
adtContainer = new ExternalArchiveSourceContainer(androidSrc, true);
}
if (srcFile.isDirectory()) {
adtContainer = new DirectorySourceContainer(srcFile, false);
}
if (adtContainer != null) {
ISourceContainer defaultContainer = new DefaultSourceContainer();
setSourceContainers(new ISourceContainer[] {adtContainer, defaultContainer});
initializeParticipants();
return;
}
}
}
}
}
}
}
initDefaults();
}
/**
* Get the options that are presented to annotation processors by the
* AnnotationProcessorEnvironment. Options are key/value pairs which are set in the project
* properties.
*
* <p>Option values can begin with a percent-delimited token representing a classpath variable or
* one of several predefined values. The token must either be followed by a path delimiter, or be
* the entire value. Such tokens will be replaced with their resolved value. The predefined values
* are <code>%ROOT%</code>, which is replaced by the absolute pathname of the workspace root
* directory, and <code>%PROJECT.DIR%</code>, which will be replaced by the absolute pathname of
* the project root directory. For example, a value of <code>
* %ECLIPSE_HOME%/configuration/config.ini</code> might be resolved to <code>
* d:/eclipse/configuration/config.ini</code>.
*
* <p>This method returns some options which are set programmatically but are not directly
* editable, are not displayed in the configuration GUI, and are not persisted to the preference
* store. This is meant to emulate the behavior of Sun's apt command-line tool, which passes most
* of its command line options to the processor environment. The programmatically set options are:
* <code>-classpath</code> [set to Java build path] <code>-sourcepath</code> [set to Java source
* path] <code>-s</code> [set to generated src dir] <code>-d</code> [set to binary output dir]
* <code>-target</code> [set to compiler target version] <code>-source</code> [set to compiler
* source version]
*
* <p>There are some slight differences between the options returned by this method and the
* options returned from this implementation of @see AnnotationProcessorEnvironment#getOptions().
* First, that method returns additional options which are only meaningful during a build, such as
* <code>phase</code>. Second, that method also adds alternate encodings of each option, to be
* compatible with a bug in Sun's apt implementation: specifically, for each option key="k",
* value="v", an additional option is created with key="-Ak=v", value=null. This includes the
* user-created options, but does not include the programmatically defined options listed above.
*
* @param jproj a project, or null to query the workspace-wide setting.
* @return a mutable, possibly empty, map of (key, value) pairs. The value part of a pair may be
* null (equivalent to "-Akey" on the Sun apt command line). The value part may contain
* spaces.
*/
public static Map<String, String> getProcessorOptions(IJavaProject jproj) {
Map<String, String> rawOptions = getRawProcessorOptions(jproj);
// map is large enough to also include the programmatically generated options
Map<String, String> options = new HashMap<String, String>(rawOptions.size() + 6);
// Resolve path metavariables like %ROOT%
for (Map.Entry<String, String> entry : rawOptions.entrySet()) {
String resolvedValue = resolveVarPath(jproj, entry.getValue());
String value = (resolvedValue == null) ? entry.getValue() : resolvedValue;
options.put(entry.getKey(), value);
}
if (jproj == null) {
// there are no programmatically set options at the workspace level
return options;
}
IWorkspaceRoot root = jproj.getProject().getWorkspace().getRoot();
// Add sourcepath and classpath variables
try {
IClasspathEntry[] classpathEntries = jproj.getResolvedClasspath(true);
Set<String> classpath = new LinkedHashSet<String>();
Set<String> sourcepath = new LinkedHashSet<String>();
// For projects on the classpath, loops can exist; need to make sure we
// don't loop forever
Set<IJavaProject> projectsProcessed = new HashSet<IJavaProject>();
projectsProcessed.add(jproj);
for (IClasspathEntry entry : classpathEntries) {
int kind = entry.getEntryKind();
if (kind == IClasspathEntry.CPE_LIBRARY) {
IPath cpPath = entry.getPath();
IResource res = root.findMember(cpPath);
// If res is null, the path is absolute (it's an external jar)
if (res == null) {
classpath.add(cpPath.toOSString());
} else {
// It's relative
classpath.add(res.getLocation().toOSString());
}
} else if (kind == IClasspathEntry.CPE_SOURCE) {
IResource res = root.findMember(entry.getPath());
if (res == null) {
continue;
}
IPath srcPath = res.getLocation();
if (srcPath == null) {
continue;
}
sourcepath.add(srcPath.toOSString());
} else if (kind == IClasspathEntry.CPE_PROJECT) {
// Add the dependent project's build path and classpath to ours
IPath otherProjectPath = entry.getPath();
IProject otherProject = root.getProject(otherProjectPath.segment(0));
// Note: JavaCore.create() is safe, even if the project is null --
// in that case, we get null back
IJavaProject otherJavaProject = JavaCore.create(otherProject);
// If it doesn't exist, ignore it
if (otherJavaProject != null && otherJavaProject.isOpen()) {
addProjectClasspath(root, otherJavaProject, projectsProcessed, classpath);
}
}
}
// if you add options here, also add them in isAutomaticProcessorOption(),
// and document them in docs/reference/automatic_processor_options.html.
// Classpath and sourcepath
options.put("-classpath", convertPathCollectionToString(classpath)); // $NON-NLS-1$
options.put("-sourcepath", convertPathCollectionToString(sourcepath)); // $NON-NLS-1$
// Get absolute path for generated source dir
IFolder genSrcDir = jproj.getProject().getFolder(getGenSrcDir(jproj));
String genSrcDirString = genSrcDir.getRawLocation().toOSString();
options.put("-s", genSrcDirString); // $NON-NLS-1$
// Absolute path for bin dir as well
IPath binPath = jproj.getOutputLocation();
IResource binPathResource = root.findMember(binPath);
String binDirString;
if (binPathResource != null) {
binDirString = root.findMember(binPath).getLocation().toOSString();
} else {
binDirString = binPath.toOSString();
}
options.put("-d", binDirString); // $NON-NLS-1$
String target = jproj.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true);
options.put("-target", target); // $NON-NLS-1$
String source = jproj.getOption(JavaCore.COMPILER_SOURCE, true);
options.put("-source", source); // $NON-NLS-1$
} catch (JavaModelException jme) {
AptPlugin.log(jme, "Could not get the classpath for project: " + jproj); // $NON-NLS-1$
}
return options;
}
