/*
* 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.dom.converters;
import com.android.sdklib.IAndroidTarget;
import com.intellij.codeInsight.lookup.LookupElementBuilder;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.resolve.ResolveCache;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Processor;
import com.intellij.util.containers.HashSet;
import com.intellij.util.xml.*;
import org.jetbrains.android.dom.LookupClass;
import org.jetbrains.android.dom.LookupPrefix;
import org.jetbrains.android.dom.manifest.*;
import org.jetbrains.android.sdk.AndroidPlatform;
import org.jetbrains.android.sdk.AndroidTargetData;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* @author yole
*/
public class ConstantFieldConverter extends Converter<String> implements CustomReferenceConverter<String> {
@Override
public String fromString(@Nullable @NonNls String s, ConvertContext context) {
return s;
}
@Override
public String toString(@Nullable String value, ConvertContext context) {
return value;
}
@NotNull
@Override
public PsiReference[] createReferences(GenericDomValue<String> value, PsiElement element, ConvertContext context) {
final List<PsiReference> result = new ArrayList<PsiReference>();
final DomElement domElement = context.getInvocationElement();
final LookupClass lookupClass = domElement.getAnnotation(LookupClass.class);
final LookupPrefix lookupPrefix = domElement.getAnnotation(LookupPrefix.class);
if (lookupClass != null && lookupPrefix != null) {
final Module module = context.getModule();
final GlobalSearchScope scope = module != null ?
GlobalSearchScope.allScope(module.getProject()) :
domElement.getResolveScope();
final PsiClass psiClass = JavaPsiFacade.getInstance(context.getPsiManager().
getProject()).findClass(lookupClass.value(), scope);
if (psiClass != null) {
final Set<String> filteringSet = getFilteringSet(context);
result.add(new MyReference(element, psiClass, lookupPrefix.value(), filteringSet));
}
}
return result.toArray(new PsiReference[result.size()]);
}
@Nullable
private static Set<String> getFilteringSet(@NotNull ConvertContext context) {
final Module module = context.getModule();
if (module == null) {
return null;
}
final AndroidPlatform platform = AndroidPlatform.getInstance(module);
if (platform == null) {
return null;
}
final IAndroidTarget target = platform.getTarget();
final AndroidTargetData targetData = platform.getSdkData().getTargetData(target);
DomElement element = context.getInvocationElement().getParent();
if (element instanceof Category) {
return targetData.getStaticConstantsData().getCategories();
}
else if (element instanceof Action) {
element = element.getParent();
if (element instanceof IntentFilter) {
element = element.getParent();
if (element instanceof Activity) {
return targetData.getStaticConstantsData().getActivityActions();
}
else if (element instanceof Service) {
return targetData.getStaticConstantsData().getServiceActions();
}
else if (element instanceof Receiver) {
return targetData.getStaticConstantsData().getReceiverActions();
}
}
}
return null;
}
private static class MyReference extends PsiReferenceBase<PsiElement> {
private final PsiClass myClass;
private final String myLookupPrefix;
private final Set<String> myFilteringSet;
public MyReference(@NotNull PsiElement element,
@NotNull PsiClass aClass,
@NotNull String lookupPrefix,
@Nullable Set<String> filteringSet) {
super(element, true);
myClass = aClass;
myLookupPrefix = lookupPrefix;
myFilteringSet = filteringSet;
}
@Nullable
@Override
public PsiElement resolve() {
return ResolveCache.getInstance(myElement.getProject()).resolveWithCaching(this, new ResolveCache.Resolver() {
@Nullable
@Override
public PsiElement resolve(@NotNull PsiReference reference, boolean incompleteCode) {
return resolveInner();
}
}, false, false);
}
@Nullable
private PsiElement resolveInner() {
final String value = getValue();
if (value.isEmpty()) {
return null;
}
final Ref<PsiElement> ref = Ref.create();
processFields(new Processor<Pair<PsiField, String>>() {
@Override
public boolean process(Pair<PsiField, String> pair) {
if (value.equals(pair.getSecond())) {
ref.set(pair.getFirst());
return false;
}
return true;
}
});
return ref.get();
}
@NotNull
@Override
public Object[] getVariants() {
final List<Object> result = new ArrayList<Object>();
final Set<String> added = new HashSet<String>();
processFields(new Processor<Pair<PsiField, String>>() {
@Override
public boolean process(Pair<PsiField, String> pair) {
final String s = pair.getSecond();
if (myFilteringSet != null && !myFilteringSet.contains(s)) {
return true;
}
if (added.add(s)) {
result.add(LookupElementBuilder.create(pair.getFirst(), s).withCaseSensitivity(false));
}
return true;
}
});
return ArrayUtil.toObjectArray(result);
}
private void processFields(@NotNull Processor<Pair<PsiField, String>> processor) {
final PsiField[] psiFields = myClass.getFields();
for (PsiField field : psiFields) {
if (field.hasModifierProperty(PsiModifier.STATIC) && field.hasModifierProperty(PsiModifier.PUBLIC)) {
final PsiExpression initializer = field.getInitializer();
if (initializer instanceof PsiLiteralExpression) {
final PsiLiteralExpression literalExpression = (PsiLiteralExpression)initializer;
final Object o = literalExpression.getValue();
if (o instanceof String && o.toString().startsWith(myLookupPrefix)) {
if (!processor.process(Pair.create(field, o.toString()))) {
return;
}
}
}
}
}
}
}
}