com.intellij.openapi.externalSystem.model.ProjectSystemId Java Examples

@RequiredUIAccess
@Override
public void actionPerformed(@Nonnull AnActionEvent e) {
  ProjectSystemId externalSystemId = e.getDataContext().getData(ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID);
  if (externalSystemId == null) {
    return;
  }

  ExternalSystemManager<?, ?, ?, ?, ?> manager = ExternalSystemApiUtil.getManager(externalSystemId);
  if (manager == null) {
    return;
  }

  Project project = e.getDataContext().getData(CommonDataKeys.PROJECT);
  if (project == null) {
    return;
  }

  ImportModuleAction.executeImportAction(project, manager.getExternalProjectDescriptor());
}
 

/**
 * @return gradle api facade to use
 * @throws Exception    in case of inability to return the facade
 */
@Nonnull
public RemoteExternalSystemFacade getFacade(@javax.annotation.Nullable Project project,
                                            @Nonnull String externalProjectPath,
                                            @Nonnull ProjectSystemId externalSystemId) throws Exception
{
  if (project == null) {
    project = ProjectManager.getInstance().getDefaultProject();
  }
  IntegrationKey key = new IntegrationKey(project, externalSystemId, externalProjectPath);
  final RemoteExternalSystemFacade facade = myFacadeWrappers.get(key);
  if (facade == null) {
    final RemoteExternalSystemFacade newFacade = (RemoteExternalSystemFacade)Proxy.newProxyInstance(
      ExternalSystemFacadeManager.class.getClassLoader(), new Class[]{RemoteExternalSystemFacade.class, Consumer.class},
      new MyHandler(key)
    );
    myFacadeWrappers.putIfAbsent(key, newFacade);
  }
  return myFacadeWrappers.get(key);
}
 

private static void collapseIfPossible(@Nonnull final Editor editor,
                                       @Nonnull ProjectSystemId externalSystemId,
                                       @Nonnull Project project)
{
  ExternalSystemManager<?,?,?,?,?> manager = ExternalSystemApiUtil.getManager(externalSystemId);
  assert manager != null;
  final AbstractExternalSystemLocalSettings settings = manager.getLocalSettingsProvider().fun(project);
  final ExternalSystemUiAware uiAware = ExternalSystemUiUtil.getUiAware(externalSystemId);

  String rawText = editor.getDocument().getText();
  for (Map.Entry<ExternalProjectPojo, Collection<ExternalProjectPojo>> entry : settings.getAvailableProjects().entrySet()) {
    if (entry.getKey().getPath().equals(rawText)) {
      collapse(editor, uiAware.getProjectRepresentationName(entry.getKey().getPath(), null));
      return;
    }
    for (ExternalProjectPojo pojo : entry.getValue()) {
      if (pojo.getPath().equals(rawText)) {
        collapse(editor, uiAware.getProjectRepresentationName(pojo.getPath(), entry.getKey().getPath()));
        return;
      }
    }
  }
}
 

public ExternalProjectPathField(@Nonnull Project project,
                                @Nonnull ProjectSystemId externalSystemId,
                                @Nonnull FileChooserDescriptor descriptor,
                                @Nonnull String fileChooserTitle)
{
  super(createPanel(project, externalSystemId), new MyBrowseListener(descriptor, fileChooserTitle, project));
  ActionListener[] listeners = getButton().getActionListeners();
  for (ActionListener listener : listeners) {
    if (listener instanceof MyBrowseListener) {
      ((MyBrowseListener)listener).setPathField(getChildComponent().getTextField());
      break;
    }
  }
  myProject = project;
  myExternalSystemId = externalSystemId;
}
 

@Nonnull
private static Tree buildRegisteredProjectsTree(@Nonnull Project project, @Nonnull ProjectSystemId externalSystemId) {
  ExternalSystemTasksTreeModel model = new ExternalSystemTasksTreeModel(externalSystemId);
  ExternalSystemTasksTree result = new ExternalSystemTasksTree(model, ContainerUtilRt.<String, Boolean>newHashMap(), project, externalSystemId);
  
  ExternalSystemManager<?, ?, ?, ?, ?> manager = ExternalSystemApiUtil.getManager(externalSystemId);
  assert manager != null;
  AbstractExternalSystemLocalSettings settings = manager.getLocalSettingsProvider().fun(project);
  Map<ExternalProjectPojo, Collection<ExternalProjectPojo>> projects = settings.getAvailableProjects();
  List<ExternalProjectPojo> rootProjects = ContainerUtilRt.newArrayList(projects.keySet());
  ContainerUtil.sort(rootProjects);
  for (ExternalProjectPojo rootProject : rootProjects) {
    model.ensureSubProjectsStructure(rootProject, projects.get(rootProject));
  }
  return result;
}
 

