import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public boolean isTargetDirty(CompileContext context) {
  final String currentState = getCurrentState(context);
  if (!currentState.equals(myConfiguration)) {
    LOG.debug(myTarget + " configuration was changed:");
    LOG.debug("Old:");
    LOG.debug(myConfiguration);
    LOG.debug("New:");
    LOG.debug(currentState);
    LOG.debug(myTarget + " will be recompiled");
    if (myTarget instanceof ModuleBuildTarget) {
      final JpsModule module = ((ModuleBuildTarget)myTarget).getModule();
      synchronized (MODULES_WITH_TARGET_CONFIG_CHANGED_KEY) {
        Set<JpsModule> modules = MODULES_WITH_TARGET_CONFIG_CHANGED_KEY.get(context);
        if (modules == null) {
          MODULES_WITH_TARGET_CONFIG_CHANGED_KEY.set(context, modules = new THashSet<JpsModule>());
        }
        modules.add(module);
      }
    }
    return true;
  }
  return false;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@NotNull
@Override
public List<JavaSourceRootDescriptor> getAdditionalRoots(@NotNull BuildTarget<JavaSourceRootDescriptor> target, BuildDataPaths dataPaths) {
  ModuleBuildTarget buildTarget = (ModuleBuildTarget)target;
  final File generatedSourcesRoot = AndroidJpsUtil.getGeneratedSourcesStorage(buildTarget.getModule(), dataPaths);
  final List<JavaSourceRootDescriptor> result = new ArrayList<JavaSourceRootDescriptor>();

  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.AAPT_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.AIDL_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.RENDERSCRIPT_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.BUILD_CONFIG_GENERATED_SOURCE_ROOT_NAME));

  addRoot(result, buildTarget, AndroidJpsUtil.getCopiedSourcesStorage(buildTarget.getModule(), dataPaths));

  return result;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public ModuleChunk(Set<ModuleBuildTarget> targets) {
  boolean containsTests = false;
  myTargets = targets;
  myModules = new LinkedHashSet<JpsModule>();
  for (ModuleBuildTarget target : targets) {
    myModules.add(target.getModule());
    containsTests |= target.isTests();
  }
  myContainsTests = containsTests;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public Collection<? extends BuildTarget<?>> getDependencies(@NotNull JpsProductionModuleOutputPackagingElement element,
                                                            TargetOutputIndex outputIndex) {
  JpsModule module = element.getModuleReference().resolve();
  if (module != null) {
    return Collections.singletonList(new ModuleBuildTarget(module, JavaModuleBuildTargetType.PRODUCTION));
  }
  return Collections.emptyList();
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@NotNull
@Override
public List<ModuleBuildTarget> computeAllTargets(@NotNull JpsModel model) {
  List<JpsModule> modules = model.getProject().getModules();
  List<ModuleBuildTarget> targets = new ArrayList<ModuleBuildTarget>(modules.size());
  for (JpsModule module : modules) {
    targets.add(new ModuleBuildTarget(module, this));
  }
  return targets;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public JavaSourceRootDescriptor(@NotNull File root,
                                @NotNull ModuleBuildTarget target,
                                boolean isGenerated,
                                boolean isTemp,
                                @NotNull String packagePrefix,
                                @NotNull Set<File> excludes) {
  this.root = root;
  this.target = target;
  this.isGeneratedSources = isGenerated;
  this.isTemp = isTemp;
  myPackagePrefix = packagePrefix;
  myExcludes = excludes;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
/**
 * It does nothing.
 *
 * @return {@link ExitCode#OK} if the modules to build are Gradle ones, otherwise it returns {@link ExitCode#NOTHING_DONE}.
 */
@NotNull
@Override
public ExitCode build(CompileContext context,
                      ModuleChunk chunk,
                      DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder,
                      OutputConsumer outputConsumer) {
  JpsAndroidGradleModuleExtension extension = AndroidGradleJps.getFirstExtension(chunk);
  if (extension == null) {
    return ExitCode.NOTHING_DONE;
  }
  return ExitCode.OK;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public Collection<BuildTarget<?>> computeDependencies(final BuildTargetRegistry registry, TargetOutputIndex outputIndex) {
  final List<BuildTarget<?>> result = new ArrayList<BuildTarget<?>>(3);

  fillDependencies(result);
  result.add(new ModuleBuildTarget(myModule, JavaModuleBuildTargetType.PRODUCTION));

  final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
  if (extension != null && extension.isPackTestCode()) {
    result.add(new ModuleBuildTarget(myModule, JavaModuleBuildTargetType.TEST));
  }
  return result;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final Collection<BuildTarget<?>> computeDependencies(
        final BuildTargetRegistry buildTargetRegistry,
        final TargetOutputIndex targetOutputIndex) {
    final List<BuildTarget<?>> dependencies = new ArrayList<>();
    dependencies.add(new ModuleBuildTarget(super.myModule, JavaModuleBuildTargetType.PRODUCTION));
    dependencies.add(this.preTargetType.createTarget(super.myModule));
    return dependencies;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public Map<BuildRootDescriptor, Set<File>> getSourcesToRecompile(@NotNull CompileContext context, BuildTarget<?> target) {
  if (target instanceof ModuleBuildTarget) {
    // multiple compilation rounds are applicable to ModuleBuildTarget only
    final FilesDelta lastRoundDelta = getRoundDelta(LAST_ROUND_DELTA_KEY, context);
    if (lastRoundDelta != null) {
      return lastRoundDelta.getSourcesToRecompile();
    }
  }
  return super.getSourcesToRecompile(context, target);
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public Set<ModuleBuildTarget> getTargets() {
  return myTargets;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public ModuleBuildTarget representativeTarget() {
  return myTargets.iterator().next();
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Nullable
@Override
public ModuleBuildTarget createTarget(@NotNull String targetId) {
  JpsModule module = myModules.get(targetId);
  return module != null ? new ModuleBuildTarget(module, JavaModuleBuildTargetType.this) : null;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public ModuleBuildTarget getTarget() {
  return target;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public boolean isDummy(@NotNull BuildTarget<?> target) {
  return (target instanceof ModuleBuildTarget || target instanceof ResourcesTarget) //todo[nik] introduce method in BuildTarget instead
       && myBuildRootIndex.getTargetRoots(target, null).isEmpty();
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public void registerOutputDirectory(@NotNull File outputDir, @NotNull Collection<String> sourcePaths) throws IOException {
  LOG.assertTrue(!(myTarget instanceof ModuleBuildTarget) && !(myTarget instanceof ArtifactBuildTarget),
                 "'registerOutputDirectory' method cannot be used for target " + myTarget + ", it will break incremental compilation");
  registerOutput(outputDir, true, sourcePaths);
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
private static void addRoot(List<JavaSourceRootDescriptor> result, ModuleBuildTarget buildTarget, final File file) {
  result.add(new JavaSourceRootDescriptor(file, buildTarget, true, false, "", Collections.<File>emptySet()));
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
public ModuleBuildTarget representativeTarget() {
     return null;
}
 

import org.jetbrains.jps.incremental.ModuleBuildTarget; //导入依赖的package包/类
@Override
public Collection<BuildTarget<?>> computeDependencies(BuildTargetRegistry targetRegistry,
        TargetOutputIndex outputIndex) {
    return Collections.singleton(new ModuleBuildTarget(myModule, JavaModuleBuildTargetType.PRODUCTION));
}