| /* |
| * Copyright (C) 2008 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.sdk; |
| |
| import static com.android.SdkConstants.DOT_XML; |
| import static com.android.SdkConstants.EXT_JAR; |
| import static com.android.SdkConstants.FD_RES; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ddmlib.IDevice; |
| import com.android.ide.common.rendering.LayoutLibrary; |
| 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.build.DexWrapper; |
| import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlEditor; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.project.LibraryClasspathContainerInitializer; |
| import com.android.ide.eclipse.adt.internal.project.ProjectHelper; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IFileListener; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IProjectListener; |
| import com.android.ide.eclipse.adt.internal.resources.manager.GlobalProjectMonitor.IResourceEventListener; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState.LibraryDifference; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState.LibraryState; |
| import com.android.io.StreamException; |
| import com.android.prefs.AndroidLocation.AndroidLocationException; |
| import com.android.sdklib.AndroidVersion; |
| import com.android.sdklib.BuildToolInfo; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.SdkManager; |
| import com.android.sdklib.devices.DeviceManager; |
| import com.android.sdklib.internal.avd.AvdManager; |
| import com.android.sdklib.internal.project.ProjectProperties; |
| import com.android.sdklib.internal.project.ProjectProperties.PropertyType; |
| import com.android.sdklib.internal.project.ProjectPropertiesWorkingCopy; |
| import com.android.sdklib.repository.FullRevision; |
| import com.android.utils.ILogger; |
| import com.google.common.collect.Maps; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IMarkerDelta; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceDelta; |
| import org.eclipse.core.resources.IncrementalProjectBuilder; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.ui.IEditorDescriptor; |
| import org.eclipse.ui.IEditorInput; |
| import org.eclipse.ui.IEditorPart; |
| import org.eclipse.ui.IEditorReference; |
| import org.eclipse.ui.IFileEditorInput; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPartSite; |
| import org.eclipse.ui.IWorkbenchWindow; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.ide.IDE; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| |
| /** |
| * Central point to load, manipulate and deal with the Android SDK. Only one SDK can be used |
| * at the same time. |
| * |
| * To start using an SDK, call {@link #loadSdk(String)} which returns the instance of |
| * the Sdk object. |
| * |
| * To get the list of platforms or add-ons present in the SDK, call {@link #getTargets()}. |
| */ |
| public final class Sdk { |
| private final static boolean DEBUG = false; |
| |
| private final static Object LOCK = new Object(); |
| |
| private static Sdk sCurrentSdk = null; |
| |
| /** |
| * Map associating {@link IProject} and their state {@link ProjectState}. |
| * <p/>This <b>MUST NOT</b> be accessed directly. Instead use {@link #getProjectState(IProject)}. |
| */ |
| private final static HashMap<IProject, ProjectState> sProjectStateMap = |
| new HashMap<IProject, ProjectState>(); |
| |
| /** |
| * Data bundled using during the load of Target data. |
| * <p/>This contains the {@link LoadStatus} and a list of projects that attempted |
| * to compile before the loading was finished. Those projects will be recompiled |
| * at the end of the loading. |
| */ |
| private final static class TargetLoadBundle { |
| LoadStatus status; |
| final HashSet<IJavaProject> projectsToReload = new HashSet<IJavaProject>(); |
| } |
| |
| private final SdkManager mManager; |
| private final Map<String, DexWrapper> mDexWrappers = Maps.newHashMap(); |
| private final AvdManager mAvdManager; |
| private final DeviceManager mDeviceManager; |
| |
| /** Map associating an {@link IAndroidTarget} to an {@link AndroidTargetData} */ |
| private final HashMap<IAndroidTarget, AndroidTargetData> mTargetDataMap = |
| new HashMap<IAndroidTarget, AndroidTargetData>(); |
| /** Map associating an {@link IAndroidTarget} and its {@link TargetLoadBundle}. */ |
| private final HashMap<IAndroidTarget, TargetLoadBundle> mTargetDataStatusMap = |
| new HashMap<IAndroidTarget, TargetLoadBundle>(); |
| |
| /** |
| * If true the target data will never load anymore. The only way to reload them is to |
| * completely reload the SDK with {@link #loadSdk(String)} |
| */ |
| private boolean mDontLoadTargetData = false; |
| |
| private final String mDocBaseUrl; |
| |
| /** |
| * Classes implementing this interface will receive notification when targets are changed. |
| */ |
| public interface ITargetChangeListener { |
| /** |
| * Sent when project has its target changed. |
| */ |
| void onProjectTargetChange(IProject changedProject); |
| |
| /** |
| * Called when the targets are loaded (either the SDK finished loading when Eclipse starts, |
| * or the SDK is changed). |
| */ |
| void onTargetLoaded(IAndroidTarget target); |
| |
| /** |
| * Called when the base content of the SDK is parsed. |
| */ |
| void onSdkLoaded(); |
| } |
| |
| /** |
| * Basic abstract implementation of the ITargetChangeListener for the case where both |
| * {@link #onProjectTargetChange(IProject)} and {@link #onTargetLoaded(IAndroidTarget)} |
| * use the same code based on a simple test requiring to know the current IProject. |
| */ |
| public static abstract class TargetChangeListener implements ITargetChangeListener { |
| /** |
| * Returns the {@link IProject} associated with the listener. |
| */ |
| public abstract IProject getProject(); |
| |
| /** |
| * Called when the listener needs to take action on the event. This is only called |
| * if {@link #getProject()} and the {@link IAndroidTarget} associated with the project |
| * match the values received in {@link #onProjectTargetChange(IProject)} and |
| * {@link #onTargetLoaded(IAndroidTarget)}. |
| */ |
| public abstract void reload(); |
| |
| @Override |
| public void onProjectTargetChange(IProject changedProject) { |
| if (changedProject != null && changedProject.equals(getProject())) { |
| reload(); |
| } |
| } |
| |
| @Override |
| public void onTargetLoaded(IAndroidTarget target) { |
| IProject project = getProject(); |
| if (target != null && target.equals(Sdk.getCurrent().getTarget(project))) { |
| reload(); |
| } |
| } |
| |
| @Override |
| public void onSdkLoaded() { |
| // do nothing; |
| } |
| } |
| |
| /** |
| * Returns the lock object used to synchronize all operations dealing with SDK, targets and |
| * projects. |
| */ |
| @NonNull |
| public static final Object getLock() { |
| return LOCK; |
| } |
| |
| /** |
| * Loads an SDK and returns an {@link Sdk} object if success. |
| * <p/>If the SDK failed to load, it displays an error to the user. |
| * @param sdkLocation the OS path to the SDK. |
| */ |
| @Nullable |
| public static Sdk loadSdk(String sdkLocation) { |
| synchronized (LOCK) { |
| if (sCurrentSdk != null) { |
| sCurrentSdk.dispose(); |
| sCurrentSdk = null; |
| } |
| |
| final AtomicBoolean hasWarning = new AtomicBoolean(); |
| final AtomicBoolean hasError = new AtomicBoolean(); |
| final ArrayList<String> logMessages = new ArrayList<String>(); |
| ILogger log = new ILogger() { |
| @Override |
| public void error(@Nullable Throwable throwable, @Nullable String errorFormat, |
| Object... arg) { |
| hasError.set(true); |
| if (errorFormat != null) { |
| logMessages.add(String.format("Error: " + errorFormat, arg)); |
| } |
| |
| if (throwable != null) { |
| logMessages.add(throwable.getMessage()); |
| } |
| } |
| |
| @Override |
| public void warning(@NonNull String warningFormat, Object... arg) { |
| hasWarning.set(true); |
| logMessages.add(String.format("Warning: " + warningFormat, arg)); |
| } |
| |
| @Override |
| public void info(@NonNull String msgFormat, Object... arg) { |
| logMessages.add(String.format(msgFormat, arg)); |
| } |
| |
| @Override |
| public void verbose(@NonNull String msgFormat, Object... arg) { |
| info(msgFormat, arg); |
| } |
| }; |
| |
| // get an SdkManager object for the location |
| SdkManager manager = SdkManager.createManager(sdkLocation, log); |
| try { |
| if (manager == null) { |
| hasError.set(true); |
| } else { |
| // create the AVD Manager |
| AvdManager avdManager = null; |
| try { |
| avdManager = AvdManager.getInstance(manager.getLocalSdk(), log); |
| } catch (AndroidLocationException e) { |
| log.error(e, "Error parsing the AVDs"); |
| } |
| sCurrentSdk = new Sdk(manager, avdManager); |
| return sCurrentSdk; |
| } |
| } finally { |
| if (hasError.get() || hasWarning.get()) { |
| StringBuilder sb = new StringBuilder( |
| String.format("%s when loading the SDK:\n", |
| hasError.get() ? "Error" : "Warning")); |
| for (String msg : logMessages) { |
| sb.append('\n'); |
| sb.append(msg); |
| } |
| if (hasError.get()) { |
| AdtPlugin.printErrorToConsole("Android SDK", sb.toString()); |
| AdtPlugin.displayError("Android SDK", sb.toString()); |
| } else { |
| AdtPlugin.printToConsole("Android SDK", sb.toString()); |
| } |
| } |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the current {@link Sdk} object. |
| */ |
| @Nullable |
| public static Sdk getCurrent() { |
| synchronized (LOCK) { |
| return sCurrentSdk; |
| } |
| } |
| |
| /** |
| * Returns the location of the current SDK as an OS path string. |
| * Guaranteed to be terminated by a platform-specific path separator. |
| * <p/> |
| * Due to {@link File} canonicalization, this MAY differ from the string used to initialize |
| * the SDK path. |
| * |
| * @return The SDK OS path or null if no SDK is setup. |
| * @deprecated Consider using {@link #getSdkFileLocation()} instead. |
| * @see #getSdkFileLocation() |
| */ |
| @Deprecated |
| @Nullable |
| public String getSdkOsLocation() { |
| String path = mManager == null ? null : mManager.getLocation(); |
| if (path != null) { |
| // For backward compatibility make sure it ends with a separator. |
| // This used to be the case when the SDK Manager was created from a String path |
| // but now that a File is internally used the trailing dir separator is lost. |
| if (path.length() > 0 && !path.endsWith(File.separator)) { |
| path = path + File.separator; |
| } |
| } |
| return path; |
| } |
| |
| /** |
| * Returns the location of the current SDK as a {@link File} or null. |
| * |
| * @return The SDK OS path or null if no SDK is setup. |
| */ |
| @Nullable |
| public File getSdkFileLocation() { |
| if (mManager == null || mManager.getLocalSdk() == null) { |
| return null; |
| } |
| return mManager.getLocalSdk().getLocation(); |
| } |
| |
| /** |
| * Returns a <em>new</em> {@link SdkManager} that can parse the SDK located |
| * at the current {@link #getSdkOsLocation()}. |
| * <p/> |
| * Implementation detail: The {@link Sdk} has its own internal manager with |
| * a custom logger which is not designed to be useful for outsiders. Callers |
| * who need their own {@link SdkManager} for parsing will often want to control |
| * the logger for their own need. |
| * <p/> |
| * This is just a convenient method equivalent to writing: |
| * <pre>SdkManager.createManager(Sdk.getCurrent().getSdkLocation(), log);</pre> |
| * |
| * @param log The logger for the {@link SdkManager}. |
| * @return A new {@link SdkManager} parsing the same location. |
| */ |
| public @Nullable SdkManager getNewSdkManager(@NonNull ILogger log) { |
| return SdkManager.createManager(getSdkOsLocation(), log); |
| } |
| |
| /** |
| * Returns the URL to the local documentation. |
| * Can return null if no documentation is found in the current SDK. |
| * |
| * @return A file:// URL on the local documentation folder if it exists or null. |
| */ |
| @Nullable |
| public String getDocumentationBaseUrl() { |
| return mDocBaseUrl; |
| } |
| |
| /** |
| * Returns the list of targets that are available in the SDK. |
| */ |
| public IAndroidTarget[] getTargets() { |
| return mManager.getTargets(); |
| } |
| |
| /** |
| * Queries the underlying SDK Manager to check whether the platforms or addons |
| * directories have changed on-disk. Does not reload the SDK. |
| * <p/> |
| * This is a quick test based on the presence of the directories, their timestamps |
| * and a quick checksum of the source.properties files. It's possible to have |
| * false positives (e.g. if a file is manually modified in a platform) or false |
| * negatives (e.g. if a platform data file is changed manually in a 2nd level |
| * directory without altering the source.properties.) |
| */ |
| public boolean haveTargetsChanged() { |
| return mManager.hasChanged(); |
| } |
| |
| /** |
| * Returns a target from a hash that was generated by {@link IAndroidTarget#hashString()}. |
| * |
| * @param hash the {@link IAndroidTarget} hash string. |
| * @return The matching {@link IAndroidTarget} or null. |
| */ |
| @Nullable |
| public IAndroidTarget getTargetFromHashString(@NonNull String hash) { |
| return mManager.getTargetFromHashString(hash); |
| } |
| |
| @Nullable |
| public BuildToolInfo getBuildToolInfo(@Nullable String buildToolVersion) { |
| if (buildToolVersion != null) { |
| try { |
| return mManager.getBuildTool(FullRevision.parseRevision(buildToolVersion)); |
| } catch (Exception e) { |
| // ignore, return null below. |
| } |
| } |
| |
| return null; |
| } |
| |
| @Nullable |
| public BuildToolInfo getLatestBuildTool() { |
| return mManager.getLatestBuildTool(); |
| } |
| |
| /** |
| * Initializes a new project with a target. This creates the <code>project.properties</code> |
| * file. |
| * @param project the project to initialize |
| * @param target the project's target. |
| * @throws IOException if creating the file failed in any way. |
| * @throws StreamException if processing the project property file fails |
| */ |
| public void initProject(@Nullable IProject project, @Nullable IAndroidTarget target) |
| throws IOException, StreamException { |
| if (project == null || target == null) { |
| return; |
| } |
| |
| synchronized (LOCK) { |
| // check if there's already a state? |
| ProjectState state = getProjectState(project); |
| |
| ProjectPropertiesWorkingCopy properties = null; |
| |
| if (state != null) { |
| properties = state.getProperties().makeWorkingCopy(); |
| } |
| |
| if (properties == null) { |
| IPath location = project.getLocation(); |
| if (location == null) { // can return null when the project is being deleted. |
| // do nothing and return null; |
| return; |
| } |
| |
| properties = ProjectProperties.create(location.toOSString(), PropertyType.PROJECT); |
| } |
| |
| // save the target hash string in the project persistent property |
| properties.setProperty(ProjectProperties.PROPERTY_TARGET, target.hashString()); |
| properties.save(); |
| } |
| } |
| |
| /** |
| * Returns the {@link ProjectState} object associated with a given project. |
| * <p/> |
| * This method is the only way to properly get the project's {@link ProjectState} |
| * If the project has not yet been loaded, then it is loaded. |
| * <p/>Because this methods deals with projects, it's not linked to an actual {@link Sdk} |
| * objects, and therefore is static. |
| * <p/>The value returned by {@link ProjectState#getTarget()} will change as {@link Sdk} objects |
| * are replaced. |
| * @param project the request project |
| * @return the ProjectState for the project. |
| */ |
| @Nullable |
| @SuppressWarnings("deprecation") |
| public static ProjectState getProjectState(IProject project) { |
| if (project == null) { |
| return null; |
| } |
| |
| synchronized (LOCK) { |
| ProjectState state = sProjectStateMap.get(project); |
| if (state == null) { |
| // load the project.properties from the project folder. |
| IPath location = project.getLocation(); |
| if (location == null) { // can return null when the project is being deleted. |
| // do nothing and return null; |
| return null; |
| } |
| |
| String projectLocation = location.toOSString(); |
| |
| ProjectProperties properties = ProjectProperties.load(projectLocation, |
| PropertyType.PROJECT); |
| if (properties == null) { |
| // legacy support: look for default.properties and rename it if needed. |
| properties = ProjectProperties.load(projectLocation, |
| PropertyType.LEGACY_DEFAULT); |
| |
| if (properties == null) { |
| AdtPlugin.log(IStatus.ERROR, |
| "Failed to load properties file for project '%s'", |
| project.getName()); |
| return null; |
| } else { |
| //legacy mode. |
| // get a working copy with the new type "project" |
| ProjectPropertiesWorkingCopy wc = properties.makeWorkingCopy( |
| PropertyType.PROJECT); |
| // and save it |
| try { |
| wc.save(); |
| |
| // delete the old file. |
| ProjectProperties.delete(projectLocation, PropertyType.LEGACY_DEFAULT); |
| |
| // make sure to use the new properties |
| properties = ProjectProperties.load(projectLocation, |
| PropertyType.PROJECT); |
| } catch (Exception e) { |
| AdtPlugin.log(IStatus.ERROR, |
| "Failed to rename properties file to %1$s for project '%s2$'", |
| PropertyType.PROJECT.getFilename(), project.getName()); |
| } |
| } |
| } |
| |
| state = new ProjectState(project, properties); |
| sProjectStateMap.put(project, state); |
| |
| // try to resolve the target |
| if (AdtPlugin.getDefault().getSdkLoadStatus() == LoadStatus.LOADED) { |
| sCurrentSdk.loadTargetAndBuildTools(state); |
| } |
| } |
| |
| return state; |
| } |
| } |
| |
| /** |
| * Returns the {@link IAndroidTarget} object associated with the given {@link IProject}. |
| */ |
| @Nullable |
| public IAndroidTarget getTarget(IProject project) { |
| if (project == null) { |
| return null; |
| } |
| |
| ProjectState state = getProjectState(project); |
| if (state != null) { |
| return state.getTarget(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Loads the {@link IAndroidTarget} and BuildTools for a given project. |
| * <p/>This method will get the target hash string from the project properties, and resolve |
| * it to an {@link IAndroidTarget} object and store it inside the {@link ProjectState}. |
| * @param state the state representing the project to load. |
| * @return the target that was loaded. |
| */ |
| @Nullable |
| public IAndroidTarget loadTargetAndBuildTools(ProjectState state) { |
| IAndroidTarget target = null; |
| if (state != null) { |
| String hash = state.getTargetHashString(); |
| if (hash != null) { |
| state.setTarget(target = getTargetFromHashString(hash)); |
| } |
| |
| String markerMessage = null; |
| String buildToolInfoVersion = state.getBuildToolInfoVersion(); |
| if (buildToolInfoVersion != null) { |
| BuildToolInfo buildToolsInfo = getBuildToolInfo(buildToolInfoVersion); |
| |
| if (buildToolsInfo != null) { |
| state.setBuildToolInfo(buildToolsInfo); |
| } else { |
| markerMessage = String.format("Unable to resolve %s property value '%s'", |
| ProjectProperties.PROPERTY_BUILD_TOOLS, |
| buildToolInfoVersion); |
| } |
| } else { |
| // this is ok, we'll use the latest one automatically. |
| state.setBuildToolInfo(null); |
| } |
| |
| handleBuildToolsMarker(state.getProject(), markerMessage); |
| } |
| |
| return target; |
| } |
| |
| /** |
| * Adds or edit a build tools marker from the given project. This is done through a Job. |
| * @param project the project |
| * @param markerMessage the message. if null the marker is removed. |
| */ |
| private void handleBuildToolsMarker(final IProject project, final String markerMessage) { |
| Job markerJob = new Job("Android SDK: Build Tools Marker") { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| try { |
| if (project.isAccessible()) { |
| // always delete existing marker first |
| project.deleteMarkers(AdtConstants.MARKER_BUILD_TOOLS, true, |
| IResource.DEPTH_ZERO); |
| |
| // add the new one if needed. |
| if (markerMessage != null) { |
| BaseProjectHelper.markProject(project, |
| AdtConstants.MARKER_BUILD_TOOLS, |
| markerMessage, IMarker.SEVERITY_ERROR, |
| IMarker.PRIORITY_HIGH); |
| } |
| } |
| } catch (CoreException e2) { |
| AdtPlugin.log(e2, null); |
| // Don't return e2.getStatus(); the job control will then produce |
| // a popup with this error, which isn't very interesting for the |
| // user. |
| } |
| |
| return Status.OK_STATUS; |
| } |
| }; |
| |
| // build jobs are run after other interactive jobs |
| markerJob.setPriority(Job.BUILD); |
| markerJob.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| markerJob.schedule(); |
| } |
| |
| /** |
| * Checks and loads (if needed) the data for a given target. |
| * <p/> The data is loaded in a separate {@link Job}, and opened editors will be notified |
| * through their implementation of {@link ITargetChangeListener#onTargetLoaded(IAndroidTarget)}. |
| * <p/>An optional project as second parameter can be given to be recompiled once the target |
| * data is finished loading. |
| * <p/>The return value is non-null only if the target data has already been loaded (and in this |
| * case is the status of the load operation) |
| * @param target the target to load. |
| * @param project an optional project to be recompiled when the target data is loaded. |
| * If the target is already loaded, nothing happens. |
| * @return The load status if the target data is already loaded. |
| */ |
| @NonNull |
| public LoadStatus checkAndLoadTargetData(final IAndroidTarget target, IJavaProject project) { |
| boolean loadData = false; |
| |
| synchronized (LOCK) { |
| if (mDontLoadTargetData) { |
| return LoadStatus.FAILED; |
| } |
| |
| TargetLoadBundle bundle = mTargetDataStatusMap.get(target); |
| if (bundle == null) { |
| bundle = new TargetLoadBundle(); |
| mTargetDataStatusMap.put(target,bundle); |
| |
| // set status to loading |
| bundle.status = LoadStatus.LOADING; |
| |
| // add project to bundle |
| if (project != null) { |
| bundle.projectsToReload.add(project); |
| } |
| |
| // and set the flag to start the loading below |
| loadData = true; |
| } else if (bundle.status == LoadStatus.LOADING) { |
| // add project to bundle |
| if (project != null) { |
| bundle.projectsToReload.add(project); |
| } |
| |
| return bundle.status; |
| } else if (bundle.status == LoadStatus.LOADED || bundle.status == LoadStatus.FAILED) { |
| return bundle.status; |
| } |
| } |
| |
| if (loadData) { |
| Job job = new Job(String.format("Loading data for %1$s", target.getFullName())) { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| AdtPlugin plugin = AdtPlugin.getDefault(); |
| try { |
| IStatus status = new AndroidTargetParser(target).run(monitor); |
| |
| IJavaProject[] javaProjectArray = null; |
| |
| synchronized (LOCK) { |
| TargetLoadBundle bundle = mTargetDataStatusMap.get(target); |
| |
| if (status.getCode() != IStatus.OK) { |
| bundle.status = LoadStatus.FAILED; |
| bundle.projectsToReload.clear(); |
| } else { |
| bundle.status = LoadStatus.LOADED; |
| |
| // Prepare the array of project to recompile. |
| // The call is done outside of the synchronized block. |
| javaProjectArray = bundle.projectsToReload.toArray( |
| new IJavaProject[bundle.projectsToReload.size()]); |
| |
| // and update the UI of the editors that depend on the target data. |
| plugin.updateTargetListeners(target); |
| } |
| } |
| |
| if (javaProjectArray != null) { |
| ProjectHelper.updateProjects(javaProjectArray); |
| } |
| |
| return status; |
| } catch (Throwable t) { |
| synchronized (LOCK) { |
| TargetLoadBundle bundle = mTargetDataStatusMap.get(target); |
| bundle.status = LoadStatus.FAILED; |
| } |
| |
| AdtPlugin.log(t, "Exception in checkAndLoadTargetData."); //$NON-NLS-1$ |
| String message = String.format("Parsing Data for %1$s failed", target.hashString()); |
| if (t instanceof UnsupportedClassVersionError) { |
| message = "To use this platform, run Eclipse with JDK 7 or later. (" + message + ")"; |
| } |
| return new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, message, t); |
| } |
| } |
| }; |
| job.setPriority(Job.BUILD); // build jobs are run after other interactive jobs |
| job.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| job.schedule(); |
| } |
| |
| // The only way to go through here is when the loading starts through the Job. |
| // Therefore the current status of the target is LOADING. |
| return LoadStatus.LOADING; |
| } |
| |
| /** |
| * Return the {@link AndroidTargetData} for a given {@link IAndroidTarget}. |
| */ |
| @Nullable |
| public AndroidTargetData getTargetData(IAndroidTarget target) { |
| synchronized (LOCK) { |
| return mTargetDataMap.get(target); |
| } |
| } |
| |
| /** |
| * Return the {@link AndroidTargetData} for a given {@link IProject}. |
| */ |
| @Nullable |
| public AndroidTargetData getTargetData(IProject project) { |
| synchronized (LOCK) { |
| IAndroidTarget target = getTarget(project); |
| if (target != null) { |
| return getTargetData(target); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns a {@link DexWrapper} object to be used to execute dx commands. If dx.jar was not |
| * loaded properly, then this will return <code>null</code>. |
| */ |
| @Nullable |
| public DexWrapper getDexWrapper(@Nullable BuildToolInfo buildToolInfo) { |
| if (buildToolInfo == null) { |
| return null; |
| } |
| synchronized (LOCK) { |
| String dexLocation = buildToolInfo.getPath(BuildToolInfo.PathId.DX_JAR); |
| DexWrapper dexWrapper = mDexWrappers.get(dexLocation); |
| |
| if (dexWrapper == null) { |
| // load DX. |
| dexWrapper = new DexWrapper(); |
| IStatus res = dexWrapper.loadDex(dexLocation); |
| if (res != Status.OK_STATUS) { |
| AdtPlugin.log(null, res.getMessage()); |
| dexWrapper = null; |
| } else { |
| mDexWrappers.put(dexLocation, dexWrapper); |
| } |
| } |
| |
| return dexWrapper; |
| } |
| } |
| |
| public void unloadDexWrappers() { |
| synchronized (LOCK) { |
| for (DexWrapper wrapper : mDexWrappers.values()) { |
| wrapper.unload(); |
| } |
| mDexWrappers.clear(); |
| } |
| } |
| |
| /** |
| * Returns the {@link AvdManager}. If the AvdManager failed to parse the AVD folder, this could |
| * be <code>null</code>. |
| */ |
| @Nullable |
| public AvdManager getAvdManager() { |
| return mAvdManager; |
| } |
| |
| @Nullable |
| public static AndroidVersion getDeviceVersion(@NonNull IDevice device) { |
| try { |
| Map<String, String> props = device.getProperties(); |
| String apiLevel = props.get(IDevice.PROP_BUILD_API_LEVEL); |
| if (apiLevel == null) { |
| return null; |
| } |
| |
| return new AndroidVersion(Integer.parseInt(apiLevel), |
| props.get((IDevice.PROP_BUILD_CODENAME))); |
| } catch (NumberFormatException e) { |
| return null; |
| } |
| } |
| |
| @NonNull |
| public DeviceManager getDeviceManager() { |
| return mDeviceManager; |
| } |
| |
| /** |
| * Returns a list of {@link ProjectState} representing projects depending, directly or |
| * indirectly on a given library project. |
| * @param project the library project. |
| * @return a possibly empty list of ProjectState. |
| */ |
| @NonNull |
| public static Set<ProjectState> getMainProjectsFor(IProject project) { |
| synchronized (LOCK) { |
| // first get the project directly depending on this. |
| Set<ProjectState> list = new HashSet<ProjectState>(); |
| |
| // loop on all project and see if ProjectState.getLibrary returns a non null |
| // project. |
| for (Entry<IProject, ProjectState> entry : sProjectStateMap.entrySet()) { |
| if (project != entry.getKey()) { |
| LibraryState library = entry.getValue().getLibrary(project); |
| if (library != null) { |
| list.add(entry.getValue()); |
| } |
| } |
| } |
| |
| // now look for projects depending on the projects directly depending on the library. |
| HashSet<ProjectState> result = new HashSet<ProjectState>(list); |
| for (ProjectState p : list) { |
| if (p.isLibrary()) { |
| Set<ProjectState> set = getMainProjectsFor(p.getProject()); |
| result.addAll(set); |
| } |
| } |
| |
| return result; |
| } |
| } |
| |
| /** |
| * Unload the SDK's target data. |
| * |
| * If <var>preventReload</var>, this effect is final until the SDK instance is changed |
| * through {@link #loadSdk(String)}. |
| * |
| * The goal is to unload the targets to be able to replace existing targets with new ones, |
| * before calling {@link #loadSdk(String)} to fully reload the SDK. |
| * |
| * @param preventReload prevent the data from being loaded again for the remaining live of |
| * this {@link Sdk} instance. |
| */ |
| public void unloadTargetData(boolean preventReload) { |
| synchronized (LOCK) { |
| mDontLoadTargetData = preventReload; |
| |
| // dispose of the target data. |
| for (AndroidTargetData data : mTargetDataMap.values()) { |
| data.dispose(); |
| } |
| |
| mTargetDataMap.clear(); |
| } |
| } |
| |
| private Sdk(SdkManager manager, AvdManager avdManager) { |
| mManager = manager; |
| mAvdManager = avdManager; |
| |
| // listen to projects closing |
| GlobalProjectMonitor monitor = GlobalProjectMonitor.getMonitor(); |
| // need to register the resource event listener first because the project listener |
| // is called back during registration with project opened in the workspace. |
| monitor.addResourceEventListener(mResourceEventListener); |
| monitor.addProjectListener(mProjectListener); |
| monitor.addFileListener(mFileListener, |
| IResourceDelta.CHANGED | IResourceDelta.ADDED | IResourceDelta.REMOVED); |
| |
| // pre-compute some paths |
| mDocBaseUrl = getDocumentationBaseUrl(manager.getLocation() + |
| SdkConstants.OS_SDK_DOCS_FOLDER); |
| |
| mDeviceManager = DeviceManager.createInstance(manager.getLocalSdk().getLocation(), |
| AdtPlugin.getDefault()); |
| |
| // update whatever ProjectState is already present with new IAndroidTarget objects. |
| synchronized (LOCK) { |
| for (Entry<IProject, ProjectState> entry: sProjectStateMap.entrySet()) { |
| loadTargetAndBuildTools(entry.getValue()); |
| } |
| } |
| } |
| |
| /** |
| * Cleans and unloads the SDK. |
| */ |
| private void dispose() { |
| GlobalProjectMonitor monitor = GlobalProjectMonitor.getMonitor(); |
| monitor.removeProjectListener(mProjectListener); |
| monitor.removeFileListener(mFileListener); |
| monitor.removeResourceEventListener(mResourceEventListener); |
| |
| // the IAndroidTarget objects are now obsolete so update the project states. |
| synchronized (LOCK) { |
| for (Entry<IProject, ProjectState> entry: sProjectStateMap.entrySet()) { |
| entry.getValue().setTarget(null); |
| } |
| |
| // dispose of the target data. |
| for (AndroidTargetData data : mTargetDataMap.values()) { |
| data.dispose(); |
| } |
| |
| mTargetDataMap.clear(); |
| } |
| } |
| |
| void setTargetData(IAndroidTarget target, AndroidTargetData data) { |
| synchronized (LOCK) { |
| mTargetDataMap.put(target, data); |
| } |
| } |
| |
| /** |
| * Returns the URL to the local documentation. |
| * Can return null if no documentation is found in the current SDK. |
| * |
| * @param osDocsPath Path to the documentation folder in the current SDK. |
| * The folder may not actually exist. |
| * @return A file:// URL on the local documentation folder if it exists or null. |
| */ |
| private String getDocumentationBaseUrl(String osDocsPath) { |
| File f = new File(osDocsPath); |
| |
| if (f.isDirectory()) { |
| try { |
| // Note: to create a file:// URL, one would typically use something like |
| // f.toURI().toURL().toString(). However this generates a broken path on |
| // Windows, namely "C:\\foo" is converted to "file:/C:/foo" instead of |
| // "file:///C:/foo" (i.e. there should be 3 / after "file:"). So we'll |
| // do the correct thing manually. |
| |
| String path = f.getAbsolutePath(); |
| if (File.separatorChar != '/') { |
| path = path.replace(File.separatorChar, '/'); |
| } |
| |
| // For some reason the URL class doesn't add the mandatory "//" after |
| // the "file:" protocol name, so it has to be hacked into the path. |
| URL url = new URL("file", null, "//" + path); //$NON-NLS-1$ //$NON-NLS-2$ |
| String result = url.toString(); |
| return result; |
| } catch (MalformedURLException e) { |
| // ignore malformed URLs |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Delegate listener for project changes. |
| */ |
| private IProjectListener mProjectListener = new IProjectListener() { |
| @Override |
| public void projectClosed(IProject project) { |
| onProjectRemoved(project, false /*deleted*/); |
| } |
| |
| @Override |
| public void projectDeleted(IProject project) { |
| onProjectRemoved(project, true /*deleted*/); |
| } |
| |
| private void onProjectRemoved(IProject removedProject, boolean deleted) { |
| if (DEBUG) { |
| System.out.println(">>> CLOSED: " + removedProject.getName()); |
| } |
| |
| // get the target project |
| synchronized (LOCK) { |
| // Don't use getProject() as it could create the ProjectState if it's not |
| // there yet and this is not what we want. We want the current object. |
| // Therefore, direct access to the map. |
| ProjectState removedState = sProjectStateMap.get(removedProject); |
| if (removedState != null) { |
| // 1. clear the layout lib cache associated with this project |
| IAndroidTarget target = removedState.getTarget(); |
| if (target != null) { |
| // get the bridge for the target, and clear the cache for this project. |
| AndroidTargetData data = mTargetDataMap.get(target); |
| if (data != null) { |
| LayoutLibrary layoutLib = data.getLayoutLibrary(); |
| if (layoutLib != null && layoutLib.getStatus() == LoadStatus.LOADED) { |
| layoutLib.clearCaches(removedProject); |
| } |
| } |
| } |
| |
| // 2. if the project is a library, make sure to update the |
| // LibraryState for any project referencing it. |
| // Also, record the updated projects that are libraries, to update |
| // projects that depend on them. |
| for (ProjectState projectState : sProjectStateMap.values()) { |
| LibraryState libState = projectState.getLibrary(removedProject); |
| if (libState != null) { |
| // Close the library right away. |
| // This remove links between the LibraryState and the projectState. |
| // This is because in case of a rename of a project, projectClosed and |
| // projectOpened will be called before any other job is run, so we |
| // need to make sure projectOpened is closed with the main project |
| // state up to date. |
| libState.close(); |
| |
| // record that this project changed, and in case it's a library |
| // that its parents need to be updated as well. |
| markProject(projectState, projectState.isLibrary()); |
| } |
| } |
| |
| // now remove the project for the project map. |
| sProjectStateMap.remove(removedProject); |
| } |
| } |
| |
| if (DEBUG) { |
| System.out.println("<<<"); |
| } |
| } |
| |
| @Override |
| public void projectOpened(IProject project) { |
| onProjectOpened(project); |
| } |
| |
| @Override |
| public void projectOpenedWithWorkspace(IProject project) { |
| // no need to force recompilation when projects are opened with the workspace. |
| onProjectOpened(project); |
| } |
| |
| @Override |
| public void allProjectsOpenedWithWorkspace() { |
| // Correct currently open editors |
| fixOpenLegacyEditors(); |
| } |
| |
| private void onProjectOpened(final IProject openedProject) { |
| |
| ProjectState openedState = getProjectState(openedProject); |
| if (openedState != null) { |
| if (DEBUG) { |
| System.out.println(">>> OPENED: " + openedProject.getName()); |
| } |
| |
| synchronized (LOCK) { |
| final boolean isLibrary = openedState.isLibrary(); |
| final boolean hasLibraries = openedState.hasLibraries(); |
| |
| if (isLibrary || hasLibraries) { |
| boolean foundLibraries = false; |
| // loop on all the existing project and update them based on this new |
| // project |
| for (ProjectState projectState : sProjectStateMap.values()) { |
| if (projectState != openedState) { |
| // If the project has libraries, check if this project |
| // is a reference. |
| if (hasLibraries) { |
| // ProjectState#needs() both checks if this is a missing library |
| // and updates LibraryState to contains the new values. |
| // This must always be called. |
| LibraryState libState = openedState.needs(projectState); |
| |
| if (libState != null) { |
| // found a library! Add the main project to the list of |
| // modified project |
| foundLibraries = true; |
| } |
| } |
| |
| // if the project is a library check if the other project depend |
| // on it. |
| if (isLibrary) { |
| // ProjectState#needs() both checks if this is a missing library |
| // and updates LibraryState to contains the new values. |
| // This must always be called. |
| LibraryState libState = projectState.needs(openedState); |
| |
| if (libState != null) { |
| // There's a dependency! Add the project to the list of |
| // modified project, but also to a list of projects |
| // that saw one of its dependencies resolved. |
| markProject(projectState, projectState.isLibrary()); |
| } |
| } |
| } |
| } |
| |
| // if the project has a libraries and we found at least one, we add |
| // the project to the list of modified project. |
| // Since we already went through the parent, no need to update them. |
| if (foundLibraries) { |
| markProject(openedState, false /*updateParents*/); |
| } |
| } |
| } |
| |
| // Correct file editor associations. |
| fixEditorAssociations(openedProject); |
| |
| // Fix classpath entries in a job since the workspace might be locked now. |
| Job fixCpeJob = new Job("Adjusting Android Project Classpath") { |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| try { |
| ProjectHelper.fixProjectClasspathEntries( |
| JavaCore.create(openedProject)); |
| } catch (JavaModelException e) { |
| AdtPlugin.log(e, "error fixing classpath entries"); |
| // Don't return e2.getStatus(); the job control will then produce |
| // a popup with this error, which isn't very interesting for the |
| // user. |
| } |
| |
| return Status.OK_STATUS; |
| } |
| }; |
| |
| // build jobs are run after other interactive jobs |
| fixCpeJob.setPriority(Job.BUILD); |
| fixCpeJob.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| fixCpeJob.schedule(); |
| |
| |
| if (DEBUG) { |
| System.out.println("<<<"); |
| } |
| } |
| } |
| |
| @Override |
| public void projectRenamed(IProject project, IPath from) { |
| // we don't actually care about this anymore. |
| } |
| }; |
| |
| /** |
| * Delegate listener for file changes. |
| */ |
| private IFileListener mFileListener = new IFileListener() { |
| @Override |
| public void fileChanged(final @NonNull IFile file, @NonNull IMarkerDelta[] markerDeltas, |
| int kind, @Nullable String extension, int flags, boolean isAndroidPRoject) { |
| if (!isAndroidPRoject) { |
| return; |
| } |
| |
| if (SdkConstants.FN_PROJECT_PROPERTIES.equals(file.getName()) && |
| file.getParent() == file.getProject()) { |
| try { |
| // reload the content of the project.properties file and update |
| // the target. |
| IProject iProject = file.getProject(); |
| |
| ProjectState state = Sdk.getProjectState(iProject); |
| |
| // get the current target and build tools |
| IAndroidTarget oldTarget = state.getTarget(); |
| boolean oldRsSupportMode = state.getRenderScriptSupportMode(); |
| |
| // get the current library flag |
| boolean wasLibrary = state.isLibrary(); |
| |
| LibraryDifference diff = state.reloadProperties(); |
| |
| // load the (possibly new) target. |
| IAndroidTarget newTarget = loadTargetAndBuildTools(state); |
| |
| // reload the libraries if needed |
| if (diff.hasDiff()) { |
| if (diff.added) { |
| synchronized (LOCK) { |
| for (ProjectState projectState : sProjectStateMap.values()) { |
| if (projectState != state) { |
| // need to call needs to do the libraryState link, |
| // but no need to look at the result, as we'll compare |
| // the result of getFullLibraryProjects() |
| // this is easier to due to indirect dependencies. |
| state.needs(projectState); |
| } |
| } |
| } |
| } |
| |
| markProject(state, wasLibrary || state.isLibrary()); |
| } |
| |
| // apply the new target if needed. |
| if (newTarget != oldTarget || |
| oldRsSupportMode != state.getRenderScriptSupportMode()) { |
| IJavaProject javaProject = BaseProjectHelper.getJavaProject( |
| file.getProject()); |
| if (javaProject != null) { |
| ProjectHelper.updateProject(javaProject); |
| } |
| |
| // update the editors to reload with the new target |
| AdtPlugin.getDefault().updateTargetListeners(iProject); |
| } |
| } catch (CoreException e) { |
| // This can't happen as it's only for closed project (or non existing) |
| // but in that case we can't get a fileChanged on this file. |
| } |
| } else if (kind == IResourceDelta.ADDED || kind == IResourceDelta.REMOVED) { |
| // check if it's an add/remove on a jar files inside libs |
| if (EXT_JAR.equals(extension) && |
| file.getProjectRelativePath().segmentCount() == 2 && |
| file.getParent().getName().equals(SdkConstants.FD_NATIVE_LIBS)) { |
| // need to update the project and whatever depend on it. |
| |
| processJarFileChange(file); |
| } |
| } |
| } |
| |
| private void processJarFileChange(final IFile file) { |
| try { |
| IProject iProject = file.getProject(); |
| |
| if (iProject.hasNature(AdtConstants.NATURE_DEFAULT) == false) { |
| return; |
| } |
| |
| List<IJavaProject> projectList = new ArrayList<IJavaProject>(); |
| IJavaProject javaProject = BaseProjectHelper.getJavaProject(iProject); |
| if (javaProject != null) { |
| projectList.add(javaProject); |
| } |
| |
| ProjectState state = Sdk.getProjectState(iProject); |
| |
| if (state != null) { |
| Collection<ProjectState> parents = state.getFullParentProjects(); |
| for (ProjectState s : parents) { |
| javaProject = BaseProjectHelper.getJavaProject(s.getProject()); |
| if (javaProject != null) { |
| projectList.add(javaProject); |
| } |
| } |
| |
| ProjectHelper.updateProjects( |
| projectList.toArray(new IJavaProject[projectList.size()])); |
| } |
| } catch (CoreException e) { |
| // This can't happen as it's only for closed project (or non existing) |
| // but in that case we can't get a fileChanged on this file. |
| } |
| } |
| }; |
| |
| /** List of modified projects. This is filled in |
| * {@link IProjectListener#projectOpened(IProject)}, |
| * {@link IProjectListener#projectOpenedWithWorkspace(IProject)}, |
| * {@link IProjectListener#projectClosed(IProject)}, and |
| * {@link IProjectListener#projectDeleted(IProject)} and processed in |
| * {@link IResourceEventListener#resourceChangeEventEnd()}. |
| */ |
| private final List<ProjectState> mModifiedProjects = new ArrayList<ProjectState>(); |
| private final List<ProjectState> mModifiedChildProjects = new ArrayList<ProjectState>(); |
| |
| private void markProject(ProjectState projectState, boolean updateParents) { |
| if (mModifiedProjects.contains(projectState) == false) { |
| if (DEBUG) { |
| System.out.println("\tMARKED: " + projectState.getProject().getName()); |
| } |
| mModifiedProjects.add(projectState); |
| } |
| |
| // if the project is resolved also add it to this list. |
| if (updateParents) { |
| if (mModifiedChildProjects.contains(projectState) == false) { |
| if (DEBUG) { |
| System.out.println("\tMARKED(child): " + projectState.getProject().getName()); |
| } |
| mModifiedChildProjects.add(projectState); |
| } |
| } |
| } |
| |
| /** |
| * Delegate listener for resource changes. This is called before and after any calls to the |
| * project and file listeners (for a given resource change event). |
| */ |
| private IResourceEventListener mResourceEventListener = new IResourceEventListener() { |
| @Override |
| public void resourceChangeEventStart() { |
| mModifiedProjects.clear(); |
| mModifiedChildProjects.clear(); |
| } |
| |
| @Override |
| public void resourceChangeEventEnd() { |
| if (mModifiedProjects.size() == 0) { |
| return; |
| } |
| |
| // first make sure all the parents are updated |
| updateParentProjects(); |
| |
| // for all modified projects, update their library list |
| // and gather their IProject |
| final List<IJavaProject> projectList = new ArrayList<IJavaProject>(); |
| for (ProjectState state : mModifiedProjects) { |
| state.updateFullLibraryList(); |
| projectList.add(JavaCore.create(state.getProject())); |
| } |
| |
| Job job = new Job("Android Library Update") { //$NON-NLS-1$ |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| LibraryClasspathContainerInitializer.updateProjects( |
| projectList.toArray(new IJavaProject[projectList.size()])); |
| |
| for (IJavaProject javaProject : projectList) { |
| try { |
| javaProject.getProject().build(IncrementalProjectBuilder.FULL_BUILD, |
| monitor); |
| } catch (CoreException e) { |
| // pass |
| } |
| } |
| return Status.OK_STATUS; |
| } |
| }; |
| job.setPriority(Job.BUILD); |
| job.setRule(ResourcesPlugin.getWorkspace().getRoot()); |
| job.schedule(); |
| } |
| }; |
| |
| /** |
| * Updates all existing projects with a given list of new/updated libraries. |
| * This loops through all opened projects and check if they depend on any of the given |
| * library project, and if they do, they are linked together. |
| */ |
| private void updateParentProjects() { |
| if (mModifiedChildProjects.size() == 0) { |
| return; |
| } |
| |
| ArrayList<ProjectState> childProjects = new ArrayList<ProjectState>(mModifiedChildProjects); |
| mModifiedChildProjects.clear(); |
| synchronized (LOCK) { |
| // for each project for which we must update its parent, we loop on the parent |
| // projects and adds them to the list of modified projects. If they are themselves |
| // libraries, we add them too. |
| for (ProjectState state : childProjects) { |
| if (DEBUG) { |
| System.out.println(">>> Updating parents of " + state.getProject().getName()); |
| } |
| List<ProjectState> parents = state.getParentProjects(); |
| for (ProjectState parent : parents) { |
| markProject(parent, parent.isLibrary()); |
| } |
| if (DEBUG) { |
| System.out.println("<<<"); |
| } |
| } |
| } |
| |
| // done, but there may be parents that are also libraries. Need to update their parents. |
| updateParentProjects(); |
| } |
| |
| /** |
| * Fix editor associations for the given project, if not already done. |
| * <p/> |
| * Eclipse has a per-file setting for which editor should be used for each file |
| * (see {@link IDE#setDefaultEditor(IFile, String)}). |
| * We're using this flag to pick between the various XML editors (layout, drawable, etc) |
| * since they all have the same file name extension. |
| * <p/> |
| * Unfortunately, the file setting can be "wrong" for two reasons: |
| * <ol> |
| * <li> The editor type was added <b>after</b> a file had been seen by the IDE. |
| * For example, we added new editors for animations and for drawables around |
| * ADT 12, but any file seen by ADT in earlier versions will continue to use |
| * the vanilla Eclipse XML editor instead. |
| * <li> A bug in ADT 14 and ADT 15 (see issue 21124) meant that files created in new |
| * folders would end up with wrong editor associations. Even though that bug |
| * is fixed in ADT 16, the fix only affects new files, it cannot retroactively |
| * fix editor associations that were set incorrectly by ADT 14 or 15. |
| * </ol> |
| * <p/> |
| * This method attempts to fix the editor bindings retroactively by scanning all the |
| * resource XML files and resetting the editor associations. |
| * Since this is a potentially slow operation, this is only done "once"; we use a |
| * persistent project property to avoid looking repeatedly. In the future if we add |
| * additional editors, we can rev the scanned version value. |
| */ |
| private void fixEditorAssociations(final IProject project) { |
| QualifiedName KEY = new QualifiedName(AdtPlugin.PLUGIN_ID, "editorbinding"); //$NON-NLS-1$ |
| |
| try { |
| String value = project.getPersistentProperty(KEY); |
| int currentVersion = 0; |
| if (value != null) { |
| try { |
| currentVersion = Integer.parseInt(value); |
| } catch (Exception ingore) { |
| } |
| } |
| |
| // The target version we're comparing to. This must be incremented each time |
| // we change the processing here so that a new version of the plugin would |
| // try to fix existing user projects. |
| final int targetVersion = 2; |
| |
| if (currentVersion >= targetVersion) { |
| return; |
| } |
| |
| // Set to specific version such that we can rev the version in the future |
| // to trigger further scanning |
| project.setPersistentProperty(KEY, Integer.toString(targetVersion)); |
| |
| // Now update the actual editor associations. |
| Job job = new Job("Update Android editor bindings") { //$NON-NLS-1$ |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| try { |
| for (IResource folderResource : project.getFolder(FD_RES).members()) { |
| if (folderResource instanceof IFolder) { |
| IFolder folder = (IFolder) folderResource; |
| |
| for (IResource resource : folder.members()) { |
| if (resource instanceof IFile && |
| resource.getName().endsWith(DOT_XML)) { |
| fixXmlFile((IFile) resource); |
| } |
| } |
| } |
| } |
| |
| // TODO change AndroidManifest.xml ID too |
| |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| |
| return Status.OK_STATUS; |
| } |
| |
| /** |
| * Attempt to fix the editor ID for the given /res XML file. |
| */ |
| private void fixXmlFile(final IFile file) { |
| // Fix the default editor ID for this resource. |
| // This has no effect on currently open editors. |
| IEditorDescriptor desc = IDE.getDefaultEditor(file); |
| |
| if (desc == null || !CommonXmlEditor.ID.equals(desc.getId())) { |
| IDE.setDefaultEditor(file, CommonXmlEditor.ID); |
| } |
| } |
| }; |
| job.setPriority(Job.BUILD); |
| job.schedule(); |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| } |
| |
| /** |
| * Tries to fix all currently open Android legacy editors. |
| * <p/> |
| * If an editor is found to match one of the legacy ids, we'll try to close it. |
| * If that succeeds, we try to reopen it using the new common editor ID. |
| * <p/> |
| * This method must be run from the UI thread. |
| */ |
| private void fixOpenLegacyEditors() { |
| |
| AdtPlugin adt = AdtPlugin.getDefault(); |
| if (adt == null) { |
| return; |
| } |
| |
| final IPreferenceStore store = adt.getPreferenceStore(); |
| int currentValue = store.getInt(AdtPrefs.PREFS_FIX_LEGACY_EDITORS); |
| // The target version we're comparing to. This must be incremented each time |
| // we change the processing here so that a new version of the plugin would |
| // try to fix existing editors. |
| final int targetValue = 1; |
| |
| if (currentValue >= targetValue) { |
| return; |
| } |
| |
| // To be able to close and open editors we need to make sure this is done |
| // in the UI thread, which this isn't invoked from. |
| PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| HashSet<String> legacyIds = |
| new HashSet<String>(Arrays.asList(CommonXmlEditor.LEGACY_EDITOR_IDS)); |
| |
| for (IWorkbenchWindow win : PlatformUI.getWorkbench().getWorkbenchWindows()) { |
| for (IWorkbenchPage page : win.getPages()) { |
| for (IEditorReference ref : page.getEditorReferences()) { |
| try { |
| IEditorInput input = ref.getEditorInput(); |
| if (input instanceof IFileEditorInput) { |
| IFile file = ((IFileEditorInput)input).getFile(); |
| IEditorPart part = ref.getEditor(true /*restore*/); |
| if (part != null) { |
| IWorkbenchPartSite site = part.getSite(); |
| if (site != null) { |
| String id = site.getId(); |
| if (legacyIds.contains(id)) { |
| // This editor matches one of legacy editor IDs. |
| fixEditor(page, part, input, file, id); |
| } |
| } |
| } |
| } |
| } catch (Exception e) { |
| // ignore |
| } |
| } |
| } |
| } |
| |
| // Remember that we managed to do fix all editors |
| store.setValue(AdtPrefs.PREFS_FIX_LEGACY_EDITORS, targetValue); |
| } |
| |
| private void fixEditor( |
| IWorkbenchPage page, |
| IEditorPart part, |
| IEditorInput input, |
| IFile file, |
| String id) { |
| IDE.setDefaultEditor(file, CommonXmlEditor.ID); |
| |
| boolean ok = page.closeEditor(part, true /*save*/); |
| |
| AdtPlugin.log(IStatus.INFO, |
| "Closed legacy editor ID %s for %s: %s", //$NON-NLS-1$ |
| id, |
| file.getFullPath(), |
| ok ? "Success" : "Failed");//$NON-NLS-1$ //$NON-NLS-2$ |
| |
| if (ok) { |
| // Try to reopen it with the new ID |
| try { |
| page.openEditor(input, CommonXmlEditor.ID); |
| } catch (PartInitException e) { |
| AdtPlugin.log(e, |
| "Failed to reopen %s", //$NON-NLS-1$ |
| file.getFullPath()); |
| } |
| } |
| } |
| }); |
| } |
| } |
