import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
public void configureDependencies(
    final @NotNull HybrisProjectDescriptor hybrisProjectDescriptor,
    final @NotNull IdeModifiableModelsProvider modifiableModelsProvider
) {
    final Map<String, ModifiableFacetModel> modifiableFacetModelMap = ContainerUtil.newHashMap();

    for (Module module : modifiableModelsProvider.getModules()) {
        final ModifiableFacetModel modifiableFacetModel = modifiableModelsProvider.getModifiableFacetModel(module);
        modifiableFacetModelMap.put(module.getName(), modifiableFacetModel);
    }

    for (HybrisModuleDescriptor moduleDescriptor : hybrisProjectDescriptor.getModulesChosenForImport()) {
        configureFacetDependencies(moduleDescriptor, modifiableFacetModelMap);
    }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
private void configureFacetDependencies(
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Map<String, ModifiableFacetModel> modifiableFacetModelMap
) {
    Validate.notNull(moduleDescriptor);
    Validate.notNull(modifiableFacetModelMap);

    final SpringFileSet springFileSet = getSpringFileSet(modifiableFacetModelMap, moduleDescriptor.getName());
    if (springFileSet == null) {
        return;
    }

    for (HybrisModuleDescriptor dependsOnModule : moduleDescriptor.getDependenciesTree()) {
        final SpringFileSet parentFileSet = getSpringFileSet(modifiableFacetModelMap, dependsOnModule.getName());
        if (parentFileSet == null) {
            continue;
        }
        springFileSet.addDependency(parentFileSet);
    }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
private SpringFileSet getSpringFileSet(
    @NotNull final Map<String, ModifiableFacetModel> modifiableFacetModelMap,
    @NotNull final String moduleName
) {
    Validate.notNull(moduleName);
    Validate.notNull(modifiableFacetModelMap);

    final ModifiableFacetModel modifiableFacetModel = modifiableFacetModelMap.get(moduleName);
    if (modifiableFacetModel == null) {
        return null;
    }
    final SpringFacet springFacet = modifiableFacetModel.getFacetByType(SpringFacet.FACET_TYPE_ID);
    if (springFacet == null || springFacet.getFileSets().isEmpty()) {
        return null;
    }
    return springFacet.getFileSets().iterator().next();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
static void setupFacet(Module module, @NotNull BuildoutFacetConfiguration config) {
  //TODO: refactor, see other python facets
  FacetManager facetManager = FacetManager.getInstance(module);
  final ModifiableFacetModel model = facetManager.createModifiableModel();
  BuildoutFacetType facetType = BuildoutFacetType.getInstance();
  BuildoutFacet facet = facetManager.createFacet(facetType, facetType.getDefaultFacetName(), config, null);
  model.addFacet(facet);

  new WriteAction() {
    protected void run(@NotNull final Result result) throws Throwable {
      model.commit();
    }
  }.execute();
  facet.updatePaths();
  BuildoutFacet.attachLibrary(module);
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@NotNull
public static AndroidFacet addAndroidFacet(final Module module, @NotNull VirtualFile contentRoot,
                                           boolean library) {
  final FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  AndroidFacet facet = model.getFacetByType(AndroidFacet.ID);

  if (facet == null) {
    facet = facetManager.createFacet(AndroidFacet.getFacetType(), "Android", null);
    AndroidFacetConfiguration configuration = facet.getConfiguration();
    configuration.init(module, contentRoot);
    if (library) {
      configuration.getState().LIBRARY_PROJECT = true;
    }
    model.addFacet(facet);
  }
  model.commit();

  return facet;
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@NotNull
private static JavaGradleFacet setAndGetJavaGradleFacet(Module module) {
  JavaGradleFacet facet = JavaGradleFacet.getInstance(module);
  if (facet != null) {
    return facet;
  }

  // Module does not have Android-Gradle facet. Create one and add it.
  FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    facet = facetManager.createFacet(JavaGradleFacet.getFacetType(), JavaGradleFacet.NAME, null);
    model.addFacet(facet);
  }
  finally {
    model.commit();
  }
  return facet;
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
public void customizeModule(@NotNull Project project,
                            @NotNull Module module,
                            @NotNull IdeModifiableModelsProvider modelsProvider,
                            @Nullable IdeaAndroidProject androidProject) {
  if (androidProject == null) {
    removeAllFacetsOfType(AndroidFacet.ID, modelsProvider.getModifiableFacetModel(module));
  }
  else {
    AndroidFacet facet = AndroidFacet.getInstance(module);
    if (facet != null) {
      configureFacet(facet, androidProject);
    }
    else {
      // Module does not have Android facet. Create one and add it.
      ModifiableFacetModel model = modelsProvider.getModifiableFacetModel(module);
      final AndroidFacetType facetType = AndroidFacet.getFacetType();
      facet = facetType.createFacet(module, AndroidFacet.NAME, facetType.createDefaultConfiguration(), null);
      model.addFacet(facet);
      configureFacet(facet, androidProject);
    }
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
private static void cleanUpAndroidModuleWithoutVariants(@NotNull Module module) {
  // Remove Android facet, otherwise the IDE will try to build the module, and fail. The facet may have been added in a previous
  // successful commit.
  AndroidFacet facet = AndroidFacet.getInstance(module);
  if (facet != null) {
    ModifiableFacetModel facetModel = FacetManager.getInstance(module).createModifiableModel();
    facetModel.removeFacet(facet);
    facetModel.commit();
  }

  // Clear all source and exclude folders.
  ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
  ModifiableRootModel rootModel = moduleRootManager.getModifiableModel();
  for (ContentEntry contentEntry : rootModel.getContentEntries()) {
    contentEntry.clearSourceFolders();
    contentEntry.clearExcludeFolders();
  }

  rootModel.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public static AndroidFacet addAndroidFacet(Module module, String sdkPath, String platformDir, boolean addSdk) {
  FacetManager facetManager = FacetManager.getInstance(module);
  AndroidFacet facet = facetManager.createFacet(AndroidFacet.getFacetType(), "Android", null);

  if (addSdk) {
    addAndroidSdk(module, sdkPath, platformDir);
  }
  final ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  facetModel.addFacet(facet);
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      facetModel.commit();
    }
  });
  return facet;
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
private void setUpLibModule() {
  FacetManager facetManager = FacetManager.getInstance(myLibModule);
  ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  try {
    AndroidFacet androidFacet = createFacet(facetManager, true);
    androidFacet.setIdeaAndroidProject(myLib);
    facetModel.addFacet(androidFacet);

    AndroidGradleFacet gradleFacet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    gradleFacet.getConfiguration().GRADLE_PROJECT_PATH = myLibGradlePath;
    facetModel.addFacet(gradleFacet);
  }
  finally {
    facetModel.commit();
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public void testRemoveAllFacetsWithAndroidFacets() throws Exception {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    AndroidFacet facet = facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null);
    model.addFacet(facet);
  }
  finally {
    model.commit();
  }

  assertEquals(1, facetManager.getFacetsByType(AndroidFacet.ID).size());

  Facets.removeAllFacetsOfType(myModule, AndroidFacet.ID);

  assertEquals(0, facetManager.getFacetsByType(AndroidFacet.ID).size());
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public void testRemoveAllFacetsWithAndroidGradleFacets() throws Exception {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    AndroidGradleFacet facet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    model.addFacet(facet);
  }
  finally {
    model.commit();
  }

  assertEquals(1, facetManager.getFacetsByType(AndroidGradleFacet.TYPE_ID).size());

  Facets.removeAllFacetsOfType(myModule, AndroidGradleFacet.TYPE_ID);

  assertEquals(0, facetManager.getFacetsByType(AndroidGradleFacet.TYPE_ID).size());
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();
  AndroidTestCaseHelper.removeExistingAndroidSdks();
  myAndroidSdkPath = AndroidTestCaseHelper.getAndroidSdkPath();

  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      FacetManager facetManager = FacetManager.getInstance(myModule);
      ModifiableFacetModel model = facetManager.createModifiableModel();
      try {
        model.addFacet(facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null));
      } finally {
        model.commit();
      }
    }
  });
  AndroidFacet facet = AndroidFacet.getInstance(myModule);
  assertNotNull(facet);
  facet.getProperties().ALLOW_USER_CONFIGURATION = false;
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public static void createAndroidFacet(Module module) {
  AndroidFacet facet = AndroidFacet.getInstance(module);
  if (facet != null) {
    configureFacet(facet);
  } else {
    // Module does not have Android facet. Create one and add it.
    FacetManager facetManager = FacetManager.getInstance(module);
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      facet = facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null);
      model.addFacet(facet);
      configureFacet(facet);
    } finally {
      model.commit();
    }
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
public void configure(
    @NotNull final ModifiableFacetModel modifiableFacetModel,
    @NotNull final HybrisModuleDescriptor moduleDescriptor,
    @NotNull final Module javaModule,
    @NotNull final ModifiableRootModel modifiableRootModel
) {
    final File webRoot = moduleDescriptor.getWebRoot();
    if (null == webRoot) {
        return;
    }

    WebFacet webFacet = modifiableFacetModel.getFacetByType(WebFacet.ID);

    if (webFacet == null) {
        final FacetType<WebFacet, FacetConfiguration> webFacetType = FacetTypeRegistry.getInstance().findFacetType(
            WebFacet.ID
        );

        if (!webFacetType.isSuitableModuleType(ModuleType.get(javaModule))) {
            return;
        }

        webFacet = FacetManager.getInstance(javaModule).createFacet(
            webFacetType, webFacetType.getDefaultFacetName(), null
        );

        modifiableFacetModel.addFacet(webFacet);

    } else {
        webFacet.removeAllWebRoots();
        webFacet.getDescriptorsContainer().getConfiguration().removeConfigFiles(
            DeploymentDescriptorsConstants.WEB_XML_META_DATA
        );
    }

    webFacet.setWebSourceRoots(modifiableRootModel.getSourceRootUrls(false));
    webFacet.addWebRootNoFire(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(webRoot.getAbsolutePath())), "/");
    this.setupFacetDeploymentDescriptor(webFacet, moduleDescriptor);
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public void setMuleFacet(Module module) {
    MuleFacetType type = (MuleFacetType)FacetTypeRegistry.getInstance().findFacetType(MuleFacet.ID);
    MuleFacetConfiguration configuration = type.createDefaultConfiguration();
    configuration.setPathToSdk(MuleSdkManager.getInstance().findFromVersion(muleVersion).getMuleHome());
    Facet facet = type.createFacet(module, type.getPresentableName(), configuration, null);
    ModifiableFacetModel model = FacetManager.getInstance(module).createModifiableModel();
    model.addFacet(facet);
    model.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
public void addSupport(@NotNull Module module, @NotNull ModifiableRootModel model, @Nullable Library library) {
  final FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  LuaFacet facet = facetManager.createFacet(LuaFacetType.getInstance(), "Lua", null);
  facet.getConfiguration().setSdk(mySdkComboBox.getSelectedSdk());
  facetModel.addFacet(facet);
  facetModel.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
public ModifiableFacetModel getFacetModifiableModel(Module module) {
  final ModulesConfigurator configurator = getModulesConfigurator(module.getProject());
  if (configurator != null) {
    return configurator.getFacetsConfigurator().getOrCreateModifiableModel(module);
  }
  return FacetManager.getInstance(module).createModifiableModel();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
public void commitFacetModifiableModel(Module module, ModifiableFacetModel model) {
  final ModulesConfigurator configurator = getModulesConfigurator(module.getProject());
  if (configurator == null || !(configurator.getFacetsConfigurator().getFacetModel(module) instanceof ModifiableFacetModel)) {
    model.commit();
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入依赖的package包/类
@Override
@NotNull
public ModifiableFacetModel getModifiableFacetModel(Module module) {
  ModifiableFacetModel result = myModifiableFacetModels.get(module);
  if (result == null) {
    result = doGetModifiableFacetModel(module);
    myModifiableFacetModels.put(module, result);
  }
  return result;
}