Java tutorial
/* * Copyright (C) 2007 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.project; import com.android.SdkConstants; import com.android.ide.common.sdk.LoadStatus; import com.android.ide.eclipse.adt.AdtConstants; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.sdk.ProjectState; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.sdklib.AndroidVersion; import com.android.sdklib.IAndroidTarget; import com.android.sdklib.IAndroidTarget.IOptionalLibrary; import com.google.common.collect.Maps; import com.google.common.io.Closeables; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.FileLocator; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.core.runtime.Path; import org.eclipse.core.runtime.Platform; import org.eclipse.jdt.core.IAccessRule; import org.eclipse.jdt.core.IClasspathAttribute; import org.eclipse.jdt.core.IClasspathContainer; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jdt.core.IJavaModel; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.osgi.framework.Bundle; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.net.URLConnection; import java.util.ArrayList; import java.util.HashSet; import java.util.Map; import java.util.regex.Pattern; /** * Classpath container initializer responsible for binding {@link AndroidClasspathContainer} to * {@link IProject}s. This removes the hard-coded path to the android.jar. */ public class AndroidClasspathContainerInitializer extends BaseClasspathContainerInitializer { public static final String NULL_API_URL = "<null>"; //$NON-NLS-1$ public static final String SOURCES_ZIP = "/sources.zip"; //$NON-NLS-1$ public static final String COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE = "com.android.ide.eclipse.source"; //$NON-NLS-1$ private static final String ANDROID_API_REFERENCE = "http://developer.android.com/reference/"; //$NON-NLS-1$ private final static String PROPERTY_ANDROID_API = "androidApi"; //$NON-NLS-1$ private final static String PROPERTY_ANDROID_SOURCE = "androidSource"; //$NON-NLS-1$ /** path separator to store multiple paths in a single property. This is guaranteed to not * be in a path. */ private final static String PATH_SEPARATOR = "\u001C"; //$NON-NLS-1$ private final static String PROPERTY_CONTAINER_CACHE = "androidContainerCache"; //$NON-NLS-1$ private final static String PROPERTY_TARGET_NAME = "androidTargetCache"; //$NON-NLS-1$ private final static String CACHE_VERSION = "01"; //$NON-NLS-1$ private final static String CACHE_VERSION_SEP = CACHE_VERSION + PATH_SEPARATOR; private final static int CACHE_INDEX_JAR = 0; private final static int CACHE_INDEX_SRC = 1; private final static int CACHE_INDEX_DOCS_URI = 2; private final static int CACHE_INDEX_OPT_DOCS_URI = 3; private final static int CACHE_INDEX_ADD_ON_START = CACHE_INDEX_OPT_DOCS_URI; public AndroidClasspathContainerInitializer() { // pass } /** * Binds a classpath container to a {@link IClasspathContainer} for a given project, * or silently fails if unable to do so. * @param containerPath the container path that is the container id. * @param project the project to bind */ @Override public void initialize(IPath containerPath, IJavaProject project) throws CoreException { if (AdtConstants.CONTAINER_FRAMEWORK.equals(containerPath.toString())) { IClasspathContainer container = allocateAndroidContainer(project); if (container != null) { JavaCore.setClasspathContainer(new Path(AdtConstants.CONTAINER_FRAMEWORK), new IJavaProject[] { project }, new IClasspathContainer[] { container }, new NullProgressMonitor()); } } } /** * Updates the {@link IJavaProject} objects with new android framework container. This forces * JDT to recompile them. * @param androidProjects the projects to update. * @return <code>true</code> if success, <code>false</code> otherwise. */ static boolean updateProjects(IJavaProject[] androidProjects) { try { // Allocate a new AndroidClasspathContainer, and associate it to the android framework // container id for each projects. // By providing a new association between a container id and a IClasspathContainer, // this forces the JDT to query the IClasspathContainer for new IClasspathEntry (with // IClasspathContainer#getClasspathEntries()), and therefore force recompilation of // the projects. int projectCount = androidProjects.length; IClasspathContainer[] containers = new IClasspathContainer[projectCount]; for (int i = 0; i < projectCount; i++) { containers[i] = allocateAndroidContainer(androidProjects[i]); } // give each project their new container in one call. JavaCore.setClasspathContainer(new Path(AdtConstants.CONTAINER_FRAMEWORK), androidProjects, containers, new NullProgressMonitor()); return true; } catch (JavaModelException e) { return false; } } /** * Allocates and returns an {@link AndroidClasspathContainer} object with the proper * path to the framework jar file. * @param javaProject The java project that will receive the container. */ private static IClasspathContainer allocateAndroidContainer(IJavaProject javaProject) { final IProject iProject = javaProject.getProject(); String markerMessage = null; boolean outputToConsole = true; IAndroidTarget target = null; try { AdtPlugin plugin = AdtPlugin.getDefault(); if (plugin == null) { // This is totally weird, but I've seen it happen! return null; } synchronized (Sdk.getLock()) { boolean sdkIsLoaded = plugin.getSdkLoadStatus() == LoadStatus.LOADED; // check if the project has a valid target. ProjectState state = Sdk.getProjectState(iProject); if (state == null) { // looks like the project state (project.properties) couldn't be read! markerMessage = String.format( "Project has no %1$s file! Edit the project properties to set one.", SdkConstants.FN_PROJECT_PROPERTIES); } else { // this might be null if the sdk is not yet loaded. target = state.getTarget(); // if we are loaded and the target is non null, we create a valid // ClassPathContainer if (sdkIsLoaded && target != null) { // check the renderscript support mode. If support mode is enabled, // target API must be 18+ if (!state.getRenderScriptSupportMode() || target.getVersion().getApiLevel() >= 18) { // first make sure the target has loaded its data Sdk.getCurrent().checkAndLoadTargetData(target, null /*project*/); String targetName = target.getClasspathName(); return new AndroidClasspathContainer( createClasspathEntries(iProject, target, targetName), new Path(AdtConstants.CONTAINER_FRAMEWORK), targetName, IClasspathContainer.K_DEFAULT_SYSTEM); } else { markerMessage = "Renderscript support mode requires compilation target API to be 18+."; } } else { // In case of error, we'll try different thing to provide the best error message // possible. // Get the project's target's hash string (if it exists) String hashString = state.getTargetHashString(); if (hashString == null || hashString.length() == 0) { // if there is no hash string we only show this if the SDK is loaded. // For a project opened at start-up with no target, this would be displayed // twice, once when the project is opened, and once after the SDK has // finished loading. // By testing the sdk is loaded, we only show this once in the console. if (sdkIsLoaded) { markerMessage = String.format( "Project has no target set. Edit the project properties to set one."); } } else if (sdkIsLoaded) { markerMessage = String.format("Unable to resolve target '%s'", hashString); } else { // this is the case where there is a hashString but the SDK is not yet // loaded and therefore we can't get the target yet. // We check if there is a cache of the needed information. AndroidClasspathContainer container = getContainerFromCache(iProject, target); if (container == null) { // either the cache was wrong (ie folder does not exists anymore), or // there was no cache. In this case we need to make sure the project // is resolved again after the SDK is loaded. plugin.setProjectToResolve(javaProject); markerMessage = String.format( "Unable to resolve target '%s' until the SDK is loaded.", hashString); // let's not log this one to the console as it will happen at // every boot, and it's expected. (we do keep the error marker though). outputToConsole = false; } else { // we created a container from the cache, so we register the project // to be checked for cache validity once the SDK is loaded plugin.setProjectToCheck(javaProject); // and return the container return container; } } } } // return a dummy container to replace the one we may have had before. // It'll be replaced by the real when if/when the target is resolved if/when the // SDK finishes loading. return new IClasspathContainer() { @Override public IClasspathEntry[] getClasspathEntries() { return new IClasspathEntry[0]; } @Override public String getDescription() { return "Unable to get system library for the project"; } @Override public int getKind() { return IClasspathContainer.K_DEFAULT_SYSTEM; } @Override public IPath getPath() { return null; } }; } } finally { processError(iProject, markerMessage, AdtConstants.MARKER_TARGET, outputToConsole); } } /** * Creates and returns an array of {@link IClasspathEntry} objects for the android * framework and optional libraries. * <p/>This references the OS path to the android.jar and the * java doc directory. This is dynamically created when a project is opened, * and never saved in the project itself, so there's no risk of storing an * obsolete path. * The method also stores the paths used to create the entries in the project persistent * properties. A new {@link AndroidClasspathContainer} can be created from the stored path * using the {@link #getContainerFromCache(IProject)} method. * @param project * @param target The target that contains the libraries. * @param targetName */ private static IClasspathEntry[] createClasspathEntries(IProject project, IAndroidTarget target, String targetName) { // get the path from the target String[] paths = getTargetPaths(target); // create the classpath entry from the paths IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths, target); // paths now contains all the path required to recreate the IClasspathEntry with no // target info. We encode them in a single string, with each path separated by // OS path separator. StringBuilder sb = new StringBuilder(CACHE_VERSION); for (String p : paths) { sb.append(PATH_SEPARATOR); sb.append(p); } // store this in a project persistent property ProjectHelper.saveStringProperty(project, PROPERTY_CONTAINER_CACHE, sb.toString()); ProjectHelper.saveStringProperty(project, PROPERTY_TARGET_NAME, targetName); return entries; } /** * Generates an {@link AndroidClasspathContainer} from the project cache, if possible. */ private static AndroidClasspathContainer getContainerFromCache(IProject project, IAndroidTarget target) { // get the cached info from the project persistent properties. String cache = ProjectHelper.loadStringProperty(project, PROPERTY_CONTAINER_CACHE); String targetNameCache = ProjectHelper.loadStringProperty(project, PROPERTY_TARGET_NAME); if (cache == null || targetNameCache == null) { return null; } // the first 2 chars must match CACHE_VERSION. The 3rd char is the normal separator. if (cache.startsWith(CACHE_VERSION_SEP) == false) { return null; } cache = cache.substring(CACHE_VERSION_SEP.length()); // the cache contains multiple paths, separated by a character guaranteed to not be in // the path (\u001C). // The first 3 are for android.jar (jar, source, doc), the rest are for the optional // libraries and should contain at least one doc and a jar (if there are any libraries). // Therefore, the path count should be 3 or 5+ String[] paths = cache.split(Pattern.quote(PATH_SEPARATOR)); if (paths.length < 3 || paths.length == 4) { return null; } // now we check the paths actually exist. // There's an exception: If the source folder for android.jar does not exist, this is // not a problem, so we skip it. // Also paths[CACHE_INDEX_DOCS_URI] is a URI to the javadoc, so we test it a // bit differently. try { if (new File(paths[CACHE_INDEX_JAR]).exists() == false || new File(new URI(paths[CACHE_INDEX_DOCS_URI])).exists() == false) { return null; } // check the path for the add-ons, if they exist. if (paths.length > CACHE_INDEX_ADD_ON_START) { // check the docs path separately from the rest of the paths as it's a URI. if (new File(new URI(paths[CACHE_INDEX_OPT_DOCS_URI])).exists() == false) { return null; } // now just check the remaining paths. for (int i = CACHE_INDEX_ADD_ON_START + 1; i < paths.length; i++) { String path = paths[i]; if (path.length() > 0) { File f = new File(path); if (f.exists() == false) { return null; } } } } } catch (URISyntaxException e) { return null; } IClasspathEntry[] entries = createClasspathEntriesFromPaths(paths, target); return new AndroidClasspathContainer(entries, new Path(AdtConstants.CONTAINER_FRAMEWORK), targetNameCache, IClasspathContainer.K_DEFAULT_SYSTEM); } /** * Generates an array of {@link IClasspathEntry} from a set of paths. * @see #getTargetPaths(IAndroidTarget) */ private static IClasspathEntry[] createClasspathEntriesFromPaths(String[] paths, IAndroidTarget target) { ArrayList<IClasspathEntry> list = new ArrayList<IClasspathEntry>(); // First, we create the IClasspathEntry for the framework. // now add the android framework to the class path. // create the path object. IPath androidLib = new Path(paths[CACHE_INDEX_JAR]); IPath androidSrc = null; String androidSrcOsPath = null; IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); if (target != null) { androidSrcOsPath = ProjectHelper.loadStringProperty(root, getAndroidSourceProperty(target)); } if (androidSrcOsPath != null && androidSrcOsPath.trim().length() > 0) { androidSrc = new Path(androidSrcOsPath); } if (androidSrc == null) { androidSrc = new Path(paths[CACHE_INDEX_SRC]); File androidSrcFile = new File(paths[CACHE_INDEX_SRC]); if (!androidSrcFile.isDirectory()) { androidSrc = null; } } if (androidSrc == null && target != null) { Bundle bundle = getSourceBundle(); if (bundle != null) { AndroidVersion version = target.getVersion(); String apiString = version.getApiString(); String sourcePath = apiString + SOURCES_ZIP; URL sourceURL = bundle.getEntry(sourcePath); if (sourceURL != null) { URL url = null; try { url = FileLocator.resolve(sourceURL); } catch (IOException ignore) { } if (url != null) { androidSrcOsPath = url.getFile(); if (new File(androidSrcOsPath).isFile()) { androidSrc = new Path(androidSrcOsPath); } } } } } // create the java doc link. String androidApiURL = ProjectHelper.loadStringProperty(root, PROPERTY_ANDROID_API); String apiURL = null; if (androidApiURL != null && testURL(androidApiURL)) { apiURL = androidApiURL; } else { if (testURL(paths[CACHE_INDEX_DOCS_URI])) { apiURL = paths[CACHE_INDEX_DOCS_URI]; } else if (testURL(ANDROID_API_REFERENCE)) { apiURL = ANDROID_API_REFERENCE; } } IClasspathAttribute[] attributes = null; if (apiURL != null && !NULL_API_URL.equals(apiURL)) { IClasspathAttribute cpAttribute = JavaCore .newClasspathAttribute(IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, apiURL); attributes = new IClasspathAttribute[] { cpAttribute }; } // create the access rule to restrict access to classes in // com.android.internal IAccessRule accessRule = JavaCore.newAccessRule(new Path("com/android/internal/**"), //$NON-NLS-1$ IAccessRule.K_NON_ACCESSIBLE); IClasspathEntry frameworkClasspathEntry = JavaCore.newLibraryEntry(androidLib, androidSrc, // source attachment path null, // default source attachment root path. new IAccessRule[] { accessRule }, attributes, false // not exported. ); list.add(frameworkClasspathEntry); // now deal with optional libraries if (paths.length >= 5) { String docPath = paths[CACHE_INDEX_OPT_DOCS_URI]; int i = 4; while (i < paths.length) { Path jarPath = new Path(paths[i++]); attributes = null; if (docPath.length() > 0) { attributes = new IClasspathAttribute[] { JavaCore .newClasspathAttribute(IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, docPath) }; } IClasspathEntry entry = JavaCore.newLibraryEntry(jarPath, null, // source attachment path null, // default source attachment root path. null, attributes, false // not exported. ); list.add(entry); } } if (apiURL != null) { ProjectHelper.saveStringProperty(root, PROPERTY_ANDROID_API, apiURL); } if (androidSrc != null && target != null) { ProjectHelper.saveStringProperty(root, getAndroidSourceProperty(target), androidSrc.toOSString()); } return list.toArray(new IClasspathEntry[list.size()]); } private static Bundle getSourceBundle() { String bundleId = System.getProperty(COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE, COM_ANDROID_IDE_ECLIPSE_ADT_SOURCE); Bundle bundle = Platform.getBundle(bundleId); return bundle; } private static String getAndroidSourceProperty(IAndroidTarget target) { if (target == null) { return null; } String androidSourceProperty = PROPERTY_ANDROID_SOURCE + "_" + target.getVersion().getApiString(); return androidSourceProperty; } /** * Cache results for testURL: Some are expensive to compute, and this is * called repeatedly (perhaps for each open project) */ private static final Map<String, Boolean> sRecentUrlValidCache = Maps.newHashMapWithExpectedSize(4); @SuppressWarnings("resource") // Eclipse does not handle Closeables#closeQuietly private static boolean testURL(String androidApiURL) { Boolean cached = sRecentUrlValidCache.get(androidApiURL); if (cached != null) { return cached.booleanValue(); } boolean valid = false; InputStream is = null; try { URL testURL = new URL(androidApiURL); URLConnection connection = testURL.openConnection(); // Only try for 5 seconds (though some implementations ignore this flag) connection.setConnectTimeout(5000); connection.setReadTimeout(5000); is = connection.getInputStream(); valid = true; } catch (Exception ignore) { } finally { Closeables.closeQuietly(is); } sRecentUrlValidCache.put(androidApiURL, valid); return valid; } /** * Checks the projects' caches. If the cache was valid, the project is removed from the list. * @param projects the list of projects to check. */ public static void checkProjectsCache(ArrayList<IJavaProject> projects) { Sdk currentSdk = Sdk.getCurrent(); int i = 0; projectLoop: while (i < projects.size()) { IJavaProject javaProject = projects.get(i); IProject iProject = javaProject.getProject(); // check if the project is opened if (iProject.isOpen() == false) { // remove from the list // we do not increment i in this case. projects.remove(i); continue; } // project that have been resolved before the sdk was loaded // will have a ProjectState where the IAndroidTarget is null // so we load the target now that the SDK is loaded. IAndroidTarget target = currentSdk.loadTargetAndBuildTools(Sdk.getProjectState(iProject)); if (target == null) { // this is really not supposed to happen. This would mean there are cached paths, // but project.properties was deleted. Keep the project in the list to force // a resolve which will display the error. i++; continue; } String[] targetPaths = getTargetPaths(target); // now get the cached paths String cache = ProjectHelper.loadStringProperty(iProject, PROPERTY_CONTAINER_CACHE); if (cache == null) { // this should not happen. We'll force resolve again anyway. i++; continue; } String[] cachedPaths = cache.split(Pattern.quote(PATH_SEPARATOR)); if (cachedPaths.length < 3 || cachedPaths.length == 4) { // paths length is wrong. simply resolve the project again i++; continue; } // Now we compare the paths. The first 4 can be compared directly. // because of case sensitiveness we need to use File objects if (targetPaths.length != cachedPaths.length) { // different paths, force resolve again. i++; continue; } // compare the main paths (android.jar, main sources, main javadoc) if (new File(targetPaths[CACHE_INDEX_JAR]).equals(new File(cachedPaths[CACHE_INDEX_JAR])) == false || new File(targetPaths[CACHE_INDEX_SRC]) .equals(new File(cachedPaths[CACHE_INDEX_SRC])) == false || new File(targetPaths[CACHE_INDEX_DOCS_URI]) .equals(new File(cachedPaths[CACHE_INDEX_DOCS_URI])) == false) { // different paths, force resolve again. i++; continue; } if (cachedPaths.length > CACHE_INDEX_OPT_DOCS_URI) { // compare optional libraries javadoc if (new File(targetPaths[CACHE_INDEX_OPT_DOCS_URI]) .equals(new File(cachedPaths[CACHE_INDEX_OPT_DOCS_URI])) == false) { // different paths, force resolve again. i++; continue; } // testing the optional jar files is a little bit trickier. // The order is not guaranteed to be identical. // From a previous test, we do know however that there is the same number. // The number of libraries should be low enough that we can simply go through the // lists manually. targetLoop: for (int tpi = 4; tpi < targetPaths.length; tpi++) { String targetPath = targetPaths[tpi]; // look for a match in the other array for (int cpi = 4; cpi < cachedPaths.length; cpi++) { if (new File(targetPath).equals(new File(cachedPaths[cpi]))) { // found a match. Try the next targetPath continue targetLoop; } } // if we stop here, we haven't found a match, which means there's a // discrepancy in the libraries. We force a resolve. i++; continue projectLoop; } } // at the point the check passes, and we can remove the project from the list. // we do not increment i in this case. projects.remove(i); } } /** * Returns the paths necessary to create the {@link IClasspathEntry} for this targets. * <p/>The paths are always in the same order. * <ul> * <li>Path to android.jar</li> * <li>Path to the source code for android.jar</li> * <li>Path to the javadoc for the android platform</li> * </ul> * Additionally, if there are optional libraries, the array will contain: * <ul> * <li>Path to the libraries javadoc</li> * <li>Path to the first .jar file</li> * <li>(more .jar as needed)</li> * </ul> */ private static String[] getTargetPaths(IAndroidTarget target) { ArrayList<String> paths = new ArrayList<String>(); // first, we get the path for android.jar // The order is: android.jar, source folder, docs folder paths.add(target.getPath(IAndroidTarget.ANDROID_JAR)); paths.add(target.getPath(IAndroidTarget.SOURCES)); paths.add(AdtPlugin.getUrlDoc()); // now deal with optional libraries. IOptionalLibrary[] libraries = target.getOptionalLibraries(); if (libraries != null) { // all the optional libraries use the same javadoc, so we start with this String targetDocPath = target.getPath(IAndroidTarget.DOCS); if (targetDocPath != null) { paths.add(ProjectHelper.getJavaDocPath(targetDocPath)); } else { // we add an empty string, to always have the same count. paths.add(""); } // because different libraries could use the same jar file, we make sure we add // each jar file only once. HashSet<String> visitedJars = new HashSet<String>(); for (IOptionalLibrary library : libraries) { String jarPath = library.getJarPath(); if (visitedJars.contains(jarPath) == false) { visitedJars.add(jarPath); paths.add(jarPath); } } } return paths.toArray(new String[paths.size()]); } @Override public boolean canUpdateClasspathContainer(IPath containerPath, IJavaProject project) { return true; } @Override public void requestClasspathContainerUpdate(IPath containerPath, IJavaProject project, IClasspathContainer containerSuggestion) throws CoreException { AdtPlugin plugin = AdtPlugin.getDefault(); synchronized (Sdk.getLock()) { boolean sdkIsLoaded = plugin.getSdkLoadStatus() == LoadStatus.LOADED; // check if the project has a valid target. IAndroidTarget target = null; if (sdkIsLoaded) { target = Sdk.getCurrent().getTarget(project.getProject()); } if (sdkIsLoaded && target != null) { String[] paths = getTargetPaths(target); IPath android_lib = new Path(paths[CACHE_INDEX_JAR]); IClasspathEntry[] entries = containerSuggestion.getClasspathEntries(); for (int i = 0; i < entries.length; i++) { IClasspathEntry entry = entries[i]; if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { IPath entryPath = entry.getPath(); if (entryPath != null) { if (entryPath.equals(android_lib)) { IPath entrySrcPath = entry.getSourceAttachmentPath(); IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); if (entrySrcPath != null) { ProjectHelper.saveStringProperty(root, getAndroidSourceProperty(target), entrySrcPath.toString()); } else { ProjectHelper.saveStringProperty(root, getAndroidSourceProperty(target), null); } IClasspathAttribute[] extraAttributtes = entry.getExtraAttributes(); if (extraAttributtes.length == 0) { ProjectHelper.saveStringProperty(root, PROPERTY_ANDROID_API, NULL_API_URL); } for (int j = 0; j < extraAttributtes.length; j++) { IClasspathAttribute extraAttribute = extraAttributtes[j]; String value = extraAttribute.getValue(); if ((value == null || value.trim().length() == 0) && IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME .equals(extraAttribute.getName())) { value = NULL_API_URL; } if (IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME .equals(extraAttribute.getName())) { ProjectHelper.saveStringProperty(root, PROPERTY_ANDROID_API, value); } } } } } } rebindClasspathEntries(project.getJavaModel(), containerPath); } } } private static void rebindClasspathEntries(IJavaModel model, IPath containerPath) throws JavaModelException { ArrayList<IJavaProject> affectedProjects = new ArrayList<IJavaProject>(); IJavaProject[] projects = model.getJavaProjects(); for (int i = 0; i < projects.length; i++) { IJavaProject project = projects[i]; IClasspathEntry[] entries = project.getRawClasspath(); for (int k = 0; k < entries.length; k++) { IClasspathEntry curr = entries[k]; if (curr.getEntryKind() == IClasspathEntry.CPE_CONTAINER && containerPath.equals(curr.getPath())) { affectedProjects.add(project); } } } if (!affectedProjects.isEmpty()) { IJavaProject[] affected = affectedProjects.toArray(new IJavaProject[affectedProjects.size()]); updateProjects(affected); } } }