Java BuildLauncher类代码示例

import org.gradle.tooling.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的package包/类
public BuildLauncher forLaunchables(Iterable<? extends Launchable> launchables) {
    Set<String> taskPaths = new LinkedHashSet<String>();
    List<InternalLaunchable> launchablesParams = Lists.newArrayList();
    for (Launchable launchable : launchables) {
        if (launchable instanceof Task) {
            taskPaths.add(((Task) launchable).getPath());
        } else if (launchable instanceof TaskListingLaunchable) {
            taskPaths.addAll(((TaskListingLaunchable) launchable).getTaskNames());
        } else if (!(launchable instanceof TaskSelector)) {
            throw new GradleException("Only Task or TaskSelector instances are supported: "
                    + (launchable != null ? launchable.getClass() : "null"));
        }
        maybeAddLaunchableParameter(launchablesParams, launchable);
    }
    operationParamsBuilder.setTasks(new ArrayList<String>(taskPaths));
    operationParamsBuilder.setLaunchables(launchablesParams);
    return this;
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的package包/类
public static void run(final BuildLauncher build, final IProgressMonitor monitor, String... runArgs) {
    monitor.beginTask("Running gradle build", IProgressMonitor.UNKNOWN);
    MessageConsole messageConsole = UiUtils.getMessageConsole("Gradle run");
    final IOConsoleOutputStream consoleStream = messageConsole.newOutputStream();
    build.setStandardOutput(consoleStream);
    build.setStandardError(consoleStream);
    GradlePluginUtils.setBuildLoggingOptions(build, runArgs);
    UiUtils.showConsoleView();
    // STUDIO-2676 - bring new console to front
    ConsolePlugin.getDefault().getConsoleManager().showConsoleView(messageConsole);
    
    build.addProgressListener(new ProgressListener() {
        
        @Override
        public void statusChanged(ProgressEvent progressEvent) {
            monitor.beginTask(progressEvent.getDescription(), IProgressMonitor.UNKNOWN);
        }
    });
    
    build.run();
    monitor.done();
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的package包/类
static void setBuildLoggingOptions(BuildLauncher build, IPreferenceStore prefs, String[] additionalArguments) {
	
	ArrayList<String> buildArgs = new ArrayList<String>();
	
	buildArgs.addAll(Arrays.asList(additionalArguments));
	
	String logLevel = prefs.getString(WorkbenchPreferencePage.GRADLE_LOG_LEVEL_ID);
	if (!logLevel.isEmpty()) {
		buildArgs.add(logLevel);	
	}
	if (prefs.getBoolean(WorkbenchPreferencePage.GRADLE_PRINT_STACKTRACES_ID)) {
		buildArgs.add(GradlePluginConstants.ENABLE_STACKTRACE_FLAG);
	}
	
	if(buildArgs.isEmpty()) {
		//do not modify the build.
		return;
	}
	
	build.withArguments(buildArgs.toArray(new String[0]));
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的package包/类
@Override
protected IStatus run(IProgressMonitor monitor) {
    BuildConfiguration buildConfig = CorePlugin.configurationManager()
            .loadBuildConfiguration(new File(project.getRawLocationURI()));

    RunConfiguration runConfiguration = CorePlugin.configurationManager().createDefaultRunConfiguration(buildConfig);

    BuildLauncher launcher = CorePlugin.gradleWorkspaceManager().getGradleBuild(buildConfig)
                    .newBuildLauncher(runConfiguration, CharStreams.nullWriter(), 
                                    getTransientRequestAttributes(GradleConnector.newCancellationTokenSource().token(), monitor));
    launcher.forTasks(":" + project.getName() + ":gfBundle").run();

    return Status.OK_STATUS;
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的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.BuildLauncher; //导入依赖的package包/类
@Override
public InputStream runTask(final List<String> args) throws IOException {
  try {
    final List<String> tasks = new ArrayList<>(4);
    final List<String> taskArgs = new ArrayList<>(4);
    for (final String temp : args) {
      for (final String arg : temp.split(" ")) {
        if (arg.startsWith("-")) {
          taskArgs.add(arg.trim());
        } else {
          tasks.add(arg.trim());
        }
      }
    }

    log.debug("task:{}:{} args:{}:{}", tasks, tasks.size(), taskArgs, taskArgs.size());

    final ProjectConnection projectConnection = getProjectConnection();
    final BuildLauncher build = projectConnection.newBuild();
    this.setBuildJVMArgs(build);
    build.forTasks(tasks.toArray(new String[tasks.size()]));
    if (taskArgs.size() > 0) {
      build.withArguments(taskArgs.toArray(new String[taskArgs.size()]));
    }

    final PipedOutputStream outputStream = new PipedOutputStream();
    PipedInputStream inputStream = new PipedInputStream(outputStream);
    build.setStandardError(outputStream);
    build.setStandardOutput(outputStream);
    final VoidResultHandler handler =
        new VoidResultHandler(outputStream, inputStream, projectConnection);
    build.run(handler);
    return inputStream;
  } finally {
    Config.setProjectRoot(this.projectRoot.getCanonicalPath());
  }
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的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();
    }
  }
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的package包/类
private void runPrepareTestCompileTask() throws IOException {
  if (!this.prepareTestCompileTask.isEmpty()) {
    final ProjectConnection connection = this.getProjectConnection();
    try {
      final String[] tasks =
          prepareTestCompileTask.toArray(new String[prepareTestCompileTask.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();
    }
  }
}
 

import org.gradle.tooling.BuildLauncher; //导入依赖的package包/类
/**
 * Starts the progress handler and executes the gradle task.
 */
@Override
public void run() {
    if (gradleTask != null && gradleTask.isValid()) {
        progressHandler = ProgressHandle.createHandle(gradleTask.getDescription(), this);
        progressHandler.start();            
        ProjectConnection connection = null;            
        try {
            connection = getGradleConnection();
            BuildLauncher buildLauncher = connection.newBuild();
            buildLauncher.forTasks(gradleTask.getName());
            String[] executionParameters = gradleTask.getExecutionParameters();
            buildLauncher.withArguments(executionParameters);
            LOG.info(EXECUTE_A_GRADLE_TASK);
            LOG.log(Level.INFO, "{0} {1} on folder: {2}", new Object[]{gradleTask.getName(), 
                                                                       Arrays.toString(executionParameters),
                                                                       gradleTask.getFolder()});
            GradleResultHandler resultHandler = gradleTask.getResultHandler();
            if (resultHandler != null) {
                buildLauncher.setStandardError(resultHandler.getErrorOutputStream());
                buildLauncher.setStandardOutput(resultHandler.getOutputStream());
                buildLauncher.run(resultHandler);
            } else {
                buildLauncher.run();
            }
        } catch(GradleConnectionException | IllegalStateException ex) {
            Exceptions.printStackTrace(ex);
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }
}