@Override
public void update(AnActionEvent e) {
  final Project project = e.getDataContext().getData(CommonDataKeys.PROJECT);
  if (project == null) {
    e.getPresentation().setEnabled(false);
    return;
  }

  final List<ProjectSystemId> systemIds = getSystemIds(e);
  if (systemIds.isEmpty()) {
    e.getPresentation().setEnabled(false);
    return;
  }

  final String name = StringUtil.join(systemIds, new Function<ProjectSystemId, String>() {
    @Override
    public String fun(ProjectSystemId projectSystemId) {
      return projectSystemId.getReadableName();
    }
  }, ",");
  e.getPresentation().setText(ExternalSystemBundle.message("action.refresh.all.projects.text", name));
  e.getPresentation().setDescription(ExternalSystemBundle.message("action.refresh.all.projects.description", name));

  ExternalSystemProcessingManager processingManager = ServiceManager.getService(ExternalSystemProcessingManager.class);
  e.getPresentation().setEnabled(!processingManager.hasTaskOfTypeInProgress(ExternalSystemTaskType.RESOLVE_PROJECT, project));
}
 

@Nullable
public ExternalSystemTask findTask(@Nonnull ExternalSystemTaskType type,
                                   @Nonnull ProjectSystemId projectSystemId,
                                   @Nonnull final String externalProjectPath) {
  for(ExternalSystemTask task : myTasksDetails.values()) {
    if(task instanceof AbstractExternalSystemTask) {
      AbstractExternalSystemTask externalSystemTask = (AbstractExternalSystemTask)task;
      if(externalSystemTask.getId().getType() == type &&
         externalSystemTask.getExternalSystemId().getId().equals(projectSystemId.getId()) &&
         externalSystemTask.getExternalProjectPath().equals(externalProjectPath)){
        return task;
      }
    }
  }

  return null;
}
 

public synchronized void remove(@Nullable final String groupName,
                                @Nonnull final NotificationSource notificationSource,
                                @Nonnull final ProjectSystemId projectSystemId) {
  final Map<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>> groupMap =
          ContainerUtil.getOrCreate(
                  map,
                  projectSystemId,
                  ContainerUtil.<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>>newHashMap());
  if (groupName != null) {
    final TObjectIntHashMap<NotificationCategory> counter = ContainerUtil.getOrCreate(
            ContainerUtil.getOrCreate(
                    groupMap,
                    groupName,
                    ContainerUtil.<NotificationSource, TObjectIntHashMap<NotificationCategory>>newHashMap()
            ),
            notificationSource,
            new TObjectIntHashMap<NotificationCategory>()
    );
    counter.clear();
  }
  else {
    for (Map<NotificationSource, TObjectIntHashMap<NotificationCategory>> sourceMap : groupMap.values()) {
      sourceMap.remove(notificationSource);
    }
  }
}
 

public synchronized void increment(@Nonnull String groupName,
                                   @Nonnull NotificationSource source,
                                   @Nonnull NotificationCategory category,
                                   @Nonnull ProjectSystemId projectSystemId) {

  final TObjectIntHashMap<NotificationCategory> counter =
          ContainerUtil.getOrCreate(
                  ContainerUtil.getOrCreate(
                          ContainerUtil.getOrCreate(
                                  map,
                                  projectSystemId,
                                  ContainerUtil.<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>>newHashMap()),
                          groupName,
                          ContainerUtil.<NotificationSource, TObjectIntHashMap<NotificationCategory>>newHashMap()
                  ),
                  source,
                  new TObjectIntHashMap<NotificationCategory>()
          );
  if (!counter.increment(category)) counter.put(category, 1);
}
 

@javax.annotation.Nullable
public static ExternalSystemManager<?, ?, ?, ?, ?> getManager(@Nonnull ProjectSystemId externalSystemId) {
  for (ExternalSystemManager manager : ExternalSystemManager.EP_NAME.getExtensionList()) {
    if (externalSystemId.equals(manager.getSystemId())) {
      return manager;
    }
  }
  return null;
}
 

