Java ModuleManager.getInstance方法代码示例

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
public static String getAndroidSdkPath(Project project) {
    ModuleManager manager = ModuleManager.getInstance(project);
    String androidSdkPath = null;

    for (Module module : manager.getModules()) {
        if (androidSdkPath != null) {
            break;
        }
        Sdk sdk = ModuleRootManager.getInstance(module).getSdk();

        if (sdk != null && sdk.getHomePath() != null) {
            File file = new File(sdk.getHomePath());
            String[] contents = file.list();

            if (contents != null) {
                for (String path : contents) {
                    if (path.equals("build-tools")) {
                        androidSdkPath = sdk.getHomePath();
                        break;
                    }
                }
            }
        }
    }
    return androidSdkPath;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
@Override
public void syncSucceeded(@NotNull Project project) {
  disposeOnTearDown(project);
  // Verify that project was imported correctly.
  assertEquals(myProjectName, project.getName());
  assertEquals(myProjectRootDir.getPath(), project.getBasePath());

  // Verify that '.idea' directory was created.
  File ideaProjectDir = new File(myProjectRootDir, Project.DIRECTORY_STORE_FOLDER);
  assertTrue(ideaProjectDir.isDirectory());

  // Verify that module was created.
  ModuleManager moduleManager = ModuleManager.getInstance(project);
  Module[] modules = moduleManager.getModules();
  assertEquals(1, modules.length);
  assertEquals(myModule.getName(), modules[0].getName());
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
@Nullable
private static File findPathOfSdkMissingOrEmptyAddonsFolder(@NotNull Project project) {
  ModuleManager moduleManager = ModuleManager.getInstance(project);
  for (Module module : moduleManager.getModules()) {
    Sdk moduleSdk = ModuleRootManager.getInstance(module).getSdk();
    if (moduleSdk != null && isAndroidSdk(moduleSdk)) {
      String homePath = moduleSdk.getHomePath();
      if (homePath != null) {
        File sdkHomeDirPath = new File(FileUtil.toSystemDependentName(homePath));
        File addonsDir = new File(sdkHomeDirPath, SdkConstants.FD_ADDONS);
        if (!addonsDir.isDirectory() || FileUtil.notNullize(addonsDir.listFiles()).length == 0) {
          return sdkHomeDirPath;
        }
      }
    }
  }
  return null;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
private void calculateRoots() {
  final ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  // assertion for read access inside
  final Module[] modules = ApplicationManager.getApplication().runReadAction(new Computable<Module[]>() {
    public Module[] compute() {
      return moduleManager.getModules();
    }
  });

  final TreeSet<VirtualFile> checkSet = new TreeSet<VirtualFile>(FilePathComparator.getInstance());
  myRoots = new HashSet<VirtualFile>();
  myRoots.addAll(myInitialRoots);
  checkSet.addAll(myInitialRoots);
  for (Module module : modules) {
    final VirtualFile[] files = ModuleRootManager.getInstance(module).getContentRoots();
    for (VirtualFile file : files) {
      final VirtualFile floor = checkSet.floor(file);
      if (floor != null) {
        myModulesSet.put(file, module.getName());
        myRoots.add(file);
      }
    }
  }
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
@Override
public void configureProject(final Project project, @NotNull final VirtualFile baseDir, final Ref<Module> moduleRef) {
  final ModuleManager moduleManager = ModuleManager.getInstance(project);
  final Module[] modules = moduleManager.getModules();
  if (modules.length == 0) {
    ApplicationManager.getApplication().runWriteAction(new Runnable() {
      @Override
      public void run() {
        String moduleName = baseDir.getName().replace(":", "");     // correct module name when opening root of drive as project (RUBY-5181)
        String imlName = baseDir.getPath() + "/.idea/" + moduleName + ModuleFileType.DOT_DEFAULT_EXTENSION;
        ModuleTypeManager instance = ModuleTypeManager.getInstance();
        String id = instance == null ? "unknown" : instance.getDefaultModuleType().getId();
        final Module module = moduleManager.newModule(imlName, id);
        ModuleRootManager rootManager = ModuleRootManager.getInstance(module);
        ModifiableRootModel rootModel = rootManager.getModifiableModel();
        if (rootModel.getContentRoots().length == 0) {
          rootModel.addContentEntry(baseDir);
        }
        rootModel.inheritSdk();
        rootModel.commit();
        moduleRef.set(module);
      }
    });
  }
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
public void generateSources() {
  BuildMode buildMode = BuildMode.SOURCE_GEN;
  setProjectBuildMode(buildMode);

  ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  List<String> tasks = findTasksToExecute(moduleManager.getModules(), buildMode, TestCompileType.NONE);

  executeTasks(tasks);
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
private static void removeGenModule(@NotNull final ModifiableRootModel model, @NotNull Ref<Boolean> modelChangedFlag) {
  final String genModuleName = getGenModuleName(model.getModule());
  final Project project = model.getProject();
  final ModuleManager moduleManager = ModuleManager.getInstance(project);

  final Module genModule = moduleManager.findModuleByName(genModuleName);
  if (genModule == null) {
    return;
  }

  for (OrderEntry entry : model.getOrderEntries()) {
    if (entry instanceof ModuleOrderEntry &&
        genModuleName.equals(((ModuleOrderEntry)entry).getModuleName())) {
      model.removeOrderEntry(entry);
      modelChangedFlag.set(true);
    }
  }
  final VirtualFile moduleFile = genModule.getModuleFile();
  moduleManager.disposeModule(genModule);

  if (moduleFile != null) {
    ApplicationManager.getApplication().invokeLater(new Runnable() {
      @Override
      public void run() {
        ApplicationManager.getApplication().runWriteAction(new Runnable() {
          @Override
          public void run() {
            try {
              moduleFile.delete(project);
            }
            catch (IOException e) {
              LOG.error(e);
            }
          }
        });
      }
    });
  }
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
/**
 * @see #isGradleProjectModule(Module)
 */
@Nullable
public static Module findGradleProjectModule(@NotNull Project project) {
  ModuleManager moduleManager = ModuleManager.getInstance(project);
  Module[] modules = moduleManager.getModules();
  if (modules.length == 1) {
    return modules[0];
  }
  for (Module module : modules) {
    if (isGradleProjectModule(module)) {
      return module;
    }
  }
  return null;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
private boolean isUniqueModuleName(@NotNull String moduleName) {
  if (myProject == null) {
    return true;
  }
  // Check our modules
  ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  for (Module m : moduleManager.getModules()) {
    if (m.getName().equalsIgnoreCase(moduleName)) {
      return false;
    }
  }
  return true;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
/**
 * Indicates whether the give project is a legacy IDEA Android project (which is deprecated in Android Studio.)
 *
 * @param project the given project.
 * @return {@code true} if the given project is a legacy IDEA Android project; {@code false} otherwise.
 */
public static boolean isIdeaAndroidProject(@NotNull Project project) {
  ModuleManager moduleManager = ModuleManager.getInstance(project);
  for (Module module : moduleManager.getModules()) {
    if (AndroidFacet.getInstance(module) != null && !isBuildWithGradle(module)) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
private void delete(@NotNull Module module) {
  if (module.isDisposed()) {
    return;
  }
  ModuleManager moduleManager = ModuleManager.getInstance(module.getProject());
  ModifiableModuleModel modifiableModel = moduleManager.getModifiableModel();
  try {
    modifiableModel.disposeModule(module);
  }
  finally {
    modifiableModel.commit();
  }
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
public void testComputeModuleName() throws Exception {
  ModuleManager manager = ModuleManager.getInstance(getProject());
  myStep = new ConfigureAndroidModuleStep(myState, getProject(), null, TemplateWizardStep.NONE);
  Module module = manager.getModules()[0];
  assertEquals("app", module.getName());

  myState.myHidden.add(ATTR_PROJECT_LOCATION);
  myState.put(ATTR_IS_LIBRARY_MODULE, true);
  // "Lib" and "lib2" already exist
  assertEquals("lib3", myStep.computeModuleName());

  myState.put(ATTR_IS_LIBRARY_MODULE, false);
  // "app" already exists
  assertEquals("app2", myStep.computeModuleName());
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
public void rebuild() {
  BuildMode buildMode = BuildMode.REBUILD;
  setProjectBuildMode(buildMode);
  ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  List<String> tasks = findTasksToExecute(moduleManager.getModules(), buildMode, TestCompileType.NONE);
  executeTasks(tasks);
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
/**
 * Indicates whether Gradle is used to build this project.
 * Note: {@link #isGradleProject(Project)} indicates whether a project has a IdeaAndroidProject model.
 * That method should be preferred in almost all cases. Use this method only if you explicitly need to check whether the model was
 * generated by Gradle (this will exclude models generated by other build systems.)
 */
public static boolean isBuildWithGradle(@NotNull Project project) {
  ModuleManager moduleManager = ModuleManager.getInstance(project);
  for (Module module : moduleManager.getModules()) {
    if (isBuildWithGradle(module)) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.openapi.module.ModuleManager; //导入方法依赖的package包/类
public void cleanProject() {
  setProjectBuildMode(BuildMode.CLEAN);

  ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  // "Clean" also generates sources.
  List<String> tasks = findTasksToExecute(moduleManager.getModules(), BuildMode.SOURCE_GEN, TestCompileType.NONE);
  tasks.add(0, GradleBuilds.CLEAN_TASK_NAME);
  executeTasks(tasks);
}