/*
* Copyright (C) 2013 The Android Open Source Project
*
* 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 com.android.tools.idea.refactoring.rtl;
import com.android.SdkConstants;
import com.android.resources.ResourceFolderType;
import com.android.xml.AndroidManifest;
import com.google.common.collect.Maps;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
import com.intellij.psi.xml.XmlAttribute;
import com.intellij.psi.xml.XmlFile;
import com.intellij.psi.xml.XmlTag;
import com.intellij.refactoring.BaseRefactoringProcessor;
import com.intellij.usageView.UsageInfo;
import com.intellij.usageView.UsageViewDescriptor;
import com.intellij.util.xml.DomElement;
import com.intellij.util.xml.DomManager;
import org.jetbrains.android.dom.layout.LayoutDomFileDescription;
import org.jetbrains.android.dom.layout.LayoutViewElement;
import org.jetbrains.android.facet.AndroidFacet;
import org.jetbrains.android.facet.IdeaSourceProvider;
import org.jetbrains.android.facet.ResourceFolderManager;
import org.jetbrains.android.util.AndroidBundle;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import static com.android.SdkConstants.*;
import static com.android.tools.idea.refactoring.rtl.RtlRefactoringUsageInfo.RtlRefactoringType.*;
import static com.android.xml.AndroidManifest.*;
public class RtlSupportProcessor extends BaseRefactoringProcessor {
private static final Logger LOG = Logger.getInstance("#com.android.tools.idea.refactoring.AddRTLSupportProcessor");
private static final String REFACTORING_NAME = AndroidBundle.message("android.refactoring.rtl.addsupport.title");
public static final String RES_V_QUALIFIER = "-v";
public static final String RES_V17_QUALIFIER = "-v17";
private final RtlSupportProperties myProperties;
private final Project myProject;
// This is the API level corresponding to the first public release for RTL support
public static final int RTL_TARGET_SDK_START = 17;
private static Map<String, String> ourMapMirroredAttributeName = Maps.newHashMapWithExpectedSize(12);
static {
initMapMirroredAttributes();
}
private static void initMapMirroredAttributes() {
ourMapMirroredAttributeName.put(ATTR_PADDING_LEFT, ATTR_PADDING_START);
ourMapMirroredAttributeName.put(ATTR_PADDING_RIGHT, ATTR_PADDING_END);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_MARGIN_LEFT, ATTR_LAYOUT_MARGIN_START);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_MARGIN_RIGHT, ATTR_LAYOUT_MARGIN_END);
ourMapMirroredAttributeName.put(ATTR_DRAWABLE_LEFT, ATTR_DRAWABLE_START);
ourMapMirroredAttributeName.put(ATTR_DRAWABLE_RIGHT, ATTR_DRAWABLE_END);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_TO_LEFT_OF, ATTR_LAYOUT_TO_START_OF);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_TO_RIGHT_OF, ATTR_LAYOUT_TO_END_OF);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_ALIGN_LEFT, ATTR_LAYOUT_ALIGN_START);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_ALIGN_RIGHT, ATTR_LAYOUT_ALIGN_END);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_ALIGN_PARENT_LEFT, ATTR_LAYOUT_ALIGN_PARENT_START);
ourMapMirroredAttributeName.put(ATTR_LAYOUT_ALIGN_PARENT_RIGHT, ATTR_LAYOUT_ALIGN_PARENT_END);
// Gravity is a special case that we will handled separately as we will mirror its value instead of its name
}
protected RtlSupportProcessor(Project project, @NotNull RtlSupportProperties properties) {
super(project);
myProject = project;
myProperties = properties;
setPreviewUsages(true);
}
@NotNull
@Override
protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) {
return new RtlSupportUsageViewDescriptor();
}
@NotNull
@Override
protected UsageInfo[] findUsages() {
if (!myProperties.hasSomethingToDo()) {
return UsageInfo.EMPTY_ARRAY;
}
final List<UsageInfo> list = new ArrayList<UsageInfo>();
if (myProperties.updateAndroidManifest) {
addManifestRefactoring(list);
// TODO: Update build.gradle as well
}
if (myProperties.updateLayouts) {
addLayoutRefactoring(list);
}
final int size = list.size();
return list.toArray(new UsageInfo[size]);
}
@Override
protected void performRefactoring(UsageInfo[] usages) {
for (UsageInfo usageInfo : usages) {
RtlRefactoringUsageInfo refactoring = (RtlRefactoringUsageInfo)usageInfo;
switch (refactoring.getType()) {
case MANIFEST_SUPPORTS_RTL:
performRefactoringForAndroidManifestApplicationTag(refactoring);
break;
case MANIFEST_TARGET_SDK:
performRefactoringForAndroidManifestTargetSdk(refactoring);
break;
case LAYOUT_FILE_ATTRIBUTE:
performRefactoringForLayoutFile(refactoring);
break;
case UNDEFINED:
break;
default:
assert false : refactoring.getType();
}
}
}
@Override
protected void performPsiSpoilingRefactoring() {
PsiDocumentManager.getInstance(myProject).commitAllDocuments();
}
private void addManifestRefactoring(List<UsageInfo> list) {
// For all non library modules in our project
for (Module module : ModuleManager.getInstance(myProject).getModules()) {
AndroidFacet facet = AndroidFacet.getInstance(module);
if (facet == null || facet.isLibraryProject()) {
continue;
}
for (VirtualFile manifestFile : IdeaSourceProvider.getManifestFiles(facet)) {
XmlFile manifestPsiFile = (XmlFile)PsiManager.getInstance(myProject).findFile(manifestFile);
try {
if (manifestPsiFile == null) {
continue;
}
XmlTag root = manifestPsiFile.getRootTag();
if (root == null) {
continue;
}
// First, deal with "supportsRtl" into the <application> tag
XmlTag[] applicationNodes = root.findSubTags(NODE_APPLICATION);
if (applicationNodes.length > 0) {
assert applicationNodes.length == 1;
XmlTag applicationTag = applicationNodes[0];
XmlAttribute supportsRtlAttribute = applicationTag.getAttribute(AndroidManifest.ATTRIBUTE_SUPPORTS_RTL, ANDROID_URI);
if (supportsRtlAttribute == null || VALUE_FALSE.equals(supportsRtlAttribute.getValue())) {
final int startOffset;
final int endOffset;
if (supportsRtlAttribute == null) {
XmlAttribute[] applicationTagAttributes = applicationTag.getAttributes();
XmlAttribute lastAttribute = applicationTagAttributes[applicationTagAttributes.length - 1];
PsiElement nextSibling = lastAttribute.getNextSibling();
assert nextSibling != null;
// Will position the caret just before the ">" for the application tag
startOffset = nextSibling.getStartOffsetInParent() + nextSibling.getTextLength();
endOffset = startOffset;
}
else {
// Will position the caret at the beginning of the "supportsRtl" attribute
startOffset = supportsRtlAttribute.getStartOffsetInParent();
endOffset = startOffset + supportsRtlAttribute.getTextLength();
}
RtlRefactoringUsageInfo usageInfo = new RtlRefactoringUsageInfo(applicationTag, startOffset, endOffset);
usageInfo.setType(MANIFEST_SUPPORTS_RTL);
list.add(usageInfo);
}
}
// Second, deal with targetSdkVersion / minSdkVersion
XmlTag[] usesSdkNodes = root.findSubTags(NODE_USES_SDK);
if (usesSdkNodes.length > 0) {
assert usesSdkNodes.length == 1;
XmlTag usesSdkTag = usesSdkNodes[0];
XmlAttribute targetSdkAttribute = usesSdkTag.getAttribute(ATTRIBUTE_TARGET_SDK_VERSION, ANDROID_URI);
int targetSdk = (targetSdkAttribute != null) ? Integer.parseInt(targetSdkAttribute.getValue()) : 0;
// Will need to set existing targetSdkVersion to 17
if (targetSdk == 0 || targetSdk < RTL_TARGET_SDK_START) {
// Will position the caret just at the start of
final int startOffset = (targetSdkAttribute != null)
? targetSdkAttribute.getStartOffsetInParent()
: usesSdkTag.getStartOffsetInParent();
final int endOffset = startOffset +
((targetSdkAttribute != null)
? targetSdkAttribute.getTextLength()
: usesSdkTag.getTextLength());
RtlRefactoringUsageInfo usageInfo = new RtlRefactoringUsageInfo(usesSdkTag, startOffset, endOffset);
usageInfo.setType(MANIFEST_TARGET_SDK);
list.add(usageInfo);
}
}
}
catch (Exception e) {
LOG.error("Could not read Manifest data", e);
}
}
}
}
private static String quote(String str) {
return quoteWith(str, "'");
}
private static String quoteWith(String str, String quote) {
return quote + str + quote;
}
@Nullable
private VirtualFile getLayoutV17(final VirtualFile oneLayoutRes, boolean bCreateIfNeeded) {
final String resName = oneLayoutRes.getName();
if (resName.contains(RES_V_QUALIFIER)) {
return null;
}
final String resNameWithV17 = resName + RES_V17_QUALIFIER;
final VirtualFile parent = oneLayoutRes.getParent();
assert parent != null;
VirtualFile layoutV17Dir = parent.findChild(resNameWithV17);
if ((layoutV17Dir == null || !layoutV17Dir.exists()) && bCreateIfNeeded) {
try {
layoutV17Dir = parent.createChildDirectory(this, resNameWithV17);
}
catch (IOException e) {
LOG.error("Cannot create " + quote(resNameWithV17) + " directory in resource directory: " + parent.getName());
}
}
if (layoutV17Dir != null) {
assert layoutV17Dir.isDirectory() : layoutV17Dir;
}
return layoutV17Dir;
}
private List<UsageInfo> getLayoutRefactoringForOneDir(@NotNull VirtualFile layoutDir, boolean createV17, int minSdk) {
List<UsageInfo> result = new ArrayList<UsageInfo>();
final VirtualFile[] layoutChildren = layoutDir.getChildren();
for (final VirtualFile oneLayoutFile : layoutChildren) {
result.addAll(getLayoutRefactoringForOneFile(oneLayoutFile, createV17, minSdk));
}
return result;
}
private List<UsageInfo> getLayoutRefactoringForOneFile(@NotNull VirtualFile layoutFile, boolean createV17, int minSdk) {
final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(layoutFile);
assert psiFile != null;
return getLayoutRefactoringForFile(psiFile, createV17, minSdk);
}
private void addLayoutRefactoring(List<UsageInfo> list) {
// For all non library modules in our project
for (Module module : ModuleManager.getInstance(myProject).getModules()) {
AndroidFacet facet = AndroidFacet.getInstance(module);
if (facet != null && !facet.isLibraryProject()) {
int minSdk = facet.getAndroidModuleInfo().getMinSdkVersion().getApiLevel();
if (myProperties.generateV17resourcesOption) {
// First get all the "res" directories
final List<VirtualFile> allRes = facet.getAllResourceDirectories();
// Then, need to get all the "layout-XXX" sub directories
final List<VirtualFile> allLayoutDir = new ArrayList<VirtualFile>();
for (VirtualFile oneRes : allRes) {
if (ResourceFolderManager.isLibraryResourceRoot(oneRes)) {
continue;
}
final VirtualFile[] children = oneRes.getChildren();
// Check every children if they are a layout dir but not a "-v17" one
for (VirtualFile oneChild : children) {
final String childName = oneChild.getName();
if (childName.startsWith(FD_RES_LAYOUT) && !childName.contains(RES_V_QUALIFIER)) {
allLayoutDir.add(oneChild);
}
}
}
// For all "layout-XXX" entries, process all the contained files
for (final VirtualFile layoutDir : allLayoutDir) {
final VirtualFile layoutV17Dir = getLayoutV17(layoutDir, false /* no creation */);
// The corresponding "v17" directory already exists
if (layoutV17Dir != null) {
// ... so add refactoring for all files in the "v17" directory if needed
if (layoutV17Dir.getChildren().length != 0) {
list.addAll(getLayoutRefactoringForOneDir(layoutV17Dir, false /* do not create v17 version */, minSdk));
}
else {
list.addAll(getLayoutRefactoringForOneDir(layoutDir, true /* create v17 version */, minSdk));
}
}
else {
// otherwise all refactoring for all the non "v17" file and will create the "v17" file later on (we *cannot*
// create them here even with a ApplicationManager.getApplication().runWriteAction(...)
list.addAll(getLayoutRefactoringForOneDir(layoutDir, true /* create the v17 version */, minSdk));
}
}
}
else {
final List<PsiFile> files = facet.getLocalResourceManager().findResourceFiles(ResourceFolderType.LAYOUT.getName());
for (PsiFile psiFile : files) {
if (ResourceFolderManager.isLibraryResourceFile(psiFile.getVirtualFile())) {
continue;
}
list.addAll(getLayoutRefactoringForFile(psiFile, false /* do not create the v17 version */, minSdk));
}
}
}
}
}
private List<UsageInfo> getLayoutRefactoringForFile(@NotNull final PsiFile layoutFile, final boolean createV17, final int minSdk) {
final List<UsageInfo> result = new ArrayList<UsageInfo>();
if (layoutFile instanceof XmlFile &&
DomManager.getDomManager(myProject).getDomFileDescription((XmlFile)layoutFile) instanceof LayoutDomFileDescription) {
layoutFile.accept(new XmlRecursiveElementVisitor() {
@Override
public void visitXmlTag(XmlTag tag) {
super.visitXmlTag(tag);
List<UsageInfo> usageInfos = getLayoutRefactoringForTag(tag, createV17, minSdk);
if (usageInfos.isEmpty()) {
return;
}
result.addAll(usageInfos);
}
});
}
return result;
}
private List<UsageInfo> getLayoutRefactoringForTag(@NotNull XmlTag tag, boolean createV17, int minSdk) {
final DomElement domElement = DomManager.getDomManager(myProject).getDomElement(tag);
if (!(domElement instanceof LayoutViewElement)) {
return Collections.emptyList();
}
final List<UsageInfo> result = new ArrayList<UsageInfo>();
final XmlAttribute[] attributes = tag.getAttributes();
for (XmlAttribute attributeToMirror : attributes) {
final String localName = attributeToMirror.getLocalName();
final String namespacePrefix = attributeToMirror.getNamespacePrefix();
final String mirroredLocalName = ourMapMirroredAttributeName.get(localName);
// Check if this is a RTL attribute to mirror or if it is a Gravity attribute
if (mirroredLocalName != null) {
// Mirror only attributes that has not been mirrored before
final XmlAttribute attributeMirrored = tag.getAttribute(namespacePrefix + ":" + mirroredLocalName);
if (attributeMirrored == null) {
final int startOffset = 0;
final int endOffset = attributeToMirror.getTextLength();
RtlRefactoringUsageInfo usageInfoForAttribute = new RtlRefactoringUsageInfo(attributeToMirror, startOffset, endOffset);
usageInfoForAttribute.setType(LAYOUT_FILE_ATTRIBUTE);
usageInfoForAttribute.setCreateV17(createV17);
usageInfoForAttribute.setAndroidManifestMinSdkVersion(minSdk);
result.add(usageInfoForAttribute);
}
}
else if (localName.equals(ATTR_GRAVITY) || localName.equals(ATTR_LAYOUT_GRAVITY)) {
final String value = attributeToMirror.getValue();
if (value != null && (value.contains(GRAVITY_VALUE_LEFT) || value.contains(GRAVITY_VALUE_RIGHT))) {
final int startOffset = 0;
final int endOffset = attributeToMirror.getTextLength();
RtlRefactoringUsageInfo usageInfoForAttribute = new RtlRefactoringUsageInfo(attributeToMirror, startOffset, endOffset);
usageInfoForAttribute.setType(LAYOUT_FILE_ATTRIBUTE);
usageInfoForAttribute.setCreateV17(createV17);
result.add(usageInfoForAttribute);
}
}
}
return result;
}
private static void performRefactoringForAndroidManifestApplicationTag(@NotNull UsageInfo usageInfo) {
PsiElement element = usageInfo.getElement();
assert element != null;
XmlTag applicationTag = (XmlTag)element;
XmlAttribute supportsRtlAttribute = applicationTag.getAttribute(ATTRIBUTE_SUPPORTS_RTL, ANDROID_URI);
if (supportsRtlAttribute != null) {
supportsRtlAttribute.setValue(SdkConstants.VALUE_TRUE);
}
else {
applicationTag.setAttribute(ATTRIBUTE_SUPPORTS_RTL, ANDROID_URI, SdkConstants.VALUE_TRUE);
}
}
private static void performRefactoringForAndroidManifestTargetSdk(@NotNull UsageInfo usageInfo) {
PsiElement element = usageInfo.getElement();
assert element != null;
XmlTag usesSdkTag = (XmlTag)element;
XmlAttribute targetSdkAttribute = usesSdkTag.getAttribute(ATTRIBUTE_TARGET_SDK_VERSION, ANDROID_URI);
if (targetSdkAttribute != null) {
targetSdkAttribute.setValue(Integer.toString(RTL_TARGET_SDK_START));
}
else {
usesSdkTag.setAttribute(ATTRIBUTE_TARGET_SDK_VERSION, ANDROID_URI, Integer.toString(RTL_TARGET_SDK_START));
}
}
private void performRefactoringForLayoutFile(@NotNull final RtlRefactoringUsageInfo usageInfo) {
final PsiElement element = usageInfo.getElement();
assert element != null;
final XmlAttribute attribute = (XmlAttribute)element;
final int minSdk = usageInfo.getAndroidManifestMinSdkVersion();
if (!usageInfo.isCreateV17()) {
updateAttributeForElement(attribute, minSdk);
}
else {
// We need first to create the v17 layout file, so first get our initial layout file
final PsiFile psiFile = element.getContainingFile();
final VirtualFile layoutFile = psiFile.getVirtualFile();
assert layoutFile != null;
final VirtualFile layoutDir = layoutFile.getParent();
assert layoutDir != null;
final VirtualFile layoutV17Dir = getLayoutV17(layoutDir, true /* create if needed */);
assert layoutV17Dir != null;
final String layoutFileName = layoutFile.getName();
// Create the v17 file if needed (should be done only once)
if (layoutV17Dir.findChild(layoutFileName) == null) {
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
try {
layoutFile.copy(this, layoutV17Dir, layoutFileName);
}
catch (IOException e) {
LOG.error("Cannot copy layout file " + quote(layoutFileName) + " from " +
quote(layoutDir.getName()) + " directory to " + quote(layoutV17Dir.getName()) +
" directory");
}
}
});
}
final VirtualFile layoutV17File = layoutV17Dir.findChild(layoutFileName);
assert layoutV17File != null;
final XmlFile xmlV17File = (XmlFile)PsiManager.getInstance(myProject).findFile(layoutV17File);
assert xmlV17File != null;
LOG.info("Processing refactoring for attribute: " + attribute.getName() + " into file: " + layoutV17File.getPath());
if (DomManager.getDomManager(myProject).getDomFileDescription((XmlFile)xmlV17File) instanceof LayoutDomFileDescription) {
xmlV17File.accept(new XmlRecursiveElementVisitor() {
@Override
public void visitXmlTag(XmlTag tag) {
super.visitXmlTag(tag);
final XmlAttribute attribute = tag.getAttribute(((XmlAttribute)element).getName());
if (attribute == null) {
return;
}
updateAttributeForElement(attribute, minSdk);
}
});
}
layoutV17File.refresh(true /* asynchronous */, false /* not recursive */);
}
}
private void updateAttributeForElement(@NotNull XmlAttribute attribute, int minSdk) {
final String attributeLocalName = attribute.getLocalName();
LOG.info("Updating attribute name: " + attributeLocalName + " value: " + attribute.getValue());
if (attributeLocalName.equals(ATTR_GRAVITY) || attributeLocalName.equals(ATTR_LAYOUT_GRAVITY)) {
// Special case for android:gravity and android:layout_gravity
final String value = StringUtil.notNullize(attribute.getValue());
final String newValue = value.replace(GRAVITY_VALUE_LEFT, GRAVITY_VALUE_START).replace(GRAVITY_VALUE_RIGHT, GRAVITY_VALUE_END);
attribute.setValue(newValue);
LOG.info("Changing gravity from: " + value + " to: " + newValue);
}
else {
// General case for RTL attributes
final String mirroredAttributeLocalName = ourMapMirroredAttributeName.get(attributeLocalName);
if (mirroredAttributeLocalName == null) {
LOG.warn("Cannot mirror attribute: " + attribute.toString());
return;
}
final String mirroredAttributeName = attribute.getNamespacePrefix() + ":" + mirroredAttributeLocalName;
XmlAttribute attributeForUpdatingValue;
if (myProperties.replaceLeftRightPropertiesOption) {
attribute.setName(mirroredAttributeName);
LOG.info("Replacing attribute name from: " + attributeLocalName + " to: " + mirroredAttributeLocalName);
attributeForUpdatingValue = attribute;
}
else {
XmlTag parent = attribute.getParent();
attributeForUpdatingValue = parent.setAttribute(mirroredAttributeName, StringUtil.notNullize(attribute.getValue()));
LOG.info("Adding attribute name: " + mirroredAttributeName + " value: " + attribute.getValue());
}
// Special case for updating attribute value
updateAttributeValueIfNeeded(attributeForUpdatingValue, minSdk);
}
}
private static void updateAttributeValueIfNeeded(@NotNull XmlAttribute attribute, int minSdk) {
final String attributeLocalName = attribute.getLocalName();
final String value = StringUtil.notNullize(attribute.getValue());
if (attributeLocalName.equals(ATTR_PADDING_LEFT) || attributeLocalName.equals(ATTR_PADDING_RIGHT) ||
attributeLocalName.equals(ATTR_PADDING_START) || attributeLocalName.equals(ATTR_PADDING_END)) {
if (minSdk >= RTL_TARGET_SDK_START &&
(value.contains(ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT) || value.contains(ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT))) {
final String newValue = value.replace(ATTR_LIST_PREFERRED_ITEM_PADDING_LEFT, ATTR_LIST_PREFERRED_ITEM_PADDING_START).
replace(ATTR_LIST_PREFERRED_ITEM_PADDING_RIGHT, ATTR_LIST_PREFERRED_ITEM_PADDING_END);
attribute.setValue(newValue);
LOG.info("Changing attribute value from: " + value + " to: " + newValue);
}
}
}
@Override
protected String getCommandName() {
return REFACTORING_NAME;
}
}