android/jps-plugin/src/org/jetbrains/jps/android/AndroidManifestMergingTarget.java

package org.jetbrains.jps.android;

import org.jetbrains.android.util.AndroidCommonUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.android.model.JpsAndroidModuleExtension;
import org.jetbrains.jps.builders.*;
import org.jetbrains.jps.builders.impl.BuildRootDescriptorImpl;
import org.jetbrains.jps.builders.storage.BuildDataPaths;
import org.jetbrains.jps.cmdline.ProjectDescriptor;
import org.jetbrains.jps.incremental.CompileContext;
import org.jetbrains.jps.incremental.TargetTypeRegistry;
import org.jetbrains.jps.indices.IgnoredFileIndex;
import org.jetbrains.jps.indices.ModuleExcludeIndex;
import org.jetbrains.jps.model.JpsModel;
import org.jetbrains.jps.model.module.JpsModule;

import java.io.File;
import java.io.PrintWriter;
import java.util.*;

/**
 * @author Eugene.Kudelevsky
 */
public class AndroidManifestMergingTarget extends ModuleBasedTarget<AndroidManifestMergingTarget.MyRootDescriptor> {
  public AndroidManifestMergingTarget(ModuleBasedBuildTargetType<?> targetType, @NotNull JpsModule module) {
    super(targetType, module);
  }

  @Override
  public boolean isCompiledBeforeModuleLevelBuilders() {
    return true;
  }

  @Override
  public boolean isTests() {
    return false;
  }

  @Override
  public String getId() {
    return myModule.getName();
  }

  @Override
  public Collection<BuildTarget<?>> computeDependencies(BuildTargetRegistry targetRegistry, TargetOutputIndex outputIndex) {
    final BuildTargetType<?> mavenResourcesProductionType =
      TargetTypeRegistry.getInstance().getTargetType("maven-resources-production");

    if (mavenResourcesProductionType != null) {
      return new ArrayList<BuildTarget<?>>(targetRegistry.getAllTargets(mavenResourcesProductionType));
    }
    return Collections.emptyList();
  }

  @Override
  public void writeConfiguration(ProjectDescriptor pd, PrintWriter out) {
  }

  @NotNull
  @Override
  public List<MyRootDescriptor> computeRootDescriptors(JpsModel model,
                                                          ModuleExcludeIndex index,
                                                          IgnoredFileIndex ignoredFileIndex,
                                                          BuildDataPaths dataPaths) {
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
    assert extension != null;
    final List<MyRootDescriptor> result = new ArrayList<MyRootDescriptor>();

    final File manifestFile = AndroidJpsUtil.getManifestFileForCompilationPath(extension);

    if (manifestFile != null) {
      result.add(new MyRootDescriptor(this, manifestFile, false));
    }

    for (JpsAndroidModuleExtension libExtension : AndroidJpsUtil.getAllAndroidDependencies(myModule, true)) {
      final File libManifest = AndroidJpsUtil.getManifestFileForCompilationPath(libExtension);

      if (libManifest != null && libManifest.exists()) {
        result.add(new MyRootDescriptor(this, libManifest, true));
      }
    }
    return result;
  }

  @Nullable
  @Override
  public MyRootDescriptor findRootDescriptor(String rootId, BuildRootIndex rootIndex) {
    for (MyRootDescriptor descriptor : rootIndex.getTargetRoots(this, null)) {
      if (descriptor.getRootId().equals(rootId)) {
        return descriptor;
      }
    }
    return null;
  }

  @NotNull
  @Override
  public String getPresentableName() {
    return "Android Manifest Merging";
  }

  @NotNull
  @Override
  public Collection<File> getOutputRoots(CompileContext context) {
    return Collections.singletonList(getOutputDirectory(context));
  }

  @NotNull
  public File getOutputDirectory(@NotNull CompileContext context) {
    return AndroidJpsUtil.getPreprocessedManifestDirectory(
      myModule, context.getProjectDescriptor().dataManager.getDataPaths());
  }

  public static class MyTargetType extends ModuleBasedBuildTargetType<AndroidManifestMergingTarget> {
    public static final MyTargetType INSTANCE = new MyTargetType();

    private MyTargetType() {
      super(AndroidCommonUtils.MANIFEST_MERGING_BUILD_TARGET_TYPE_ID);
    }

    @NotNull
    @Override
    public List<AndroidManifestMergingTarget> computeAllTargets(@NotNull JpsModel model) {
      if (!AndroidJpsUtil.isAndroidProjectWithoutGradleFacet(model.getProject())) {
        return Collections.emptyList();
      }
      final List<AndroidManifestMergingTarget> targets = new ArrayList<AndroidManifestMergingTarget>();

      for (JpsModule module : model.getProject().getModules()) {
        final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(module);

        if (extension != null && !extension.isLibrary() && extension.isManifestMergingEnabled()) {
          targets.add(new AndroidManifestMergingTarget(this, module));
        }
      }
      return targets;
    }

    @NotNull
    @Override
    public BuildTargetLoader<AndroidManifestMergingTarget> createLoader(@NotNull JpsModel model) {
      final Map<String, AndroidManifestMergingTarget> targetMap = new HashMap<String, AndroidManifestMergingTarget>();

      for (AndroidManifestMergingTarget target : computeAllTargets(model)) {
        targetMap.put(target.getId(), target);
      }
      return new BuildTargetLoader<AndroidManifestMergingTarget>() { {}
        @Nullable
        @Override
        public AndroidManifestMergingTarget createTarget(@NotNull String targetId) {
          return targetMap.get(targetId);
        }
      };
    }
  }

  public static class MyRootDescriptor extends BuildRootDescriptorImpl {
    private final boolean myLibManifestRoot;

    private MyRootDescriptor(@NotNull BuildTarget target, @NotNull File root, boolean libManifestRoot) {
      super(target, root);
      myLibManifestRoot = libManifestRoot;
    }

    public boolean isLibManifestRoot() {
      return myLibManifestRoot;
    }
  }
}