Java ProcessListener类代码示例

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public ScopedBlazeProcessHandler(
    Project project,
    List<String> command,
    WorkspaceRoot workspaceRoot,
    ScopedProcessHandlerDelegate scopedProcessHandlerDelegate)
    throws ExecutionException {
  super(new GeneralCommandLine(command).withWorkDirectory(workspaceRoot.directory().getPath()));

  this.scopedProcessHandlerDelegate = scopedProcessHandlerDelegate;
  this.context = new BlazeContext();
  // The context is released in the ScopedProcessHandlerListener.
  this.context.hold();

  for (ProcessListener processListener :
      scopedProcessHandlerDelegate.createProcessListeners(context)) {
    addProcessListener(processListener);
  }
  addProcessListener(new ScopedProcessHandlerListener(project));
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
private static void clearRestarterListener(@NotNull ProcessHandler processHandler) {
  ProcessListener restarterListener = ON_TERMINATION_RESTARTER_KEY.get(processHandler, null);
  if (restarterListener != null) {
    processHandler.removeProcessListener(restarterListener);
    ON_TERMINATION_RESTARTER_KEY.set(processHandler, null);
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
static void runTool(String actionId,
                    DataContext context,
                    @Nullable AnActionEvent e,
                    long executionId,
                    @Nullable ProcessListener processListener) {
  Tool tool = findTool(actionId, context);
  if (tool != null) {
    tool.execute(e, new HackyDataContext(context), executionId, processListener);
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void execute(AnActionEvent event, DataContext dataContext, long executionId, @Nullable final ProcessListener processListener) {
  final Project project = CommonDataKeys.PROJECT.getData(dataContext);
  if (project == null) {
    return;
  }

  FileDocumentManager.getInstance().saveAllDocuments();
  try {
    if (isUseConsole()) {
      ExecutionEnvironment environment = ExecutionEnvironmentBuilder.create(project,
                                                                            DefaultRunExecutor.getRunExecutorInstance(),
                                                                            new ToolRunProfile(this, dataContext)).build();
      environment.setExecutionId(executionId);
      environment.getRunner().execute(environment, new ProgramRunner.Callback() {
        @Override
        public void processStarted(RunContentDescriptor descriptor) {
          ProcessHandler processHandler = descriptor.getProcessHandler();
          if (processHandler != null && processListener != null) {
            processHandler.addProcessListener(processListener);
          }
        }
      });
    }
    else {
      GeneralCommandLine commandLine = createCommandLine(dataContext);
      if (commandLine == null) {
        return;
      }
      OSProcessHandler handler = new OSProcessHandler(commandLine.createProcess(), commandLine.getCommandLineString());
      handler.addProcessListener(new ToolProcessAdapter(project, synchronizeAfterExecution(), getName()));
      if (processListener != null) {
        handler.addProcessListener(processListener);
      }
      handler.startNotify();
    }
  }
  catch (ExecutionException ex) {
    ExecutionErrorDialog.show(ex, ToolsBundle.message("tools.process.start.error"), project);
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void addProcessListener(ProcessListener processListener) {
  synchronized(myProcessListeners) {
    if(getExecutionResult() != null) {
      getExecutionResult().getProcessHandler().addProcessListener(processListener);
    }
    else {
      myProcessListeners.add(processListener);
    }
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void removeProcessListener(ProcessListener processListener) {
  synchronized (myProcessListeners) {
    if(getExecutionResult() != null) {
      getExecutionResult().getProcessHandler().removeProcessListener(processListener);
    }
    else {
      myProcessListeners.remove(processListener);
    }
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
/**
 * @return <code>true</code> if task has been started successfully
 */
static boolean runTool(String actionId, DataContext context, @Nullable AnActionEvent e, long executionId, @Nullable ProcessListener processListener) {
  Tool tool = findTool(actionId, context);
  if (tool != null) {
    return tool.execute(e, new HackyDataContext(context, e), executionId, processListener);
  }
  return false;
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
private static void clearRestarterListener(@Nonnull ProcessHandler processHandler) {
  ProcessListener restarterListener = ON_TERMINATION_RESTARTER_KEY.get(processHandler, null);
  if (restarterListener != null) {
    processHandler.removeProcessListener(restarterListener);
    ON_TERMINATION_RESTARTER_KEY.set(processHandler, null);
  }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
@Override
public ProcessListener createProcessListener(Project project, UserDataHolder extensionData)
{
	final Integer port = extensionData.getUserData(PORT);
	assert port != null;
	return new DebugProcessListener(project, port);
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void addProcessListener(ProcessListener processListener)
{
	synchronized(myProcessListeners)
	{
		if(getProcessHandler() != null)
		{
			getProcessHandler().addProcessListener(processListener);
		}
		else
		{
			myProcessListeners.add(processListener);
		}
	}
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void removeProcessListener(ProcessListener processListener)
{
	synchronized(myProcessListeners)
	{
		if(getProcessHandler() != null)
		{
			getProcessHandler().removeProcessListener(processListener);
		}
		else
		{
			myProcessListeners.remove(processListener);
		}
	}
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void addListener(ProcessListener outputListener) {
    m_outputListener = outputListener;
    if (m_bsb != null) {
        m_bsb.addProcessListener(outputListener);
    }
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void addProcessListener(@NotNull final ProcessListener listener) {
  myListeners.add(listener);
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
@NotNull
public List<ProcessListener> getProcessListeners() {
  return myListeners;
}
 

import com.intellij.execution.process.ProcessListener; //导入依赖的package包/类
public void addProcessListener(ProcessListener listener) {
  ProcessHandler handler = doGetProcessHandler();
  if (handler != null) {
    handler.addProcessListener(listener);
  }
}