<!--
  ~ Copyright 2011 the original author or authors.
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~      http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->
<chapter id="embedding">
    <title>Tooling API (Embedding Gradle)</title>

    <section id='sec:embedding_introduction'>
        <title>Introduction to the Tooling API</title>
        <para>Since Gradle 1.0-milestone-3, Gradle has had a programmatic API called the Tooling API,
            which you can use for embedding Gradle into your own software.
            This API allows you to execute and monitor builds and to query Gradle about the details of a build.
            The main audience for this API is IDE, CI server, other UI authors; however, the API is open for anyone who needs to embed Gradle in their application.

            <itemizedlist>
                <listitem>
                    <link linkend="test_kit">Gradle TestKit</link> uses the Tooling API for functional testing of your Gradle plugins.
                </listitem>
                <listitem>
                    <ulink url="http://projects.eclipse.org/projects/tools.buildship">Eclipse Buildship</ulink> uses the Tooling API for importing your Gradle project and running tasks.
                </listitem>
                <listitem>
                    <ulink url="https://www.jetbrains.com/idea/">IntelliJ IDEA</ulink> uses the Tooling API for importing your Gradle project and running tasks.
                </listitem>
            </itemizedlist>
        </para>
    </section>
    <section id='sec:embedding_features'>
        <title>Tooling API Features</title>
        <para>A fundamental characteristic of the Tooling API is that it operates in a version independent way.
            This means that you can use the same API to work with different target versions of Gradle.
            The Tooling API is Gradle wrapper aware and, by default,
            uses the same target Gradle version as that used by the wrapper-powered project.
        </para>

        <para>Some features that the Tooling API provides today:
            <itemizedlist>
                <listitem>You can query Gradle for the details of a build,
                    including the project hierarchy and the project dependencies,
                    external dependencies (including source and Javadoc jars),
                    source directories and tasks of each project.
                </listitem>
                <listitem>You can execute a build and listen to stdout and stderr logging and progress
                    (e.g. the messages shown in the 'status bar' when you run on the command line).
                </listitem>
                <listitem>Tooling API can download and install the appropriate Gradle version, similar to the wrapper.
                    Bear in mind that the Tooling API is wrapper aware so you should not need to configure a Gradle distribution directly.
                </listitem>
                <listitem>The implementation is lightweight, with only a small number of dependencies.
                    It is also a well-behaved library, and makes no assumptions about your classloader structure or logging configuration.
                    This makes the API easy to bundle in your application.
                </listitem>
            </itemizedlist>
        </para>

        <para>In the future we may support other interesting features:
            <itemizedlist>
                <listitem>Performance. The API gives us the opportunity to do lots of caching,
                    static analysis and preemptive work, to make things faster for the user.
                </listitem>
                <listitem>Better progress monitoring and build cancellation.
                    For example, allowing test execution to be monitored.
                </listitem>
                <listitem>Notifications when things in the build change.
                    For example, your Eclipse or IDEA project could be updated immediately in the background.
                </listitem>
                <listitem>Validating and prompting for user supplied configuration.
                </listitem>
                <listitem>Prompting for and managing user credentials.
                </listitem>
            </itemizedlist>
        </para>
    </section>

    <section id='sec:embedding_daemon'>
        <title>Tooling API and the Gradle Build Daemon</title>
        <para>
            The Tooling API uses the daemon all the time. This means that subsequent calls to the Tooling API, be it model building requests or task executing requests
            can be executed in the same long-living process. <xref linkend="gradle_daemon"/> contains more details about the daemon,
            specifically information on situations when new daemons are forked.
        </para>
    </section>

    <section id='sec:embedding_quickstart'>
        <title>Quickstart</title>
        <para>As the Tooling API is an interface for developers, the Javadoc is the main documentation for it. We provide several <emphasis>samples</emphasis> that live
            in <filename>samples/toolingApi</filename> in your Gradle distribution. These samples specify all of the required dependencies for the Tooling API with examples for
            querying information from Gradle builds and executing tasks from the Tooling API.
        </para>
        <para>
            The main entry point to the Tooling API is the <apilink class="org.gradle.tooling.GradleConnector"/>. You can navigate from there to find code samples and
            explore the available Tooling API models.

            There are two ways of using the <literal>GradleConnector</literal> to connect to a Gradle build.
            <itemizedlist>
                <listitem>
                    You can use <apilink class="org.gradle.tooling.GradleConnector" method="connect()"/> to create a <apilink class="org.gradle.tooling.ProjectConnection"/>.
                    <literal>ProjectConnection</literal> can only be used to connect to a single Gradle project at a time.  Executing tasks and retrieving models are all relative to this project.
                </listitem>
                <listitem>
                    You can use <apilink class="org.gradle.tooling.GradleConnector" method="newGradleConnection()"/> to create a
                    <apilink class="org.gradle.tooling.connection.GradleConnectionBuilder"/>.
                    <literal>GradleConnectionBuilder</literal> can be used to connect to any number of Gradle builds at one time. Executing tasks and retrieving models are performed in the context
                    of the composite. Instead of retrieving a single model for a single Gradle project, the Tooling API can provide all models for all projects with a single method call.
                </listitem>
            </itemizedlist>
        </para>
    </section>

</chapter>
