Java IStreamListener类代码示例

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
/**
 * Adds listener to monitor, and calls listener with any content monitor already has.
 * NOTE: This methods synchronises on monitor while listener is called. Listener may
 * not wait on any thread that waits for monitors monitor, what would result in dead-lock.
 */
public static void addAndNotifyStreamListener(IStreamMonitor monitor, IStreamListener listener) {
	// Synchronise on monitor to prevent writes to stream while we are adding listener.
	// It's weird to synchronise on monitor because that's a shared object, but that's
	// what ProcessConsole does.
	synchronized (monitor) {
		String contents = monitor.getContents();
		if (!contents.isEmpty()) {
			// Call to unknown code while synchronising on monitor. This is dead-lock prone!
			// Listener must not wait for other threads that are waiting in line to
			// synchronise on monitor.
			listener.streamAppended(contents, monitor);
		}
		monitor.addListener(listener);
	}
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
private void onAfterCodeServerStarted(DebugEvent event) {
  if (!(event.getSource() instanceof IProcess)) {
    return;
  }

  IProcess runtimeProcess = (IProcess) event.getSource();
  final ILaunch launch = runtimeProcess.getLaunch();
  IProcess[] processes = launch.getProcesses();
  final IProcess process = processes[0];

  // Look for the links in the sdm console output
  consoleStreamListenerCodeServer = new IStreamListener() {
    @Override
    public void streamAppended(String text, IStreamMonitor monitor) {
      displayCodeServerUrlInDevMode(launch, text);
    }
  };

  // Listen to Console output
  streamMonitorCodeServer = process.getStreamsProxy().getOutputStreamMonitor();
  streamMonitorCodeServer.addListener(consoleStreamListenerCodeServer);
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
@Override
		public synchronized void flush() throws IOException {
			super.flush();
			String cont;
			try {
				cont = this.toString(encoding);
				
			} 
			catch (UnsupportedEncodingException ex) {
				DbgActivator.getDefault().logError("Encoding problem", ex);
				cont = this.toString();
			}
			String appended = cont.substring(flushLength);
			flushLength = cont.length();
			if (this.content != null) {
				this.reset();
				flushLength = 0;
			}
			
//			System.out.println(oldLength + ":" + this.toString() + ":" + appended + ":" + this.listeners.size());
			for (IStreamListener l : this.listeners) {
				l.streamAppended(appended, monitor);
			}
		}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
/**
 * Executes the given command and returns a handle to the 
 * process. Should only be used if access to {@link IProcess}
 * instance is desired. 
 * 
 * @param command
 * @param workingDirectory
 * @param monitor
 * @param envp
 * @param launchConfiguration
 * @param outStreamListener
 * @param errorStreamListener
 * @return the process
 * @throws CoreException
 */
public IProcess exec(String[] command, File workingDirectory, IProgressMonitor monitor, 
		String[] envp, ILaunchConfiguration launchConfiguration, 
		IStreamListener outStreamListener, IStreamListener errorStreamListener ) throws CoreException{
	
	checkCommands(command);
	checkWorkingDirectory(workingDirectory);
	if(monitor == null ){
		monitor = new NullProgressMonitor();
	}
	if (envp == null && launchConfiguration != null ){
		envp = DebugPlugin.getDefault().getLaunchManager().getEnvironment(launchConfiguration);
	}
	if (monitor.isCanceled()) {
		return null;
	}
	Process process = DebugPlugin.exec(command, workingDirectory, envp);
	
	Map<String, String> processAttributes = generateProcessAttributes(command, launchConfiguration);
	Launch launch = new Launch(launchConfiguration, "run", null);
	IProcess prcs = DebugPlugin.newProcess(launch, process, command[0], processAttributes);
	setTracing(command, outStreamListener, errorStreamListener, prcs);
	DebugPlugin.getDefault().getLaunchManager().addLaunch(launch);
	return prcs;
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
private void setTracing(String[] command, IStreamListener outStreamListener, IStreamListener errorStreamListener,
		IProcess prcs) {
	if(HybridCore.DEBUG){
		HybridCore.trace("Creating TracingStreamListeners for " + Arrays.toString(command));
		outStreamListener = new TracingStreamListener(outStreamListener);
		errorStreamListener = new TracingStreamListener(outStreamListener);
	}
	
	if( outStreamListener != null ){
		prcs.getStreamsProxy().getOutputStreamMonitor().addListener(outStreamListener);
		//See bug 121454. Ensure that output to fast processes is processed
		outStreamListener.streamAppended(prcs.getStreamsProxy().getOutputStreamMonitor().getContents(), null);
	}

	if( errorStreamListener != null ){
		prcs.getStreamsProxy().getErrorStreamMonitor().addListener(errorStreamListener);
		//See bug 121454. Ensure that output to fast processes is processed
		errorStreamListener.streamAppended(prcs.getStreamsProxy().getErrorStreamMonitor().getContents(), null);
	}
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
public synchronized void addListener(IStreamListener listener) {
	if (!this.listeners.contains(listener)) {
		this.listeners.add(listener);
	}
	try {
		this.content = this.toString(encoding);
	} 
	catch (UnsupportedEncodingException ex) {
		this.content = this.toString();
	}
	synchronized (this.lock) {
		this.lock.notify();
	}
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
@Override
public synchronized void flush() {
  if (!isFlushing) {
    return;
  }
  String text = writer.toString();
  int lastLinePos;
  final boolean flushOnlyFullLines = true;
  if (flushOnlyFullLines) {
    int pos = text.lastIndexOf('\n');
    if (pos == -1) {
      // No full line in the buffer.
      return;
    }
    lastLinePos = pos + 1;
  } else {
    lastLinePos = text.length();
  }
  String readyText = text.substring(0, lastLinePos);
  writer = new StringWriter();
  if (lastLinePos != text.length()) {
    String rest = text.substring(lastLinePos);
    writer.append(rest);
  }
  for (IStreamListener listener : listeners) {
    listener.streamAppended(readyText, this);
  }
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
private CordovaProjectCLI setupMockCLI(HybridProject project) throws CoreException {
	IProcess mockProcess = mock(IProcess.class);
	IStreamsProxy2 mockStreams = mock(IStreamsProxy2.class);
	CordovaProjectCLI mockCLI = spy(CordovaProjectCLI.newCLIforProject(mockProject));

	doReturn(mockProcess).when(mockCLI).startShell(any(IStreamListener.class), any(IProgressMonitor.class),
			any(ILaunchConfiguration.class));

	when(mockProcess.getStreamsProxy()).thenReturn(mockStreams);
	when(mockProcess.isTerminated()).thenReturn(Boolean.TRUE);

	doReturn(mockCLI).when(project).getProjectCLI();
	return mockCLI;
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
@Test
public void testAdditionalEnvProperties() throws CoreException{
	CordovaProjectCLI mockCLI = getMockCLI();
	IProcess mockProcess = mock(IProcess.class);
	IStreamsProxy2 mockStreams  = mock(IStreamsProxy2.class);
	setupMocks(mockCLI, mockProcess, mockStreams);
	ArgumentCaptor<ILaunchConfiguration> confCaptor = ArgumentCaptor.forClass(ILaunchConfiguration.class);
	mockCLI.prepare(new NullProgressMonitor(), "android");
	verify(mockCLI).startShell(any(IStreamListener.class), any(IProgressMonitor.class), confCaptor.capture());
	Map<String,String> attr = confCaptor.getValue().getAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, (Map<String,String>)null);
	assertEquals(EnvironmentPropsExt.ENV_VALUE, attr.get(EnvironmentPropsExt.ENV_KEY));
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
@Test
  public void testAdditionalEnvProperties() throws CoreException{
CordovaCLI mockCLI = getMockCLI();
  	IProcess mockProcess = mock(IProcess.class);
  	IStreamsProxy2 mockStreams  = mock(IStreamsProxy2.class);
  	setupMocks(mockCLI, mockProcess, mockStreams);
  	
  	ArgumentCaptor<ILaunchConfiguration> confCaptor = ArgumentCaptor.forClass(ILaunchConfiguration.class);
  	mockCLI.version(new NullProgressMonitor());
  	verify(mockCLI).startShell(any(IStreamListener.class), any(IProgressMonitor.class), confCaptor.capture());
  	Map<String,String> attr = confCaptor.getValue().getAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES, (Map<String,String>)null);
  	assertEquals(EnvironmentPropsExt.ENV_VALUE, attr.get(EnvironmentPropsExt.ENV_KEY));
  }
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
public void logcat(String filter, IStreamListener outListener, IStreamListener errorListener, String serialNumber) throws CoreException{
	ExternalProcessUtility processUtility = new ExternalProcessUtility();
	StringBuilder command = new StringBuilder(getADBCommand());
	command.append(" -s ").append(serialNumber);
	command.append(" logcat ");
	if(filter !=null && !filter.isEmpty()){
		command.append(filter);
	}
	processUtility.execAsync(command.toString(), null, outListener, errorListener, null);
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
/**
 * Convenience method to specify command line as a string for {@link #execAsync(String[], File, IStreamListener, IStreamListener, String[])}
 */
public void execAsync ( String commandLine, File workingDirectory, 
		IStreamListener outStreamListener, 
		IStreamListener errorStreamListener, String[] envp) throws CoreException{
	checkCommandLine(commandLine);
	this.execAsync(DebugPlugin.parseArguments(commandLine),
			workingDirectory, outStreamListener, errorStreamListener, envp);
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
/**
 * Executes the given commands synchronously.
 *
 * <p>
 * If the workingDirectory is null, the current directory for process is used.
 * </p>
 * @param command the command line can not be null or empty
 * @param workingDirectory working directory for the executed command, can be null
 * @param outStreamListener  listener for output, can be null
 * @param errorStreamListene listener for error output, can be null
 * @param envp environment variables to set in the process, can be null
 * @param launchConfiguration the launch to add as part of this call, can be null
 * @return the exit code for the process
 * @throws CoreException if the execution fails
 */
public int execSync ( String[] command, File workingDirectory, 
		IStreamListener outStreamListener, 
		IStreamListener errorStreamListener, IProgressMonitor monitor, 
		String[] envp, ILaunchConfiguration launchConfiguration) throws CoreException{
	if(monitor == null){
		monitor = new NullProgressMonitor();
	}
	HybridCore.trace("Sync Execute command line: "+Arrays.toString(command));
	IProcess prcs = exec(command, workingDirectory, monitor, envp, launchConfiguration,outStreamListener,errorStreamListener);
	if(prcs == null ){
		return 0;
	}
	
	while (!prcs.isTerminated()) {
		try {
			if (monitor.isCanceled()) {
				prcs.terminate();
				break;
			}
			Thread.sleep(50);
		} catch (InterruptedException e) {
			HybridCore.log(IStatus.INFO, "Exception waiting for process to terminate", e);
		}
	}
	return prcs.getExitValue();
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
public IProcess startShell(final IStreamListener listener, final IProgressMonitor monitor, 
		final ILaunchConfiguration launchConfiguration) throws CoreException{
	ArrayList<String> commandList = new ArrayList<String>();
	if(isWindows()){
		commandList.add("cmd");
	}else{
		commandList.add("/bin/bash");
		commandList.add("-l");
	}
	
	ExternalProcessUtility ep = new ExternalProcessUtility();
	IProcess process = ep.exec(commandList.toArray(new String[commandList.size()]), getWorkingDirectory(), 
			monitor, null, launchConfiguration, listener, listener);
	 return process;
}
 

import org.eclipse.debug.core.IStreamListener; //导入依赖的package包/类
private void fireStreamAppend(String text) {
    synchronized (listeners) {
        for (IStreamListener oneListener : listeners) {
            oneListener.streamAppended(text, this);
        }
    }
}