Java Code Examples for com.intellij.openapi.progress.ProgressManager

public void actionPerformed(AnActionEvent e) {
    Project project = e.getProject();

    if (project != null) {
        for (Module module : ModuleManager.getInstance(project).getModules()) {
            if (ModuleType.get(module) instanceof DWModuleType) {
                ModuleServiceManager.getService(module, DWServerConnection.class);
                ProgressManager.getInstance().run(
                        new DWCleanTask(project, module, "Cleaning cartridges...", true, PerformInBackgroundOption.ALWAYS_BACKGROUND)
                );

            }
        }
    }

}
 

private void refreshFile(VcsFileRevision revision) {
  Runnable refresh = null;
  final VirtualFile vf = getVirtualFile();
  if (vf == null) {
    final LocalHistoryAction action = startLocalHistoryAction(revision);
    final VirtualFile vp = myFilePath.getVirtualFileParent();
    if (vp != null) {
      refresh = () -> vp.refresh(false, true, action::finish);
    }
  }
  else {
    refresh = () -> vf.refresh(false, false);
  }
  if (refresh != null) {
    ProgressManager.getInstance().runProcessWithProgressSynchronously(refresh, "Refreshing Files...", false, myVcs.getProject());
  }
}
 

private static boolean processFile(@Nonnull final VirtualFile vFile,
                                   @Nonnull final PsiElementVisitor visitor,
                                   @Nonnull final PsiManager psiManager,
                                   final boolean needReadAction,
                                   final boolean clearResolveCache) {
  final Runnable runnable = new Runnable() {
    @Override
    public void run() {
      doProcessFile(visitor, psiManager, vFile, clearResolveCache);
    }
  };
  if (needReadAction && !ApplicationManager.getApplication().isDispatchThread()) {
    commitAndRunInSmartMode(runnable, psiManager.getProject());
  }
  else {
    runnable.run();
  }
  final ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  return indicator == null || !indicator.isCanceled();
}
 

private boolean isToBeHighlighted(@Nullable VirtualFile virtualFile) {
  if (virtualFile == null) return false;

  synchronized (myFilters) {
    if (!myFiltersLoaded) {
      myFiltersLoaded = true;
      myFilters.addAll(Arrays.asList(FILTER_EP_NAME.getExtensions(myProject)));
    }
  }
  for (final Condition<VirtualFile> filter : myFilters) {
    ProgressManager.checkCanceled();
    if (filter.value(virtualFile)) {
      return true;
    }
  }

  return false;
}
 

static int processUsagesInFile(@Nonnull final PsiFile psiFile, @Nonnull final VirtualFile virtualFile, @Nonnull final FindModel findModel, @Nonnull final Processor<? super UsageInfo> consumer) {
  if (findModel.getStringToFind().isEmpty()) {
    if (!ReadAction.compute(() -> consumer.process(new UsageInfo(psiFile)))) {
      throw new ProcessCanceledException();
    }
    return 1;
  }
  if (virtualFile.getFileType().isBinary()) return 0; // do not decompile .class files
  final Document document = ReadAction.compute(() -> virtualFile.isValid() ? FileDocumentManager.getInstance().getDocument(virtualFile) : null);
  if (document == null) return 0;
  final int[] offset = {0};
  int count = 0;
  int found;
  ProgressIndicator indicator = ProgressWrapper.unwrap(ProgressManager.getInstance().getProgressIndicator());
  TooManyUsagesStatus tooManyUsagesStatus = TooManyUsagesStatus.getFrom(indicator);
  do {
    tooManyUsagesStatus.pauseProcessingIfTooManyUsages(); // wait for user out of read action
    found = ReadAction.compute(() -> {
      if (!psiFile.isValid()) return 0;
      return addToUsages(document, findModel, psiFile, offset, USAGES_PER_READ_ACTION, consumer);
    });
    count += found;
  }
  while (found != 0);
  return count;
}
 

