private static void addModuleNodes(
      @NotNull ExternalProjectsView externalProjectsView,
      @NotNull MultiMap<Key<?>, DataNode<?>> dataNodes,
      @NotNull List<ExternalSystemNode<?>> result) {
    final Collection<DataNode<?>> moduleDataNodes = dataNodes.get(ProjectKeys.MODULE);
    if (!moduleDataNodes.isEmpty()) {
      final AbstractExternalSystemSettings systemSettings =
          ExternalSystemApiUtil.getSettings(
              externalProjectsView.getProject(), externalProjectsView.getSystemId());

      for (DataNode<?> dataNode : moduleDataNodes) {
        final ModuleData data = (ModuleData) dataNode.getData();

        final ExternalProjectSettings projectSettings =
            systemSettings.getLinkedProjectSettings(data.getLinkedExternalProjectPath());
        final boolean isRoot =
            projectSettings != null
                && data.getLinkedExternalProjectPath()
                    .equals(projectSettings.getExternalProjectPath());
        //noinspection unchecked
        final ModuleNode moduleNode =
            new ModuleNode(externalProjectsView, (DataNode<ModuleData>) dataNode, isRoot);
        result.add(moduleNode);
      }
    }
  }
 @NotNull
 private ExternalProjectSettings getCurrentExternalProjectSettings() {
   ExternalProjectSettings result = myControl.getProjectSettings().clone();
   File externalProjectConfigFile =
       getExternalProjectConfigToUse(new File(result.getExternalProjectPath()));
   final String linkedProjectPath = FileUtil.toCanonicalPath(externalProjectConfigFile.getPath());
   assert linkedProjectPath != null;
   result.setExternalProjectPath(linkedProjectPath);
   return result;
 }
 @NotNull
 @Override
 public List<VirtualFile> findAll(@NotNull ExternalProjectSettings externalProjectSettings) {
   List<VirtualFile> list = ContainerUtil.newArrayList();
   for (String path : externalProjectSettings.getModules()) {
     VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(path));
     if (vFile != null) {
       for (VirtualFile child : vFile.getChildren()) {
         String name = child.getName();
         if (!child.isDirectory() && name.endsWith(GradleConstants.EXTENSION)) {
           list.add(child);
         }
       }
     }
   }
   return list;
 }
Exemplo n.º 4
0
  /**
   * Tries to obtain external project info implied by the given settings and link that external
   * project to the given ide project.
   *
   * @param externalSystemId target external system
   * @param projectSettings settings of the external project to link
   * @param project target ide project to link external project to
   * @param executionResultCallback it might take a while to resolve external project info, that's
   *     why it's possible to provide a callback to be notified on processing result. It receives
   *     <code>true</code> if an external project has been successfully linked to the given ide
   *     project; <code>false</code> otherwise (note that corresponding notification with error
   *     details is expected to be shown to the end-user then)
   * @param isPreviewMode flag which identifies if missing external project binaries should be
   *     downloaded
   * @param progressExecutionMode identifies how progress bar will be represented for the current
   *     processing
   */
  @SuppressWarnings("UnusedDeclaration")
  public static void linkExternalProject(
      @NotNull final ProjectSystemId externalSystemId,
      @NotNull final ExternalProjectSettings projectSettings,
      @NotNull final Project project,
      @Nullable final Consumer<Boolean> executionResultCallback,
      boolean isPreviewMode,
      @NotNull final ProgressExecutionMode progressExecutionMode) {
    ExternalProjectRefreshCallback callback =
        new ExternalProjectRefreshCallback() {
          @SuppressWarnings("unchecked")
          @Override
          public void onSuccess(@Nullable final DataNode<ProjectData> externalProject) {
            if (externalProject == null) {
              if (executionResultCallback != null) {
                executionResultCallback.consume(false);
              }
              return;
            }
            AbstractExternalSystemSettings systemSettings =
                ExternalSystemApiUtil.getSettings(project, externalSystemId);
            Set<ExternalProjectSettings> projects =
                ContainerUtilRt.newHashSet(systemSettings.getLinkedProjectsSettings());
            projects.add(projectSettings);
            systemSettings.setLinkedProjectsSettings(projects);
            ensureToolWindowInitialized(project, externalSystemId);
            ExternalSystemApiUtil.executeProjectChangeAction(
                new DisposeAwareProjectChange(project) {
                  @Override
                  public void execute() {
                    ProjectRootManagerEx.getInstanceEx(project)
                        .mergeRootsChangesDuring(
                            new Runnable() {
                              @Override
                              public void run() {
                                ProjectDataManager dataManager =
                                    ServiceManager.getService(ProjectDataManager.class);
                                dataManager.importData(
                                    externalProject.getKey(),
                                    Collections.singleton(externalProject),
                                    project,
                                    true);
                              }
                            });
                  }
                });
            if (executionResultCallback != null) {
              executionResultCallback.consume(true);
            }
          }

          @Override
          public void onFailure(@NotNull String errorMessage, @Nullable String errorDetails) {
            if (executionResultCallback != null) {
              executionResultCallback.consume(false);
            }
          }
        };
    refreshProject(
        project,
        externalSystemId,
        projectSettings.getExternalProjectPath(),
        callback,
        isPreviewMode,
        progressExecutionMode);
  }
