android/src/com/android/tools/idea/gradle/project/AdtModuleImporter.java

/*
 * Copyright (C) 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tools.idea.gradle.project;

import com.android.SdkConstants;
import com.android.tools.idea.gradle.eclipse.GradleImport;
import com.android.tools.idea.gradle.eclipse.AdtImportBuilder;
import com.android.tools.idea.gradle.eclipse.AdtImportProvider;
import com.android.tools.idea.gradle.util.GradleUtil;
import com.google.common.base.Supplier;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.intellij.ide.util.projectWizard.ModuleWizardStep;
import com.intellij.ide.util.projectWizard.WizardContext;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.util.*;

/**
 * Creates new project modules from existing Android Eclipse projects.
 */
public final class AdtModuleImporter extends ModuleImporter {
  private final WizardContext myContext;
  private List<ModuleWizardStep> myWizardSteps;
  private final AdtImportProvider myProvider;

  public AdtModuleImporter(WizardContext context) {
    super();
    myContext = context;
    myProvider = new AdtImportProvider(false);
    myContext.setProjectBuilder(myProvider.getBuilder());
  }

  public static boolean isAdtProjectLocation(VirtualFile importSource) {
    VirtualFile target = ProjectImportUtil.findImportTarget(importSource);
    if (target == null) {
      return false;
    }
    VirtualFile targetDir = target.isDirectory() ? target : target.getParent();
    File targetDirFile = VfsUtilCore.virtualToIoFile(targetDir);
    return GradleImport.isAdtProjectDir(targetDirFile) && targetDir.findChild(SdkConstants.FN_BUILD_GRADLE) == null;
  }

  @Override
  public List<? extends ModuleWizardStep> createWizardSteps() {
    ModuleWizardStep[] adtImportSteps = myProvider.createSteps(myContext);
    myWizardSteps = Lists.newArrayList(adtImportSteps);
    return myWizardSteps;
  }

  @Override
  public void importProjects(Map<String, VirtualFile> projects) {
    Project project = myContext.getProject();
    assert project != null;
    AdtImportBuilder builder = AdtImportBuilder.getBuilder(myContext);
    assert builder != null;
    GradleImport importer = getGradleImport();
    ImmutableMap.Builder<File, String> modules = ImmutableMap.builder();
    for (Map.Entry<String, VirtualFile> entry : projects.entrySet()) {
      modules.put(VfsUtilCore.virtualToIoFile(entry.getValue()),
                  GradleUtil.getDefaultPhysicalPathFromGradlePath(entry.getKey()));
    }

    importer.setImportModuleNames(modules.build());
    if (builder.validate(null, project)) {
      builder.commit(project, null, ModulesProvider.EMPTY_MODULES_PROVIDER, null);
      if (!ApplicationManager.getApplication().isUnitTestMode()) {
        project.save();
      }
      builder.cleanup();
    }
  }

  @NotNull
  private GradleImport getGradleImport() {
    AdtImportBuilder builder = AdtImportBuilder.getBuilder(myContext);
    assert builder != null;
    GradleImport importer = builder.getImporter();
    assert importer != null;
    return importer;
  }

  @Override
  public boolean isValid() {
    return true;
  }

  @Override
  public boolean canImport(VirtualFile importSource) {
    return isAdtProjectLocation(importSource);
  }

  @Override
  public Set<ModuleToImport> findModules(VirtualFile importSource) throws IOException {
    final AdtImportBuilder builder = (AdtImportBuilder)myContext.getProjectBuilder();
    assert builder != null;
    builder.setSelectedProject(VfsUtilCore.virtualToIoFile(importSource));
    final GradleImport gradleImport = getGradleImport();
    gradleImport.importProjects(Collections.singletonList(VfsUtilCore.virtualToIoFile(importSource)));
    Map<String, File> adtProjects = gradleImport.getDetectedModuleLocations();
    Set<ModuleToImport> modules = Sets.newHashSet();
    for (final Map.Entry<String, File> entry : adtProjects.entrySet()) {
      VirtualFile location = VfsUtil.findFileByIoFile(entry.getValue(), false);
      modules.add(new ModuleToImport(entry.getKey(), location, new Supplier<Iterable<String>>() {
        @Override
        public Iterable<String> get() {
          return gradleImport.getProjectDependencies(entry.getKey());
        }
      }));
    }
    return modules;
  }

  @Override
  public boolean isStepVisible(ModuleWizardStep step) {
    return myWizardSteps.contains(step);
  }

}