protected void acceptDirectory(final VirtualFile file, final String fileRoot, final String filePath) {
  ProgressManager.checkCanceled();
  final VirtualFile[] children = file.getChildren();
  for (final VirtualFile child : children) {
    final String name = child.getName();
    final String _filePath;
    final StringBuilder buf = StringBuilderSpinAllocator.alloc();
    try {
      buf.append(filePath).append("/").append(name);
      _filePath = buf.toString();
    }
    finally {
      StringBuilderSpinAllocator.dispose(buf);
    }
    accept(child, fileRoot, _filePath);
  }
}
 

/**
 * Run the given computation with its execution time restricted to the given amount of time in milliseconds.<p></p>
 * <p>
 * Internally, it creates a new {@link ProgressIndicator}, runs the computation with that indicator and cancels it after the the timeout.
 * The computation should call {@link ProgressManager#checkCanceled()} frequently enough, so that after the timeout has been exceeded
 * it can stop the execution by throwing {@link ProcessCanceledException}, which will be caught by this {@code withTimeout}.<p></p>
 * <p>
 * If a {@link ProcessCanceledException} happens due to any other reason (e.g. a thread's progress indicator got canceled),
 * it'll be thrown out of this method.
 *
 * @return the computation result or {@code null} if timeout has been exceeded.
 */
@Nullable
public static <T> T withTimeout(long timeoutMs, @Nonnull Computable<T> computation) {
  ProgressManager.checkCanceled();
  ProgressIndicator outer = ProgressIndicatorProvider.getGlobalProgressIndicator();
  ProgressIndicator inner = outer != null ? new SensitiveProgressWrapper(outer) : new ProgressIndicatorBase(false, false);
  AtomicBoolean canceledByTimeout = new AtomicBoolean();
  ScheduledFuture<?> cancelProgress = AppExecutorUtil.getAppScheduledExecutorService().schedule(() -> {
    canceledByTimeout.set(true);
    inner.cancel();
  }, timeoutMs, TimeUnit.MILLISECONDS);
  try {
    return ProgressManager.getInstance().runProcess(computation, inner);
  }
  catch (ProcessCanceledException e) {
    if (canceledByTimeout.get()) {
      return null;
    }
    throw e; // canceled not by timeout
  }
  finally {
    cancelProgress.cancel(false);
  }
}
 

public void execute(ClassEntity targetClass) {
        this.targetClass = targetClass;
        ProgressManager.getInstance().run(new Task.Backgroundable(project, "GsonFormat") {

            @Override
            public void run(@NotNull ProgressIndicator progressIndicator) {
                progressIndicator.setIndeterminate(true);
                long currentTimeMillis = System.currentTimeMillis();
                execute();
                progressIndicator.setIndeterminate(false);
                progressIndicator.setFraction(1.0);
                StringBuffer sb = new StringBuffer();
                sb.append("GsonFormat [" + (System.currentTimeMillis() - currentTimeMillis) + " ms]\n");
//                sb.append("generate class : ( "+generateClassList.size()+" )\n");
//                for (String item: generateClassList) {
//                    sb.append("    at "+item+"\n");
//                }
//                sb.append("  \n");
//                NotificationCenter.info(sb.toString());
                Toast.make(project, MessageType.INFO, sb.toString());
            }
        });
    }
 

public static void reparseProjectFiles(@NotNull final Project project) {
  Task.Backgroundable task = new Task.Backgroundable(project, HaxeBundle.message("haxe.project.reparsing"), false) {
    public void run(@NotNull ProgressIndicator indicator) {
      final Collection<VirtualFile> haxeFiles = new ArrayList<VirtualFile>();
      final VirtualFile baseDir = project.getBaseDir();
      if (baseDir != null) {
        FileBasedIndex.getInstance().iterateIndexableFiles(new ContentIterator() {
          public boolean processFile(VirtualFile file) {
            if (HaxeFileType.HAXE_FILE_TYPE == file.getFileType()) {
              haxeFiles.add(file);
            }
            return true;
          }
        }, project, indicator);
      }
      ApplicationManager.getApplication().invokeAndWait(new Runnable() {
        public void run() {
          FileContentUtil.reparseFiles(project, haxeFiles, !project.isDefault());
        }
      }, ModalityState.NON_MODAL);
    }
  };
  ProgressManager.getInstance().run(task);
}
 

