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

package org.jetbrains.jps.android.builder;

import com.intellij.util.ArrayUtil;
import org.jetbrains.android.compiler.tools.AndroidApkBuilder;
import org.jetbrains.android.util.AndroidCommonUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.ProjectPaths;
import org.jetbrains.jps.android.AndroidJpsUtil;
import org.jetbrains.jps.android.AndroidPlatform;
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.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.FileFilter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

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

  @NotNull
  public static String[] collectNativeLibsFolders(@NotNull JpsAndroidModuleExtension extension, boolean checkExistence) {
    final List<String> result = new ArrayList<String>();
    final File libsDir = extension.getNativeLibsDir();

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

    for (JpsAndroidModuleExtension depExtension : AndroidJpsUtil.getAllAndroidDependencies(extension.getModule(), true)) {
      final File depLibsDir = depExtension.getNativeLibsDir();

      if (depLibsDir != null && (!checkExistence || depLibsDir.exists())) {
        result.add(depLibsDir.getPath());
      }
    }
    return ArrayUtil.toStringArray(result);
  }

  @NotNull
  @Override
  protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                               ModuleExcludeIndex index,
                                                               IgnoredFileIndex ignoredFileIndex,
                                                               BuildDataPaths dataPaths) {
    final File resPackage = AndroidResourcePackagingBuildTarget.getOutputFile(dataPaths, myModule);
    final File classesDexFile = AndroidDexBuildTarget.getOutputFile(dataPaths, myModule);

    final List<BuildRootDescriptor> roots = new ArrayList<BuildRootDescriptor>();

    roots.add(new BuildRootDescriptorImpl(this, resPackage));
    roots.add(new BuildRootDescriptorImpl(this, classesDexFile));

    final AndroidPlatform platform = AndroidJpsUtil.getAndroidPlatform(myModule, null, null);

    if (platform != null) {
      for (String jarOrLibDir : AndroidJpsUtil.getExternalLibraries(dataPaths, myModule, platform, false, true, false)) {
        roots.add(new BuildRootDescriptorImpl(this, new File(jarOrLibDir), false));
      }
    }

    for (File resourceRoot : AndroidJpsUtil.getJavaOutputRootsForModuleAndDependencies(myModule)) {
      roots.add(new MyResourceRootDescriptor(this, resourceRoot));
    }
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
    assert extension != null;

    for (String nativeLibDir : collectNativeLibsFolders(extension, false)) {
      roots.add(new BuildRootDescriptorImpl(this, new File(nativeLibDir)));
    }
    return roots;
  }

  @NotNull
  @Override
  public Collection<File> getOutputRoots(CompileContext context) {
    final File moduleOutputDir = ProjectPaths.getModuleOutputDir(myModule, false);
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);

    if (moduleOutputDir == null || extension == null) {
      return Collections.emptyList();
    }
    final String outputPath = AndroidJpsUtil.getApkPath(extension, moduleOutputDir);

    if (outputPath == null) {
      return Collections.emptyList();
    }
    return Collections.singletonList(new File(outputPath));
  }

  @Override
  protected void fillDependencies(List<BuildTarget<?>> result) {
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);

    if (extension != null && !extension.isLibrary()) {
      // todo: remove this when AndroidPackagingBuilder will be fully target-based
      result.add(new AndroidDexBuildTarget(myModule));
      result.add(new AndroidResourcePackagingBuildTarget(myModule));
    }
  }

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

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

    @Override
    public AndroidPackagingBuildTarget createBuildTarget(@NotNull JpsAndroidModuleExtension extension) {
      return new AndroidPackagingBuildTarget(extension.getModule());
    }
  }

  private static class MyResourceRootDescriptor extends BuildRootDescriptorImpl {
    private MyResourceRootDescriptor(BuildTarget target, File root) {
      super(target, root);
    }

    @NotNull
    @Override
    public FileFilter createFileFilter() {
      return new FileFilter() {
        @Override
        public boolean accept(File file) {
          return AndroidApkBuilder.checkFileForPackaging(file);
        }
      };
    }
  }
}