public ExternalSystemResolveProjectTask(@Nonnull ProjectSystemId externalSystemId,
                                        @Nonnull Project project,
                                        @Nonnull String projectPath,
                                        boolean isPreviewMode) {
  super(externalSystemId, ExternalSystemTaskType.RESOLVE_PROJECT, project, projectPath);
  myProjectPath = projectPath;
  myIsPreviewMode = isPreviewMode;
}
 

@Deprecated
public ModuleData(@Nonnull ProjectSystemId owner,
                  @Nonnull String name,
                  @Nonnull String moduleDir,
                  @Nonnull String externalConfigPath) {
  this("", owner, name, moduleDir, externalConfigPath);
}
 

public ModuleData(@Nonnull String id,
                  @Nonnull ProjectSystemId owner,
                  @Nonnull String name,
                  @Nonnull String moduleFileDirectoryPath,
                  @Nonnull String externalConfigPath) {
  super(owner, name, name.replaceAll("(/|\\\\)", "_"));
  myId = id;
  myExternalConfigPath = externalConfigPath;
  myArtifacts = Collections.emptyList();
  setModuleDirPath(moduleFileDirectoryPath);
}
 

protected AbstractExternalSystemTask(@Nonnull ProjectSystemId id,
                                     @Nonnull ExternalSystemTaskType type,
                                     @Nonnull Project project,
                                     @Nonnull String externalProjectPath) {
  myExternalSystemId = id;
  myIdeProject = project;
  myId = ExternalSystemTaskId.create(id, type, myIdeProject);
  myExternalProjectPath = externalProjectPath;
}
 

@Nullable
private Content findContent(@Nonnull Pair<NotificationSource, ProjectSystemId> contentIdPair, @Nonnull String contentDisplayName) {
  Content targetContent = null;
  final MessageView messageView = ServiceManager.getService(myProject, MessageView.class);
  for (Content content : messageView.getContentManager().getContents()) {
    if (contentIdPair.equals(content.getUserData(CONTENT_ID_KEY))
        && StringUtil.equals(content.getDisplayName(), contentDisplayName) && !content.isPinned()) {
      targetContent = content;
    }
  }
  return targetContent;
}
 

public ExternalSystemExecuteTaskTask(@Nonnull ProjectSystemId externalSystemId,
                                     @Nonnull Project project,
                                     @Nonnull List<ExternalTaskPojo> tasksToExecute,
                                     @Nullable String vmOptions,
                                     @javax.annotation.Nullable String scriptParameters,
                                     @javax.annotation.Nullable String debuggerSetup) throws IllegalArgumentException {
  super(externalSystemId, ExternalSystemTaskType.EXECUTE_TASK, project, getLinkedExternalProjectPath(tasksToExecute));
  myTasksToExecute = tasksToExecute;
  myVmOptions = vmOptions;
  myScriptParameters = scriptParameters;
  myDebuggerSetup = debuggerSetup;
}
 

@Deprecated
public ProjectData(@Nonnull ProjectSystemId owner,
                   @Nonnull String ideProjectFileDirectoryPath,
                   @Nonnull String linkedExternalProjectPath) {
  super(owner, "unnamed");
  myLinkedExternalProjectPath = ExternalSystemApiUtil.toCanonicalPath(linkedExternalProjectPath);
  myIdeProjectFileDirectoryPath = ExternalSystemApiUtil.toCanonicalPath(ideProjectFileDirectoryPath);
}
 

private static List<ProjectSystemId> getSystemIds(AnActionEvent e) {
  final List<ProjectSystemId> systemIds = ContainerUtil.newArrayList();

  final ProjectSystemId externalSystemId = e.getDataContext().getData(ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID);
  if (externalSystemId != null) {
    systemIds.add(externalSystemId);
  }
  else {
    for (ExternalSystemManager manager : ExternalSystemManager.EP_NAME.getExtensionList()) {
      systemIds.add(manager.getSystemId());
    }
  }

  return systemIds;
}
 