/**
 * Finds duplicates of the code fragment specified in the finder in given scopes.
 * Note that in contrast to {@link #processDuplicates} the search is performed synchronously because normally you need the results in
 * order to complete the refactoring. If user cancels it, empty list will be returned.
 *
 * @param finder          finder object to seek for duplicates
 * @param searchScopes    scopes where to look them in
 * @param generatedMethod new method that should be excluded from the search
 * @return list of discovered duplicate code fragments or empty list if user interrupted the search
 * @see #replaceDuplicates(PsiElement, Editor, Consumer, List)
 */
@Nonnull
public static List<SimpleMatch> collectDuplicates(@Nonnull SimpleDuplicatesFinder finder,
                                                  @Nonnull List<PsiElement> searchScopes,
                                                  @Nonnull PsiElement generatedMethod) {
  final Project project = generatedMethod.getProject();
  try {
    //noinspection RedundantCast
    return ProgressManager.getInstance().runProcessWithProgressSynchronously(
            (ThrowableComputable<List<SimpleMatch>, RuntimeException>)() -> {
              ProgressManager.getInstance().getProgressIndicator().setIndeterminate(true);
              ThrowableComputable<List<SimpleMatch>, RuntimeException> action = () -> finder.findDuplicates(searchScopes, generatedMethod);
              return AccessRule.read(action);
            }, RefactoringBundle.message("searching.for.duplicates"), true, project);
  }
  catch (ProcessCanceledException e) {
    return Collections.emptyList();
  }
}
 

@Nullable
private static WorkspacePath findBlazePackagePath(Project project, WorkspacePath source) {
  WorkspacePathResolver pathResolver =
      WorkspacePathResolverProvider.getInstance(project).getPathResolver();
  if (pathResolver == null) {
    return null;
  }
  BuildSystemProvider provider = Blaze.getBuildSystemProvider(project);
  while (source != null) {
    ProgressManager.checkCanceled();
    if (provider.findBuildFileInDirectory(pathResolver.resolveToFile(source)) != null) {
      return source;
    }
    source = source.getParent();
  }
  return null;
}
 

@Nonnull
private File copyToMirror(@Nonnull File original, @Nonnull File mirror) {
  ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
  if (progress != null) {
    progress.pushState();
    progress.setText(VfsBundle.message("jar.copy.progress", original.getPath()));
    progress.setFraction(0);
  }

  try {
    FileUtil.copy(original, mirror);
  }
  catch (final IOException e) {
    reportIOErrorWithJars(original, mirror, e);
    return original;
  }
  finally {
    if (progress != null) {
      progress.popState();
    }
  }


  return mirror;
}
 

public static boolean wrap(final ThrowableRunnable<VcsException> runnable, final Project project, final String title) {
  final VcsException[] exc = new VcsException[1];
  final Runnable process = new Runnable() {
    @Override
    public void run() {
      try {
        runnable.run();
      }
      catch (VcsException e) {
        exc[0] = e;
      }
    }
  };
  final boolean notCanceled;
  if (ApplicationManager.getApplication().isDispatchThread()) {
    notCanceled = ProgressManager.getInstance().runProcessWithProgressSynchronously(process, title, true, project);
  } else {
    process.run();
    notCanceled = true;
  }
  if (exc[0] != null) {
    AbstractVcsHelper.getInstance(project).showError(exc[0], title);
    return false;
  }
  return notCanceled;
}
 

