| /* |
| * 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.editors.layout.descriptors; |
| |
| import static com.android.SdkConstants.ANDROID_NS_NAME_PREFIX; |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.AUTO_URI; |
| import static com.android.SdkConstants.CLASS_VIEWGROUP; |
| import static com.android.SdkConstants.URI_PREFIX; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.resources.ResourceFile; |
| import com.android.ide.common.resources.ResourceItem; |
| import com.android.ide.common.resources.platform.AttributeInfo; |
| import com.android.ide.common.resources.platform.AttrsXmlParser; |
| import com.android.ide.common.resources.platform.ViewClassInfo; |
| import com.android.ide.common.resources.platform.ViewClassInfo.LayoutParamsInfo; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.AttributeDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.resources.ResourceType; |
| import com.android.sdklib.IAndroidTarget; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.ObjectArrays; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.jdt.core.IClassFile; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.IType; |
| import org.eclipse.jdt.core.ITypeHierarchy; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.swt.graphics.Image; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Service responsible for creating/managing {@link ViewElementDescriptor} objects for custom |
| * View classes per project. |
| * <p/> |
| * The service provides an on-demand monitoring of custom classes to check for changes. Monitoring |
| * starts once a request for an {@link ViewElementDescriptor} object has been done for a specific |
| * class. |
| * <p/> |
| * The monitoring will notify a listener of any changes in the class triggering a change in its |
| * associated {@link ViewElementDescriptor} object. |
| * <p/> |
| * If the custom class does not exist, no monitoring is put in place to avoid having to listen |
| * to all class changes in the projects. |
| */ |
| public final class CustomViewDescriptorService { |
| |
| private static CustomViewDescriptorService sThis = new CustomViewDescriptorService(); |
| |
| /** |
| * Map where keys are the project, and values are another map containing all the known |
| * custom View class for this project. The custom View class are stored in a map |
| * where the keys are the fully qualified class name, and the values are their associated |
| * {@link ViewElementDescriptor}. |
| */ |
| private HashMap<IProject, HashMap<String, ViewElementDescriptor>> mCustomDescriptorMap = |
| new HashMap<IProject, HashMap<String, ViewElementDescriptor>>(); |
| |
| /** |
| * TODO will be used to update the ViewElementDescriptor of the custom view when it |
| * is modified (either the class itself or its attributes.xml) |
| */ |
| @SuppressWarnings("unused") |
| private ICustomViewDescriptorListener mListener; |
| |
| /** |
| * Classes which implements this interface provide a method that deal with modifications |
| * in custom View class triggering a change in its associated {@link ViewClassInfo} object. |
| */ |
| public interface ICustomViewDescriptorListener { |
| /** |
| * Sent when a custom View class has changed and |
| * its {@link ViewElementDescriptor} was modified. |
| * |
| * @param project the project containing the class. |
| * @param className the fully qualified class name. |
| * @param descriptor the updated ElementDescriptor. |
| */ |
| public void updatedClassInfo(IProject project, |
| String className, |
| ViewElementDescriptor descriptor); |
| } |
| |
| /** |
| * Returns the singleton instance of {@link CustomViewDescriptorService}. |
| */ |
| public static CustomViewDescriptorService getInstance() { |
| return sThis; |
| } |
| |
| /** |
| * Sets the listener receiving custom View class modification notifications. |
| * @param listener the listener to receive the notifications. |
| * |
| * TODO will be used to update the ViewElementDescriptor of the custom view when it |
| * is modified (either the class itself or its attributes.xml) |
| */ |
| public void setListener(ICustomViewDescriptorListener listener) { |
| mListener = listener; |
| } |
| |
| /** |
| * Returns the {@link ViewElementDescriptor} for a particular project/class when the |
| * fully qualified class name actually matches a class from the given project. |
| * <p/> |
| * Custom descriptors are created as needed. |
| * <p/> |
| * If it is the first time the {@link ViewElementDescriptor} is requested, the method |
| * will check that the specified class is in fact a custom View class. Once this is |
| * established, a monitoring for that particular class is initiated. Any change will |
| * trigger a notification to the {@link ICustomViewDescriptorListener}. |
| * |
| * @param project the project containing the class. |
| * @param fqcn the fully qualified name of the class. |
| * @return a {@link ViewElementDescriptor} or <code>null</code> if the class was not |
| * a custom View class. |
| */ |
| public ViewElementDescriptor getDescriptor(IProject project, String fqcn) { |
| // look in the map first |
| synchronized (mCustomDescriptorMap) { |
| HashMap<String, ViewElementDescriptor> map = mCustomDescriptorMap.get(project); |
| |
| if (map != null) { |
| ViewElementDescriptor descriptor = map.get(fqcn); |
| if (descriptor != null) { |
| return descriptor; |
| } |
| } |
| |
| // if we step here, it looks like we haven't created it yet. |
| // First lets check this is in fact a valid type in the project |
| |
| try { |
| // We expect the project to be both opened and of java type (since it's an android |
| // project), so we can create a IJavaProject object from our IProject. |
| IJavaProject javaProject = JavaCore.create(project); |
| |
| // replace $ by . in the class name |
| String javaClassName = fqcn.replaceAll("\\$", "\\."); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| // look for the IType object for this class |
| IType type = javaProject.findType(javaClassName); |
| if (type != null && type.exists()) { |
| // the type exists. Let's get the parent class and its ViewClassInfo. |
| |
| // get the type hierarchy |
| ITypeHierarchy hierarchy = type.newSupertypeHierarchy( |
| new NullProgressMonitor()); |
| |
| ViewElementDescriptor parentDescriptor = createViewDescriptor( |
| hierarchy.getSuperclass(type), project, hierarchy); |
| |
| if (parentDescriptor != null) { |
| // we have a valid parent, lets create a new ViewElementDescriptor. |
| List<AttributeDescriptor> attrList = new ArrayList<AttributeDescriptor>(); |
| List<AttributeDescriptor> paramList = new ArrayList<AttributeDescriptor>(); |
| Map<ResourceFile, Long> files = findCustomDescriptors(project, type, |
| attrList, paramList); |
| |
| AttributeDescriptor[] attributes = |
| getAttributeDescriptor(type, parentDescriptor); |
| if (!attrList.isEmpty()) { |
| attributes = join(attrList, attributes); |
| } |
| AttributeDescriptor[] layoutAttributes = |
| getLayoutAttributeDescriptors(type, parentDescriptor); |
| if (!paramList.isEmpty()) { |
| layoutAttributes = join(paramList, layoutAttributes); |
| } |
| String name = DescriptorsUtils.getBasename(fqcn); |
| ViewElementDescriptor descriptor = new CustomViewDescriptor(name, fqcn, |
| attributes, |
| layoutAttributes, |
| parentDescriptor.getChildren(), |
| project, files); |
| descriptor.setSuperClass(parentDescriptor); |
| |
| synchronized (mCustomDescriptorMap) { |
| map = mCustomDescriptorMap.get(project); |
| if (map == null) { |
| map = new HashMap<String, ViewElementDescriptor>(); |
| mCustomDescriptorMap.put(project, map); |
| } |
| |
| map.put(fqcn, descriptor); |
| } |
| |
| //TODO setup listener on this resource change. |
| |
| return descriptor; |
| } |
| } |
| } catch (JavaModelException e) { |
| // there was an error accessing any of the IType, we'll just return null; |
| } |
| } |
| |
| return null; |
| } |
| |
| private static AttributeDescriptor[] join( |
| @NonNull List<AttributeDescriptor> attributeList, |
| @NonNull AttributeDescriptor[] attributes) { |
| if (!attributeList.isEmpty()) { |
| return ObjectArrays.concat( |
| attributeList.toArray(new AttributeDescriptor[attributeList.size()]), |
| attributes, |
| AttributeDescriptor.class); |
| } else { |
| return attributes; |
| } |
| |
| } |
| |
| /** Cache used by {@link #getParser(ResourceFile)} */ |
| private Map<ResourceFile, AttrsXmlParser> mParserCache; |
| |
| private AttrsXmlParser getParser(ResourceFile file) { |
| if (mParserCache == null) { |
| mParserCache = new HashMap<ResourceFile, AttrsXmlParser>(); |
| } |
| |
| AttrsXmlParser parser = mParserCache.get(file); |
| if (parser == null) { |
| parser = new AttrsXmlParser( |
| file.getFile().getOsLocation(), |
| AdtPlugin.getDefault(), 20); |
| parser.preload(); |
| mParserCache.put(file, parser); |
| } |
| |
| return parser; |
| } |
| |
| /** Compute/find the styleable resources for the given type, if possible */ |
| private Map<ResourceFile, Long> findCustomDescriptors( |
| IProject project, |
| IType type, |
| List<AttributeDescriptor> customAttributes, |
| List<AttributeDescriptor> customLayoutAttributes) { |
| // Look up the project where the type is declared (could be a library project; |
| // we cannot use type.getJavaProject().getProject()) |
| IProject library = getProjectDeclaringType(type); |
| if (library == null) { |
| library = project; |
| } |
| |
| String className = type.getElementName(); |
| Set<ResourceFile> resourceFiles = findAttrsFiles(library, className); |
| if (resourceFiles != null && resourceFiles.size() > 0) { |
| String appUri = getAppResUri(project); |
| Map<ResourceFile, Long> timestamps = |
| Maps.newHashMapWithExpectedSize(resourceFiles.size()); |
| for (ResourceFile file : resourceFiles) { |
| AttrsXmlParser attrsXmlParser = getParser(file); |
| String fqcn = type.getFullyQualifiedName(); |
| |
| // Attributes |
| ViewClassInfo classInfo = new ViewClassInfo(true, fqcn, className); |
| attrsXmlParser.loadViewAttributes(classInfo); |
| appendAttributes(customAttributes, classInfo.getAttributes(), appUri); |
| |
| // Layout params |
| LayoutParamsInfo layoutInfo = new ViewClassInfo.LayoutParamsInfo( |
| classInfo, "Layout", null /*superClassInfo*/); //$NON-NLS-1$ |
| attrsXmlParser.loadLayoutParamsAttributes(layoutInfo); |
| appendAttributes(customLayoutAttributes, layoutInfo.getAttributes(), appUri); |
| |
| timestamps.put(file, file.getFile().getModificationStamp()); |
| } |
| |
| return timestamps; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Finds the set of XML files (if any) in the given library declaring |
| * attributes for the given class name |
| */ |
| @Nullable |
| private static Set<ResourceFile> findAttrsFiles(IProject library, String className) { |
| Set<ResourceFile> resourceFiles = null; |
| ResourceManager manager = ResourceManager.getInstance(); |
| ProjectResources resources = manager.getProjectResources(library); |
| if (resources != null) { |
| Collection<ResourceItem> items = |
| resources.getResourceItemsOfType(ResourceType.DECLARE_STYLEABLE); |
| for (ResourceItem item : items) { |
| String viewName = item.getName(); |
| if (viewName.equals(className) |
| || (viewName.startsWith(className) |
| && viewName.equals(className + "_Layout"))) { //$NON-NLS-1$ |
| if (resourceFiles == null) { |
| resourceFiles = new HashSet<ResourceFile>(); |
| } |
| resourceFiles.addAll(item.getSourceFileList()); |
| } |
| } |
| } |
| return resourceFiles; |
| } |
| |
| /** |
| * Find the project containing this type declaration. We cannot use |
| * {@link IType#getJavaProject()} since that will return the including |
| * project and we're after the library project such that we can find the |
| * attrs.xml file in the same project. |
| */ |
| @Nullable |
| private static IProject getProjectDeclaringType(IType type) { |
| IClassFile classFile = type.getClassFile(); |
| if (classFile != null) { |
| IPath path = classFile.getPath(); |
| IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); |
| IResource resource; |
| if (path.isAbsolute()) { |
| resource = AdtUtils.fileToResource(path.toFile()); |
| } else { |
| resource = workspace.findMember(path); |
| } |
| if (resource != null && resource.getProject() != null) { |
| return resource.getProject(); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** Returns the name space to use for application attributes */ |
| private static String getAppResUri(IProject project) { |
| String appResource; |
| ProjectState projectState = Sdk.getProjectState(project); |
| if (projectState != null && projectState.isLibrary()) { |
| appResource = AUTO_URI; |
| } else { |
| ManifestInfo manifestInfo = ManifestInfo.get(project); |
| appResource = URI_PREFIX + manifestInfo.getPackage(); |
| } |
| return appResource; |
| } |
| |
| |
| /** Append the {@link AttributeInfo} objects converted {@link AttributeDescriptor} |
| * objects into the given attribute list. |
| * <p> |
| * This is nearly identical to |
| * {@link DescriptorsUtils#appendAttribute(List, String, String, AttributeInfo, boolean, Map)} |
| * but it handles namespace declarations in the attrs.xml file where the android: |
| * namespace is included in the names. |
| */ |
| private static void appendAttributes(List<AttributeDescriptor> attributes, |
| AttributeInfo[] attributeInfos, String appResource) { |
| // Custom attributes |
| for (AttributeInfo info : attributeInfos) { |
| String nsUri; |
| if (info.getName().startsWith(ANDROID_NS_NAME_PREFIX)) { |
| info.setName(info.getName().substring(ANDROID_NS_NAME_PREFIX.length())); |
| nsUri = ANDROID_URI; |
| } else { |
| nsUri = appResource; |
| } |
| |
| DescriptorsUtils.appendAttribute(attributes, |
| null /*elementXmlName*/, nsUri, info, false /*required*/, |
| null /*overrides*/); |
| } |
| } |
| |
| /** |
| * Computes (if needed) and returns the {@link ViewElementDescriptor} for the specified type. |
| * |
| * @return A {@link ViewElementDescriptor} or null if type or typeHierarchy is null. |
| */ |
| private ViewElementDescriptor createViewDescriptor(IType type, IProject project, |
| ITypeHierarchy typeHierarchy) { |
| // check if the type is a built-in View class. |
| List<ViewElementDescriptor> builtInList = null; |
| |
| // give up if there's no type |
| if (type == null) { |
| return null; |
| } |
| |
| String fqcn = type.getFullyQualifiedName(); |
| |
| Sdk currentSdk = Sdk.getCurrent(); |
| if (currentSdk != null) { |
| IAndroidTarget target = currentSdk.getTarget(project); |
| if (target != null) { |
| AndroidTargetData data = currentSdk.getTargetData(target); |
| if (data != null) { |
| LayoutDescriptors descriptors = data.getLayoutDescriptors(); |
| ViewElementDescriptor d = descriptors.findDescriptorByClass(fqcn); |
| if (d != null) { |
| return d; |
| } |
| builtInList = descriptors.getViewDescriptors(); |
| } |
| } |
| } |
| |
| // it's not a built-in class? Lets look if the superclass is built-in |
| // give up if there's no type |
| if (typeHierarchy == null) { |
| return null; |
| } |
| |
| IType parentType = typeHierarchy.getSuperclass(type); |
| if (parentType != null) { |
| ViewElementDescriptor parentDescriptor = createViewDescriptor(parentType, project, |
| typeHierarchy); |
| |
| if (parentDescriptor != null) { |
| // parent class is a valid View class with a descriptor, so we create one |
| // for this class. |
| String name = DescriptorsUtils.getBasename(fqcn); |
| // A custom view accepts children if its parent descriptor also does. |
| // The only exception to this is ViewGroup, which accepts children even though |
| // its parent does not. |
| boolean isViewGroup = fqcn.equals(CLASS_VIEWGROUP); |
| boolean hasChildren = isViewGroup || parentDescriptor.hasChildren(); |
| ViewElementDescriptor[] children = null; |
| if (hasChildren && builtInList != null) { |
| // We can't figure out what the allowable children are by just |
| // looking at the class, so assume any View is valid |
| children = builtInList.toArray(new ViewElementDescriptor[builtInList.size()]); |
| } |
| ViewElementDescriptor descriptor = new CustomViewDescriptor(name, fqcn, |
| getAttributeDescriptor(type, parentDescriptor), |
| getLayoutAttributeDescriptors(type, parentDescriptor), |
| children, project, null); |
| descriptor.setSuperClass(parentDescriptor); |
| |
| // add it to the map |
| synchronized (mCustomDescriptorMap) { |
| HashMap<String, ViewElementDescriptor> map = mCustomDescriptorMap.get(project); |
| |
| if (map == null) { |
| map = new HashMap<String, ViewElementDescriptor>(); |
| mCustomDescriptorMap.put(project, map); |
| } |
| |
| map.put(fqcn, descriptor); |
| |
| } |
| |
| //TODO setup listener on this resource change. |
| |
| return descriptor; |
| } |
| } |
| |
| // class is neither a built-in view class, nor extend one. return null. |
| return null; |
| } |
| |
| /** |
| * Returns the array of {@link AttributeDescriptor} for the specified {@link IType}. |
| * <p/> |
| * The array should contain the descriptor for this type and all its supertypes. |
| * |
| * @param type the type for which the {@link AttributeDescriptor} are returned. |
| * @param parentDescriptor the {@link ViewElementDescriptor} of the direct superclass. |
| */ |
| private static AttributeDescriptor[] getAttributeDescriptor(IType type, |
| ViewElementDescriptor parentDescriptor) { |
| // TODO add the class attribute descriptors to the parent descriptors. |
| return parentDescriptor.getAttributes(); |
| } |
| |
| private static AttributeDescriptor[] getLayoutAttributeDescriptors(IType type, |
| ViewElementDescriptor parentDescriptor) { |
| return parentDescriptor.getLayoutAttributes(); |
| } |
| |
| private class CustomViewDescriptor extends ViewElementDescriptor { |
| private Map<ResourceFile, Long> mTimeStamps; |
| private IProject mProject; |
| |
| public CustomViewDescriptor(String name, String fqcn, AttributeDescriptor[] attributes, |
| AttributeDescriptor[] layoutAttributes, |
| ElementDescriptor[] children, IProject project, |
| Map<ResourceFile, Long> timestamps) { |
| super( |
| fqcn, // xml name |
| name, // ui name |
| fqcn, // full class name |
| fqcn, // tooltip |
| null, // sdk_url |
| attributes, |
| layoutAttributes, |
| children, |
| false // mandatory |
| ); |
| mTimeStamps = timestamps; |
| mProject = project; |
| } |
| |
| @Override |
| public Image getGenericIcon() { |
| IconFactory iconFactory = IconFactory.getInstance(); |
| |
| int index = mXmlName.lastIndexOf('.'); |
| if (index != -1) { |
| return iconFactory.getIcon(mXmlName.substring(index + 1), |
| "customView"); //$NON-NLS-1$ |
| } |
| |
| return iconFactory.getIcon("customView"); //$NON-NLS-1$ |
| } |
| |
| @Override |
| public boolean syncAttributes() { |
| // Check if any of the descriptors |
| if (mTimeStamps != null) { |
| // Prevent checking actual file timestamps too frequently on rapid burst calls |
| long now = System.currentTimeMillis(); |
| if (now - sLastCheck < 1000) { |
| return true; |
| } |
| sLastCheck = now; |
| |
| // Check whether the resource files (typically just one) which defined |
| // custom attributes for this custom view have changed, and if so, |
| // refresh the attribute descriptors. |
| // This doesn't work the cases where you add descriptors for a custom |
| // view after using it, or add attributes in a separate file, but those |
| // scenarios aren't quite as common (and would require a bit more expensive |
| // analysis.) |
| for (Map.Entry<ResourceFile, Long> entry : mTimeStamps.entrySet()) { |
| ResourceFile file = entry.getKey(); |
| Long timestamp = entry.getValue(); |
| boolean recompute = false; |
| if (file.getFile().getModificationStamp() > timestamp.longValue()) { |
| // One or more attributes changed: recompute |
| recompute = true; |
| mParserCache.remove(file); |
| } |
| |
| if (recompute) { |
| IJavaProject javaProject = JavaCore.create(mProject); |
| String fqcn = getFullClassName(); |
| IType type = null; |
| try { |
| type = javaProject.findType(fqcn); |
| } catch (CoreException e) { |
| AdtPlugin.log(e, null); |
| } |
| if (type == null || !type.exists()) { |
| return true; |
| } |
| |
| List<AttributeDescriptor> attrList = new ArrayList<AttributeDescriptor>(); |
| List<AttributeDescriptor> paramList = new ArrayList<AttributeDescriptor>(); |
| |
| mTimeStamps = findCustomDescriptors(mProject, type, attrList, paramList); |
| |
| ViewElementDescriptor parentDescriptor = getSuperClassDesc(); |
| AttributeDescriptor[] attributes = |
| getAttributeDescriptor(type, parentDescriptor); |
| if (!attrList.isEmpty()) { |
| attributes = join(attrList, attributes); |
| } |
| attributes = attrList.toArray(new AttributeDescriptor[attrList.size()]); |
| setAttributes(attributes); |
| |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| } |
| |
| /** Timestamp of the most recent {@link CustomViewDescriptor#syncAttributes} check */ |
| private static long sLastCheck; |
| } |
