Java ProjectConnection.close方法代码示例

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包/类
@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包/类
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包/类
/**
 * 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 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包/类
private ProjectOutcomes executeBuild(ComparableGradleBuildExecuter executer) {
    ProjectConnection connection = createProjectConnection(executer);
    try {
        return executer.executeWith(connection);
    } finally {
        connection.close();
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
public static void main(String[] args) {
    // Configure the connector and create the connection
    GradleConnector connector = GradleConnector.newConnector();

    if (args.length > 0) {
        connector.useInstallation(new File(args[0]));
        if (args.length > 1) {
            connector.useGradleUserHomeDir(new File(args[1]));
        }
    }

    connector.forProjectDirectory(new File("."));

    ProjectConnection connection = connector.connect();
    try {
        // Configure the build
        BuildLauncher launcher = connection.newBuild();
        launcher.forTasks("help");
        launcher.setStandardOutput(System.out);
        launcher.setStandardError(System.err);

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

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
/**
 * Main method.
 *
 * @param args command line arguments.
 */
public static void main(String args[]) {

    ProjectConnection gradleConnection = null;
    try {
        Pair<String, String> auth = CommandLineUtils.commandLineArgs(args);

        // Get configuration from .json.
        Configuration configuration = Configuration.parseConfiguration("configuration.json");

        configuration.setBintrayUsername(auth.getKey());
        configuration.setBintrayKey(auth.getValue());

        gradleConnection = GradleConnector.newConnector()
                .forProjectDirectory(new File(configuration.getBasePath()))
                .connect();

        // Clean build and deploy all projects.
        rebuildAndBintrayDeploy(gradleConnection, configuration);

        if (configuration.canRunExtraTasks()) {
            runExtraTasks(gradleConnection, configuration);
        }

    } catch (Exception e) {
        System.out.println("Automator Error: " + e.toString());
    } finally {
        if (gradleConnection != null) {
            gradleConnection.close();
        }
    }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
static AndroidProject getAndroidProject(
    final File root, final org.gradle.tooling.model.GradleProject gradleProject) {
  String path = gradleProject.getPath();
  String name = path.substring(1);
  File childDir = new File(root, name);
  GradleConnector childConnector = GradleConnector.newConnector().forProjectDirectory(childDir);
  ProjectConnection childConnection = childConnector.connect();
  try {
    return childConnection.getModel(AndroidProject.class);
  } catch (Exception e) {
    return null;
  } finally {
    childConnection.close();
  }
}
 

import org.gradle.tooling.ProjectConnection; //导入方法依赖的package包/类
void prepareCompileAndroidTestJava() {
  ProjectConnection connection = this.project.getProjectConnection();
  try {
    BuildLauncher buildLauncher = connection.newBuild();
    String genTestTask = this.project.getName() + genUnitTestTaskName;
    String genAndroidTestTask = this.project.getName() + genAndroidTestTaskName;

    buildLauncher.forTasks(genTestTask, genAndroidTestTask).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包/类
private void runPrepareCompileTask() throws IOException {
  if (!this.prepareCompileTask.isEmpty()) {
    final ProjectConnection connection = this.getProjectConnection();
    try {
      final String[] tasks = prepareCompileTask.toArray(new String[prepareCompileTask.size()]);
      final BuildLauncher buildLauncher = connection.newBuild();
      log.info("project {} run tasks:{}", this.name, (Object) tasks);
      this.setBuildJVMArgs(buildLauncher);
      buildLauncher.forTasks(tasks).run();
    } finally {
      connection.close();
    }
  }
}