public void unshelveSilentlyAsynchronously(@Nonnull final Project project,
                                           @Nonnull final List<ShelvedChangeList> selectedChangeLists,
                                           @Nonnull final List<ShelvedChange> selectedChanges,
                                           @Nonnull final List<ShelvedBinaryFile> selectedBinaryChanges,
                                           @Nullable final LocalChangeList forcePredefinedOneChangelist) {
  ProgressManager.getInstance().run(new Task.Backgroundable(project, VcsBundle.message("unshelve.changes.progress.title"), true) {
    @Override
    public void run(@Nonnull ProgressIndicator indicator) {
      for (ShelvedChangeList changeList : selectedChangeLists) {
        List<ShelvedChange> changesForChangelist = ContainerUtil.newArrayList(ContainerUtil.intersection(changeList.getChanges(myProject), selectedChanges));
        List<ShelvedBinaryFile> binariesForChangelist =
                ContainerUtil.newArrayList(ContainerUtil.intersection(changeList.getBinaryFiles(), selectedBinaryChanges));
        boolean shouldUnshelveAllList = changesForChangelist.isEmpty() && binariesForChangelist.isEmpty();
        unshelveChangeList(changeList, shouldUnshelveAllList ? null : changesForChangelist, shouldUnshelveAllList ? null : binariesForChangelist,
                           forcePredefinedOneChangelist != null ? forcePredefinedOneChangelist : getChangeListUnshelveTo(changeList), true);
      }
    }
  });
}
 

/**
 *
 * @param element
 * @param editor
 * @return For the case the search has been cancelled
 */
@Nullable
protected PsiElement[] searchDefinitions(PsiElement element, Editor editor) {
  PsiElement[][] result = new PsiElement[1][];
  if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(() -> {
    try {
      result[0] = search(element, editor).toArray(PsiElement.EMPTY_ARRAY);
    }
    catch (IndexNotReadyException e) {
      dumbModeNotification(element);
      result[0] = null;
    }
  }, SEARCHING_FOR_IMPLEMENTATIONS, true, element.getProject())) {
    return null;
  }
  return result[0];
}
 

@Override
protected void fireModulesAdded() {
  Runnable runnableWithProgress = () -> {
    for (final Module module : myModuleModel.getModules()) {
      final Application app = ApplicationManager.getApplication();
      final Runnable swingRunnable = () -> fireModuleAddedInWriteAction(module);
      if (app.isDispatchThread() || app.isHeadlessEnvironment()) {
        swingRunnable.run();
      }
      else {
        ProgressIndicator pi = ProgressManager.getInstance().getProgressIndicator();
        app.invokeAndWait(swingRunnable, pi.getModalityState());
      }
    }
  };

  ProgressIndicator progressIndicator = myProgressManager.getProgressIndicator();
  if (progressIndicator == null) {
    myProgressManager.runProcessWithProgressSynchronously(runnableWithProgress, "Loading modules", false, myProject);
  }
  else {
    runnableWithProgress.run();
  }
}
 

@Override
public boolean processTextOccurrence(@Nonnull PsiElement element, int offsetInElement, @Nonnull final Processor<? super PsiReference> consumer) {
  if (!myTarget.isValid()) {
    return false;
  }

  final List<PsiReference> references = ourReferenceService.getReferences(element, new PsiReferenceService.Hints(myTarget, offsetInElement));
  //noinspection ForLoopReplaceableByForEach
  for (int i = 0; i < references.size(); i++) {
    PsiReference ref = references.get(i);
    ProgressManager.checkCanceled();
    if (ReferenceRange.containsOffsetInElement(ref, offsetInElement) && ref.isReferenceTo(myTarget) && !consumer.process(ref)) {
      return false;
    }
  }
  return true;
}
 

