android/src/org/jetbrains/android/resourceManagers/ResourceManager.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright 2000-2010 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
  *
  * 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 org.jetbrains.android.resourceManagers;

 import com.android.resources.ResourceType;
 import com.android.tools.idea.AndroidPsiUtils;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.fileTypes.StdFileTypes;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.xml.XmlAttributeValue;
 import com.intellij.psi.xml.XmlFile;
 import com.intellij.psi.xml.XmlTag;
 import com.intellij.util.containers.HashMap;
 import com.intellij.util.containers.HashSet;
 import com.intellij.util.indexing.FileBasedIndex;
 import com.intellij.util.xml.DomElement;
 import org.jetbrains.android.AndroidIdIndex;
 import org.jetbrains.android.AndroidValueResourcesIndex;
 import org.jetbrains.android.dom.attrs.AttributeDefinitions;
 import org.jetbrains.android.dom.resources.ResourceElement;
 import org.jetbrains.android.dom.resources.Resources;
 import org.jetbrains.android.dom.wrappers.FileResourceElementWrapper;
 import org.jetbrains.android.dom.wrappers.LazyValueResourceElementWrapper;
 import org.jetbrains.android.util.AndroidCommonUtils;
 import org.jetbrains.android.util.AndroidResourceUtil;
 import org.jetbrains.android.util.AndroidUtils;
 import org.jetbrains.android.util.ResourceEntry;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.*;

 import static java.util.Collections.addAll;

 /**
  * @author coyote
  */
 public abstract class ResourceManager {
   protected final Project myProject;

   protected ResourceManager(@NotNull Project project) {
     myProject = project;
   }

   /** Returns all the resource directories for this module <b>and all of its module dependencies</b> */
   @NotNull
   public abstract VirtualFile[] getAllResourceDirs();

   /** Returns all the resource directories for this module only */
   @NotNull
   public abstract List<VirtualFile> getResourceDirs();

   /** Returns true if the given directory is a resource directory in this module */
   public abstract boolean isResourceDir(@NotNull VirtualFile dir);

   public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor) {
     return processFileResources(resourceType, processor, true);
   }

   public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor,
                                       boolean withDependencies) {
     return processFileResources(resourceType, processor, withDependencies, true);
   }

   public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor,
                                       boolean withDependencies, boolean publicOnly) {
     final VirtualFile[] resDirs;
     if (withDependencies) {
       resDirs = getAllResourceDirs();
     } else {
       List<VirtualFile> resourceDirs = getResourceDirs();
       resDirs = resourceDirs.toArray(new VirtualFile[resourceDirs.size()]);
     }

     for (VirtualFile resSubdir : AndroidResourceUtil.getResourceSubdirs(resourceType, resDirs)) {
       final String resType = AndroidCommonUtils.getResourceTypeByDirName(resSubdir.getName());

       if (resType != null) {
         assert resourceType == null || resourceType.equals(resType);
         for (VirtualFile resFile : resSubdir.getChildren()) {
           final String resName = AndroidCommonUtils.getResourceName(resType, resFile.getName());

           if (!resFile.isDirectory() && (!publicOnly || isResourcePublic(resType, resName))) {
             if (!processor.process(resFile, resName, resType)) {
               return false;
             }
           }
         }
       }
     }
     return true;
   }

   @NotNull
   public VirtualFile[] getResourceOverlayDirs() {
     return VirtualFile.EMPTY_ARRAY;
   }

   protected boolean isResourcePublic(@NotNull String type, @NotNull String name) {
     return true;
   }

   @NotNull
   public List<VirtualFile> getResourceSubdirs(@Nullable String resourceType) {
     return AndroidResourceUtil.getResourceSubdirs(resourceType, getAllResourceDirs());
   }

   @NotNull
   public List<PsiFile> findResourceFiles(@NotNull final String resType,
                                          @Nullable final String resName,
                                          final boolean distinguishDelimetersInName,
                                          @NotNull String... extensions) {
     return findResourceFiles(resType, resName, distinguishDelimetersInName, true, extensions);
   }

   @NotNull
   public List<PsiFile> findResourceFiles(@NotNull final String resType1,
                                          @Nullable final String resName1,
                                          final boolean distinguishDelimetersInName,
                                          final boolean withDependencies,
                                          @NotNull final String... extensions) {
     final List<PsiFile> result = new ArrayList<PsiFile>();
     final Set<String> extensionSet = new HashSet<String>();
     addAll(extensionSet, extensions);

     processFileResources(resType1, new FileResourceProcessor() {
       @Override
       public boolean process(@NotNull final VirtualFile resFile, @NotNull String resName, @NotNull String resFolderType) {
         final String extension = resFile.getExtension();

         if ((extensions.length == 0 || extensionSet.contains(extension)) &&
             (resName1 == null || AndroidUtils.equal(resName1, resName, distinguishDelimetersInName))) {
           final PsiFile file = AndroidPsiUtils.getPsiFileSafely(myProject, resFile);
           if (file != null) {
             result.add(file);
           }
         }
         return true;
       }
     }, withDependencies);
     return result;
   }

   public List<PsiFile> findResourceFiles(@NotNull String resType, @NotNull String resName, @NotNull String... extensions) {
     return findResourceFiles(resType, resName, true, extensions);
   }

   @NotNull
   public List<PsiFile> findResourceFiles(@NotNull String resType) {
     return findResourceFiles(resType, null, true);
   }

   protected List<Pair<Resources, VirtualFile>> getResourceElements(@Nullable Set<VirtualFile> files) {
     return getRootDomElements(Resources.class, files);
   }

   private <T extends DomElement> List<Pair<T, VirtualFile>> getRootDomElements(@NotNull Class<T> elementType,
                                                                                @Nullable Set<VirtualFile> files) {
     final List<Pair<T, VirtualFile>> result = new ArrayList<Pair<T, VirtualFile>>();
     for (VirtualFile file : getAllValueResourceFiles()) {
       if ((files == null || files.contains(file)) && file.isValid()) {
         final T element = AndroidUtils.loadDomElement(myProject, file, elementType);
         if (element != null) {
           result.add(Pair.create(element, file));
         }
       }
     }
     return result;
   }

   @NotNull
   protected Set<VirtualFile> getAllValueResourceFiles() {
     final Set<VirtualFile> files = new HashSet<VirtualFile>();

     for (VirtualFile valueResourceDir : getResourceSubdirs("values")) {
       for (VirtualFile valueResourceFile : valueResourceDir.getChildren()) {
         if (!valueResourceFile.isDirectory() && valueResourceFile.getFileType().equals(StdFileTypes.XML)) {
           files.add(valueResourceFile);
         }
       }
     }
     return files;
   }

   protected List<ResourceElement> getValueResources(@NotNull final String resourceType, @Nullable Set<VirtualFile> files) {
     final List<ResourceElement> result = new ArrayList<ResourceElement>();
     List<Pair<Resources, VirtualFile>> resourceFiles = getResourceElements(files);
     for (final Pair<Resources, VirtualFile> pair : resourceFiles) {
       final Resources resources = pair.getFirst();
       ApplicationManager.getApplication().runReadAction(new Runnable() {
         @Override
         public void run() {
           if (!resources.isValid() || myProject.isDisposed()) {
             return;
           }
           final List<ResourceElement> valueResources = AndroidResourceUtil.getValueResourcesFromElement(resourceType, resources);
           for (ResourceElement valueResource : valueResources) {
             final String resName = valueResource.getName().getValue();

             if (resName != null && isResourcePublic(resourceType, resName)) {
               result.add(valueResource);
             }
           }
         }
       });
     }
     return result;
   }

   @Nullable
   public String getValueResourceType(@NotNull XmlTag tag) {
     String fileResType = getFileResourceType(tag.getContainingFile());
     if ("values".equals(fileResType)) {
       return tag.getName();
     }
     return null;
   }

   @Nullable
   public String getFileResourceType(@NotNull final PsiFile file) {
     return ApplicationManager.getApplication().runReadAction(new Computable<String>() {
       @Nullable
       @Override
       public String compute() {
         PsiDirectory dir = file.getContainingDirectory();
         if (dir == null) return null;
         PsiDirectory possibleResDir = dir.getParentDirectory();
         if (possibleResDir == null || !isResourceDir(possibleResDir.getVirtualFile())) {
           return null;
         }
         String type = AndroidCommonUtils.getResourceTypeByDirName(dir.getName());
         if (type == null) return null;
         return type;
       }
     });
   }

   @NotNull
   public Set<String> getFileResourcesNames(@NotNull final String resourceType) {
     final Set<String> result = new HashSet<String>();

     processFileResources(resourceType, new FileResourceProcessor() {
       @Override
       public boolean process(@NotNull VirtualFile resFile, @NotNull String resName, @NotNull String resFolderType) {
         result.add(resName);
         return true;
       }
     });
     return result;
   }

   @NotNull
   public Collection<String> getValueResourceNames(@NotNull final String resourceType) {
     final Set<String> result = new HashSet<String>();
     final boolean attr = ResourceType.ATTR.getName().equals(resourceType);

     for (ResourceEntry entry : getValueResourceEntries(resourceType)) {
       final String name = entry.getName();

       if (!attr || !name.startsWith("android:")) {
         result.add(name);
       }
     }
     return result;
   }

   @NotNull
   public Collection<ResourceEntry> getValueResourceEntries(@NotNull final String resourceType) {
     final ResourceType type = ResourceType.getEnum(resourceType);

     if (type == null) {
       return Collections.emptyList();
     }
     final FileBasedIndex index = FileBasedIndex.getInstance();
     final ResourceEntry typeMarkerEntry = AndroidValueResourcesIndex.createTypeMarkerKey(resourceType);
     final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);

     final Map<VirtualFile, Set<ResourceEntry>> file2resourceSet = new HashMap<VirtualFile, Set<ResourceEntry>>();

     index.processValues(AndroidValueResourcesIndex.INDEX_ID, typeMarkerEntry, null, new FileBasedIndex.ValueProcessor<Set<AndroidValueResourcesIndex.MyResourceInfo>>() {
       @Override
       public boolean process(VirtualFile file, Set<AndroidValueResourcesIndex.MyResourceInfo> infos) {
         for (AndroidValueResourcesIndex.MyResourceInfo info : infos) {
           Set<ResourceEntry> resourcesInFile = file2resourceSet.get(file);

           if (resourcesInFile == null) {
             resourcesInFile = new HashSet<ResourceEntry>();
             file2resourceSet.put(file, resourcesInFile);
           }
           resourcesInFile.add(info.getResourceEntry());
         }
         return true;
       }
     }, scope);

     final List<ResourceEntry> result = new ArrayList<ResourceEntry>();

     for (VirtualFile file : getAllValueResourceFiles()) {
       final Set<ResourceEntry> entries = file2resourceSet.get(file);

       if (entries != null) {
         for (ResourceEntry entry : entries) {
           if (isResourcePublic(entry.getType(), entry.getName())) {
             result.add(entry);
           }
         }
       }
     }
     return result;
   }

   @NotNull
   public Collection<String> getResourceNames(@NotNull String type) {
     final Set<String> result = new HashSet<String>();
     result.addAll(getValueResourceNames(type));
     result.addAll(getFileResourcesNames(type));
     if (type.equals(ResourceType.ID.getName())) {
       result.addAll(getIds(true));
     }
     return result;
   }

   @Nullable
   public abstract AttributeDefinitions getAttributeDefinitions();

   // searches only declarations such as "@+id/..."
   @NotNull
   public List<XmlAttributeValue> findIdDeclarations(@NotNull final String id) {
     if (!isResourcePublic(ResourceType.ID.getName(), id)) {
       return Collections.emptyList();
     }

     final List<XmlAttributeValue> declarations = new ArrayList<XmlAttributeValue>();
     final Collection<VirtualFile> files =
       FileBasedIndex.getInstance().getContainingFiles(AndroidIdIndex.INDEX_ID, "+" + id, GlobalSearchScope.allScope(myProject));
     final Set<VirtualFile> fileSet = new HashSet<VirtualFile>(files);
     final PsiManager psiManager = PsiManager.getInstance(myProject);

     for (VirtualFile subdir : getResourceSubdirsToSearchIds()) {
       for (VirtualFile file : subdir.getChildren()) {
         if (fileSet.contains(file)) {
           final PsiFile psiFile = psiManager.findFile(file);

           if (psiFile instanceof XmlFile) {
             psiFile.accept(new XmlRecursiveElementVisitor() {
               @Override
               public void visitXmlAttributeValue(XmlAttributeValue attributeValue) {
                 if (AndroidResourceUtil.isIdDeclaration(attributeValue)) {
                   final String idInAttr = AndroidResourceUtil.getResourceNameByReferenceText(attributeValue.getValue());

                   if (id.equals(idInAttr)) {
                     declarations.add(attributeValue);
                   }
                 }
               }
             });
           }
         }
       }
     }
     return declarations;
   }

   @NotNull
   public Collection<String> getIds(boolean declarationsOnly) {

     if (myProject.isDisposed()) {
       return Collections.emptyList();
     }
     final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);

     final FileBasedIndex index = FileBasedIndex.getInstance();
     final Map<VirtualFile, Set<String>> file2idEntries = new HashMap<VirtualFile, Set<String>>();

     index.processValues(AndroidIdIndex.INDEX_ID, AndroidIdIndex.MARKER, null, new FileBasedIndex.ValueProcessor<Set<String>>() {
       @Override
       public boolean process(VirtualFile file, Set<String> value) {
         file2idEntries.put(file, value);
         return true;
       }
     }, scope);

     final Set<String> result = new HashSet<String>();

     for (VirtualFile resSubdir : getResourceSubdirsToSearchIds()) {
       for (VirtualFile resFile : resSubdir.getChildren()) {
         final Set<String> idEntries = file2idEntries.get(resFile);

         if (idEntries != null) {
           for (String idEntry : idEntries) {
             if (idEntry.startsWith("+")) {
               idEntry = idEntry.substring(1);
             }
             else if (declarationsOnly) {
               continue;
             }
             if (isResourcePublic(ResourceType.ID.getName(), idEntry)) {
               result.add(idEntry);
             }
           }
         }
       }
     }
     return result;
   }

   @NotNull
   public List<VirtualFile> getResourceSubdirsToSearchIds() {
     final List<VirtualFile> resSubdirs = new ArrayList<VirtualFile>();
     for (ResourceType type : AndroidCommonUtils.ID_PROVIDING_RESOURCE_TYPES) {
       resSubdirs.addAll(getResourceSubdirs(type.getName()));
     }
     return resSubdirs;
   }

   public List<ResourceElement> findValueResources(@NotNull String resType, @NotNull String resName) {
     return findValueResources(resType, resName, true);
   }

   // not recommended to use, because it is too slow
   @NotNull
   public List<ResourceElement> findValueResources(@NotNull String resourceType,
                                                   @NotNull String resourceName,
                                                   boolean distinguishDelimitersInName) {
     final List<ValueResourceInfoImpl> resources = findValueResourceInfos(resourceType, resourceName, distinguishDelimitersInName, false);
     final List<ResourceElement> result = new ArrayList<ResourceElement>();

     for (ValueResourceInfoImpl resource : resources) {
       final ResourceElement domElement = resource.computeDomElement();

       if (domElement != null) {
         result.add(domElement);
       }
     }
     return result;
   }

   public void collectLazyResourceElements(@NotNull String resType,
                                           @NotNull String resName,
                                           boolean withAttrs,
                                           @NotNull PsiElement context,
                                           @NotNull Collection<PsiElement> elements) {
     List<ValueResourceInfoImpl> valueResources = findValueResourceInfos(resType, resName, false, withAttrs);

     for (final ValueResourceInfo resource : valueResources) {
       elements.add(new LazyValueResourceElementWrapper(resource, context));
     }
     if (resType.equals("id")) {
       elements.addAll(findIdDeclarations(resName));
     }
     if (elements.size() == 0) {
       for (PsiFile file : findResourceFiles(resType, resName, false)) {
         elements.add(new FileResourceElementWrapper(file));
       }
     }
   }

   @NotNull
   public List<ValueResourceInfoImpl> findValueResourceInfos(@NotNull String resourceType,
                                                             @NotNull final String resourceName,
                                                             final boolean distinguishDelimetersInName,
                                                             boolean searchAttrs) {
     final ResourceType type = resourceType.startsWith("+") ? ResourceType.ID : ResourceType.getEnum(resourceType);
     if (type == null ||
         !AndroidResourceUtil.VALUE_RESOURCE_TYPES.contains(type) &&
         (type != ResourceType.ATTR || !searchAttrs)) {
       return Collections.emptyList();
     }
     final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
     final List<ValueResourceInfoImpl> result = new ArrayList<ValueResourceInfoImpl>();
     final Set<VirtualFile> valueResourceFiles = getAllValueResourceFiles();

     FileBasedIndex.getInstance()
       .processValues(AndroidValueResourcesIndex.INDEX_ID, AndroidValueResourcesIndex.createTypeNameMarkerKey(resourceType, resourceName),
                      null, new FileBasedIndex.ValueProcessor<Set<AndroidValueResourcesIndex.MyResourceInfo>>() {
       @Override
       public boolean process(VirtualFile file, Set<AndroidValueResourcesIndex.MyResourceInfo> infos) {
         for (AndroidValueResourcesIndex.MyResourceInfo info : infos) {
           final String name = info.getResourceEntry().getName();

           if (AndroidUtils.equal(resourceName, name, distinguishDelimetersInName)) {
             if (valueResourceFiles.contains(file)) {
               result.add(new ValueResourceInfoImpl(info.getResourceEntry().getName(), type, file, myProject, info.getOffset()));
             }
           }
         }
         return true;
       }
     }, scope);
     return result;
   }
 }
	/*
	* Copyright 2000-2010 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
	*
	* 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 org.jetbrains.android.resourceManagers;

	import com.android.resources.ResourceType;
	import com.android.tools.idea.AndroidPsiUtils;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.fileTypes.StdFileTypes;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.util.Computable;
	import com.intellij.openapi.util.Pair;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.psi.*;
	import com.intellij.psi.search.GlobalSearchScope;
	import com.intellij.psi.xml.XmlAttributeValue;
	import com.intellij.psi.xml.XmlFile;
	import com.intellij.psi.xml.XmlTag;
	import com.intellij.util.containers.HashMap;
	import com.intellij.util.containers.HashSet;
	import com.intellij.util.indexing.FileBasedIndex;
	import com.intellij.util.xml.DomElement;
	import org.jetbrains.android.AndroidIdIndex;
	import org.jetbrains.android.AndroidValueResourcesIndex;
	import org.jetbrains.android.dom.attrs.AttributeDefinitions;
	import org.jetbrains.android.dom.resources.ResourceElement;
	import org.jetbrains.android.dom.resources.Resources;
	import org.jetbrains.android.dom.wrappers.FileResourceElementWrapper;
	import org.jetbrains.android.dom.wrappers.LazyValueResourceElementWrapper;
	import org.jetbrains.android.util.AndroidCommonUtils;
	import org.jetbrains.android.util.AndroidResourceUtil;
	import org.jetbrains.android.util.AndroidUtils;
	import org.jetbrains.android.util.ResourceEntry;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.util.*;

	import static java.util.Collections.addAll;

	/**
	* @author coyote
	*/
	public abstract class ResourceManager {
	protected final Project myProject;

	protected ResourceManager(@NotNull Project project) {
	myProject = project;
	}

	/** Returns all the resource directories for this module <b>and all of its module dependencies</b> */
	@NotNull
	public abstract VirtualFile[] getAllResourceDirs();

	/** Returns all the resource directories for this module only */
	@NotNull
	public abstract List<VirtualFile> getResourceDirs();

	/** Returns true if the given directory is a resource directory in this module */
	public abstract boolean isResourceDir(@NotNull VirtualFile dir);

	public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor) {
	return processFileResources(resourceType, processor, true);
	}

	public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor,
	boolean withDependencies) {
	return processFileResources(resourceType, processor, withDependencies, true);
	}

	public boolean processFileResources(@Nullable String resourceType, @NotNull FileResourceProcessor processor,
	boolean withDependencies, boolean publicOnly) {
	final VirtualFile[] resDirs;
	if (withDependencies) {
	resDirs = getAllResourceDirs();
	} else {
	List<VirtualFile> resourceDirs = getResourceDirs();
	resDirs = resourceDirs.toArray(new VirtualFile[resourceDirs.size()]);
	}

	for (VirtualFile resSubdir : AndroidResourceUtil.getResourceSubdirs(resourceType, resDirs)) {
	final String resType = AndroidCommonUtils.getResourceTypeByDirName(resSubdir.getName());

	if (resType != null) {
	assert resourceType == null \|\| resourceType.equals(resType);
	for (VirtualFile resFile : resSubdir.getChildren()) {
	final String resName = AndroidCommonUtils.getResourceName(resType, resFile.getName());

	if (!resFile.isDirectory() && (!publicOnly \|\| isResourcePublic(resType, resName))) {
	if (!processor.process(resFile, resName, resType)) {
	return false;
	}
	}
	}
	}
	}
	return true;
	}

	@NotNull
	public VirtualFile[] getResourceOverlayDirs() {
	return VirtualFile.EMPTY_ARRAY;
	}

	protected boolean isResourcePublic(@NotNull String type, @NotNull String name) {
	return true;
	}

	@NotNull
	public List<VirtualFile> getResourceSubdirs(@Nullable String resourceType) {
	return AndroidResourceUtil.getResourceSubdirs(resourceType, getAllResourceDirs());
	}

	@NotNull
	public List<PsiFile> findResourceFiles(@NotNull final String resType,
	@Nullable final String resName,
	final boolean distinguishDelimetersInName,
	@NotNull String... extensions) {
	return findResourceFiles(resType, resName, distinguishDelimetersInName, true, extensions);
	}

	@NotNull
	public List<PsiFile> findResourceFiles(@NotNull final String resType1,
	@Nullable final String resName1,
	final boolean distinguishDelimetersInName,
	final boolean withDependencies,
	@NotNull final String... extensions) {
	final List<PsiFile> result = new ArrayList<PsiFile>();
	final Set<String> extensionSet = new HashSet<String>();
	addAll(extensionSet, extensions);

	processFileResources(resType1, new FileResourceProcessor() {
	@Override
	public boolean process(@NotNull final VirtualFile resFile, @NotNull String resName, @NotNull String resFolderType) {
	final String extension = resFile.getExtension();

	if ((extensions.length == 0 \|\| extensionSet.contains(extension)) &&
	(resName1 == null \|\| AndroidUtils.equal(resName1, resName, distinguishDelimetersInName))) {
	final PsiFile file = AndroidPsiUtils.getPsiFileSafely(myProject, resFile);
	if (file != null) {
	result.add(file);
	}
	}
	return true;
	}
	}, withDependencies);
	return result;
	}

	public List<PsiFile> findResourceFiles(@NotNull String resType, @NotNull String resName, @NotNull String... extensions) {
	return findResourceFiles(resType, resName, true, extensions);
	}

	@NotNull
	public List<PsiFile> findResourceFiles(@NotNull String resType) {
	return findResourceFiles(resType, null, true);
	}

	protected List<Pair<Resources, VirtualFile>> getResourceElements(@Nullable Set<VirtualFile> files) {
	return getRootDomElements(Resources.class, files);
	}

	private <T extends DomElement> List<Pair<T, VirtualFile>> getRootDomElements(@NotNull Class<T> elementType,
	@Nullable Set<VirtualFile> files) {
	final List<Pair<T, VirtualFile>> result = new ArrayList<Pair<T, VirtualFile>>();
	for (VirtualFile file : getAllValueResourceFiles()) {
	if ((files == null \|\| files.contains(file)) && file.isValid()) {
	final T element = AndroidUtils.loadDomElement(myProject, file, elementType);
	if (element != null) {
	result.add(Pair.create(element, file));
	}
	}
	}
	return result;
	}

	@NotNull
	protected Set<VirtualFile> getAllValueResourceFiles() {
	final Set<VirtualFile> files = new HashSet<VirtualFile>();

	for (VirtualFile valueResourceDir : getResourceSubdirs("values")) {
	for (VirtualFile valueResourceFile : valueResourceDir.getChildren()) {
	if (!valueResourceFile.isDirectory() && valueResourceFile.getFileType().equals(StdFileTypes.XML)) {
	files.add(valueResourceFile);
	}
	}
	}
	return files;
	}

	protected List<ResourceElement> getValueResources(@NotNull final String resourceType, @Nullable Set<VirtualFile> files) {
	final List<ResourceElement> result = new ArrayList<ResourceElement>();
	List<Pair<Resources, VirtualFile>> resourceFiles = getResourceElements(files);
	for (final Pair<Resources, VirtualFile> pair : resourceFiles) {
	final Resources resources = pair.getFirst();
	ApplicationManager.getApplication().runReadAction(new Runnable() {
	@Override
	public void run() {
	if (!resources.isValid() \|\| myProject.isDisposed()) {
	return;
	}
	final List<ResourceElement> valueResources = AndroidResourceUtil.getValueResourcesFromElement(resourceType, resources);
	for (ResourceElement valueResource : valueResources) {
	final String resName = valueResource.getName().getValue();

	if (resName != null && isResourcePublic(resourceType, resName)) {
	result.add(valueResource);
	}
	}
	}
	});
	}
	return result;
	}

	@Nullable
	public String getValueResourceType(@NotNull XmlTag tag) {
	String fileResType = getFileResourceType(tag.getContainingFile());
	if ("values".equals(fileResType)) {
	return tag.getName();
	}
	return null;
	}

	@Nullable
	public String getFileResourceType(@NotNull final PsiFile file) {
	return ApplicationManager.getApplication().runReadAction(new Computable<String>() {
	@Nullable
	@Override
	public String compute() {
	PsiDirectory dir = file.getContainingDirectory();
	if (dir == null) return null;
	PsiDirectory possibleResDir = dir.getParentDirectory();
	if (possibleResDir == null \|\| !isResourceDir(possibleResDir.getVirtualFile())) {
	return null;
	}
	String type = AndroidCommonUtils.getResourceTypeByDirName(dir.getName());
	if (type == null) return null;
	return type;
	}
	});
	}

	@NotNull
	public Set<String> getFileResourcesNames(@NotNull final String resourceType) {
	final Set<String> result = new HashSet<String>();

	processFileResources(resourceType, new FileResourceProcessor() {
	@Override
	public boolean process(@NotNull VirtualFile resFile, @NotNull String resName, @NotNull String resFolderType) {
	result.add(resName);
	return true;
	}
	});
	return result;
	}

	@NotNull
	public Collection<String> getValueResourceNames(@NotNull final String resourceType) {
	final Set<String> result = new HashSet<String>();
	final boolean attr = ResourceType.ATTR.getName().equals(resourceType);

	for (ResourceEntry entry : getValueResourceEntries(resourceType)) {
	final String name = entry.getName();

	if (!attr \|\| !name.startsWith("android:")) {
	result.add(name);
	}
	}
	return result;
	}

	@NotNull
	public Collection<ResourceEntry> getValueResourceEntries(@NotNull final String resourceType) {
	final ResourceType type = ResourceType.getEnum(resourceType);

	if (type == null) {
	return Collections.emptyList();
	}
	final FileBasedIndex index = FileBasedIndex.getInstance();
	final ResourceEntry typeMarkerEntry = AndroidValueResourcesIndex.createTypeMarkerKey(resourceType);
	final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);

	final Map<VirtualFile, Set<ResourceEntry>> file2resourceSet = new HashMap<VirtualFile, Set<ResourceEntry>>();

	index.processValues(AndroidValueResourcesIndex.INDEX_ID, typeMarkerEntry, null, new FileBasedIndex.ValueProcessor<Set<AndroidValueResourcesIndex.MyResourceInfo>>() {
	@Override
	public boolean process(VirtualFile file, Set<AndroidValueResourcesIndex.MyResourceInfo> infos) {
	for (AndroidValueResourcesIndex.MyResourceInfo info : infos) {
	Set<ResourceEntry> resourcesInFile = file2resourceSet.get(file);

	if (resourcesInFile == null) {
	resourcesInFile = new HashSet<ResourceEntry>();
	file2resourceSet.put(file, resourcesInFile);
	}
	resourcesInFile.add(info.getResourceEntry());
	}
	return true;
	}
	}, scope);

	final List<ResourceEntry> result = new ArrayList<ResourceEntry>();

	for (VirtualFile file : getAllValueResourceFiles()) {
	final Set<ResourceEntry> entries = file2resourceSet.get(file);

	if (entries != null) {
	for (ResourceEntry entry : entries) {
	if (isResourcePublic(entry.getType(), entry.getName())) {
	result.add(entry);
	}
	}
	}
	}
	return result;
	}

	@NotNull
	public Collection<String> getResourceNames(@NotNull String type) {
	final Set<String> result = new HashSet<String>();
	result.addAll(getValueResourceNames(type));
	result.addAll(getFileResourcesNames(type));
	if (type.equals(ResourceType.ID.getName())) {
	result.addAll(getIds(true));
	}
	return result;
	}

	@Nullable
	public abstract AttributeDefinitions getAttributeDefinitions();

	// searches only declarations such as "@+id/..."
	@NotNull
	public List<XmlAttributeValue> findIdDeclarations(@NotNull final String id) {
	if (!isResourcePublic(ResourceType.ID.getName(), id)) {
	return Collections.emptyList();
	}

	final List<XmlAttributeValue> declarations = new ArrayList<XmlAttributeValue>();
	final Collection<VirtualFile> files =
	FileBasedIndex.getInstance().getContainingFiles(AndroidIdIndex.INDEX_ID, "+" + id, GlobalSearchScope.allScope(myProject));
	final Set<VirtualFile> fileSet = new HashSet<VirtualFile>(files);
	final PsiManager psiManager = PsiManager.getInstance(myProject);

	for (VirtualFile subdir : getResourceSubdirsToSearchIds()) {
	for (VirtualFile file : subdir.getChildren()) {
	if (fileSet.contains(file)) {
	final PsiFile psiFile = psiManager.findFile(file);

	if (psiFile instanceof XmlFile) {
	psiFile.accept(new XmlRecursiveElementVisitor() {
	@Override
	public void visitXmlAttributeValue(XmlAttributeValue attributeValue) {
	if (AndroidResourceUtil.isIdDeclaration(attributeValue)) {
	final String idInAttr = AndroidResourceUtil.getResourceNameByReferenceText(attributeValue.getValue());

	if (id.equals(idInAttr)) {
	declarations.add(attributeValue);
	}
	}
	}
	});
	}
	}
	}
	}
	return declarations;
	}

	@NotNull
	public Collection<String> getIds(boolean declarationsOnly) {

	if (myProject.isDisposed()) {
	return Collections.emptyList();
	}
	final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);

	final FileBasedIndex index = FileBasedIndex.getInstance();
	final Map<VirtualFile, Set<String>> file2idEntries = new HashMap<VirtualFile, Set<String>>();

	index.processValues(AndroidIdIndex.INDEX_ID, AndroidIdIndex.MARKER, null, new FileBasedIndex.ValueProcessor<Set<String>>() {
	@Override
	public boolean process(VirtualFile file, Set<String> value) {
	file2idEntries.put(file, value);
	return true;
	}
	}, scope);

	final Set<String> result = new HashSet<String>();

	for (VirtualFile resSubdir : getResourceSubdirsToSearchIds()) {
	for (VirtualFile resFile : resSubdir.getChildren()) {
	final Set<String> idEntries = file2idEntries.get(resFile);

	if (idEntries != null) {
	for (String idEntry : idEntries) {
	if (idEntry.startsWith("+")) {
	idEntry = idEntry.substring(1);
	}
	else if (declarationsOnly) {
	continue;
	}
	if (isResourcePublic(ResourceType.ID.getName(), idEntry)) {
	result.add(idEntry);
	}
	}
	}
	}
	}
	return result;
	}

	@NotNull
	public List<VirtualFile> getResourceSubdirsToSearchIds() {
	final List<VirtualFile> resSubdirs = new ArrayList<VirtualFile>();
	for (ResourceType type : AndroidCommonUtils.ID_PROVIDING_RESOURCE_TYPES) {
	resSubdirs.addAll(getResourceSubdirs(type.getName()));
	}
	return resSubdirs;
	}

	public List<ResourceElement> findValueResources(@NotNull String resType, @NotNull String resName) {
	return findValueResources(resType, resName, true);
	}

	// not recommended to use, because it is too slow
	@NotNull
	public List<ResourceElement> findValueResources(@NotNull String resourceType,
	@NotNull String resourceName,
	boolean distinguishDelimitersInName) {
	final List<ValueResourceInfoImpl> resources = findValueResourceInfos(resourceType, resourceName, distinguishDelimitersInName, false);
	final List<ResourceElement> result = new ArrayList<ResourceElement>();

	for (ValueResourceInfoImpl resource : resources) {
	final ResourceElement domElement = resource.computeDomElement();

	if (domElement != null) {
	result.add(domElement);
	}
	}
	return result;
	}

	public void collectLazyResourceElements(@NotNull String resType,
	@NotNull String resName,
	boolean withAttrs,
	@NotNull PsiElement context,
	@NotNull Collection<PsiElement> elements) {
	List<ValueResourceInfoImpl> valueResources = findValueResourceInfos(resType, resName, false, withAttrs);

	for (final ValueResourceInfo resource : valueResources) {
	elements.add(new LazyValueResourceElementWrapper(resource, context));
	}
	if (resType.equals("id")) {
	elements.addAll(findIdDeclarations(resName));
	}
	if (elements.size() == 0) {
	for (PsiFile file : findResourceFiles(resType, resName, false)) {
	elements.add(new FileResourceElementWrapper(file));
	}
	}
	}

	@NotNull
	public List<ValueResourceInfoImpl> findValueResourceInfos(@NotNull String resourceType,
	@NotNull final String resourceName,
	final boolean distinguishDelimetersInName,
	boolean searchAttrs) {
	final ResourceType type = resourceType.startsWith("+") ? ResourceType.ID : ResourceType.getEnum(resourceType);
	if (type == null \|\|
	!AndroidResourceUtil.VALUE_RESOURCE_TYPES.contains(type) &&
	(type != ResourceType.ATTR \|\| !searchAttrs)) {
	return Collections.emptyList();
	}
	final GlobalSearchScope scope = GlobalSearchScope.allScope(myProject);
	final List<ValueResourceInfoImpl> result = new ArrayList<ValueResourceInfoImpl>();
	final Set<VirtualFile> valueResourceFiles = getAllValueResourceFiles();

	FileBasedIndex.getInstance()
	.processValues(AndroidValueResourcesIndex.INDEX_ID, AndroidValueResourcesIndex.createTypeNameMarkerKey(resourceType, resourceName),
	null, new FileBasedIndex.ValueProcessor<Set<AndroidValueResourcesIndex.MyResourceInfo>>() {
	@Override
	public boolean process(VirtualFile file, Set<AndroidValueResourcesIndex.MyResourceInfo> infos) {
	for (AndroidValueResourcesIndex.MyResourceInfo info : infos) {
	final String name = info.getResourceEntry().getName();

	if (AndroidUtils.equal(resourceName, name, distinguishDelimetersInName)) {
	if (valueResourceFiles.contains(file)) {
	result.add(new ValueResourceInfoImpl(info.getResourceEntry().getName(), type, file, myProject, info.getOffset()));
	}
	}
	}
	return true;
	}
	}, scope);
	return result;
	}
	}