Java ProcessAdapter类代码示例

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
protected DebuggerSession attachVM(final RemoteConnection remoteConnection, final boolean pollConnection)
        throws InvocationTargetException, InterruptedException {
  final RemoteState remoteState = new RemoteStateState(myProject, remoteConnection);

  final DebuggerSession[] debuggerSession = new DebuggerSession[1];
  UIUtil.invokeAndWaitIfNeeded(new Runnable() {
    @Override
    public void run() {
      try {
        debuggerSession[0] = attachVirtualMachine(remoteState, new ExecutionEnvironmentBuilder(myProject, DefaultDebugExecutor.getDebugExecutorInstance())
          .runProfile(new MockConfiguration())
          .build(), remoteConnection, pollConnection);
      }
      catch (ExecutionException e) {
        fail(e.getMessage());
      }
    }
  });
  debuggerSession[0].getProcess().getProcessHandler().addProcessListener(new ProcessAdapter() {
    @Override
    public void onTextAvailable(ProcessEvent event, Key outputType) {
      print(event.getText(), outputType);
    }
  });
  return debuggerSession[0];
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
@NotNull
protected OSProcessHandler startProcess() throws ExecutionException {
  final OSProcessHandler handler = JavaCommandLineStateUtil.startProcess(createCommandLine());
  ProcessTerminatedListener.attach(handler, myProject, JavadocBundle.message("javadoc.generate.exited"));
  handler.addProcessListener(new ProcessAdapter() {
    public void processTerminated(ProcessEvent event) {
      if (myConfiguration.OPEN_IN_BROWSER) {
        File url = new File(myConfiguration.OUTPUT_DIRECTORY, INDEX_HTML);
        if (url.exists() && event.getExitCode() == 0) {
          BrowserUtil.browse(url);
        }
      }
    }
  });
  return handler;
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
public XDebugSessionTab init(@NotNull XDebugProcess process, @NotNull XDebugSessionData sessionData, @Nullable RunContentDescriptor contentToReuse) {
  LOG.assertTrue(myDebugProcess == null);
  myDebugProcess = process;
  mySessionData = sessionData;

  if (myDebugProcess.checkCanInitBreakpoints()) {
    initBreakpoints();
  }

  myDebugProcess.getProcessHandler().addProcessListener(new ProcessAdapter() {
    @Override
    public void processTerminated(final ProcessEvent event) {
      stopImpl();
      myDebugProcess.getProcessHandler().removeProcessListener(this);
    }
  });
  //todo[nik] make 'createConsole()' method return ConsoleView
  myConsoleView = (ConsoleView)myDebugProcess.createConsole();
  if (!myShowTabOnSuspend.get()) {
    initSessionTab(contentToReuse);
  }

  return mySessionTab;
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
public void run() {
  FileDocumentManager.getInstance().saveAllDocuments();

  // Use user-provided console if exist. Create new otherwise
  ConsoleView view = (myUserProvidedConsole != null ? myUserProvidedConsole :  createConsole(myProject));
  view.attachToProcess(myProcess);
  if (myAfterCompletion != null) {
    myProcess.addProcessListener(new ProcessAdapter() {
      @Override
      public void processTerminated(ProcessEvent event) {
        SwingUtilities.invokeLater(myAfterCompletion);
      }
    });
  }
  myProcess.startNotify();
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
private void doStart() {
  if (myDebugMode) {
    AndroidDebugBridge.addClientChangeListener(this);
  }
  final MyDeviceChangeListener[] deviceListener = {null};
  getProcessHandler().addProcessListener(new ProcessAdapter() {
    @Override
    public void processWillTerminate(ProcessEvent event, boolean willBeDestroyed) {
      if (myDebugMode) {
        AndroidDebugBridge.removeClientChangeListener(AndroidRunningState.this);
      }
      if (deviceListener[0] != null) {
        Disposer.dispose(deviceListener[0]);
        AndroidDebugBridge.removeDeviceChangeListener(deviceListener[0]);
      }
      myStopped = true;
      synchronized (myLock) {
        myLock.notifyAll();
      }
    }
  });
  deviceListener[0] = prepareAndStartAppWhenDeviceIsOnline();
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
private static void tryToCloseOldSessions(final Executor executor, Project project) {
  final ExecutionManager manager = ExecutionManager.getInstance(project);
  ProcessHandler[] processes = manager.getRunningProcesses();
  for (ProcessHandler process : processes) {
    final AndroidSessionInfo info = process.getUserData(ANDROID_SESSION_INFO);
    if (info != null) {
      process.addProcessListener(new ProcessAdapter() {
        @Override
        public void processTerminated(ProcessEvent event) {
          ApplicationManager.getApplication().invokeLater(new Runnable() {
            @Override
            public void run() {
              manager.getContentManager().removeRunContent(executor, info.getDescriptor());
            }
          });
        }
      });
      process.detachProcess();
    }
  }
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
public void onProcessStarted(final ProcessHandler process) {
  if (myTestsBuilt) return;
  process.addProcessListener(new ProcessAdapter() {
    @Override
    public void processTerminated(ProcessEvent event) {
      process.removeProcessListener(this);
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          myStateInfo.setTerminated(myState);
          if (!myTestsBuilt && myProgressBar.getValue() == 0) {
            setStatusColor(ColorProgressBar.RED);
            setFraction(1.0);
            myState.append(ExecutionBundle.message("junit.running.info.failed.to.start.error.message"));
          }
        }
      });
    }
  });
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
public SquirrelDebugProcess(@NotNull XDebugSession session, ExecutionEnvironment env, RunContentDescriptor executionResult) throws ExecutionException {
    super(session);
    session.setPauseActionSupported(false);

    myExecutionEnvironment = env;
    myRunningState = (SquirrelRunningState) getRunConfiguration().getState(myExecutionEnvironment.getExecutor(), myExecutionEnvironment);
    if (myRunningState == null) {
        throw new ExecutionException("Failed to execute a run configuration.");
    }

    myRunContentDescriptor = executionResult;

    getProcessHandler().addProcessListener(new ProcessAdapter() {
        @Override
        public void processWillTerminate(ProcessEvent event, boolean willBeDestroyed) {
            stop();
        }
    });

    myDebuggerConnection = new SquirrelDebuggerConnection(this, "127.0.0.1", 1234);  // todo make configurable
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
private void resolveUsingPantsGoal(
  @NotNull final ExternalSystemTaskId id,
  @NotNull PantsCompileOptionsExecutor executor,
  final ExternalSystemTaskNotificationListener listener,
  @NotNull DataNode<ProjectData> projectDataNode
) {
  final PantsResolver dependenciesResolver = new PantsResolver(executor);
  dependenciesResolver.resolve(
    new Consumer<String>() {
      @Override
      public void consume(String status) {
        listener.onStatusChange(new ExternalSystemTaskNotificationEvent(id, status));
      }
    },
    new ProcessAdapter() {
      @Override
      public void onTextAvailable(ProcessEvent event, Key outputType) {
        listener.onTaskOutput(id, event.getText(), outputType == ProcessOutputTypes.STDOUT);
      }
    }
  );
  dependenciesResolver.addInfoTo(projectDataNode);
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
@NotNull
private static String loadProjectStructureFromScript(
  @NotNull String scriptPath,
  @NotNull Consumer<String> statusConsumer,
  @Nullable ProcessAdapter processAdapter
) throws IOException, ExecutionException {
  final GeneralCommandLine commandLine = PantsUtil.defaultCommandLine(scriptPath);
  commandLine.setExePath(scriptPath);
  statusConsumer.consume("Executing " + PathUtil.getFileName(scriptPath));
  final ProcessOutput processOutput = PantsUtil.getCmdOutput(commandLine, processAdapter);
  if (processOutput.checkSuccess(LOG)) {
    return processOutput.getStdout();
  }
  else {
    throw new PantsExecutionException("Failed to update the project!", scriptPath, processOutput);
  }
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
@NotNull
private String loadProjectStructureFromTargets(
  @NotNull Consumer<String> statusConsumer,
  @Nullable ProcessAdapter processAdapter
) throws IOException, ExecutionException {
  final File outputFile = FileUtil.createTempFile("pants_depmap_run", ".out");
  final GeneralCommandLine command = getPantsExportCommand(outputFile, statusConsumer);
  statusConsumer.consume("Resolving dependencies...");
  PantsMetrics.markExportStart();
  final ProcessOutput processOutput = getProcessOutput(command);
  PantsMetrics.markExportEnd();
  if (processOutput.getStdout().contains("no such option")) {
    throw new ExternalSystemException("Pants doesn't have necessary APIs. Please upgrade your pants!");
  }
  if (processOutput.checkSuccess(LOG)) {
    return FileUtil.loadFile(outputFile);
  }
  else {
    throw new PantsExecutionException("Failed to update the project!", command.getCommandLineString("pants"), processOutput);
  }
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
private void afterProcessStarted(final Runnable run) {
  class MyProcessAdapter extends ProcessAdapter {
    private boolean alreadyRun = false;

    public synchronized void run() {
      if(!alreadyRun) {
        alreadyRun = true;
        run.run();
      }
      removeProcessListener(this);
    }

    public void startNotified(ProcessEvent event) {
      run();
    }
  }
  MyProcessAdapter processListener = new MyProcessAdapter();
  addProcessListener(processListener);
  if(myExecutionResult != null) {
    if(myExecutionResult.getProcessHandler().isStartNotified()) {
      processListener.run();
    }
  }
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
protected DebuggerSession attachVM(final RemoteConnection remoteConnection, final boolean pollConnection)
        throws InvocationTargetException, InterruptedException {
  final RemoteState remoteState = new RemoteStateState(myProject, remoteConnection);

  final DebuggerSession[] debuggerSession = new DebuggerSession[1];
  UIUtil.invokeAndWaitIfNeeded(new Runnable() {
    @Override
    public void run() {
      try {
        debuggerSession[0] = attachVirtualMachine(remoteState, remoteConnection, pollConnection);
      }
      catch (ExecutionException e) {
        fail(e.getMessage());
      }
    }
  });
  debuggerSession[0].getProcess().getExecutionResult().getProcessHandler().addProcessListener(new ProcessAdapter() {
    @Override
    public void onTextAvailable(ProcessEvent event, Key outputType) {
      print(event.getText(), outputType);
    }
  });
  return debuggerSession[0];
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
@NotNull
protected OSProcessHandler startProcess() throws ExecutionException {
  final OSProcessHandler handler = JavaCommandLineStateUtil.startProcess(createCommandLine());
  ProcessTerminatedListener.attach(handler, myProject, JavadocBundle.message("javadoc.generate.exited"));
  handler.addProcessListener(new ProcessAdapter() {
    public void processTerminated(ProcessEvent event) {
      if (OPEN_IN_BROWSER) {
        File url = new File(OUTPUT_DIRECTORY, INDEX_HTML);
        if (url.exists() && event.getExitCode() == 0) {
          BrowserUtil.browse(url);
        }
      }
    }
  });
  return handler;
}
 

import com.intellij.execution.process.ProcessAdapter; //导入依赖的package包/类
public XDebugSessionTab init(final XDebugProcess process, @NotNull final XDebugSessionData sessionData) {
  LOG.assertTrue(myDebugProcess == null);
  myDebugProcess = process;
  mySessionData = sessionData;

  if (autoInitBreakpoints) {
    initBreakpoints();
  }

  myDebugProcess.getProcessHandler().addProcessListener(new ProcessAdapter() {
    @Override
    public void processTerminated(final ProcessEvent event) {
      stopImpl();
    }
  });
  //todo[nik] make 'createConsole()' method return ConsoleView
  myConsoleView = (ConsoleView)myDebugProcess.createConsole();
  if (!myShowTabOnSuspend) {
    initSessionTab();
  }

  return mySessionTab;
}