@Override
public void startBackgroundTask(@Nonnull final MMDPrintPanel source, @Nonnull final String taskName, @Nonnull final Runnable task) {
  final Task.Backgroundable backgroundTask = new Task.Backgroundable(this.project, taskName) {
    @Override
    public void run(@Nonnull final ProgressIndicator indicator) {
      try {
        indicator.setIndeterminate(true);
        task.run();
        IdeaUtils.showPopup(String.format("%s has been sent to the printer", taskName), MessageType.INFO);
      } catch (Exception ex) {
        LOGGER.error("Print error", ex);
        IdeaUtils.showPopup("Print error! See the log!", MessageType.ERROR);
      } finally {
        indicator.stop();
      }
    }
  };
  ProgressManager.getInstance().run(backgroundTask);
}
 

public static void withBatchUpdate(Runnable runnable, CompletionProcess process) {
  if (ourIsInBatchUpdate.get().booleanValue() || !(process instanceof CompletionProgressIndicator)) {
    runnable.run();
    return;
  }

  try {
    ourIsInBatchUpdate.set(Boolean.TRUE);
    runnable.run();
    ProgressManager.checkCanceled();
    CompletionProgressIndicator currentIndicator = (CompletionProgressIndicator)process;
    CompletionThreadingBase threading = Objects.requireNonNull(currentIndicator.getCompletionThreading());
    threading.flushBatchResult(currentIndicator);
  }
  finally {
    ourIsInBatchUpdate.set(Boolean.FALSE);
  }
}
 

public static void runAfterCompilationCheck(Task.Backgroundable afterCompilationBackgroundable,
                                            Project project, ProjectInfo projectInfo) {
    final Task.Backgroundable compilationBackgroundable = new Task.Backgroundable(project, IntelliJDeodorantBundle.message("project.compiling.indicator.text"), true) {
        @Override
        public void run(@NotNull ProgressIndicator indicator) {
            runAfterCompilationCheck(projectInfo, afterCompilationBackgroundable);
        }
    };

    ProgressManager.getInstance().run(compilationBackgroundable);
}
 

private void delegateCommitToVcsThread(final GeneralCommitProcessor processor) {
  final ProgressIndicator indicator = new DelegatingProgressIndicator();

  final Semaphore endSemaphore = new Semaphore();
  endSemaphore.down();

  ChangeListManagerImpl.getInstanceImpl(myProject).executeOnUpdaterThread(new Runnable() {
    @Override
    public void run() {
      indicator.setText("Performing VCS commit...");
      try {
        ProgressManager.getInstance().runProcess(new Runnable() {
          @Override
          public void run() {
            indicator.checkCanceled();
            generalCommit(processor);
          }
        }, indicator);
      }
      finally {
        endSemaphore.up();
      }
    }
  });

  indicator.setText("Waiting for VCS background tasks to finish...");
  while (!endSemaphore.waitFor(20)) {
    indicator.checkCanceled();
  }
}
 

@Nonnull
private static CallbackData createInteractive(@Nonnull Project project,
                                              @Nonnull InvokeAfterUpdateMode mode,
                                              @Nonnull Runnable afterUpdate,
                                              String title,
                                              @Nullable ModalityState state) {
  Task task = mode.isSynchronous()
              ? new Waiter(project, afterUpdate, title, mode.isCancellable())
              : new FictiveBackgroundable(project, afterUpdate, title, mode.isCancellable(), state);
  Runnable callback = () -> {
    logUpdateFinished(project, mode);
    setDone(task);
  };
  return new CallbackData(callback, () -> ProgressManager.getInstance().run(task));
}
 

