org.gradle.tooling

## Interface ProjectConnection

-     public interface ProjectConnection

  Represents a long-lived connection to a Gradle project. You obtain an instance of a `ProjectConnection` by using `GradleConnector.connect()`.

       ProjectConnection connection = GradleConnector.newConnector()
          .forProjectDirectory(new File("someFolder"))
          .connect();

       try {
          //obtain some information from the build
          BuildEnvironment environment = connection.model(BuildEnvironment.class)
            .get();

          //run some tasks
          connection.newBuild()
            .forTasks("tasks")
            .setStandardOutput(System.out)
            .run();

       } finally {
          connection.close();
       }

  ### Thread safety information

  All implementations of `ProjectConnection` are thread-safe, and may be shared by any number of threads.

  All notifications from a given `ProjectConnection` instance are delivered by a single thread at a time. Note, however, that the delivery thread may change over time.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `close()` Closes this connection.
    `<T extends Model> T` | `getModel(Class<T> viewType)` Fetches a snapshot of the model of the given type for this project.
    `<T extends Model> void` | `getModel(Class<T> viewType, ResultHandler<? super T> handler)` Fetches a snapshot of the model for this project asynchronously.
    `<T extends Model> ModelBuilder<T>` | `model(Class<T> modelType)` Creates a builder which can be used to build the model of the given type.
    `BuildLauncher` | `newBuild()` Creates a launcher which can be used to execute a build.

- - ### Method Detail

    - #### getModel

          <T extends Model> T getModel(Class<T> viewType)
                                   throws UnsupportedVersionException,
                                          UnknownModelException,
                                          BuildException,
                                          GradleConnectionException,
                                          IllegalStateException

      Fetches a snapshot of the model of the given type for this project.

      This method blocks until the model is available.

      Type Parameters:
        `T` - The model type.
      Parameters:
        `viewType` - The model type.
      Returns:
        The model.
      Throws:
        `UnsupportedVersionException` - When the target Gradle version does not support the given model.
        `UnknownModelException` - When you are building a model unknown to the Tooling API, for example you attempt to build a model of a type does not come from the Tooling API.
        `BuildException` - On some failure executing the Gradle build, in order to build the model.
        `GradleConnectionException` - On some other failure using the connection.
        `IllegalStateException` - When this connection has been closed or is closing.

    - #### getModel

          <T extends Model> void getModel(Class<T> viewType,
                                        ResultHandler<? super T> handler)
                        throws IllegalStateException,
                               UnknownModelException

      Fetches a snapshot of the model for this project asynchronously. This method return immediately, and the result of the operation is passed to the supplied result handler.
      Type Parameters:
        `T` - The model type.
      Parameters:
        `viewType` - The model type.
        `handler` - The handler to pass the result to.
      Throws:
        `IllegalStateException` - When this connection has been closed or is closing.
        `UnknownModelException` - When you are building a model unknown to the Tooling API, for example you attempt to build a model of a type does not come from the Tooling API.

    - #### newBuild

          BuildLauncher newBuild()

      Creates a launcher which can be used to execute a build.
      Returns:
        The launcher.

    - #### model

          <T extends Model> ModelBuilder<T> model(Class<T> modelType)
                                              throws UnknownModelException

      Creates a builder which can be used to build the model of the given type.
      Type Parameters:
        `T` - The model type.
      Parameters:
        `modelType` - The model type
      Returns:
        The builder.
      Throws:
        `UnknownModelException` - When you are building a model unknown to the Tooling API, for example you attempt to build a model of a type does not come from the Tooling API.

    - #### close

          void close()

      Closes this connection. Blocks until any pending operations are complete. Once this method has returned, no more notifications will be delivered by any threads.