/**
 * Returned when the daemon starts a build command, signifying that it has begun processing it.
 */
public class BuildStarted extends Message {

    private final DaemonDiagnostics diagnostics;

    public BuildStarted(DaemonDiagnostics diagnostics) {
        this.diagnostics = diagnostics;
    }

    public DaemonDiagnostics getDiagnostics() {
        return diagnostics;
    }

    }

    /**
     * Should be set with a timestamp from a {@link org.gradle.BuildListener#beforeSettings(Settings)}
     * callback.
     */
    public void setBuildStarted(long buildStarted) {
        this.buildStarted = buildStarted;
    }

    /**
     * Should be set with a timestamp from a {@link org.gradle.BuildListener#settingsEvaluated}
     * callback.
     */

import org.gradle.launcher.daemon.context.DaemonConnectDetails
import org.gradle.launcher.daemon.diagnostics.DaemonDiagnostics
import org.gradle.launcher.daemon.protocol.Build
import org.gradle.launcher.daemon.protocol.BuildStarted
import org.gradle.launcher.daemon.protocol.Cancel
import org.gradle.launcher.daemon.protocol.CloseInput
import org.gradle.launcher.daemon.protocol.DaemonUnavailable
import org.gradle.launcher.daemon.protocol.Failure

        }
    }

    private static class BuildStartedSerializer implements Serializer<BuildStarted> {
        @Override
        public void write(Encoder encoder, BuildStarted buildStarted) throws Exception {
            FILE_SERIALIZER.write(encoder, buildStarted.getDiagnostics().getDaemonLog());
            if (buildStarted.getDiagnostics().getPid() == null) {
                encoder.writeBoolean(false);
            } else {

     */
    void daemonUnavailable(DaemonUnavailable unavailable);

    /**
     * Dispatches a build started message to the client.
     */
    void buildStarted(BuildStarted buildStarted);

    /**
     * Dispatches a log event message to the client.
     */
    void logEvent(OutputEvent logEvent);

    /**
     * Dispatches some build event to the client.
     */

    @Override
    public void daemonUnavailable(DaemonUnavailable unavailable) {
        connection.dispatchAndFlush(unavailable);
    }

    @Override
    public void buildStarted(BuildStarted buildStarted) {
        connection.dispatchAndFlush(buildStarted);
    }

    @Override
    public void logEvent(OutputEvent logEvent) {
        connection.dispatchAndFlush(new OutputMessage(logEvent));
    }

    @Override

        result instanceof Cancel
    }

    def "can serialize BuildStarted message"() {
        expect:
        def diagnostics = new DaemonDiagnostics(new File("log"), 1234L)
        def message = new BuildStarted(diagnostics)
        def result = serialize(message, serializer)
        result instanceof BuildStarted
        result.diagnostics.daemonLog == message.diagnostics.daemonLog

        return startTime;
    }

    public long getAllBuildsTime() {
        return allBuildsTime;
    }

    // TODO: these should be moved off to a separate type

    public void buildStarted() {
        ++buildCount;
        currentBuildTimer.reset();
    }

    public void buildFinished() {
        long buildTime = Math.max(currentBuildTimer.getElapsedMillis(), 1);
        allBuildsTime += buildTime;

        LOGGER.debug("Received result {} from daemon {} (build should be starting).", result, connection.getDaemon());

        DaemonDiagnostics diagnostics = null;
        if (result instanceof BuildStarted) {
            diagnostics = ((BuildStarted) result).getDiagnostics();
            result = monitorBuild(build, diagnostics, connection, cancellationToken, buildEventConsumer);
        }

        LOGGER.debug(DaemonMessages.STARTED_BUILD);
        LOGGER.debug("Executing build with daemon context: {}", execution.getDaemonContext());
        runningStats.buildStarted();
        DaemonConnectionBackedEventConsumer buildEventConsumer = new DaemonConnectionBackedEventConsumer(execution);
        try {