private static void checkProgressAndReadAction(final List<Object> objects,
                                               final DaemonProgressIndicator progress,
                                               final boolean runInReadAction) throws Throwable {
  final AtomicReference<Throwable> exception = new AtomicReference<Throwable>();
  JobLauncher.getInstance().invokeConcurrentlyUnderProgress(objects, progress, runInReadAction, new Processor<Object>() {
    @Override
    public boolean process(Object o) {
      try {
        if (objects.size() <= 1 || JobSchedulerImpl.getCPUCoresCount() <= 2) {
          assertTrue(ApplicationManager.getApplication().isDispatchThread());
        }
        else {
          // generally we know nothing about current thread since FJP can help others task to execute while in current context
        }
        ProgressIndicator actualIndicator = ProgressManager.getInstance().getProgressIndicator();
        assertTrue(actualIndicator instanceof SensitiveProgressWrapper);
        actualIndicator = ((SensitiveProgressWrapper)actualIndicator).getOriginalProgressIndicator();
        if (progress != null) {
          assertSame(progress, actualIndicator);
        }
        else {
          assertNotNull(actualIndicator);
        }
        // there can be read access even if we didn't ask for it (e.g. when task under read action steals others work)
        assertTrue(!runInReadAction || ApplicationManager.getApplication().isReadAccessAllowed());
      }
      catch (Throwable e) {
        exception.set(e);
      }
      return true;
    }
  });
  if (exception.get() != null) throw exception.get();
}
 

@Override
public void generateProject(@NotNull final Project project, final @NotNull VirtualFile baseDir, final @NotNull ShopwareInstallerSettings settings, @NotNull Module module) {

    String downloadPath = settings.getVersion().getUrl();
    String toDir = baseDir.getPath();

    VirtualFile zipFile = PhpConfigurationUtil.downloadFile(project, null, toDir, downloadPath, "shopware.zip");

    if (zipFile == null) {
        showErrorNotification(project, "Cannot download Shopware.zip file");
        return;
    }

    // Convert files
    File zip = VfsUtil.virtualToIoFile(zipFile);
    File base = VfsUtil.virtualToIoFile(baseDir);

    Task.Backgroundable task = new Task.Backgroundable(project, "Extracting", true) {
        @Override
        public void run(@NotNull ProgressIndicator progressIndicator) {

            try {
                // unzip file
                ZipUtil.extract(zip, base, null);

                // Delete TMP File
                FileUtil.delete(zip);

                // Activate Plugin
                IdeHelper.enablePluginAndConfigure(project);
            } catch (IOException e) {
                showErrorNotification(project, "There is a error occurred");
            }
        }
    };

    ProgressManager.getInstance().run(task);
}
 

void invalidate() {
  final List<String> componentNames = new ArrayList<>(componentNameToClass.keySet());
  LOG.debug("Invalidating " + componentNames);
  if (componentNames.isEmpty()) return;
  IntervalLogger logger = new IntervalLogger(LOG);

  ProgressManager.getInstance()
      .run(
          new Task.Backgroundable(project, "Invalidating In-Memory Files") {
            @Override
            public void run(ProgressIndicator indicator) {
              indicator.setIndeterminate(false);
              for (int i = 0, size = componentNames.size(); i < size; i++) {
                indicator.setFraction(((double) i + 1) / size);
                indicator.setText2(i + 1 + "/" + size);
                String clsName = componentNames.get(i);
                AtomicBoolean found = new AtomicBoolean(false);
                ReadAction.run(
                    () -> {
                      final boolean foundCls =
                          Arrays.stream(PsiSearchUtils.findClasses(project, clsName))
                              .anyMatch(cls -> !ComponentScope.contains(cls.getContainingFile()));
                      found.set(foundCls);
                    });
                if (found.get()) {
                  logger.logStep("removing " + clsName);
                  componentNameToClass.remove(clsName);
                } else {
                  logger.logStep("keeping " + clsName);
                }
              }
            }
          });
}
 