@Nonnull
public static MyInfo getProcessingInfo(@Nonnull DataContext context) {
  ExternalProjectPojo externalProject = context.getData(ExternalSystemDataKeys.SELECTED_PROJECT);
  if (externalProject == null) {
    return MyInfo.EMPTY;
  }

  ProjectSystemId externalSystemId = context.getData(ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID);
  if (externalSystemId == null) {
    return MyInfo.EMPTY;
  }

  Project ideProject = context.getData(CommonDataKeys.PROJECT);
  if (ideProject == null) {
    return MyInfo.EMPTY;
  }

  AbstractExternalSystemSettings<?, ?, ?> settings = ExternalSystemApiUtil.getSettings(ideProject, externalSystemId);
  ExternalProjectSettings externalProjectSettings = settings.getLinkedProjectSettings(externalProject.getPath());
  AbstractExternalSystemLocalSettings localSettings = ExternalSystemApiUtil.getLocalSettings(ideProject, externalSystemId);

  return new MyInfo(externalProjectSettings == null ? null : settings,
                    localSettings == null ? null : localSettings,
                    externalProjectSettings == null ? null : externalProject,
                    ideProject,
                    externalSystemId);
}
 

@SuppressWarnings("MethodMayBeStatic")
@Nonnull
protected ExternalSystemRunConfiguration doCreateConfiguration(@Nonnull ProjectSystemId externalSystemId,
                                                               @Nonnull Project project,
                                                               @Nonnull ConfigurationFactory factory,
                                                               @Nonnull String name)
{
  return new ExternalSystemRunConfiguration(externalSystemId, project, factory, name);
}
 

@Nullable
@Override
public RemoteExternalSystemFacade acquire(@Nonnull String id, @Nonnull ProjectSystemId externalSystemId)
  throws Exception
{
  myTargetExternalSystemId.set(externalSystemId);
  final RemoteExternalSystemFacade facade;
  try {
    facade = mySupport.acquire(this, id);
  }
  finally {
    myTargetExternalSystemId.set(null);
  }
  if (facade == null) {
    return null;
  }

  RemoteExternalSystemProgressNotificationManager exported = myExportedNotificationManager.get();
  if (exported == null) {
    try {
      exported = (RemoteExternalSystemProgressNotificationManager)UnicastRemoteObject.exportObject(myProgressManager, 0);
      myExportedNotificationManager.set(exported);
    }
    catch (RemoteException e) {
      exported = myExportedNotificationManager.get();
    }
  }
  if (exported == null) {
    LOG.warn("Can't export progress manager");
  }
  else {
    facade.applyProgressManager(exported);
  }
  return facade;
}
 

@Nullable
private static VirtualFile getExternalConfig(@Nonnull DataContext context) {
  ProjectSystemId externalSystemId = context.getData(ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID);
  if (externalSystemId == null) {
    return null;
  }

  ExternalProjectPojo projectPojo = context.getData(ExternalSystemDataKeys.SELECTED_PROJECT);
  if (projectPojo == null) {
    return null;
  }

  String path = projectPojo.getPath();
  LocalFileSystem fileSystem = LocalFileSystem.getInstance();
  VirtualFile externalSystemConfigPath = fileSystem.refreshAndFindFileByPath(path);
  if (externalSystemConfigPath == null) {
    return null;
  }

  VirtualFile toOpen = externalSystemConfigPath;
  for (ExternalSystemConfigLocator locator : ExternalSystemConfigLocator.EP_NAME.getExtensionList()) {
    if (externalSystemId.equals(locator.getTargetExternalSystemId())) {
      toOpen = locator.adjust(toOpen);
      if (toOpen == null) {
        return null;
      }
    }
  }
  return toOpen.isDirectory() ? null : toOpen;
}
 

public synchronized int getCount(@Nullable final String groupName,
                                 @Nonnull final NotificationSource notificationSource,
                                 @Nullable final NotificationCategory notificationCategory,
                                 @Nonnull final ProjectSystemId projectSystemId) {
  int count = 0;
  final Map<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>> groupMap = ContainerUtil.getOrElse(
          map,
          projectSystemId,
          Collections.<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>>emptyMap());

  for (Map.Entry<String, Map<NotificationSource, TObjectIntHashMap<NotificationCategory>>> entry : groupMap.entrySet()) {
    if (groupName == null || groupName.equals(entry.getKey())) {
      final TObjectIntHashMap<NotificationCategory> counter = entry.getValue().get(notificationSource);
      if (counter == null) continue;

      if (notificationCategory == null) {
        for (int aCount : counter.getValues()) {
          count += aCount;
        }
      }
      else {
        count = counter.get(notificationCategory);
      }
    }
  }

  return count;
}
 

