import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
protected Components collectComponentsToScan(@Nullable DataNode<ProjectData> externalProject) {
    Components components = ComponentsFactory.create();
    // This set is used to make sure the artifacts added are unique
    Set<String> added = Sets.newHashSet();
    for (MavenProject mavenProject : MavenProjectsManager.getInstance(project).getProjects()) {
        for (MavenArtifactNode mavenArtifactNode : mavenProject.getDependencyTree()) {
            if (added.add(mavenArtifactNode.getArtifact().getDisplayStringForLibraryName())) {
                addArtifact(components, mavenArtifactNode.getArtifact());
                for (MavenArtifactNode artifactNode : mavenArtifactNode.getDependencies()) {
                    addArtifact(components, artifactNode.getArtifact());
                }
            }
        }
    }
    return components;
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
/**
 * This function is called after change in the build.gradle file or refresh gradle dependencies call.
 * @param toImport the project dependencies
 * @param projectData the project data
 * @param project the current project
 * @param modelsProvider contains the project modules
 */
@Override
public void importData(@NotNull Collection<DataNode<LibraryDependencyData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
    if (projectData == null || !projectData.getOwner().equals(GradleConstants.SYSTEM_ID)) {
        return;
    }

    ScanManager scanManager = ScanManagerFactory.getScanManager(project);
    if (scanManager == null) {
        ScanManagerFactory scanManagerFactory = ServiceManager.getService(project, ScanManagerFactory.class);
        scanManagerFactory.initScanManager(project);
        scanManager = ScanManagerFactory.getScanManager(project);
        if (scanManager == null) {
            return;
        }
        MessageBus messageBus = ApplicationManager.getApplication().getMessageBus();
        messageBus.syncPublisher(Events.ON_IDEA_FRAMEWORK_CHANGE).update();
    }
    if (GlobalSettings.getInstance().isCredentialsSet()) {
        scanManager.asyncScanAndUpdateResults(true, toImport);
    }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
private String makeDescription() {
  StringBuilder desc = new StringBuilder();
  final ProjectData projectData = getData();
  desc
    .append("<table>" +
            "<tr>" +
            "<td nowrap>" +
            "<table>" +
            "<tr><td nowrap>Project:</td><td nowrap>").append(getName()).append("</td></tr>")
    .append(projectData != null ?
            "<tr><td nowrap>Location:</td><td nowrap>" + projectData.getLinkedExternalProjectPath() + "</td></tr>" : "")
    .append(projectData != null && !StringUtil.isEmptyOrSpaces(projectData.getDescription()) ?
            "<tr><td colspan='2' nowrap><hr align='center' width='90%' />" + projectData.getDescription() + "</td></tr>" : "")
    .append("</td></tr>" +
            "</table>" +
            "</td>" +
            "</tr>");
  appendProblems(desc);
  desc.append("</table>");
  return desc.toString();
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
synchronized void restoreInclusionSettings(@Nullable DataNode<ProjectData> projectDataNode) {
  if (projectDataNode == null) return;
  final String rootProjectPath = projectDataNode.getData().getLinkedExternalProjectPath();
  final ProjectState projectState = myState.map.get(rootProjectPath);
  if (projectState == null) return;

  ExternalSystemApiUtil.visit(projectDataNode, new Consumer<DataNode<?>>() {
    @Override
    public void consume(DataNode node) {
      final DataNode<ExternalConfigPathAware> projectOrModuleNode = resolveProjectNode(node);
      assert projectOrModuleNode != null;
      final ModuleState moduleState = projectState.map.get(projectOrModuleNode.getData().getLinkedExternalProjectPath());
      node.setIgnored(isIgnored(projectState, moduleState, node.getKey()));
    }
  });
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
private static DataNode<ProjectData> convert(@NotNull ProjectSystemId systemId,
                                             @NotNull ExternalProjectPojo rootProject,
                                             @NotNull Collection<ExternalProjectPojo> childProjects,
                                             @NotNull Map<String, Collection<ExternalTaskPojo>> availableTasks) {
  ProjectData projectData = new ProjectData(systemId, rootProject.getName(), rootProject.getPath(), rootProject.getPath());
  DataNode<ProjectData> projectDataNode = new DataNode<ProjectData>(PROJECT, projectData, null);

  for (ExternalProjectPojo childProject : childProjects) {
    String moduleConfigPath = childProject.getPath();
    ModuleData moduleData = new ModuleData(childProject.getName(), systemId,
                                           ModuleTypeId.JAVA_MODULE, childProject.getName(),
                                           moduleConfigPath, moduleConfigPath);
    final DataNode<ModuleData> moduleDataNode = projectDataNode.createChild(MODULE, moduleData);

    final Collection<ExternalTaskPojo> moduleTasks = availableTasks.get(moduleConfigPath);
    if (moduleTasks != null) {
      for (ExternalTaskPojo moduleTask : moduleTasks) {
        TaskData taskData = new TaskData(systemId, moduleTask.getName(), moduleConfigPath, moduleTask.getDescription());
        moduleDataNode.createChild(TASK, taskData);
      }
    }
  }

  return projectDataNode;
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
synchronized void setIgnored(@NotNull final DataNode<?> dataNode, final boolean isIgnored) {
  //noinspection unchecked
  final DataNode<ProjectData> projectDataNode =
    PROJECT.equals(dataNode.getKey()) ? (DataNode<ProjectData>)dataNode : ExternalSystemApiUtil.findParent(dataNode, PROJECT);
  if (projectDataNode == null) {
    return;
  }

  ExternalSystemApiUtil.visit(dataNode, new Consumer<DataNode<?>>() {
    @Override
    public void consume(DataNode node) {
      node.setIgnored(isIgnored);
    }
  });

  saveInclusionSettings(projectDataNode);
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void importData(@NotNull Collection<DataNode<ModuleDependencyData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
  MultiMap<DataNode<ModuleData>, DataNode<ModuleDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
  for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ModuleDependencyData>>> entry : byModule.entrySet()) {
    Module ideModule = modelsProvider.findIdeModule(entry.getKey().getData());
    if (ideModule == null) {
      LOG.warn(String.format(
        "Can't import module dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
        entry.getValue(), entry.getKey()
      ));
      continue;
    }
    importData(entry.getValue(), ideModule, modelsProvider);
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void importData(@NotNull Collection<DataNode<ContentRootData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
  if (toImport.isEmpty()) {
    return;
  }

  MultiMap<DataNode<ModuleData>, DataNode<ContentRootData>> byModule = ExternalSystemApiUtil.groupBy(toImport, ProjectKeys.MODULE);
  for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<ContentRootData>>> entry : byModule.entrySet()) {
    Module module = modelsProvider.findIdeModule(entry.getKey().getData());
    if (module == null) {
      LOG.warn(String.format(
        "Can't import content roots. Reason: target module (%s) is not found at the ide. Content roots: %s",
        entry.getKey(), entry.getValue()
      ));
      continue;
    }
    importData(modelsProvider, entry.getValue(), module);
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
public void updateExternalProjectData(ExternalProjectInfo externalProject) {
  // update external projects data
  ExternalProjectsDataStorage.getInstance(myProject).update(externalProject);

  // update shortcuts manager
  if (externalProject.getExternalProjectStructure() != null) {
    final ProjectData projectData = externalProject.getExternalProjectStructure().getData();

    ExternalSystemUtil.scheduleExternalViewStructureUpdate(myProject, projectData.getOwner());

    Collection<DataNode<TaskData>> taskData =
      ExternalSystemApiUtil.findAllRecursively(externalProject.getExternalProjectStructure(), TASK);
    myShortcutsManager.scheduleKeymapUpdate(taskData);
    myShortcutsManager.scheduleRunConfigurationKeymapUpdate(projectData.getOwner());
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <E, I> void removeData(@NotNull Key<E> key,
                              @NotNull Collection<I> toRemove,
                              @NotNull final Collection<DataNode<E>> toIgnore,
                              @NotNull final ProjectData projectData,
                              @NotNull Project project,
                              @NotNull final IdeModifiableModelsProvider modelsProvider,
                              boolean synchronous) {
  try {
    List<ProjectDataService<?, ?>> services = myServices.getValue().get(key);
    for (ProjectDataService service : services) {
      final long removeStartTime = System.currentTimeMillis();
      service.removeData(new Computable.PredefinedValueComputable<Collection>(toRemove), toIgnore, projectData, project, modelsProvider);
      final long removeTimeInMs = System.currentTimeMillis() - removeStartTime;
      LOG.debug(String.format("Service %s removed data in %d ms", service.getClass().getSimpleName(), removeTimeInMs));
    }

    commit(modelsProvider, project, synchronous, "Removed data");
  }
  catch (Throwable t) {
    dispose(modelsProvider, project, synchronous);
    ExceptionUtil.rethrowAllAsUnchecked(t);
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void importData(@NotNull Collection<DataNode<ProjectData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull final Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
  // root project can be marked as ignored
  if(toImport.isEmpty()) return;

  if (toImport.size() != 1) {
    throw new IllegalArgumentException(String.format("Expected to get a single project but got %d: %s", toImport.size(), toImport));
  }
  DataNode<ProjectData> node = toImport.iterator().next();
  assert projectData == node.getData();

  if (!ExternalSystemApiUtil.isOneToOneMapping(project, node)) {
    return;
  }
  
  if (!project.getName().equals(projectData.getInternalName())) {
    renameProject(projectData.getInternalName(), projectData.getOwner(), project);
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void importData(@NotNull Collection<DataNode<ModuleData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
  if (toImport.isEmpty()) {
    return;
  }

  final Collection<DataNode<ModuleData>> toCreate = filterExistingModules(toImport, modelsProvider);
  if (!toCreate.isEmpty()) {
    createModules(toCreate, modelsProvider);
  }
  for (DataNode<ModuleData> node : toImport) {
    Module module = modelsProvider.findIdeModule(node.getData());
    if (module != null) {
      syncPaths(module, modelsProvider, node.getData());
    }
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
private static void setModuleOptions(Module module, DataNode<ModuleData> moduleDataNode) {
  ModuleData moduleData = moduleDataNode.getData();
  module.putUserData(MODULE_DATA_KEY, moduleData);

  module.setOption(ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY, moduleData.getOwner().toString());
  module.setOption(ExternalSystemConstants.LINKED_PROJECT_ID_KEY, moduleData.getId());
  module.setOption(ExternalSystemConstants.LINKED_PROJECT_PATH_KEY, moduleData.getLinkedExternalProjectPath());
  ProjectData projectData = moduleDataNode.getData(ProjectKeys.PROJECT);
  module.setOption(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY, projectData != null ? projectData.getLinkedExternalProjectPath() : "");

  if (moduleData.getGroup() != null) {
    module.setOption(ExternalSystemConstants.EXTERNAL_SYSTEM_MODULE_GROUP_KEY, moduleData.getGroup());
  }
  if (moduleData.getVersion() != null) {
    module.setOption(ExternalSystemConstants.EXTERNAL_SYSTEM_MODULE_VERSION_KEY, moduleData.getVersion());
  }

  // clear maven option
  module.clearOption("org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule");
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void removeData(@NotNull final Computable<Collection<Library>> toRemoveComputable,
                       @NotNull Collection<DataNode<LibraryData>> toIgnore,
                       @NotNull ProjectData projectData,
                       @NotNull final Project project,
                       @NotNull final IdeModifiableModelsProvider modelsProvider) {
  final Collection<Library> toRemove = toRemoveComputable.compute();
  if (toRemove.isEmpty()) {
    return;
  }

  final LibraryTable.ModifiableModel librariesModel = modelsProvider.getModifiableProjectLibrariesModel();
  for (Library library : toRemove) {
    String libraryName = library.getName();
    if (libraryName != null) {
      Library libraryToRemove = librariesModel.getLibraryByName(libraryName);
      if (libraryToRemove != null) {
        librariesModel.removeLibrary(libraryToRemove);
      }
    }
  }
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的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.project.ProjectData; //导入依赖的package包/类
public static void refreshProject(@NotNull final Project project,
                                  @NotNull final ProjectSystemId externalSystemId,
                                  @NotNull final String externalProjectPath,
                                  final boolean isPreviewMode,
                                  @NotNull final ProgressExecutionMode progressExecutionMode) {
  refreshProject(project, externalSystemId, externalProjectPath, new ExternalProjectRefreshCallback() {
    @Override
    public void onSuccess(@Nullable final DataNode<ProjectData> externalProject) {
      if (externalProject == null) {
        return;
      }
      final boolean synchronous = progressExecutionMode == ProgressExecutionMode.MODAL_SYNC;
      ServiceManager.getService(ProjectDataManager.class).importData(externalProject, project, synchronous);
    }

    @Override
    public void onFailure(@NotNull String errorMessage, @Nullable String errorDetails) {
    }
  }, isPreviewMode, progressExecutionMode, true);
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@Override
public void setSelected(AnActionEvent e, boolean state) {
  final ProjectSystemId projectSystemId = getSystemId(e);
  final ExternalSystemNode<ExternalConfigPathAware> projectNode = getProjectNode(e);
  if (projectSystemId == null || projectNode == null || projectNode.getData() == null) return;

  projectNode.setIgnored(state);

  final Project project = getProject(e);

  final String externalProjectPath = projectNode.getData().getLinkedExternalProjectPath();
  final ExternalProjectInfo externalProjectInfo =
    ExternalSystemUtil.getExternalProjectInfo(project, projectSystemId, externalProjectPath);
  if (externalProjectInfo == null || externalProjectInfo.getExternalProjectStructure() == null) {
    if (LOG.isDebugEnabled()) {
      LOG.debug(String.format("external project data not found, path: %s, data: %s", externalProjectPath, externalProjectInfo));
    }
    return;
  }

  final DataNode<ProjectData> projectDataNode = externalProjectInfo.getExternalProjectStructure();
  ServiceManager.getService(ProjectDataManager.class).importData(projectDataNode, project, true);
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
protected void ignoreData(BooleanFunction<DataNode<?>> booleanFunction, final boolean ignored) {
  final ExternalProjectInfo externalProjectInfo = ProjectDataManager.getInstance().getExternalProjectData(
    myProject, getExternalSystemId(), getCurrentExternalProjectSettings().getExternalProjectPath());
  assertNotNull(externalProjectInfo);

  final DataNode<ProjectData> projectDataNode = externalProjectInfo.getExternalProjectStructure();
  assertNotNull(projectDataNode);

  final Collection<DataNode<?>> nodes = ExternalSystemApiUtil.findAllRecursively(projectDataNode, booleanFunction);
  for (DataNode<?> node : nodes) {
    ExternalSystemApiUtil.visit(node, new Consumer<DataNode<?>>() {
      @Override
      public void consume(DataNode dataNode) {
        dataNode.setIgnored(ignored);
      }
    });
  }
  ServiceManager.getService(ProjectDataManager.class).importData(projectDataNode, myProject, true);
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
@VisibleForTesting
static boolean isCacheMissingModels(@NotNull DataNode<ProjectData> cache, @NotNull Project project) {
  Collection<DataNode<ModuleData>> moduleDataNodes = findAll(cache, MODULE);
  if (!moduleDataNodes.isEmpty()) {
    Map<String, DataNode<ModuleData>> moduleDataNodesByName = indexByModuleName(moduleDataNodes);

    ModuleManager moduleManager = ModuleManager.getInstance(project);
    for (Module module : moduleManager.getModules()) {
      DataNode<ModuleData> moduleDataNode = moduleDataNodesByName.get(module.getName());
      if (moduleDataNode == null) {
        // When a Gradle facet is present, there should be a cache node for the module.
        AndroidGradleFacet gradleFacet = AndroidGradleFacet.getInstance(module);
        if (gradleFacet != null) {
          return true;
        }
      }
      else if (isCacheMissingModels(moduleDataNode, module)) {
        return true;
      }
    }
    return false;
  }
  return true;
}
 

import com.intellij.openapi.externalSystem.model.project.ProjectData; //导入依赖的package包/类
/**
 * Sets an Android SDK and facets to the modules of a project that has been imported from an Android-Gradle project.
 *
 * @param toImport    contains the Android-Gradle project.
 * @param project     IDEA project to configure.
 * @param synchronous indicates whether this operation is synchronous.
 */
@Override
public void importData(@NotNull Collection<DataNode<IdeaAndroidProject>> toImport,
                       @Nullable final ProjectData projectData,
                       @NotNull final Project project,
                       @NotNull final IdeModifiableModelsProvider modelsProvider) {
  if (!toImport.isEmpty()) {
    try {
      doImport(toImport, project, modelsProvider);
    }
    catch (Throwable e) {
      LOG.error(String.format("Failed to set up Android modules in project '%1$s'", project.getName()), e);
      String msg = e.getMessage();
      if (msg == null) {
        msg = e.getClass().getCanonicalName();
      }
      GradleSyncState.getInstance(project).syncFailed(msg);
    }
  }
}