android/src/com/android/tools/idea/rendering/IncludeReference.java

/*
 * 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.rendering;

import com.android.annotations.NonNull;
import com.android.ide.common.rendering.api.RenderResources;
import com.android.ide.common.rendering.api.ResourceValue;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.xml.XmlFile;
import com.intellij.psi.xml.XmlTag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.io.File;

import static com.android.SdkConstants.LAYOUT_RESOURCE_PREFIX;
import static com.android.SdkConstants.TOOLS_URI;

/**
 * A reference to a particular file in the project
 */
public class IncludeReference {
  @SuppressWarnings("ConstantConditions")
  public static final IncludeReference NONE = new IncludeReference(null, null, null);

  /** Tools namespace attribute for declaring a surrounding layout to be used */
  public static final String ATTR_RENDER_IN = "showIn";

  /**
   * The source file of the reference (included from)
   */
  @NotNull
  private final VirtualFile myFromFile;

  /**
   * The destination file of the reference (the file being included)
   */
  @Nullable
  private final VirtualFile myToFile;

  /**
   * The module containing the file
   */
  @NotNull
  private final Module myModule;

  /**
   * Creates a new include reference
   */
  private IncludeReference(@NonNull Module module, @NonNull VirtualFile fromFile,  @Nullable VirtualFile toFile) {
    myModule = module;
    myFromFile = fromFile;
    myToFile = toFile;
  }

  /**
   * Creates a new include reference
   */
  public static IncludeReference create(@NonNull Module module, @NonNull VirtualFile fromFile,  @Nullable VirtualFile toFile) {
    return new IncludeReference(module, fromFile, toFile);
  }

  /**
   * Returns the associated module
   * @return the module
   */
  @NotNull
  public Module getModule() {
    return myModule;
  }

  /**
   * Returns the file for the include reference
   * @return the file
   */
  @NotNull
  public VirtualFile getFromFile() {
    return myFromFile;
  }

  /**
   * Returns the path for the include reference
   * @return the path
   */
  @NotNull
  public File getFromPath() {
    return VfsUtilCore.virtualToIoFile(myFromFile);
  }

  /**
   * Returns the destination file for the include reference
   * @return the destination file
   */
  @Nullable
  public VirtualFile getToFile() {
    return myToFile;
  }

  /**
   * Returns the destination path for the include reference
   * @return the destination path, if known
   */
  @Nullable
  public File getToPath() {
    return myToFile != null ? VfsUtilCore.virtualToIoFile(myToFile) : null;
  }

  /**
   * Returns a description of this reference, suitable to be shown to the user
   *
   * @return a display name for the reference
   */
  @NotNull
  public String getFromDisplayName() {
    // The ID is deliberately kept in a pretty user-readable format but we could
    // consider prepending layout/ on ids that don't have it (to make the display
    // more uniform) or ripping out all layout[-constraint] prefixes out and
    // instead prepending @ etc.
    if (myToFile != null && myToFile.getParent() != null && myToFile.getParent().equals(myFromFile.getParent())) {
      return myFromFile.getName();
    }

    return myFromFile.getParent().getName() + '/' + myFromFile.getName();
  }

  /**
   * Returns the resource name of this layout
   *
   * @return the resource name
   */
  @NotNull
  public String getFromResourceName() {
    return ResourceHelper.getResourceName(myFromFile);
  }

  /**
   * Returns the resource URL for this layout, such as {@code @layout/foo}.
   *
   * @return the resource URL
   */
  @NotNull
  public String getFromResourceUrl() {
    return LAYOUT_RESOURCE_PREFIX + getFromResourceName();
  }

  @Nullable
  public static String getIncludingLayout(@NotNull final XmlFile file) {
    if (!ApplicationManager.getApplication().isReadAccessAllowed()) {
      return ApplicationManager.getApplication().runReadAction(new Computable<String>() {
        @Nullable
        @Override
        public String compute() {
          return getIncludingLayout(file);
        }
      });
    }
    XmlTag rootTag = file.getRootTag();
    if (rootTag != null && rootTag.isValid()) {
      return rootTag.getAttributeValue(ATTR_RENDER_IN, TOOLS_URI);
    }

    return null;
  }

  public static void setIncludingLayout(@NotNull Project project, @NotNull XmlFile xmlFile, @Nullable String layout) {
    XmlTag tag = xmlFile.getRootTag();
    if (tag != null) {
      SetAttributeFix fix = new SetAttributeFix(project, tag, ATTR_RENDER_IN, TOOLS_URI, layout);
      fix.execute();
    }
  }

  /** Returns an {link IncludeReference} specified for the given file, or {@link #NONE} if no include should be performed from the
   * given file */
  @NotNull
  public static IncludeReference get(@NotNull final Module module, @NotNull final XmlFile file, @NotNull final RenderResources resolver) {
    if (!ApplicationManager.getApplication().isReadAccessAllowed()) {
      return ApplicationManager.getApplication().runReadAction(new Computable<IncludeReference>() {
        @NotNull
        @Override
        public IncludeReference compute() {
          return get(module, file, resolver);
        }
      });
    }

    ApplicationManager.getApplication().assertReadAccessAllowed();
    XmlTag rootTag = file.getRootTag();
    if (rootTag != null) {
      String layout = rootTag.getAttributeValue(ATTR_RENDER_IN, TOOLS_URI);
      if (layout != null) {
        ResourceValue resValue = resolver.findResValue(layout, false);
        if (resValue != null) {
          // TODO: Do some sort of picking based on best configuration!!
          // I should make sure I also get a configuration that is compatible with
          // my target include! I could stash it in the include reference!
          File path = ResourceHelper.resolveLayout(resolver, resValue);
          if (path != null) {
            VirtualFile source = LocalFileSystem.getInstance().findFileByIoFile(path);
            if (source != null) {
              VirtualFile target = file.getVirtualFile();
              return create(module, source, target);
            }
          }
        }
      }
    }

    return NONE;
  }
}