import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private static void fetch(File buildDir, File gradleInstallDir, boolean embedded) {
    System.out.println("* Fetching model for " + buildDir);
    System.out.println("* Using tooling API " + GradleVersion.current().getVersion());

    Timer timer = new Timer();

    GradleConnector gradleConnector = GradleConnector.newConnector();
    gradleConnector.forProjectDirectory(buildDir);
    ((DefaultGradleConnector) gradleConnector).embedded(embedded);
    if (gradleInstallDir != null) {
        gradleConnector.useInstallation(gradleInstallDir);
    }

    ProjectConnection connect = gradleConnector.connect();
    try {
        for (int i = 0; i < 5; i++) {
            SyncAction.withProjectConnection(connect, null);
        }
    } finally {
        connect.close();
    }

    timer.stop();
    System.out.println("total time: " + timer.duration());
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private ProjectConnection createProjectConnection(ComparableGradleBuildExecuter executer) {
    GradleConnector connector = GradleConnector.newConnector();
    connector.forProjectDirectory(executer.getSpec().getProjectDir());
    File gradleUserHomeDir = gradle.getStartParameter().getGradleUserHomeDir();
    if (gradleUserHomeDir != null) {
        connector.useGradleUserHomeDir(gradleUserHomeDir);
    }

    GradleVersion gradleVersion = executer.getGradleVersion();
    if (gradleVersion.equals(GradleVersion.current())) {
        connector.useInstallation(gradle.getGradleHomeDir());
    } else {
        connector.useGradleVersion(gradleVersion.getVersion());
    }

    return connector.connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
@Override
public void generate(File targetDir, ProjectRequest projectRequest) {
    GradleConnector gradleConnector = GradleConnector.newConnector().forProjectDirectory(targetDir);

    if (projectRequest.getGradleVersion() != null) {
        gradleConnector.useGradleVersion(projectRequest.getGradleVersion());
    }

    ProjectConnection connection = gradleConnector.connect();

    try {
        connection.newBuild().forTasks(buildTasks(projectRequest)).run();
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
void prepareCompileAndroidJava() {
  ProjectConnection connection = this.project.getProjectConnection();
  try {
    BuildLauncher buildLauncher = connection.newBuild();
    String genTask = this.project.getName() + this.genSourceTaskName;
    buildLauncher.forTasks(genTask).run();

    int size = this.project.getDependencies().size();

    String aar =
        Joiner.on(File.separator)
            .join(this.project.getProjectRoot(), BUILD_DIR, INTERMEDIATE_DIR, EXPLODED_DIR);
    List<File> jars = FileUtils.collectFiles(new File(aar), EXT_JAR);
    for (File jar : jars) {
      addAAR(jar);
    }

    int after = this.project.getDependencies().size();
    if (size != after) {
      CachedASMReflector.getInstance().createClassIndexes(jars);
      this.project.resetCachedClasspath();
    }
  } finally {
    connection.close();
  }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
ProjectConnection getProjectConnection() {
  final String gradleVersion = Config.load().getGradleVersion();
  GradleConnector connector;
  if (gradleVersion.isEmpty()) {
    connector = GradleConnector.newConnector().forProjectDirectory(this.rootProject);
  } else {
    log.debug("use gradle version:'{}'", gradleVersion);
    connector =
        GradleConnector.newConnector()
            .useGradleVersion(gradleVersion)
            .forProjectDirectory(this.rootProject);
  }

  if (connector instanceof DefaultGradleConnector) {
    final DefaultGradleConnector defaultGradleConnector = (DefaultGradleConnector) connector;
    defaultGradleConnector.daemonMaxIdleTime(1, TimeUnit.HOURS);
  }
  return connector.connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public ProjectConnection createProject(String name) throws IOException {
	File projectDirectory = new File("target/" + name);
	projectDirectory.mkdirs();

	File gradleScript = new File(projectDirectory, "build.gradle");

	if (new File("src/test/resources", name).isDirectory()) {
		FileSystemUtils.copyRecursively(new File("src/test/resources", name),
				projectDirectory);
	}
	else {
		FileCopyUtils.copy(new File("src/test/resources/" + name + ".gradle"),
				gradleScript);
	}

	GradleConnector gradleConnector = GradleConnector.newConnector();
	gradleConnector.useGradleVersion(this.gradleVersion);

	((DefaultGradleConnector) gradleConnector).embedded(true);
	return gradleConnector.forProjectDirectory(projectDirectory).connect();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
@Test
public void defaultJvmArgsArePreservedWhenLoadedAgentIsConfigured()
		throws IOException {
	ProjectConnection project = new ProjectCreator()
			.createProject("spring-loaded-jvm-args");
	project.newBuild().forTasks("bootRun")
			.withArguments("-PbootVersion=" + BOOT_VERSION,
					"-PspringLoadedVersion=" + SPRING_LOADED_VERSION, "--stacktrace")
			.run();

	List<String> output = getOutput();
	assertOutputContains("-DSOME_ARG=someValue", output);
	assertOutputContains("-Xverify:none", output);
	assertOutputMatches("-javaagent:.*springloaded-" + SPRING_LOADED_VERSION + ".jar",
			output);
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public static void gradleBuild(IProject project, String task, IProgressMonitor monitor) throws CoreException {
	String taskName = String.format("Executing %s on project %s", task, project.getName());
	try {
		IConsoleService console = Activator.getService(IConsoleService.class);
		console.activate();
		console.writeOutput(String.format("\n%s\n\n", taskName)); //$NON-NLS-1$

		File projectDir = new File(project.getLocationURI());
		ProjectConnection connection = GradleConnector.newConnector().forProjectDirectory(projectDir).connect();
		connection.newBuild().forTasks(task).setStandardOutput(console.getOutputStream())
				.setStandardError(console.getErrorStream()).run();
		connection.close();
		project.refreshLocal(IResource.DEPTH_INFINITE, monitor);
	} catch (BuildException | IOException e) {
		throw new CoreException(new Status(IStatus.ERROR, Activator.getId(), taskName, e));
	}
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
protected byte[] runTasks(String pathToRootOfProject, String... tasks) {
    ProjectConnection connection = GradleConnector.newConnector().forProjectDirectory(new File(pathToRootOfProject)).connect();
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

    try {
        BuildLauncher build = connection.newBuild();
        build.forTasks(tasks);
        build.setStandardOutput(outputStream);
        build.setStandardError(outputStream);
        build.run();
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        connection.close();
    }
    return outputStream.toByteArray();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns the project model without building.
 *
 * This will fail if the project is a multi-project setup.
 *
 * @param emulateStudio_1_0 whether to emulate an older IDE (studio 1.0) querying the model.
 * @param assertNoSyncIssues true if the presence of sync issues during the model evaluation
 *                           should raise a {@link AssertionError}s
 */
@NonNull
private AndroidProject getSingleModel(boolean emulateStudio_1_0, boolean assertNoSyncIssues) {
    ProjectConnection connection = getProjectConnection();
    try {
        Map<String, AndroidProject> modelMap = buildModel(
                connection,
                new GetAndroidModelAction(),
                emulateStudio_1_0);

        // ensure there was only one project
        assertEquals("Quering GradleTestProject.getModel() with multi-project settings",
                1, modelMap.size());

        AndroidProject androidProject = modelMap.get(":");
        if (assertNoSyncIssues) {
            assertNoSyncIssues(androidProject);
        }
        return androidProject;
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private void executeBuild(List<String> arguments, ProjectConnection connection,
        String[] tasks) {
    List<String> args = Lists.newArrayListWithCapacity(3 + arguments.size());
    args.add("-i");
    args.add("-u");
    args.addAll(arguments);

    BuildLauncher launcher = connection.newBuild()
            .forTasks(tasks)
            .withArguments(Iterables.toArray(args, String.class));

    setJvmArguments(launcher);

    if (stdout != null) {
        launcher.setStandardOutput(stdout);
    } else {
        launcher.setStandardOutput(System.out);
    }
    if (stderr != null) {
        launcher.setStandardError(stderr);
    } else {
        launcher.setStandardError(System.err);
    }
    launcher.run();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns a project model for each sub-project without building.
 *
 * @param connection the opened ProjectConnection
 * @param action the build action to gather the model
 * @param emulateStudio_1_0 whether to emulate an older IDE (studio 1.0) querying the model.
 */
@NonNull
private <K,V> Map<K, V> buildModel(
        @NonNull ProjectConnection connection,
        @NonNull BuildAction<Map<K, V>> action,
        boolean emulateStudio_1_0) {

    BuildActionExecuter<Map<K, V>> executor = connection.action(action);

    List<String> arguments = Lists.newArrayListWithCapacity(emulateStudio_1_0 ? 2 : 3);
    arguments.add("-P" + AndroidProject.PROPERTY_BUILD_MODEL_ONLY + "=true");
    arguments.add("-P" + AndroidProject.PROPERTY_INVOKED_FROM_IDE + "=true");
    if (!emulateStudio_1_0) {
        arguments.add("-P" + AndroidProject.PROPERTY_BUILD_MODEL_ONLY_ADVANCED + "=true");
    }

    setJvmArguments(executor);

    executor.withArguments(Iterables.toArray(arguments, String.class));

    executor.setStandardOutput(System.out);
    executor.setStandardError(System.err);

    return executor.run();
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的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 org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Returns the {@link com.android.builder.model.AndroidProject} given the gradle project root.
 * Note that this works only single module projects (only one build.gradle)
 */
@Nullable
private static AndroidProject getAndroidProject(String projectPath) {
  File androidPlugin = new File(AndroidTestBase.getAndroidPluginHome());
  File projectDir = new File(androidPlugin, BASE_PATH + projectPath);
  GradleConnector connector = GradleConnector.newConnector();
  connector.forProjectDirectory(projectDir);
  connector.useDistribution(new DistributionLocator().getDistributionFor(GradleVersion.version("2.2.1")));

  AndroidProject model = null;
  ProjectConnection connection = connector.connect();
  try {
    model = connection.getModel(AndroidProject.class);
  } finally {
    connection.close();
  }

  return model;
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private static void addGradleClassPath(@NotNull final List<String> classpath) {
  String gradleLibDirPath = null;
  String gradleToolingApiJarPath = PathUtil.getJarPathForClass(ProjectConnection.class);
  if (!StringUtil.isEmpty(gradleToolingApiJarPath)) {
    gradleLibDirPath = PathUtil.getParentPath(gradleToolingApiJarPath);
  }
  if (gradleLibDirPath == null || gradleLibDirPath.isEmpty()) return;

  File gradleLibDir = new File(gradleLibDirPath);
  if (!gradleLibDir.isDirectory()) return;

  File[] children = FileUtil.notNullize(gradleLibDir.listFiles());
  for (File child : children) {
    final String fileName = child.getName();
    if (fileName.endsWith(".jar") && child.isFile()) {
      classpath.add(child.getAbsolutePath());
    }
  }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public ProjectOutcomes executeWith(ProjectConnection connection) {
    List<String> tasksList = getSpec().getTasks();
    String[] tasks = tasksList.toArray(new String[tasksList.size()]);
    List<String> argumentsList = getImpliedArguments();
    String[] arguments = argumentsList.toArray(new String[argumentsList.size()]);

    if (isCanObtainProjectOutcomesModel()) {
        // Run the build and get the build outcomes model
        ModelBuilder<ProjectOutcomes> modelBuilder = connection.model(ProjectOutcomes.class);
        return modelBuilder.
                withArguments(arguments).
                forTasks(tasks).
                get();
    } else {
        BuildLauncher buildLauncher = connection.newBuild();
        buildLauncher.
                withArguments(arguments).
                forTasks(tasks).
                run();

        return null;
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
private EclipseProject getGradleModel(final String absoluteTargetPath) {

        GradleConnector connector = GradleConnector.newConnector();
        File target = new File(absoluteTargetPath);
        connector.forProjectDirectory(target);
        ProjectConnection connection = null;
        EclipseProject eclipseProject = null;
        try {
            connection = connector.connect();

            eclipseProject = connection.getModel(EclipseProject.class);


        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return eclipseProject;
    }
 

import org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
public void compile() throws Exception {

        ProjectConnection connection = getConnector().connect();
        try {
            // Configure the build
            BuildLauncher launcher = connection.newBuild();
            if (flavor != null) {
                launcher.forTasks(task + StringUtils.capitalize(flavor));
            } else {
                launcher.forTasks(task);
            }
            if (buildFile != null) {
                launcher.withArguments("-b", buildFile.getAbsolutePath());
            }
            launcher.setStandardOutput(System.out);
            launcher.setStandardError(System.err);

            // Run the build
            launcher.run();
        } finally {
            // Clean up
            connection.close();
        }
    }
 

import org.gradle.tooling.ProjectConnection; //导入依赖的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 org.gradle.tooling.ProjectConnection; //导入依赖的package包/类
/**
 * Performs this task.
 * @throws GradleException if and only if the build was failed
 */
@Override
public void run(IProgressMonitor monitor) throws GradleException, CoreException {
    SubMonitor sub = SubMonitor.convert(monitor, Messages.GradleBuildTask_monitorRun, 100);
    try {
        try {
            GradleUtil.enhance(sub.newChild(10, SubMonitor.SUPPRESS_NONE), configuration);
            ProjectConnection connection = createProjectConnection(sub.newChild(10, SubMonitor.SUPPRESS_NONE));
            try {
                buildProject(sub.newChild(60, SubMonitor.SUPPRESS_NONE), connection);
            } finally {
                disconnectProject(sub.newChild(10, SubMonitor.SUPPRESS_NONE), connection);
            }
        } finally {
            GradleUtil.dispose(sub.newChild(10, SubMonitor.SUPPRESS_NONE), configuration);
        }
    } finally {
        monitor.done();
    }
}