android/jps-plugin/src/org/jetbrains/jps/android/builder/AndroidResourcePackagingBuildTarget.java

package org.jetbrains.jps.android.builder;

import com.android.SdkConstants;
import org.jetbrains.android.util.AndroidCommonUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.android.AndroidJpsUtil;
import org.jetbrains.jps.android.model.JpsAndroidModuleExtension;
import org.jetbrains.jps.builders.BuildRootDescriptor;
import org.jetbrains.jps.builders.BuildTarget;
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.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.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * @author Eugene.Kudelevsky
 */
public class AndroidResourcePackagingBuildTarget extends AndroidBuildTarget {
  public AndroidResourcePackagingBuildTarget(@NotNull JpsModule module) {
    super(MyTargetType.INSTANCE, module);
  }

  @Override
  public void writeConfiguration(ProjectDescriptor pd, PrintWriter out) {
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
    assert extension != null;

    if (extension.isUseCustomManifestPackage()) {
      out.println(extension.getCustomManifestPackage());
    }
    out.println(extension.getAdditionalPackagingCommandLineParameters());
  }

  @NotNull
  @Override
  protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                               ModuleExcludeIndex index,
                                                               IgnoredFileIndex ignoredFileIndex,
                                                               BuildDataPaths dataPaths) {
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
    assert extension != null;

    final String[] resourceDirs = AndroidJpsUtil.collectResourceDirsForCompilation(extension, true, dataPaths, false);

    final List<String> assertDirs = new ArrayList<String>();
    collectAssetDirs(extension, assertDirs, false);

    final File manifestFile = AndroidJpsUtil.getPreprocessedManifestFile(extension, dataPaths);
    final List<BuildRootDescriptor> result = new ArrayList<BuildRootDescriptor>();

    for (String resourceDir : resourceDirs) {
      result.add(new BuildRootDescriptorImpl(this, new File(resourceDir)));
    }

    for (String assetDir : assertDirs) {
      result.add(new BuildRootDescriptorImpl(this, new File(assetDir)));
    }

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

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

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

  @NotNull
  public static File getOutputFile(@NotNull BuildDataPaths dataPaths, @NotNull JpsModule module) {
    final File dir = AndroidJpsUtil.getDirectoryForIntermediateArtifacts(dataPaths, module);
    return new File(dir.getPath(), module.getName() + ".apk.res");
  }

  public static void collectAssetDirs(@NotNull JpsAndroidModuleExtension extension, @NotNull List<String> result, boolean checkExistence) {
    final File assetsDir = extension.getAssetsDir();

    if (assetsDir != null && (!checkExistence || assetsDir.exists())) {
      result.add(assetsDir.getPath());
    }

    if (extension.isIncludeAssetsFromLibraries()) {
      for (JpsAndroidModuleExtension depExtension : AndroidJpsUtil.getAllAndroidDependencies(extension.getModule(), true)) {
        final File depAssetsDir = depExtension.getAssetsDir();

        if (depAssetsDir != null && (!checkExistence || depAssetsDir.exists())) {
          result.add(depAssetsDir.getPath());
        }
      }
      collectAssetDirsFromAarDeps(extension.getModule(), result);
    }
  }

  private static void collectAssetDirsFromAarDeps(@NotNull JpsModule module, @NotNull Collection<String> result) {
    final List<String> resDirsFromAarDeps = new ArrayList<String>();
    AndroidJpsUtil.collectResDirectoriesFromAarDeps(module, resDirsFromAarDeps);

    if (resDirsFromAarDeps.isEmpty()) {
      return;
    }
    for (String path : resDirsFromAarDeps) {
      final File assetsSibling = new File(new File(path).getParentFile(), SdkConstants.FD_ASSETS);

      if (assetsSibling.isDirectory()) {
        result.add(assetsSibling.getPath());
      }
    }
  }

  @Override
  protected void fillDependencies(List<BuildTarget<?>> result) {
    super.fillDependencies(result);
    result.add(new AndroidResourceCachingBuildTarget(myModule));

    for (JpsAndroidModuleExtension depExtension : AndroidJpsUtil.getAllAndroidDependencies(myModule, true)) {
      result.add(new AndroidResourceCachingBuildTarget(depExtension.getModule()));
    }
  }

  public static class MyTargetType extends AndroidBuildTargetType<AndroidResourcePackagingBuildTarget> {
    public static final MyTargetType INSTANCE = new MyTargetType();

    private MyTargetType() {
      super(AndroidCommonUtils.RESOURCE_PACKAGING_BUILD_TARGET_ID, "Resource Packaging");
    }

    @Override
    public AndroidResourcePackagingBuildTarget createBuildTarget(@NotNull JpsAndroidModuleExtension extension) {
      return !extension.isLibrary() ? new AndroidResourcePackagingBuildTarget(extension.getModule()) : null;
    }
  }
}