import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
public boolean isTaskActive(@NotNull ExternalSystemTaskId id) {
  Map<IntegrationKey, Pair<RemoteExternalSystemFacade, ExternalSystemExecutionSettings>> copy
    = ContainerUtilRt.newHashMap(myRemoteFacades);
  for (Map.Entry<IntegrationKey, Pair<RemoteExternalSystemFacade, ExternalSystemExecutionSettings>> entry : copy.entrySet()) {
    try {
      if (entry.getValue().first.isTaskInProgress(id)) {
        return true;
      }
    }
    catch (RemoteException e) {
      myLock.lock();
      try {
        myRemoteFacades.remove(entry.getKey());
        myFacadeWrappers.remove(entry.getKey());
      }
      finally {
        myLock.unlock();
      }
    }
  }
  return false;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(@NotNull final ExternalSystemTaskId id,
                                                @NotNull final String projectPath,
                                                final boolean isPreviewMode,
                                                final S settings)
  throws ExternalSystemException, IllegalArgumentException, IllegalStateException
{
  return execute(id, new Producer<DataNode<ProjectData>>() {
    @Nullable
    @Override
    public DataNode<ProjectData> produce() {
      return myDelegate.resolveProjectInfo(id, projectPath, isPreviewMode, settings, getNotificationListener());
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public void executeTasks(@NotNull final ExternalSystemTaskId id,
                         @NotNull final List<String> taskNames,
                         @NotNull final String projectPath,
                         @Nullable final S settings,
                         @NotNull final List<String> vmOptions,
                         @NotNull final List<String> scriptParameters,
                         @Nullable final String debuggerSetup) throws RemoteException, ExternalSystemException
{
  execute(id, new Producer<Object>() {
    @Nullable
    @Override
    public Object produce() {
      myDelegate.executeTasks(
        id, taskNames, projectPath, settings, vmOptions, scriptParameters, debuggerSetup, getNotificationListener());
      return null;
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public boolean executeTasks(@NotNull ExternalSystemTaskId id,
                            @NotNull List<String> taskNames,
                            @NotNull String projectPath,
                            @Nullable GradleExecutionSettings settings,
                            @NotNull final List<String> vmOptions,
                            @NotNull final List<String> scriptParameters,
                            @Nullable String debuggerSetup,
                            @NotNull ExternalSystemTaskNotificationListener listener) throws ExternalSystemException
{
  GradleInvoker invoker = getInvoker();
  if (invoker == null) {
    // Returning false gives control back to the framework, and the task(s) will be invoked by IDEA.
    return false;
  }
  invoker.executeTasks(taskNames, Collections.<String>emptyList(), id, listener, true);
  return true;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();
  myIdeaProject = new IdeaProjectStub("multiProject");
  myAndroidProject = TestProjects.createBasicProject(myIdeaProject.getRootDir());

  myAndroidModule = myIdeaProject.addModule(myAndroidProject.getName(), "androidTask");
  myUtilModule = myIdeaProject.addModule("util", "compileJava", "jar", "classes");
  myIdeaProject.addModule("notReallyAGradleProject");

  ProjectImportAction.AllModels allModels = new ProjectImportAction.AllModels(myIdeaProject);
  allModels.addExtraProject(myAndroidProject, AndroidProject.class, myAndroidModule);

  ExternalSystemTaskId id = ExternalSystemTaskId.create(SYSTEM_ID, RESOLVE_PROJECT, myIdeaProject.getName());
  String projectPath = FileUtil.toSystemDependentName(myIdeaProject.getBuildFile().getParent());
  ExternalSystemTaskNotificationListener notificationListener = new ExternalSystemTaskNotificationListenerAdapter() {};
  myResolverCtx = new ProjectResolverContext(id, projectPath, null, createMock(ProjectConnection.class), notificationListener, true);
  myResolverCtx.setModels(allModels);

  myProjectResolver = new AndroidGradleProjectResolver(createMock(ProjectImportErrorHandler.class));
  myProjectResolver.setProjectResolverContext(myResolverCtx);

  GradleProjectResolverExtension next = new BaseGradleProjectResolverExtension();
  next.setProjectResolverContext(myResolverCtx);
  myProjectResolver.setNext(next);
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public boolean cancelTask(@NotNull ExternalSystemTaskId id, @NotNull ExternalSystemTaskNotificationListener listener)
  throws ExternalSystemException {

  // extension points are available only in IDE process
  if (ExternalSystemApiUtil.isInProcessMode(GradleConstants.SYSTEM_ID)) {
    for (GradleTaskManagerExtension gradleTaskManagerExtension : GradleTaskManagerExtension.EP_NAME.getExtensions()) {
      if (gradleTaskManagerExtension.cancelTask(id, listener)) return true;
    }
  }

  final CancellationTokenSource cancellationTokenSource = myCancellationMap.get(id);
  if (cancellationTokenSource != null) {
    cancellationTokenSource.cancel();
  }
  return true;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(
  @NotNull ExternalSystemTaskId id,
  @NotNull String projectPath,
  boolean isPreviewMode,
  @Nullable PantsExecutionSettings settings,
  @NotNull ExternalSystemTaskNotificationListener listener
) throws ExternalSystemException, IllegalArgumentException, IllegalStateException {
  if (projectPath.startsWith(".pants.d")) {
    return null;
  }
  checkForDifferentPantsExecutables(id, projectPath);

  final PantsCompileOptionsExecutor executor = PantsCompileOptionsExecutor.create(projectPath, settings);
  task2executor.put(id, executor);
  final DataNode<ProjectData> projectDataNode =
    resolveProjectInfoImpl(id, executor, listener, isPreviewMode, settings.isEnableIncrementalImport());
  doViewSwitch(id, projectPath);
  task2executor.remove(id);
  return projectDataNode;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
private void doViewSwitch(@NotNull ExternalSystemTaskId id, @NotNull String projectPath) {
  Project ideProject = id.findProject();
  if (ideProject == null) {
    return;
  }
  // Disable zooming on subsequent project resolves/refreshes,
  // i.e. a project that already has existing modules, because it may zoom at a module
  // that is going to be replaced by the current resolve.
  if (ModuleManager.getInstance(ideProject).getModules().length > 0) {
    return;
  }

  MessageBusConnection messageBusConnection = ideProject.getMessageBus().connect();
  messageBusConnection.subscribe(
    ProjectTopics.PROJECT_ROOTS,
    new ModuleRootListener() {
      @Override
      public void rootsChanged(ModuleRootEvent event) {
        // Initiate view switch only when project modules have been created.
        new ViewSwitchProcessor(ideProject, projectPath).asyncViewSwitch();
      }
    }
  );
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
/**
 * Check whether the pants executable of the new project to import is the same as the existing project's pants executable.
 */
private void checkForDifferentPantsExecutables(@NotNull ExternalSystemTaskId id, @NotNull String projectPath) {
  final Project existingIdeProject = id.findProject();
  if (existingIdeProject == null) {
    return;
  }
  String projectFilePath = existingIdeProject.getProjectFilePath();
  if (projectFilePath == null) {
    return;
  }
  final Optional<VirtualFile> existingPantsExe = PantsUtil.findPantsExecutable(projectFilePath);
  final Optional<VirtualFile> newPantsExe = PantsUtil.findPantsExecutable(projectPath);
  if (!existingPantsExe.isPresent() || !newPantsExe.isPresent()) {
    return;
  }
  if (!existingPantsExe.get().getCanonicalFile().getPath().equals(newPantsExe.get().getCanonicalFile().getPath())) {
    throw new ExternalSystemException(String.format(
      "Failed to import. Target/Directory to be added uses a different pants executable %s compared to the existing project's %s",
      existingPantsExe, newPantsExe
    ));
  }
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
private void resolveUsingPantsGoal(
  @NotNull final ExternalSystemTaskId id,
  @NotNull PantsCompileOptionsExecutor executor,
  final ExternalSystemTaskNotificationListener listener,
  @NotNull DataNode<ProjectData> projectDataNode
) {
  final PantsResolver dependenciesResolver = new PantsResolver(executor);
  dependenciesResolver.resolve(
    new Consumer<String>() {
      @Override
      public void consume(String status) {
        listener.onStatusChange(new ExternalSystemTaskNotificationEvent(id, status));
      }
    },
    new ProcessAdapter() {
      @Override
      public void onTextAvailable(ProcessEvent event, Key outputType) {
        listener.onTaskOutput(id, event.getText(), outputType == ProcessOutputTypes.STDOUT);
      }
    }
  );
  dependenciesResolver.addInfoTo(projectDataNode);
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(@NotNull final ExternalSystemTaskId id,
                                                @NotNull final String projectPath,
                                                final boolean downloadLibraries,
                                                ExternalSystemExecutionSettings settings)
  throws ExternalSystemException, IllegalArgumentException, IllegalStateException
{
  return execute(id, new Producer<DataNode<ProjectData>>() {
    @Nullable
    @Override
    public DataNode<ProjectData> produce() {
      return myDelegate.resolveProjectInfo(id, projectPath, downloadLibraries, getSettings(), getNotificationListener());
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public void executeTasks(@NotNull final ExternalSystemTaskId id,
                         @NotNull final List<String> taskNames,
                         @NotNull final String projectPath,
                         @Nullable final S settings,
                         @Nullable final String vmOptions) throws RemoteException, ExternalSystemException
{
  execute(id, new Producer<Object>() {
    @Nullable
    @Override
    public Object produce() {
      myDelegate.executeTasks(id, taskNames, projectPath, settings, vmOptions, getNotificationListener());
      return null;
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(@NotNull ExternalSystemTaskId id,
                                                  @NotNull String projectPath,
                                                  boolean downloadLibraries,
                                                  @Nullable S settings)
  throws ExternalSystemException, IllegalArgumentException, IllegalStateException, RemoteException
{
  myProgressManager.onQueued(id);
  try {
    return getDelegate().resolveProjectInfo(id, projectPath, downloadLibraries, settings);
  }
  finally {
    myProgressManager.onEnd(id);
  }
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@NotNull
private DataNode<ProjectData> doResolveProjectInfo(@NotNull final ExternalSystemTaskId id,
                                                   @NotNull String projectPath,
                                                   @Nullable GradleExecutionSettings settings,
                                                   @NotNull ProjectConnection connection,
                                                   @NotNull ExternalSystemTaskNotificationListener listener,
                                                   boolean downloadLibraries)
  throws IllegalArgumentException, IllegalStateException
{
  ModelBuilder<? extends IdeaProject> modelBuilder = myHelper.getModelBuilder(id, settings, connection, listener, downloadLibraries);
  IdeaProject project = modelBuilder.get();
  DataNode<ProjectData> result = populateProject(project, projectPath);

  // We need two different steps ('create' and 'populate') in order to handle module dependencies, i.e. when one module is
  // configured to be dependency for another one, corresponding dependency module object should be available during
  // populating dependent module object.
  Map<String, Pair<DataNode<ModuleData>, IdeaModule>> modules = createModules(project, result);
  populateModules(modules.values(), result);
  Collection<DataNode<LibraryData>> libraries = ExternalSystemApiUtil.getChildren(result, ProjectKeys.LIBRARY);
  myLibraryNamesMixer.mixNames(libraries);
  parseTasks(result, project);
  return result;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public void executeTasks(@NotNull final ExternalSystemTaskId id,
                         @NotNull final List<String> taskNames,
                         @NotNull String projectPath,
                         @Nullable final GradleExecutionSettings settings,
                         @Nullable final String vmOptions,
                         @NotNull final ExternalSystemTaskNotificationListener listener) throws ExternalSystemException
{
  Function<ProjectConnection, Void> f = new Function<ProjectConnection, Void>() {
    @Override
    public Void fun(ProjectConnection connection) {
      BuildLauncher launcher = myHelper.getBuildLauncher(id, connection, settings, listener);
      if (!StringUtil.isEmpty(vmOptions)) {
        assert vmOptions != null;
        launcher.setJvmArguments(vmOptions.trim());
      }
      launcher.forTasks(ArrayUtil.toStringArray(taskNames));
      launcher.run();
      return null;
    }
  };
  myHelper.execute(projectPath, settings, f); 
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
protected void detachProcessImpl() {
  myTask.cancel(new ExternalSystemTaskNotificationListenerAdapter() {

    private boolean myResetGreeting = true;

    @Override
    public void onTaskOutput(@Nonnull ExternalSystemTaskId id, @Nonnull String text, boolean stdOut) {
      if (myResetGreeting) {
        notifyTextAvailable("\r", ProcessOutputTypes.SYSTEM);
        myResetGreeting = false;
      }
      notifyTextAvailable(text, stdOut ? ProcessOutputTypes.STDOUT : ProcessOutputTypes.STDERR);
    }
  });
  notifyProcessDetached();
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
public boolean isTaskActive(@Nonnull ExternalSystemTaskId id) {
  Map<IntegrationKey, Pair<RemoteExternalSystemFacade, ExternalSystemExecutionSettings>> copy
    = ContainerUtilRt.newHashMap(myRemoteFacades);
  for (Map.Entry<IntegrationKey, Pair<RemoteExternalSystemFacade, ExternalSystemExecutionSettings>> entry : copy.entrySet()) {
    try {
      if (entry.getValue().first.isTaskInProgress(id)) {
        return true;
      }
    }
    catch (RemoteException e) {
      myLock.lock();
      try {
        myRemoteFacades.remove(entry.getKey());
        myFacadeWrappers.remove(entry.getKey());
      }
      finally {
        myLock.unlock();
      }
    }
  }
  return false;
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@javax.annotation.Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(@Nonnull final ExternalSystemTaskId id,
                                                @Nonnull final String projectPath,
                                                final boolean isPreviewMode,
                                                ExternalSystemExecutionSettings settings)
  throws ExternalSystemException, IllegalArgumentException, IllegalStateException
{
  return execute(id, new Producer<DataNode<ProjectData>>() {
    @javax.annotation.Nullable
    @Override
    public DataNode<ProjectData> produce() {
      return myDelegate.resolveProjectInfo(id, projectPath, isPreviewMode, getSettings(), getNotificationListener());
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
@Override
public void executeTasks(@Nonnull final ExternalSystemTaskId id,
                         @Nonnull final List<String> taskNames,
                         @Nonnull final String projectPath,
                         @javax.annotation.Nullable final S settings,
                         @Nonnull final List<String> vmOptions,
                         @Nonnull final List<String> scriptParameters,
                         @javax.annotation.Nullable final String debuggerSetup) throws RemoteException, ExternalSystemException
{
  execute(id, new Producer<Object>() {
    @javax.annotation.Nullable
    @Override
    public Object produce() {
      myDelegate.executeTasks(
              id, taskNames, projectPath, settings, vmOptions, scriptParameters, debuggerSetup, getNotificationListener());
      return null;
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId; //导入依赖的package包/类
/**
 * 执行./gradlew assembleRelease
 * @param project
 */
public static void buildAndroid(Project project) {
    GradleUtil.executeTask(project, "assembleRelease", "-Pmirror", new ExternalSystemTaskNotificationListenerAdapter() {
        @Override
        public void onTaskOutput(@NotNull ExternalSystemTaskId id, @NotNull String text, boolean stdOut) {
            super.onTaskOutput(id, text, stdOut);
        }
    });
}