@SuppressWarnings("unchecked")
@Nonnull
public static AbstractExternalSystemSettings getSettings(@Nonnull Project project, @Nonnull ProjectSystemId externalSystemId)
        throws IllegalArgumentException {
  ExternalSystemManager<?, ?, ?, ?, ?> manager = getManager(externalSystemId);
  if (manager == null) {
    throw new IllegalArgumentException(String.format("Can't retrieve external system settings for id '%s'. Reason: no such external system is registered",
                                                     externalSystemId.getReadableName()));
  }
  return manager.getSettingsProvider().fun(project);
}
 

@SuppressWarnings("unchecked")
public static <S extends AbstractExternalSystemLocalSettings> S getLocalSettings(@Nonnull Project project, @Nonnull ProjectSystemId externalSystemId)
        throws IllegalArgumentException {
  ExternalSystemManager<?, ?, ?, ?, ?> manager = getManager(externalSystemId);
  if (manager == null) {
    throw new IllegalArgumentException(
            String.format("Can't retrieve local external system settings for id '%s'. Reason: no such external system is registered",
                          externalSystemId.getReadableName()));
  }
  return (S)manager.getLocalSettingsProvider().fun(project);
}
 

@Override
public void update(AnActionEvent e) {
  ProjectSystemId externalSystemId = e.getDataContext().getData(ExternalSystemDataKeys.EXTERNAL_SYSTEM_ID);
  if (externalSystemId == null) {
    e.getPresentation().setEnabled(false);
    return;
  }

  e.getPresentation().setText(ExternalSystemBundle.message("action.open.config.text", externalSystemId.getReadableName()));
  e.getPresentation().setDescription(ExternalSystemBundle.message("action.open.config.description", externalSystemId.getReadableName()));
  e.getPresentation().setIcon(ExternalSystemUiUtil.getUiAware(externalSystemId).getProjectIcon());

  VirtualFile config = getExternalConfig(e.getDataContext());
  e.getPresentation().setEnabled(config != null);
}
 

MyInfo(@Nullable AbstractExternalSystemSettings<?, ?, ?> settings,
       @Nullable AbstractExternalSystemLocalSettings localSettings,
       @javax.annotation.Nullable ExternalProjectPojo externalProject,
       @javax.annotation.Nullable Project ideProject,
       @Nullable ProjectSystemId externalSystemId)
{
  this.settings = settings;
  this.localSettings = localSettings;
  this.externalProject = externalProject;
  this.ideProject = ideProject;
  this.externalSystemId = externalSystemId;
}
 

@SuppressWarnings("unchecked")
@Nullable
@Override
public RemoteExternalSystemFacade acquire(@Nonnull String id, @Nonnull ProjectSystemId externalSystemId) throws Exception {
  ExternalSystemManager<?, ?, ?, ?, ?> manager = ExternalSystemApiUtil.getManager(externalSystemId);
  assert manager != null;
  InProcessExternalSystemFacadeImpl result = new InProcessExternalSystemFacadeImpl(manager.getProjectResolverClass(),
                                                                                   manager.getTaskManagerClass());
  result.applyProgressManager(myProgressManager);
  return result;
}
 

MyEntry(@Nonnull ProjectSystemId externalSystemId,
        @Nonnull AbstractExternalSystemSettings<?, ?, ?> systemSettings,
        @Nonnull ExternalSystemAutoImportAware aware)
{
  this.externalSystemId = externalSystemId;
  this.systemSettings = systemSettings;
  this.aware = aware;
}
 

private void addPath(@Nonnull ProjectSystemId externalSystemId, @Nonnull String path) {
  Lock lock = myVfsLock.readLock();
  lock.lock();
  try {
    Set<String> paths = myFilesToRefresh.get(externalSystemId);
    while (paths == null) {
      myFilesToRefresh.putIfAbsent(externalSystemId, ContainerUtilRt.<String>newHashSet());
      paths = myFilesToRefresh.get(externalSystemId);
    }
    paths.add(path);
  }
  finally {
    lock.unlock();
  }
}