*/
package org.gradle.api.artifacts;

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

/**
 * A {@code DependencyResolutionListener} is notified as dependencies are resolved.
 */
@EventScope(Scope.Build.class)
public interface DependencyResolutionListener {
    /**
     * This method is called immediately before a set of dependencies are resolved.
     *

        when:
        manager.apply(rulesClass)

        then:
        1 * target.applyRules(null, rulesClass)

        and:
        manager.hasPlugin("foo")
    }

    def "action is notified when rules plugin with id is applied by class"() {
        def action = Mock(Action)

        given:
        addPluginId("foo", rulesClass)
        manager.withPlugin("foo", action)

        when:

 * Tracks some state for build operations of a given type.
 */
public interface BuildOperationTracker {
    /**
     * Returns the trackers that are used by this tracker. If this tracker is required, then its trackers should be notified of
     * build operation execution. If this tracker is not required, the trackers can be ignored.
     */
    default List<? extends BuildOperationTracker> getTrackers() {
        return Collections.emptyList();
    }

         */
        void visit(ArtifactVisitor visitor);
    }

    /**
     * A listener that is notified as artifacts are made available while visiting the contents of a set. Implementations must be thread safe as they are notified from multiple threads concurrently.
     */
    interface Visitor {
        /**

        // However, it is not always known whether a dependency will be scheduled or not when it is added here.
        // For example, the dependency may later be filtered from the graph and this set is never notified that it is complete
        // This lifecycle could be simplified and allow the dependencies to be discarded at this point
        pruned = false;
        waitingFor.add(node);
        return this;
    }

import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope.Global;
import org.gradle.launcher.daemon.context.DaemonConnectDetails;

/**
 * Notified when a daemon is started.
 */
@EventScope(Global.class)
public interface DaemonStartListener {
    void daemonStarted(DaemonConnectDetails daemonInfo);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.tooling;

/**
 * A listener which is notified as some long running operation makes progress.
 * @since 1.0-milestone-3
 */
public interface ProgressListener {
    /**
     * Called when the progress status changes.
     *

        if (!seenChanges) {
            LOGGER.debug("notifying pending changes");
            delegate.onPendingChanges();
            seenChanges = true;
        } else {
            LOGGER.debug("already notified");
        }
    }

     *
     * It expects to receive notifications about all operations from the very start of the build.
     */
    BuildOperationNotificationListener getBuildOperationNotificationListener();

    /**
     * Notified when the build invocation has finished by Gradle.
     */
    GradleEnterprisePluginEndOfBuildListener getEndOfBuildListener();

 * limitations under the License.
 */

package org.gradle.internal.scan.eob;

import javax.annotation.Nullable;

/**
 * Used by the scan plugin to register a listener to be notified about the build finishing.
 */
public interface BuildScanEndOfBuildNotifier {

    interface BuildResult {
        @Nullable
        Throwable getFailure();
    }

    interface BuildScanResult {