| /* |
| * Copyright (C) 2011 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.resources.manager; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.ide.eclipse.adt.AdtConstants.MARKER_AAPT_COMPILE; |
| import static org.eclipse.core.resources.IResource.DEPTH_ONE; |
| import static org.eclipse.core.resources.IResource.DEPTH_ZERO; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.resources.ResourceRepository; |
| import com.android.ide.common.resources.ScanningContext; |
| import com.android.ide.common.resources.platform.AttributeInfo; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.build.AaptParser; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.utils.Pair; |
| |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.CoreException; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * An {@link IdeScanningContext} is a specialized {@link ScanningContext} which |
| * carries extra information about the scanning state, such as which file is |
| * currently being scanned, and which files have been scanned in the past, such |
| * that at the end of a scan we can mark and clear errors, etc. |
| */ |
| public class IdeScanningContext extends ScanningContext { |
| private final IProject mProject; |
| private final List<IResource> mScannedResources = new ArrayList<IResource>(); |
| private IResource mCurrentFile; |
| private List<Pair<IResource, String>> mErrors; |
| private Set<IProject> mFullAaptProjects; |
| private boolean mValidate; |
| private Map<String, AttributeInfo> mAttributeMap; |
| private ResourceRepository mFrameworkResources; |
| |
| /** |
| * Constructs a new {@link IdeScanningContext} |
| * |
| * @param repository the associated {@link ResourceRepository} |
| * @param project the associated project |
| * @param validate if true, check that the attributes and resources are |
| * valid and if not request a full AAPT check |
| */ |
| public IdeScanningContext(@NonNull ResourceRepository repository, @NonNull IProject project, |
| boolean validate) { |
| super(repository); |
| mProject = project; |
| mValidate = validate; |
| |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk != null) { |
| AndroidTargetData targetData = sdk.getTargetData(project); |
| if (targetData != null) { |
| mAttributeMap = targetData.getAttributeMap(); |
| mFrameworkResources = targetData.getFrameworkResources(); |
| } |
| } |
| } |
| |
| @Override |
| public void addError(@NonNull String error) { |
| super.addError(error); |
| |
| if (mErrors == null) { |
| mErrors = new ArrayList<Pair<IResource,String>>(); |
| } |
| mErrors.add(Pair.of(mCurrentFile, error)); |
| } |
| |
| /** |
| * Notifies the context that the given resource is about to be scanned. |
| * |
| * @param resource the resource about to be scanned |
| */ |
| public void startScanning(@NonNull IResource resource) { |
| assert mCurrentFile == null : mCurrentFile; |
| mCurrentFile = resource; |
| mScannedResources.add(resource); |
| } |
| |
| /** |
| * Notifies the context that the given resource has been scanned. |
| * |
| * @param resource the resource that was scanned |
| */ |
| public void finishScanning(@NonNull IResource resource) { |
| assert mCurrentFile != null; |
| mCurrentFile = null; |
| } |
| |
| /** |
| * Process any errors found to add error markers in the affected files (and |
| * also clear up any aapt errors in files that are no longer applicable) |
| * |
| * @param async if true, delay updating markers until the next display |
| * thread event loop update |
| */ |
| public void updateMarkers(boolean async) { |
| // Run asynchronously? This is necessary for example when adding markers |
| // as the result of a resource change notification, since at that point the |
| // resource tree is locked for modifications and attempting to create a |
| // marker will throw a org.eclipse.core.internal.resources.ResourceException. |
| if (async) { |
| AdtPlugin.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| updateMarkers(false); |
| } |
| }); |
| return; |
| } |
| |
| // First clear out old/previous markers |
| for (IResource resource : mScannedResources) { |
| try { |
| if (resource.exists()) { |
| int depth = resource instanceof IFolder ? DEPTH_ONE : DEPTH_ZERO; |
| resource.deleteMarkers(MARKER_AAPT_COMPILE, true, depth); |
| } |
| } catch (CoreException ce) { |
| // Pass |
| } |
| } |
| |
| // Add new errors |
| if (mErrors != null && mErrors.size() > 0) { |
| List<String> errors = new ArrayList<String>(); |
| for (Pair<IResource, String> pair : mErrors) { |
| errors.add(pair.getSecond()); |
| } |
| AaptParser.parseOutput(errors, mProject); |
| } |
| } |
| |
| @Override |
| public boolean needsFullAapt() { |
| // returns true if it was explicitly requested or if a file that has errors was modified. |
| // This handles the case where an edit doesn't add any new id but fix a compile error. |
| return super.needsFullAapt() || hasModifiedFilesWithErrors(); |
| } |
| |
| /** |
| * Returns true if any of the scanned resources has an error marker on it. |
| */ |
| private boolean hasModifiedFilesWithErrors() { |
| for (IResource resource : mScannedResources) { |
| try { |
| int depth = resource instanceof IFolder ? DEPTH_ONE : DEPTH_ZERO; |
| if (resource.exists()) { |
| IMarker[] markers = resource.findMarkers(IMarker.PROBLEM, |
| true /*includeSubtypes*/, depth); |
| for (IMarker marker : markers) { |
| if (marker.getAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO) == |
| IMarker.SEVERITY_ERROR) { |
| return true; |
| } |
| } |
| } |
| } catch (CoreException ce) { |
| // Pass |
| } |
| } |
| |
| return false; |
| } |
| |
| @Override |
| protected void requestFullAapt() { |
| super.requestFullAapt(); |
| |
| if (mCurrentFile != null) { |
| if (mFullAaptProjects == null) { |
| mFullAaptProjects = new HashSet<IProject>(); |
| } |
| mFullAaptProjects.add(mCurrentFile.getProject()); |
| } else { |
| assert false : "No current context to apply IdeScanningContext to"; |
| } |
| } |
| |
| /** |
| * Returns the collection of projects that scanned resources have requested |
| * a full aapt for. |
| * |
| * @return a collection of projects that scanned resources requested full |
| * aapt runs for, or null |
| */ |
| public Collection<IProject> getAaptRequestedProjects() { |
| return mFullAaptProjects; |
| } |
| |
| @Override |
| public boolean checkValue(@Nullable String uri, @NonNull String name, @NonNull String value) { |
| if (!mValidate) { |
| return true; |
| } |
| |
| if (!needsFullAapt() && mAttributeMap != null && ANDROID_URI.equals(uri)) { |
| AttributeInfo info = mAttributeMap.get(name); |
| if (info != null && !info.isValid(value, mRepository, mFrameworkResources)) { |
| return false; |
| } |
| } |
| |
| return super.checkValue(uri, name, value); |
| } |
| } |