Exemplo n.º 5
0
  /**
   * Asks to refresh all external projects of the target external system linked to the given ide
   * project based on provided spec
   *
   * @param specBuilder import specification builder
   */
  public static void refreshProjects(@NotNull final ImportSpecBuilder specBuilder) {
    ImportSpec spec = specBuilder.build();

    ExternalSystemManager<?, ?, ?, ?, ?> manager =
        ExternalSystemApiUtil.getManager(spec.getExternalSystemId());
    if (manager == null) {
      return;
    }
    AbstractExternalSystemSettings<?, ?, ?> settings =
        manager.getSettingsProvider().fun(spec.getProject());
    final Collection<? extends ExternalProjectSettings> projectsSettings =
        settings.getLinkedProjectsSettings();
    if (projectsSettings.isEmpty()) {
      return;
    }

    final ProjectDataManager projectDataManager =
        ServiceManager.getService(ProjectDataManager.class);
    final int[] counter = new int[1];

    ExternalProjectRefreshCallback callback =
        new MyMultiExternalProjectRefreshCallback(
            spec.getProject(), projectDataManager, counter, spec.getExternalSystemId());

    Map<String, Long> modificationStamps =
        manager
            .getLocalSettingsProvider()
            .fun(spec.getProject())
            .getExternalConfigModificationStamps();
    Set<String> toRefresh = ContainerUtilRt.newHashSet();
    for (ExternalProjectSettings setting : projectsSettings) {

      // don't refresh project when auto-import is disabled if such behavior needed (e.g. on project
      // opening when auto-import is disabled)
      if (!setting.isUseAutoImport() && spec.isWhenAutoImportEnabled()) continue;

      if (spec.isForceWhenUptodate()) {
        toRefresh.add(setting.getExternalProjectPath());
      } else {
        Long oldModificationStamp = modificationStamps.get(setting.getExternalProjectPath());
        long currentModificationStamp = getTimeStamp(setting, spec.getExternalSystemId());
        if (oldModificationStamp == null || oldModificationStamp < currentModificationStamp) {
          toRefresh.add(setting.getExternalProjectPath());
        }
      }
    }

    if (!toRefresh.isEmpty()) {
      ExternalSystemNotificationManager.getInstance(spec.getProject())
          .clearNotifications(null, NotificationSource.PROJECT_SYNC, spec.getExternalSystemId());

      counter[0] = toRefresh.size();
      for (String path : toRefresh) {
        refreshProject(
            spec.getProject(),
            spec.getExternalSystemId(),
            path,
            callback,
            false,
            spec.getProgressExecutionMode());
      }
    }
  }