/**
 * 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

    List<BuildEvent> buildStarted = []
    List<BuildEvent> buildFinished = []
    List<BuildEvent> targetStarted = []
    List<BuildEvent> targetFinished = []
    List<BuildEvent> taskStarted = []
    List<BuildEvent> taskFinished = []
    List<BuildEvent> messageLogged = []

    void buildStarted(BuildEvent event) {
        buildStarted << event
    }

    void buildFinished(BuildEvent event) {

        }
    }

    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 {

        def unsupportedFileSystemMountPoint = file("unsupported").createDir()
        def unwatchableContent = unsupportedFileSystemMountPoint.file("file.txt").createFile()

        when:
        buildStarted(WatchMode.DEFAULT, [unsupportedFileSystemMountPoint])
        registerWatchableHierarchies([unsupportedFileSystemMountPoint])
        addSnapshot(snapshotRegularFile(unwatchableContent))
        then:

                public void run() {
                    LOGGER.info("Daemon is about to start building {}. Dispatching build started information...", build);
                    execution.getConnection().buildStarted(new BuildStarted(diagnostics));
                    execution.proceed();
                }
            };

            stateCoordinator.runCommand(command, execution.toString());
        } catch (DaemonUnavailableException e) {

     */
    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.
     */

      <states>
        <state type="buildAddedToQueue" enabled="false" />
        <state type="buildRemovedFromQueue" enabled="true" />
        <state type="buildStarted" enabled="true" />
        <state type="changesLoaded" enabled="true" />
        <state type="buildInterrupted" enabled="true" />
        <state type="beforeBuildFinish" enabled="false" />

    @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