Java RunProfile類代碼示例

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
private void addToHistory(final SMTestProxy.SMRootTestProxy root,
                          TestConsoleProperties consoleProperties,
                          Disposable parentDisposable) {
  final RunProfile configuration = consoleProperties.getConfiguration();
  if (configuration instanceof RunConfiguration && 
      !(consoleProperties instanceof ImportedTestConsoleProperties) &&
      !ApplicationManager.getApplication().isUnitTestMode() &&
      !myDisposed) {
    final MySaveHistoryTask backgroundable = new MySaveHistoryTask(consoleProperties, root, (RunConfiguration)configuration);
    final BackgroundableProcessIndicator processIndicator = new BackgroundableProcessIndicator(backgroundable);
    Disposer.register(parentDisposable, new Disposable() {
      @Override
      public void dispose() {
        processIndicator.cancel();
        backgroundable.dispose();
      }
    });
    Disposer.register(parentDisposable, processIndicator);
    ProgressManager.getInstance().runProcessWithProgressAsynchronously(backgroundable, processIndicator);
  }
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
ExecutionEnvironment(@NotNull RunProfile runProfile,
                     @NotNull Executor executor,
                     @NotNull ExecutionTarget target,
                     @NotNull Project project,
                     @Nullable RunnerSettings runnerSettings,
                     @Nullable ConfigurationPerRunnerSettings configurationSettings,
                     @Nullable RunContentDescriptor contentToReuse,
                     @Nullable RunnerAndConfigurationSettings settings,
                     @NotNull ProgramRunner<?> runner) {
  myExecutor = executor;
  myTarget = target;
  myRunProfile = runProfile;
  myRunnerSettings = runnerSettings;
  myConfigurationSettings = configurationSettings;
  myProject = project;
  setContentToReuse(contentToReuse);
  myRunnerAndConfigurationSettings = settings;

  myRunner = runner;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@NotNull
protected GlobalSearchScope initScope() {
  RunProfile configuration = getConfiguration();
  if (!(configuration instanceof ModuleRunProfile)) {
    return GlobalSearchScope.allScope(myProject);
  }

  Module[] modules = ((ModuleRunProfile)configuration).getModules();
  if (modules.length == 0) {
    return GlobalSearchScope.allScope(myProject);
  }

  GlobalSearchScope scope = GlobalSearchScope.EMPTY_SCOPE;
  for (Module each : modules) {
    scope = scope.uniteWith(GlobalSearchScope.moduleRuntimeScope(each, true));
  }
  return scope;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Nullable
public static Object getData(final AbstractTestProxy testProxy, final String dataId, final TestFrameworkRunningModel model) {
  final TestConsoleProperties properties = model.getProperties();
  final Project project = properties.getProject();
  if (testProxy == null) return null;
  if (AbstractTestProxy.DATA_KEY.is(dataId)) return testProxy;
  if (CommonDataKeys.NAVIGATABLE.is(dataId)) return getOpenFileDescriptor(testProxy, model);
  if (CommonDataKeys.PSI_ELEMENT.is(dataId)) {
    final Location location = testProxy.getLocation(project, properties.getScope());
    if (location != null) {
      final PsiElement element = location.getPsiElement();
      return element.isValid() ? element : null;
    }
    else {
      return null;
    }
  }
  if (Location.DATA_KEY.is(dataId)) return testProxy.getLocation(project, properties.getScope());
  if (RunConfiguration.DATA_KEY.is(dataId)) {
    final RunProfile configuration = properties.getConfiguration();
    if (configuration instanceof RunConfiguration) {
      return configuration;
    }
  }
  return null;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
protected void attachNotificationTo(final Content content) {
  if (myConsole instanceof ObservableConsoleView) {
    ObservableConsoleView observable = (ObservableConsoleView)myConsole;
    observable.addChangeListener(new ObservableConsoleView.ChangeListener() {
      @Override
      public void contentAdded(final Collection<ConsoleViewContentType> types) {
        if (types.contains(ConsoleViewContentType.ERROR_OUTPUT) || types.contains(ConsoleViewContentType.NORMAL_OUTPUT)) {
          content.fireAlert();
        }
      }
    }, content);
    RunProfile profile = getRunProfile();
    if (profile instanceof RunConfigurationBase && !ApplicationManager.getApplication().isUnitTestMode()) {
      observable.addChangeListener(new RunContentBuilder.ConsoleToFrontListener((RunConfigurationBase)profile,
                                                                                myProject,
                                                                                DefaultDebugExecutor.getDebugExecutorInstance(),
                                                                                myRunContentDescriptor,
                                                                                myUi),
                                   content);
    }
  }
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
public void onRunnerStateChanged(final StateEvent event) {
  if (!(event instanceof CompletionEvent)) {
    return;
  }
  final boolean areTestsFailed = myModel.getRoot().isDefect();
  final CompletionEvent completion = (CompletionEvent)event;
  final RunProfile configuration = myModel.getProperties().getConfiguration();
  if (configuration == null) {
    return;
  }
  if (testsTerminatedAndNotFailed(completion, areTestsFailed)) return;

  if (completion.isNormalExit()) {
    LvcsHelper.addLabel(myModel);
  }
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Nullable
@Override
public ExecutionResult execute(Executor executor, @NotNull ProgramRunner runner) throws ExecutionException {
  RunProfile profile = myEnvironment.getRunProfile();
  if (profile instanceof AntRunConfiguration) {
    AntRunConfiguration antRunConfiguration = (AntRunConfiguration)profile;
    AntBuildTarget target = antRunConfiguration.getTarget();
    if (target == null) return null;
    ProcessHandler processHandler = ExecutionHandler
      .executeRunConfiguration(antRunConfiguration, myEnvironment.getDataContext(), new ArrayList<BuildFileProperty>(),
                               new AntBuildListener() {
                                 @Override
                                 public void buildFinished(int state, int errorCount) {

                                 }
                               });
    if (processHandler == null) return null;
    return new DefaultExecutionResult(null, processHandler);
  }
  return null;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Override
public boolean ensureRunnerConfigured(@Nullable Module module, RunProfile profile, Executor executor, final Project project) {
  if (GantUtils.getSDKInstallPath(module, project).isEmpty()) {
    int result = Messages
      .showOkCancelDialog("Gant is not configured. Do you want to configure it?", "Configure Gant SDK",
                          JetgroovyIcons.Groovy.Gant_16x16);
    if (result == Messages.OK) {
      ShowSettingsUtil.getInstance().editConfigurable(project, new GantConfigurable(project));
    }
    if (GantUtils.getSDKInstallPath(module, project).isEmpty()) {
      return false;
    }
  }

  return true;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Nullable
private CoverageSuitesBundle getCurrentCoverageSuite() {
  if (myModel == null) {
    return null;
  }

  final RunProfile runConf = myModel.getProperties().getConfiguration();
  if (runConf instanceof ModuleBasedConfiguration) {

    // if coverage supported for run configuration
    if (CoverageEnabledConfiguration.isApplicableTo((ModuleBasedConfiguration) runConf)) {

      // Get coverage settings
      Executor executor = myProperties.getExecutor();
      if (executor != null && executor.getId().equals(CoverageExecutor.EXECUTOR_ID)) {
        return CoverageDataManager.getInstance(myProperties.getProject()).getCurrentSuitesBundle();
      }
    }
  }
  return null;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Override
public boolean canRun(String executorId, RunProfile profile) {
  BlazeAndroidRunConfigurationHandler handler =
      BlazeAndroidRunConfigurationHandler.getHandlerFrom(profile);
  if (handler == null) {
    return false;
  }
  // In practice, the stock runner will probably handle all non-incremental-install configs.
  if (DefaultDebugExecutor.EXECUTOR_ID.equals(executorId)
      || DefaultRunExecutor.EXECUTOR_ID.equals(executorId)) {
    return true;
  }
  // Otherwise, the configuration must be a Blaze incremental install configuration running with
  // an incremental install executor.
  if (!(handler instanceof BlazeAndroidBinaryRunConfigurationHandler)) {
    return false;
  }
  AndroidBinaryLaunchMethod launchMethod =
      ((BlazeAndroidBinaryRunConfigurationHandler) handler).getState().getLaunchMethod();
  return (AndroidBinaryLaunchMethod.MOBILE_INSTALL.equals(launchMethod)
          || AndroidBinaryLaunchMethod.MOBILE_INSTALL_V2.equals(launchMethod))
      && (IncrementalInstallDebugExecutor.EXECUTOR_ID.equals(executorId)
          || IncrementalInstallRunExecutor.EXECUTOR_ID.equals(executorId));
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
public static boolean isApplicableTo(RunProfile runProfile) {
  BlazeCommandRunConfiguration config = toBlazeConfig(runProfile);
  if (config == null) {
    return false;
  }
  if (Blaze.getBuildSystem(config.getProject()) != BuildSystem.Blaze) {
    // temporarily disable coverage for Bazel, until we properly interface with its API and output
    // file locations
    return false;
  }
  BlazeCommandRunConfigurationCommonState handlerState =
      config.getHandlerStateIfType(BlazeCommandRunConfigurationCommonState.class);
  if (handlerState == null) {
    return false;
  }
  BlazeCommandName command = handlerState.getCommandState().getCommand();
  return BlazeCommandName.TEST.equals(command) || BlazeCommandName.COVERAGE.equals(command);
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Nullable
static HotSwappableDebugSession findHotSwappableBlazeDebuggerSession(Project project) {
  DebuggerManagerEx debuggerManager = DebuggerManagerEx.getInstanceEx(project);
  DebuggerSession session = debuggerManager.getContext().getDebuggerSession();
  if (session == null || !session.isAttached()) {
    return null;
  }
  JavaDebugProcess process = session.getProcess().getXdebugProcess();
  if (process == null) {
    return null;
  }
  ExecutionEnvironment env = ((XDebugSessionImpl) process.getSession()).getExecutionEnvironment();
  if (env == null || ClassFileManifestBuilder.getManifest(env) == null) {
    return null;
  }
  RunProfile runProfile = env.getRunProfile();
  if (!(runProfile instanceof BlazeCommandRunConfiguration)) {
    return null;
  }
  return new HotSwappableDebugSession(session, env, (BlazeCommandRunConfiguration) runProfile);
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
/** Get all the background snapshot states. */
public List<CloudDebugProcessState> getBackgroundListeningStates() {
  List<CloudDebugProcessState> states = new ArrayList<CloudDebugProcessState>();

  for (Project project : ProjectManager.getInstance().getOpenProjects()) {
    Set<RunProfile> runningProfiles = getProfilesWithActiveDebugSession(project);

    RunManager manager = RunManager.getInstance(project);

    // find all CloudDebugRunConfiguration that do not have active debug sessions but are
    // listening in the background
    for (final RunnerAndConfigurationSettings config : manager.getAllSettings()) {
      if (notRunningConfiguration(runningProfiles, config.getConfiguration())) {
        if (config.getConfiguration() instanceof CloudDebugRunConfiguration) {
          final CloudDebugRunConfiguration cloudConfig =
              (CloudDebugRunConfiguration) config.getConfiguration();
          CloudDebugProcessState state = cloudConfig.getProcessState();
          if (listensInBackground(state)) {
            states.add(state);
          }
        }
      }
    }
  }
  return states;
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Override
public void stop() {
  getStateController().stopBackgroundListening();

  RunProfile profile = getXDebugSession().getRunProfile();
  if (profile instanceof CloudDebugRunConfiguration) {
    ((CloudDebugRunConfiguration) profile).setProcessState(processState);
  }

  getRepositoryValidator().restoreToOriginalState(getXDebugSession().getProject());

  XBreakpointManager breakpointManager =
      XDebuggerManager.getInstance(getXDebugSession().getProject()).getBreakpointManager();
  for (XBreakpoint bp : breakpointManager.getAllBreakpoints()) {
    com.intellij.debugger.ui.breakpoints.Breakpoint cloudBreakpoint =
        BreakpointManager.getJavaBreakpoint(bp);
    if (!(cloudBreakpoint instanceof CloudLineBreakpointType.CloudLineBreakpoint)) {
      continue;
    }
    CloudLineBreakpointType.CloudLineBreakpoint cloudLineBreakpoint =
        (CloudLineBreakpointType.CloudLineBreakpoint) cloudBreakpoint;
    cloudLineBreakpoint.setVerified(false);
    cloudLineBreakpoint.setErrorMessage(null);
    updateBreakpointPresentation(cloudLineBreakpoint);
  }
}
 

import com.intellij.execution.configurations.RunProfile; //導入依賴的package包/類
@Test
public void testGetProfilesWithActiveDebugSession_returnsNotStoppedSessionsWithRunProfile() {
  Project project = mock(Project.class);

  XDebugSession notStoppedSession =
      createMockSession(false, mock(CloudDebugRunConfiguration.class));
  XDebugSession stoppedSession = createMockSession(true, mock(CloudDebugRunConfiguration.class));
  XDebugSession stoppedSessionWithoutRunProfile = createMockSession(true, null);

  createMockXDebuggerManager(
      project,
      new XDebugSession[] {notStoppedSession, stoppedSession, stoppedSessionWithoutRunProfile});

  Set<RunProfile> profiles =
      new CloudDebugProcessStateCollector().getProfilesWithActiveDebugSession(project);

  assertNotNull(profiles);
  assertThat(profiles).hasSize(1);
}