Notify listeners of stdout and stderr changes

This change completes the loop, such that stdout and stderr messages
are now reported back to all ConsoleService listeners as desired.

When output occurs, something needs to tell the ConsoleService, so that
it can tell all its listeners what happened. That's where the
OutputStreamReporter comes in: it is added to the MultiOutputStream,
which is wrapped by a MultiPrintStream, which overrides the default
System.out or System.err, such that when output occurs, the
OutputStreamReporter finds out and calls ConsoleService#notifyListeners.

This change also cleans up after itself when the context is disposed,
removing the OutputStreamReporters as appropriate.

Author: ctrueden

src/main/java/org/scijava/console/DefaultConsoleService.java

@@ -31,15 +31,20 @@
 
 package org.scijava.console;
 
+import java.io.OutputStream;
 import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.LinkedList;
 
+import org.scijava.Context;
+import org.scijava.console.OutputEvent.Source;
 import org.scijava.log.LogService;
 import org.scijava.plugin.AbstractHandlerService;
 import org.scijava.plugin.Parameter;
 import org.scijava.plugin.Plugin;
 import org.scijava.service.Service;
+import org.scijava.thread.ThreadService;
+import org.scijava.thread.ThreadService.ThreadContext;
 
 /**
  * Default service for managing interaction with the console.
@@ -52,10 +57,14 @@ public class DefaultConsoleService extends
 	ConsoleService
 {
 
+	@Parameter
+	private ThreadService threadService;
+
 	@Parameter
 	private LogService log;
 
 	private MultiPrintStream sysout, syserr;
+	private OutputStreamReporter out, err;
 
 	/** List of listeners for {@code stdout} and {@code stderr} output. */
 	private ArrayList<OutputListener> listeners;
@@ -124,6 +133,14 @@ public Class<LinkedList<String>> getType() {
 		return (Class) LinkedList.class;
 	}
 
+	// -- Disposable methods --
+
+	@Override
+	public void dispose() {
+		if (out != null) sysout.getParent().removeOutputStream(out);
+		if (err != null) syserr.getParent().removeOutputStream(err);
+	}
+
 	// -- Helper methods - lazy initialization --
 
 	/** Initializes {@link #listeners} and related data structures. */
@@ -132,8 +149,13 @@ private synchronized void initListeners() {
 
 		sysout = multiPrintStream(System.out);
 		if (System.out != sysout) System.setOut(sysout);
+		out = new OutputStreamReporter(Source.STDOUT);
+		sysout.getParent().addOutputStream(out);
+
 		syserr = multiPrintStream(System.err);
 		if (System.err != syserr) System.setErr(syserr);
+		err = new OutputStreamReporter(Source.STDERR);
+		syserr.getParent().addOutputStream(err);
 
 		listeners = new ArrayList<OutputListener>();
 	}
@@ -145,4 +167,50 @@ private MultiPrintStream multiPrintStream(final PrintStream ps) {
 		return new MultiPrintStream(ps);
 	}
 
+	// -- Helper classes --
+
+	/**
+	 * An output stream that publishes its output to the {@link OutputListener}s
+	 * of its associated {@link ConsoleService}.
+	 */
+	private class OutputStreamReporter extends OutputStream {
+
+		/** Source of the output stream; i.e., {@code stdout} or {@code stderr}. */
+		private final Source source;
+
+		public OutputStreamReporter(final Source source) {
+			this.source = source;
+		}
+
+		// -- OutputStream methods --
+
+		@Override
+		public void write(final int b) {
+			final ThreadContext relevance = getRelevance();
+			if (relevance == ThreadContext.OTHER) return; // different context
+			publish(relevance, "" + b);
+		}
+
+		@Override
+		public void write(final byte[] buf, final int off, final int len) {
+			final ThreadContext relevance = getRelevance();
+			if (relevance == ThreadContext.OTHER) return; // different context
+			publish(relevance, new String(buf, off, len));
+		}
+
+		// -- Helper methods --
+
+		private ThreadContext getRelevance() {
+			return threadService.getThreadContext(Thread.currentThread());
+		}
+
+		private void publish(final ThreadContext relevance, final String output) {
+			final Context context = getContext();
+			final boolean contextual = relevance == ThreadContext.SAME;
+			final OutputEvent event =
+				new OutputEvent(context, source, output, contextual);
+			notifyListeners(event);
+		}
+	}
+
 }