import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
protected void refreshDependencies(ExternalProjectRefreshCallback cbk, @Nullable Collection<DataNode<LibraryDependencyData>> libraryDependencies) {
    if (libraryDependencies != null) {
        // Change the dependencies only if there are new dependencies
        this.libraryDependencies = libraryDependencies;
        cbk.onSuccess(null);
        return;
    }
    if (this.libraryDependencies != null) {
        cbk.onSuccess(null);
        return;
    }
    ExternalSystemProcessingManager processingManager = ServiceManager.getService(ExternalSystemProcessingManager.class);
    if (processingManager != null && processingManager.findTask(ExternalSystemTaskType.RESOLVE_PROJECT, GradleConstants.SYSTEM_ID, getProjectBasePath(project)) != null) {
        // Another scan in progress
        return;
    }
    ExternalSystemUtil.refreshProject(project, GradleConstants.SYSTEM_ID, getProjectBasePath(project), cbk, false, ProgressExecutionMode.IN_BACKGROUND_ASYNC);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的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 org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@VisibleForTesting
@Nullable
static File addLocalMavenRepoInitScriptCommandLineOption(@NotNull List<String> args, @NotNull File repoPath) {
  try {
    File file = createTempFile("asLocalRepo", DOT_GRADLE);
    file.deleteOnExit();

    String contents = "allprojects {\n" +
                      "  buildscript {\n" +
                      "    repositories {\n" +
                      "      maven { url '" + GradleImport.escapeGroovyStringLiteral(repoPath.getPath()) + "'}\n" +
                      "    }\n" +
                      "  }\n" +
                      "}\n";
    writeToFile(file, contents);
    addAll(args, GradleConstants.INIT_SCRIPT_CMD_OPTION, file.getAbsolutePath());

    return file;
  }
  catch (IOException e) {
    LOG.warn("Failed to set up 'local repo' Gradle init script", e);
  }
  return null;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
public void testCustomizeModule() {
  File rootDir = androidProject.getRootDir();
  IdeaAndroidProject ideaAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myModule.getName(), rootDir, androidProject,
                                                                 "debug", AndroidProject.ARTIFACT_ANDROID_TEST);
  String compilerOutputPath = "";
  final IdeModifiableModelsProviderImpl modelsProvider = new IdeModifiableModelsProviderImpl(myProject);
  try {
    customizer.customizeModule(myProject, myModule, modelsProvider, ideaAndroidProject);
    CompilerModuleExtension compilerSettings = modelsProvider.getModifiableRootModel(myModule).getModuleExtension(CompilerModuleExtension.class);
    compilerOutputPath = compilerSettings.getCompilerOutputUrl();
    modelsProvider.commit();
  }
  catch (Throwable t) {
    modelsProvider.dispose();
    ExceptionUtil.rethrowAllAsUnchecked(t);
  }

  File classesFolder = ideaAndroidProject.getSelectedVariant().getMainArtifact().getClassesFolder();
  String path = FileUtil.toSystemIndependentName(classesFolder.getPath());
  String expected = VfsUtilCore.pathToUrl(ExternalSystemApiUtil.toCanonicalPath(path));
  assertEquals(expected, compilerOutputPath);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();

  String basePath = myProject.getBasePath();
  assertNotNull(basePath);
  File baseDir = new File(basePath);
  myAndroidProject = createBasicProject(baseDir, myProject.getName());

  Collection<Variant> variants = myAndroidProject.getVariants();
  Variant selectedVariant = getFirstItem(variants);
  assertNotNull(selectedVariant);
  myIdeaAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myAndroidProject.getName(), baseDir, myAndroidProject,
                                                selectedVariant.getName(), ARTIFACT_ANDROID_TEST);

  addContentEntry();
  myCustomizer = new ContentRootModuleCustomizer();
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
public void testCustomizeModule() {
  File rootDir = myAndroidProject.getRootDir();
  VariantStub selectedVariant = myAndroidProject.getFirstVariant();
  assertNotNull(selectedVariant);
  String selectedVariantName = selectedVariant.getName();
  IdeaAndroidProject project = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, myAndroidProject.getName(), rootDir, myAndroidProject,
                                                      selectedVariantName, AndroidProject.ARTIFACT_ANDROID_TEST);
  final IdeModifiableModelsProviderImpl modelsProvider = new IdeModifiableModelsProviderImpl(myProject);
  try {
    myCustomizer.customizeModule(myProject, myModule, modelsProvider, project);
    modelsProvider.commit();
  }
  catch (Throwable t) {
    modelsProvider.dispose();
    ExceptionUtil.rethrowAllAsUnchecked(t);
  }

  // Verify that AndroidFacet was added and configured.
  AndroidFacet facet = AndroidFacet.getInstance(myModule);
  assertNotNull(facet);
  assertSame(project, facet.getIdeaAndroidProject());

  JpsAndroidModuleProperties facetState = facet.getProperties();
  assertFalse(facetState.ALLOW_USER_CONFIGURATION);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
public void testGetCustomizers() {
  BuildVariantModuleCustomizer<?> customizer1 = createCustomizer(GradleConstants.SYSTEM_ID, IdeaAndroidProjectStub.class);
  BuildVariantModuleCustomizer<?> customizer2 = createCustomizer(ProjectSystemId.IDE, IdeaAndroidProject.class);
  BuildVariantModuleCustomizer<?> customizer3 = createCustomizer(GradleConstants.SYSTEM_ID, IdeaJavaProject.class);
  BuildVariantModuleCustomizer<?> customizer4 = createCustomizer(ProjectSystemId.IDE, IdeaJavaProject.class);

  replay(customizer1, customizer2, customizer3, customizer4);

  List<BuildVariantModuleCustomizer<IdeaAndroidProject>> customizers =
    BuildVariantUpdater.getCustomizers(GradleConstants.SYSTEM_ID, customizer1, customizer2, customizer3, customizer4);

  verify(customizer1, customizer2, customizer3, customizer4);

  // The list should include only the customizers that:
  // 1. Have a matching ProjectSystemId, or have ProjectSystemId.IDE as their ProjectSystemId
  // 2. Have IdeaAndroidProject (or subclass) as the supported model type
  assertThat(customizers).containsOnly(customizer1, customizer2);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
private void addArchiveLibraries() {
  // Add in some Android projects too
  myFacet.getProperties().ALLOW_USER_CONFIGURATION = false; // make it a Gradle project
  AndroidProjectStub androidProject = TestProjects.createFlavorsProject();
  VariantStub variant = androidProject.getFirstVariant();
  assertNotNull(variant);
  File rootDir = androidProject.getRootDir();
  IdeaAndroidProject ideaAndroidProject = new IdeaAndroidProject(GradleConstants.SYSTEM_ID, androidProject.getName(), rootDir,
                                                                 androidProject, variant.getName(), AndroidProject.ARTIFACT_ANDROID_TEST);
  myFacet.setIdeaAndroidProject(ideaAndroidProject);

  File bundle = new File(rootDir, "bundle.aar");
  File libJar = new File(rootDir, "bundle_aar" + File.separatorChar + "library.jar");
  AndroidLibraryStub library = new AndroidLibraryStub(bundle, libJar);
  variant.getMainArtifact().getDependencies().addLibrary(library);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public void enhanceRemoteProcessing(@NotNull SimpleJavaParameters parameters) throws ExecutionException {
  final Set<String> additionalEntries = ContainerUtilRt.newHashSet();
  for (GradleProjectResolverExtension extension : RESOLVER_EXTENSIONS.getValue()) {
    ContainerUtilRt.addIfNotNull(additionalEntries, PathUtil.getJarPathForClass(extension.getClass()));
    for (Class aClass : extension.getExtraProjectModelClasses()) {
      ContainerUtilRt.addIfNotNull(additionalEntries, PathUtil.getJarPathForClass(aClass));
    }
    extension.enhanceRemoteProcessing(parameters);
  }

  final PathsList classPath = parameters.getClassPath();
  for (String entry : additionalEntries) {
    classPath.add(entry);
  }

  parameters.getVMParametersList().addProperty(
    ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY, GradleConstants.SYSTEM_ID.getId());
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  final List<War> warModels;
  final WebConfiguration webConfiguration = resolverCtx.getExtraProject(gradleModule, WebConfiguration.class);
  if (webConfiguration != null) {
    warModels = ContainerUtil.map(webConfiguration.getWarModels(), new Function<WebConfiguration.WarModel, War>() {
        @Override
        public War fun(WebConfiguration.WarModel model) {
          War war = new War(model.getWarName(), model.getWebAppDirName(), model.getWebAppDir());
          war.setWebXml(model.getWebXml());
          war.setWebResources(map(model.getWebResources()));
          war.setClasspath(model.getClasspath());
          war.setManifestContent(model.getManifestContent());
          return war;
        }
      });
    ideModule.createChild(WebConfigurationModelData.KEY, new WebConfigurationModelData(GradleConstants.SYSTEM_ID, warModels));
  }
  nextResolver.populateModuleExtraModels(gradleModule, ideModule);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public boolean isConfigurationFromContext(ExternalSystemRunConfiguration configuration, ConfigurationContext context) {
  if (configuration == null) return false;
  if (!GradleConstants.SYSTEM_ID.equals(configuration.getSettings().getExternalSystemId())) return false;

  final PsiPackage psiPackage = JavaRuntimeConfigurationProducerBase.checkPackage(context.getPsiLocation());
  if (psiPackage == null) return false;

  if (context.getModule() == null) return false;

  if (!StringUtil.equals(
    context.getModule().getOptionValue(ExternalSystemConstants.LINKED_PROJECT_PATH_KEY),
    configuration.getSettings().getExternalProjectPath())) {
    return false;
  }
  if (!configuration.getSettings().getTaskNames().containsAll(TASKS_TO_RUN)) return false;

  final String scriptParameters = configuration.getSettings().getScriptParameters() + ' ';
  return psiPackage.getQualifiedName().isEmpty()
         ? scriptParameters.contains("--tests * ")
         : scriptParameters.contains(String.format("--tests %s.* ", psiPackage.getQualifiedName()));
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
private static boolean applyTestMethodConfiguration(@NotNull ExternalSystemRunConfiguration configuration,
                                                    @NotNull ConfigurationContext context,
                                                    @NotNull PsiMethod psiMethod,
                                                    @NotNull PsiClass... containingClasses) {
  if (!StringUtil.equals(
    context.getModule().getOptionValue(ExternalSystemConstants.EXTERNAL_SYSTEM_ID_KEY),
    GradleConstants.SYSTEM_ID.toString())) {
    return false;
  }

  configuration.getSettings().setExternalProjectPath(context.getModule().getOptionValue(ExternalSystemConstants.LINKED_PROJECT_PATH_KEY));
  configuration.getSettings().setTaskNames(TASKS_TO_RUN);

  StringBuilder buf = new StringBuilder();
  for (PsiClass aClass : containingClasses) {
    buf.append(creatTestFilter(aClass, psiMethod));
  }

  configuration.getSettings().setScriptParameters(buf.toString().trim());
  configuration.setName(psiMethod.getName());
  return true;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Nullable
private VirtualFile setupGradleBuildFile(@NotNull VirtualFile modelContentRootDir)
  throws ConfigurationException {
  final VirtualFile file = getOrCreateExternalProjectConfigFile(modelContentRootDir.getPath(), GradleConstants.DEFAULT_SCRIPT_NAME);

  if (file != null) {
    final String templateName = getExternalProjectSettings().getDistributionType() == DistributionType.WRAPPED
                                ? TEMPLATE_GRADLE_BUILD_WITH_WRAPPER
                                : DEFAULT_TEMPLATE_GRADLE_BUILD;
    Map<String, String> attributes = ContainerUtil.newHashMap();
    if (myProjectId != null) {
      attributes.put(TEMPLATE_ATTRIBUTE_MODULE_VERSION, myProjectId.getVersion());
      attributes.put(TEMPLATE_ATTRIBUTE_MODULE_GROUP, myProjectId.getGroupId());
      attributes.put(TEMPLATE_ATTRIBUTE_GRADLE_VERSION, GradleVersion.current().getVersion());
    }
    saveFile(file, templateName, attributes);
  }
  return file;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public void populateModuleExtraModels(@NotNull IdeaModule gradleModule, @NotNull DataNode<ModuleData> ideModule) {
  final BuildScriptClasspathModel buildScriptClasspathModel = resolverCtx.getExtraProject(gradleModule, BuildScriptClasspathModel.class);
  final List<BuildScriptClasspathData.ClasspathEntry> classpathEntries;
  if (buildScriptClasspathModel != null) {
    classpathEntries = ContainerUtil
      .map(buildScriptClasspathModel.getClasspath(), new Function<ClasspathEntryModel, BuildScriptClasspathData.ClasspathEntry>() {
        @Override
        public BuildScriptClasspathData.ClasspathEntry fun(ClasspathEntryModel model) {
          return new BuildScriptClasspathData.ClasspathEntry(model.getClasses(), model.getSources(), model.getJavadoc());
        }
      });
  }
  else {
    classpathEntries = ContainerUtil.emptyList();
  }
  BuildScriptClasspathData buildScriptClasspathData = new BuildScriptClasspathData(GradleConstants.SYSTEM_ID, classpathEntries);
  ideModule.createChild(BuildScriptClasspathData.KEY, buildScriptClasspathData);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Nullable
@Override
protected PsiType getClosureParameterType(GrClosableBlock closure, int index) {

  PsiFile file = closure.getContainingFile();
  if (file == null || !FileUtilRt.extensionEquals(file.getName(), GradleConstants.EXTENSION)) return null;

  PsiType psiType = super.getClosureParameterType(closure, index);
  if (psiType instanceof PsiWildcardType) {
    PsiWildcardType wildcardType = (PsiWildcardType)psiType;
    if (wildcardType.isSuper() && wildcardType.getBound() != null &&
        wildcardType.getBound().equalsToText(GradleCommonClassNames.GRADLE_API_SOURCE_SET)) {
      return wildcardType.getBound();
    }
    if (wildcardType.isSuper() && wildcardType.getBound() != null &&
        wildcardType.getBound().equalsToText(GradleCommonClassNames.GRADLE_API_DISTRIBUTION)) {
      return wildcardType.getBound();
    }
  }

  return null;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Override
public void processDynamicElements(@NotNull PsiType qualifierType,
                                   PsiClass aClass,
                                   @NotNull PsiScopeProcessor processor,
                                   @NotNull PsiElement place,
                                   @NotNull ResolveState state) {
  if (!(aClass instanceof GroovyScriptClass)) {
    return;
  }

  PsiFile file = aClass.getContainingFile();
  if (file == null || !file.getName().equals(GradleConstants.SETTINGS_FILE_NAME)) {
    return;
  }

  GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());
  GradleResolverUtil.processDeclarations(psiManager, processor, state, place, GradleCommonClassNames.GRADLE_API_INITIALIZATION_SETTINGS);
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@Nullable
@Override
public VirtualFile adjust(@NotNull VirtualFile configPath) {
  if (!configPath.isDirectory()) {
    return configPath;
  }

  VirtualFile result = configPath.findChild(GradleConstants.DEFAULT_SCRIPT_NAME);
  if (result != null) {
    return result;
  }
  
  for (VirtualFile child : configPath.getChildren()) {
    String name = child.getName();
    if (!name.endsWith(GradleConstants.EXTENSION)) {
      continue;
    }
    if (!GradleConstants.SETTINGS_FILE_NAME.equals(name) && !child.isDirectory()) {
      return child;
    }
  }
  return null;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
@NotNull
@Override
public List<VirtualFile> findAll(@NotNull ExternalProjectSettings externalProjectSettings) {
  List<VirtualFile> list = ContainerUtil.newArrayList();
  for (String path : externalProjectSettings.getModules()) {
    VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(path));
    if (vFile != null) {
      for (VirtualFile child : vFile.getChildren()) {
        String name = child.getName();
        if (!child.isDirectory() && name.endsWith(GradleConstants.EXTENSION)) {
          list.add(child);
        }
      }
    }
  }
  return list;
}
 

import org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的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 org.jetbrains.plugins.gradle.util.GradleConstants; //导入依赖的package包/类
private static void updateNotification(@NotNull final NotificationData notificationData,
                                       @NotNull final Project project,
                                       @NotNull ExternalSystemException e) {

  for (String fix : e.getQuickFixes()) {
    if (OpenGradleSettingsCallback.ID.equals(fix)) {
      notificationData.setListener(OpenGradleSettingsCallback.ID, new OpenGradleSettingsCallback(project));
    }
    else if (ApplyGradlePluginCallback.ID.equals(fix)) {
      notificationData.setListener(ApplyGradlePluginCallback.ID, new ApplyGradlePluginCallback(notificationData, project));
    }
    else if (GotoSourceNotificationCallback.ID.equals(fix)) {
      notificationData.setListener(GotoSourceNotificationCallback.ID, new GotoSourceNotificationCallback(notificationData, project));
    }
    else if (OpenExternalSystemSettingsCallback.ID.equals(fix)) {
      String linkedProjectPath = e instanceof LocationAwareExternalSystemException ?
                                 ((LocationAwareExternalSystemException)e).getFilePath() : null;
      notificationData.setListener(
        OpenExternalSystemSettingsCallback.ID,
        new OpenExternalSystemSettingsCallback(project, GradleConstants.SYSTEM_ID, linkedProjectPath)
      );
    }
  }
}