@RequiredReadAction
private static Collection<CustomRegionTreeElement> collectCustomRegions(@Nonnull PsiElement rootElement, @Nonnull Set<? extends TextRange> ranges) {
  TextRange rootRange = getTextRange(rootElement);
  Iterator<PsiElement> iterator =
          SyntaxTraverser.psiTraverser(rootElement).filter(element -> isCustomRegionCommentCandidate(element) && rootRange.contains(element.getTextRange()) && !isInsideRanges(element, ranges)).iterator();

  List<CustomRegionTreeElement> customRegions = new SmartList<>();
  CustomRegionTreeElement currRegionElement = null;
  CustomFoldingProvider provider = null;
  while (iterator.hasNext()) {
    ProgressManager.checkCanceled();
    PsiElement child = iterator.next();
    if (provider == null) provider = getProvider(child);
    if (provider != null) {
      String commentText = child.getText();
      if (provider.isCustomRegionStart(commentText)) {
        if (currRegionElement == null) {
          currRegionElement = new CustomRegionTreeElement(child, provider);
          customRegions.add(currRegionElement);
        }
        else {
          currRegionElement = currRegionElement.createNestedRegion(child);
        }
      }
      else if (provider.isCustomRegionEnd(commentText) && currRegionElement != null) {
        currRegionElement = currRegionElement.endRegion(child);
      }
    }
  }
  return customRegions;
}
 

public static void checkInspectionsDuplicates(@Nonnull InspectionToolWrapper[] toolWrappers) {
  if (alreadyChecked) return;
  alreadyChecked = true;
  Set<InspectionProfileEntry> uniqTools = new THashSet<InspectionProfileEntry>(toolWrappers.length);
  for (InspectionToolWrapper toolWrapper : toolWrappers) {
    ProgressManager.checkCanceled();
    if (!uniqTools.add(toolWrapper.getTool())) {
      LOG.error("Inspection " + toolWrapper.getDisplayName() + " (" + toolWrapper.getTool().getClass() + ") already registered");
    }
  }
}
 

@Override
public void actionPerformed(AnActionEvent e) {
  final Project project = e.getData(CommonDataKeys.PROJECT);
  final DirectoryIndex index = DirectoryIndex.getInstance(project);
  if (project != null) {
    final VirtualFile root = e.getData(PlatformDataKeys.VIRTUAL_FILE);
    ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
      @Override
      public void run() {
        final ContentIterator contentIterator = new ContentIterator() {
          @Override
          public boolean processFile(VirtualFile fileOrDir) {
            LOG.info(fileOrDir.getPath());

            final DirectoryInfo directoryInfo = index.getInfoForDirectory(fileOrDir);
            if (directoryInfo != null) {
              LOG.info(directoryInfo.toString());
            }
            return true;
          }
        };
        if (root != null) {
          ProjectRootManager.getInstance(project).getFileIndex().iterateContentUnderDirectory(root, contentIterator);
        } else {
          ProjectRootManager.getInstance(project).getFileIndex().iterateContent(contentIterator);
        }
      }
    }, "Dumping directory index", true, project);
  }
}
 

private String parsePortByLogcatWithTimeout(Project project, String adbPath) {
    final String[] parsedPort = new String[1];
    ProgressManager.getInstance().
            runProcessWithProgressSynchronously(new Runnable() {
                public void run() {
                    ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator();
                    progressIndicator.setIndeterminate(false);
                    progressIndicator.setFraction(0.3);
                    mLogger.info("parsePortByLogcatWithTimeout start parsing");
                    Future<String> result = mExecutorService.submit(new Callable<String>() {
                        @Override
                        public String call() throws Exception {
                            return parsePortByLogcat(adbPath, progressIndicator);
                        }
                    });
                    mLogger.info("parsePortByLogcatWithTimeout wait parsing");
                    try {
                        parsedPort[0] = result.get(5, TimeUnit.SECONDS);
                        mLogger.info("parsePortByLogcatWithTimeout wait end,get parsed port:" + parsedPort[0]);
                    } catch (Throwable e) {
                        e.printStackTrace();
                        mLogger.info("parsePortByLogcatWithTimeout wait end, timeout.");
                    }
                    progressIndicator.setFraction(1.0);
                }
            }, "Parsing Port, Wait For 5 Seconds...", true, project);
    mLogger.info("parsePortByLogcatWithTimeout return");
    return parsedPort[0];
}
 

private void counting() {
  myTotalFileCount++;
  ProgressIndicator indicator = ProgressManager.getInstance().getProgressIndicator();
  if (indicator != null) {
    update(indicator, true, -1);
  }
}