Question

I’m writing an Eclipse plug-in in which the user can interact with another process via the Console view (in this case, an interpreter), for example, evaluate expressions and so on.

Sometimes the program needs to ask the interpreter for certain values. These interactions however, shouldn’t be shown in the console view to the user.

I have following instances:

private IProcess process;
private ILaunch launch;
private IStreamsProxy proxy;

the queries my program do are made via adding an IStreamListener to the proxy:

proxy.getOutputStreamMonitor().addListener(new IStreamListener(){
    @Override
    public void streamAppended(String response, IStreamMonitor arg1) {
             doSomeStuffWiththeRepsonse(response);
        }
    });

while the listener is listening to the OutputStreamMonitor of the proxy, I don’t want the response to pop up in the console view of the plugin.

How can I do that?

Answer 1

Okay, here is how I did it.

The launch system of Eclipse works as follows:

1. Implement a ILaunchConfigurationDelegate, the only method in this interface is launch, which recieves an ILaunchConfiguration, a mode, an ILaunch and an IProgressMonitor.

In my program, launch starts an inferiorProcess using DebugPlugin.exec() using a commandline argument. Then a new Process is created by calling DebugPlugin.newProcess() with the ILaunch, the inferiorProcess, the name for the interpreter and some attributes.
This method creates a new RuntimeProcess and adds it to the ILaunch and vice versa.

2. Define a LaunchConfigurationType by using the extension point org.eclipse.debug.core.launchConfigurationTypes and add it to the plugin.xml:

<extension
    point="org.eclipse.debug.core.launchConfigurationTypes">
    <launchConfigurationType
            delegate="myplugin.MyLaunchConfigurationDelegate" (1)
            id="myplugin.myExternalProgram" (2)
            modes="run" (3)
            name="MyExternalProgram" (4)
            public="false"> (5)
      </launchConfigurationType>
</extension>

The extension point gives the exact path to the ILaunchConfigurationDelegate class created as above (1) and an unqiue identifier (2) to retrieve the instance of ILaunchConfigurationType from the LaunchManager used to launch the program. (3) defines the modes it can run as, run and debug. The name (4) is later shown in the top bar of the console view. If you only want to access and launch your external program programmatically in your plug-in (and not via the Run drop-down menu) (5) must be set to false.

3. Create a class that stores the Instances of IProcess, ILaunch and IStreamsProxy and which calls apropiate methods to start the process and to write onto the streamsproxy. A method for starting the process could look like this:

// is the process already running?
public boolean isRunning() {
        boolean result = false;
        try {
            if (this.process != null) {
                result = true;
                this.process.getExitValue();
                result = false;
            }
        }
        catch (DebugException exception) {
        }
        return result;
}

// start the process
public void start() {
        try {
            if (!isRunning()) {
                // get the ILaunchConfigurationType from the platform
                ILaunchConfigurationType configType = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(myplugin.myExternalProgram);
                // the ILaunchConfigurationType can't be changed or worked with, so get a WorkingCopy
                ILaunchConfigurationWorkingCopy copy = configType.newInstance(null, "myExternalProgram");
                this.launch = copy.launch(ILaunchManager.RUN_MODE, new NullProgressMonitor());
                IProcess[] processes = this.launch.getProcesses();

                if (processes.length > 0) {
                    // get the IProcess instance from the launch
                    this.process = this.launch.getProcesses()[0];
                    // get the streamsproxy from the process
                    this.proxy = this.process.getStreamsProxy();                       
                }
            }
        }
        catch (CoreException exception) {
        }
        if (isRunning())
            // bring up the console and show it in the workbench
            showConsole();
    }

public void showConsole() {
        if (this.process != null && this.process.getLaunch() != null) {
            IConsole console = DebugUITools.getConsole(this.process);                
            ConsolePlugin.getDefault().getConsoleManager().showConsoleView(console);
            IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
            IViewPart view = page.findView("org.eclipse.ui.console.ConsoleView");
            if (view != null) 
                view.setFocus();
          }
    }

Now to the initial problem of the question
The IStreamsListener of the console view, which listens to the OutputStreamMonitor of the IStreamsProxy could not be retrieved and thus not being stopped of listening. Prints to the console could not be prevented. OutputStreamMonitor doesn’t provide methods to get the current listeners. It is not possible to just subclass it and override/add some methods, because the important fields and methods are private.

http://www.java2s.com/Open-Source/Java-Document/IDE-Eclipse/debug/org/eclipse/debug/internal/core/OutputStreamMonitor.java.htm

Just copy the code and add a get-method for the fListeners field and change some method modifiers to public.
In order to get your own OutputStreamMonitor into the system, you need to create your own IStreamsProxy. Again only subclassing wont work, you need to copy the code again and make some changes.

http://www.java2s.com/Open-Source/Java-Document/IDE-Eclipse/debug/org/eclipse/debug/internal/core/StreamsProxy.java.htm

Important:

public class MyStreamsProxy implements  IStreamsProxy, IStreamsProxy2 {
    /**
     * The monitor for the output stream (connected to standard out of the process)
     */
    private MyOutputStreamMonitor fOutputMonitor;
    /**
     * The monitor for the error stream (connected to standard error of the process)
     */
    private MyOutputStreamMonitor fErrorMonitor;

(...)

public MyStreamsProxy(Process process) {
        if (process == null) {
            return;
        }
        fOutputMonitor = new MyOutputStreamMonitor(process
                .getInputStream());
        fErrorMonitor = new MyOutputStreamMonitor(process
                .getErrorStream());
        fInputMonitor = new InputStreamMonitor(process
                .getOutputStream());
        fOutputMonitor.startMonitoring();
        fErrorMonitor.startMonitoring();
        fInputMonitor.startMonitoring();
    }

The only thing remaining is providing your own IProcess that uses your IStreamsProxy. This time subclassing RuntimeProcess and overriding the method createStreamsProxy() is enough:

public class MyProcess extends RuntimeProcess {

    public MyProcess(ILaunch launch, Process process, String name,
            Map attributes) {
        super(launch, process, name, attributes);
    }

    @Override
    protected IStreamsProxy createStreamsProxy() {
        String encoding = getLaunch().getAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING);
        return new MyStreamsProxy(getSystemProcess());
    }
}

MyProcess is integrated by creating a new instance of it in the launch method in the ILaunchConfigurationDelegate instead of using DebugPlugin.newProcess().

Now it is possible to hide and expose the output of the console view.

    /**
     * Storage field for the console listener
     */
    private IStreamListener oldListener;


    /**
     * Hides the output coming from the process so the user doesn't see it.
     */
    protected void hideConsoleOutput() {
        MyOutputStreamMonitor out 
            = (MyOutputStreamMonitor) this.process.getStreamsProxy().getOutputStreamMonitor();
        List<IStreamListener> listeners = out.getListeners();
        // the console listener
        this.oldListener = listeners.get(0);
        out.removeListener(this.oldListener);

    }

    /**
     * Reverts the changes made by hideConsoleOutput() so the user sees the response from the process again.
     */
    protected void exposeConsoleOutput() {
        MyOutputStreamMonitor out 
        = (MyOutputStreamMonitor) this.process.getStreamsProxy().getOutputStreamMonitor();
        out.addListener(oldListener);
        this.oldListener = null;

    }

The hide and expose methods have to be called before any other listeners are added. There might be a better solution, however, this works.