import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void configureProject(Project project, @NotNull VirtualFile baseDir, Ref<Module> moduleRef) {
  final Module[] modules = ModuleManager.getInstance(project).getModules();
  if (modules.length > 0) {
    final Module module = modules[0];
    if (BuildoutFacet.getInstance(module) == null) {
      baseDir.refresh(false, false);
      final VirtualFile runner = BuildoutFacet.getRunner(baseDir);
      if (runner != null) {
        // TODO parse buildout.cfg and find out the part to use for the default script
        final File script = BuildoutFacet.findScript(null, "buildout", project.getBaseDir());
        if (script != null) {
          final ProjectFacetManager facetManager = ProjectFacetManager.getInstance(module.getProject());
          final BuildoutFacetConfiguration config = facetManager.createDefaultConfiguration(BuildoutFacetType.getInstance());
          config.setScriptName(script.getPath());
          setupFacet(module, config);
        }
      }
    }
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
private static boolean isMyContext(@NotNull final PsiElement element, @NotNull final Project project) {
  if (element instanceof PsiClass) {
    return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
      @Override
      public Boolean compute() {
        PsiFile file = element.getContainingFile();
        if (file == null) {
          return false;
        }
        VirtualFile vFile = file.getVirtualFile();
        if (vFile == null) {
          return false;
        }
        String path = FileUtil.toSystemIndependentName(vFile.getPath());
        if (path.toLowerCase(Locale.US).contains("/" + SdkConstants.FN_FRAMEWORK_LIBRARY + "!/")) {
          if (ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID).size() > 0) {
            VirtualFile jarFile = JarFileSystem.getInstance().getVirtualFileForJar(vFile);
            return jarFile != null && SdkConstants.FN_FRAMEWORK_LIBRARY.equals(jarFile.getName());
          }
        }
        return false;
      }
    });
  }
  return false;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public boolean handleError(@NotNull List<String> message,
                           @NotNull ExternalSystemException error,
                           @NotNull NotificationData notification,
                           @NotNull Project project) {
  String lastLine = message.get(message.size() - 1);

  if (lastLine.contains(INSTALL_ANDROID_SUPPORT_REPO)) {
    List<AndroidFacet> facets = ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID);
    NotificationHyperlink[] hyperlinks = EMPTY;
    if (!facets.isEmpty()) {
      // We can only open SDK manager if the project has an Android facet. Android facet has a reference to the Android SDK manager.
      hyperlinks = new NotificationHyperlink[] {new OpenAndroidSdkManagerHyperlink()};
    }
    updateNotification(notification, project, error.getMessage(), hyperlinks);
    return true;
  }
  return false;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void decorate(ProjectViewNode node, PresentationData data) {
  if (!(node instanceof PsiDirectoryNode)) {
    return;
  }

  final PsiDirectoryNode psiDirectoryNode = (PsiDirectoryNode)node;
  PsiDirectory psiDirectory = psiDirectoryNode.getValue();

  Project project = psiDirectory.getProject();
  if (!ProjectFacetManager.getInstance(project).hasFacets(AndroidFacet.ID)) {
    return;
  }

  VirtualFile folder = psiDirectory.getVirtualFile();
  Module module = ProjectRootManager.getInstance(project).getFileIndex().getModuleForFile(folder);
  if (module != null && ModuleUtilCore.isModuleDir(module, folder)) {
    data.setIcon(GradleUtil.getModuleIcon(module));
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void update(AnActionEvent e) {
  final Project project = e.getProject();
  e.getPresentation().setEnabledAndVisible(
    project != null && ProjectFacetManager.getInstance(project).hasFacets(AppEngineFacet.ID));

  if (project != null) {
    String text;
    RunnerAndConfigurationSettings configurationToRun = getConfigurationToRun(project);
    if (configurationToRun == null) {
      text = getTemplatePresentation().getText();
    }
    else {
      text = "Upload App Engine Application '" + configurationToRun.getName() + "'";
    }
    e.getPresentation().setText(text);
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
public static boolean isMuleModule(Module module) {
    boolean muleModule = false;
    ProjectFacetManager manager = ProjectFacetManager.getInstance(module.getProject());
    final List<MuleFacet> facets = manager.getFacets(MuleFacetType.TYPE_ID, new Module[]{module});
    muleModule = (facets != null && !facets.isEmpty());
    if (!muleModule) { //Check for src/main/apps too, since not all modules may have facet added
        VirtualFile[] contentRoots = ModuleRootManager.getInstance(module).getContentRoots();
        for (VirtualFile f : contentRoots) {
            VirtualFile deployProperties = f.findFileByRelativePath("src/main/app/mule-deploy.properties");
            if (deployProperties != null && deployProperties.exists() && deployProperties.isValid())
                return true;
        }
    }
    return muleModule;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
public <C extends FacetConfiguration> FacetTypeEditor(@NotNull Project project, final StructureConfigurableContext context, @NotNull FacetType<?, C> facetType) {
  myProject = project;
  myContext = context;
  myFacetType = facetType;

  if (!(facetType instanceof InvalidFacetType)) {
    C configuration = ProjectFacetManager.getInstance(project).createDefaultConfiguration(facetType);
    DefaultFacetSettingsEditor defaultSettingsEditor = facetType.createDefaultConfigurationEditor(project, configuration);
    if (defaultSettingsEditor != null) {
      myDefaultSettingsConfigurable = new DefaultFacetSettingsConfigurable<C>(facetType, project, defaultSettingsEditor, configuration);
      add(myDefaultSettingsConfigurable);
    }
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@NotNull
@Override
public List<DataSourceTemplate> getDataSourceTemplates() {
  if (ProjectFacetManager.getInstance(myDbFacade.getProject()).hasFacets(AndroidFacet.ID)) {
    return Collections.singletonList(DEFAULT_TEMPLATE);
  }
  else {
    return Collections.emptyList();
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void projectClosed() {
  if (!ProjectFacetManager.getInstance(myProject).hasFacets(AndroidFacet.ID)) {
    return;
  }
  final String basePath = FileUtil.toCanonicalPath(myProject.getBasePath());

  if (basePath != null) {
    final Set<AndroidRemoteDbInfo> infos = collectAllUsedDatabases();
    AndroidRemoteDataBaseManager.getInstance().updateDbUsagesForProject(basePath, infos);
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@NotNull
@Override
public PsiClass[] findClasses(@NotNull String qualifiedName, @NotNull GlobalSearchScope scope) {
  Project project = scope.getProject();
  if (project == null || !ProjectFacetManager.getInstance(project).hasFacets(AndroidFacet.ID)) {
    return PsiClass.EMPTY_ARRAY;
  }

  if (INTERNAL_R_CLASS_QNAME.equals(qualifiedName)) {
    CommonProcessors.CollectUniquesProcessor<PsiClass> processor = new CommonProcessors.CollectUniquesProcessor<PsiClass>();
    processInternalRClasses(project, scope, processor);
    Collection<PsiClass> results = processor.getResults();
    return results.isEmpty() ? PsiClass.EMPTY_ARRAY : results.toArray(new PsiClass[results.size()]);
  }

  final int lastDot = qualifiedName.lastIndexOf('.');
  if (lastDot < 0) {
    return PsiClass.EMPTY_ARRAY;
  }
  final String shortName = qualifiedName.substring(lastDot + 1);
  final String parentName = qualifiedName.substring(0, lastDot);

  if (shortName.length() == 0 || !parentName.endsWith(".R")) {
    return PsiClass.EMPTY_ARRAY;
  }
  List<PsiClass> result = new SmartList<PsiClass>();
  for (PsiClass parentClass : JavaPsiFacade.getInstance(project).findClasses(parentName, scope)) {
    ContainerUtil.addIfNotNull(result, parentClass.findInnerClassByName(shortName, false));
  }
  return result.isEmpty() ? PsiClass.EMPTY_ARRAY : result.toArray(new PsiClass[result.size()]);
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void projectOpened() {
  final CompilerManager manager = CompilerManager.getInstance(myProject);
  manager.addBeforeTask(new AndroidPrecompileTask());

  myDisposable = new Disposable() {
    @Override
    public void dispose() {
    }
  };

  if (!ApplicationManager.getApplication().isUnitTestMode() &&
      !ApplicationManager.getApplication().isHeadlessEnvironment()) {

    if (ProjectFacetManager.getInstance(myProject).hasFacets(AndroidFacet.ID)) {
      createAndroidSpecificComponents();
    }
    else {
      final MessageBusConnection connection = myProject.getMessageBus().connect(myDisposable);

      connection.subscribe(FacetManager.FACETS_TOPIC, new FacetManagerAdapter() {
        @Override
        public void facetAdded(@NotNull Facet facet) {
          if (facet instanceof AndroidFacet) {
            createAndroidSpecificComponents();
            connection.disconnect();
          }
        }
      });
    }
  }
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Nullable
@Override
public GlobalSearchScope getResolveScope(@NotNull VirtualFile file, Project project) {
  if (!ProjectFacetManager.getInstance(project).hasFacets(AndroidFacet.ID)) return null;

  ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
  JdkOrderEntry entry = ContainerUtil.findInstance(index.getOrderEntriesForFile(file), JdkOrderEntry.class);
  final Sdk sdk = entry == null ? null : entry.getJdk();
  if (sdk == null || !(sdk.getSdkType() instanceof AndroidSdkType)) {
    return null;
  }

  return new MyJdkScope(project, entry, index.isInLibrarySource(file));
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void update(AnActionEvent e) {
  super.update(e);
  final Project project = e.getData(CommonDataKeys.PROJECT);
  e.getPresentation().setVisible(project != null &&
                                 ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID).size() > 0);
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@NotNull
private static Set<String> collectAllProcessNames(Project project) {
  final List<AndroidFacet> facets = ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID);
  final Set<String> result = new HashSet<String>();

  for (AndroidFacet facet : facets) {
    final String packageName = AndroidCompileUtil.getAaptManifestPackage(facet);

    if (packageName != null) {
      result.add(packageName.toLowerCase());
    }
    final Manifest manifest = facet.getManifest();

    if (manifest != null) {
      final XmlElement xmlElement = manifest.getXmlElement();

      if (xmlElement != null) {
        collectProcessNames(xmlElement, result);
      }
    }
    final IdeaAndroidProject androidProject = facet.getIdeaAndroidProject();
    if (androidProject != null) {
      collectApplicationIds(androidProject, result);
    }
  }

  return result;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public void update(@NotNull AnActionEvent e) {
  final Project project = e.getProject();
  e.getPresentation().setEnabledAndVisible(
    project != null &&
    !ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID).isEmpty() &&
    AndroidSdkUtils.isAndroidSdkAvailable());
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@NotNull
public static List<AndroidFacet> getApplicationFacets(@NotNull Project project) {
  final List<AndroidFacet> result = new ArrayList<AndroidFacet>();

  for (AndroidFacet facet : ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID)) {
    if (!facet.isLibraryProject()) {
      result.add(facet);
    }
  }
  return result;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Nullable
private static AndroidSdkData getFirstAndroidModuleSdkData(Project project) {
  List<AndroidFacet> facets = ProjectFacetManager.getInstance(project).getFacets(AndroidFacet.ID);
  for (AndroidFacet facet : facets) {
    AndroidPlatform androidPlatform = facet.getConfiguration().getAndroidPlatform();
    if (androidPlatform != null) {
      return androidPlatform.getSdkData();
    }
  }
  return null;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public boolean execute(CompileContext context) {
  final Project project = context.getProject();

  if (!ProjectFacetManager.getInstance(project).hasFacets(AndroidFacet.ID)) {
    return true;
  }
  BuildManager.forceModelLoading(context);

  // in out-of-process mode gen roots will be excluded by AndroidExcludedJavaSourceRootProvider
  // we do it here for internal mode and also to make there roots 'visibly excluded' in IDE settings
  createGenModulesAndSourceRoots(project);

  return true;
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Override
public boolean canProcessElement(@NotNull PsiElement element) {
  if (element instanceof PsiPackage) {
    // possibly renaming application package
    return ProjectFacetManager.getInstance(element.getProject()).hasFacets(AndroidFacet.ID);
  }
  return AndroidRenameHandler.isPackageAttributeInManifest(element.getProject(), element);
}
 

import com.intellij.facet.ProjectFacetManager; //导入依赖的package包/类
@Nullable
private AndroidPlatform getPlatform() {
  AndroidPlatform newPlatform = null;
  final List<AndroidFacet> facets = ProjectFacetManager.getInstance(myProject).getFacets(AndroidFacet.ID);
  if (facets.size() > 0) {
    final AndroidFacet facet = facets.get(0);
    newPlatform = facet.getConfiguration().getAndroidPlatform();
  }
  return newPlatform;
}