android/src/com/android/tools/idea/gradle/eclipse/AdtImportBuilder.java

/*
 * Copyright (C) 2013 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.eclipse;

import com.android.tools.idea.gradle.project.GradleProjectImporter;
import com.android.tools.idea.gradle.project.NewProjectImportGradleSyncListener;
import com.android.tools.idea.templates.TemplateManager;
import com.intellij.ide.util.projectWizard.WizardContext;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.ModifiableModuleModel;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
import com.intellij.openapi.ui.Messages;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.packaging.artifacts.ModifiableArtifactModel;
import com.intellij.projectImport.ProjectImportBuilder;
import icons.EclipseIcons;
import org.jetbrains.android.sdk.AndroidSdkData;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.List;

import static com.android.tools.idea.gradle.eclipse.GradleImport.IMPORT_SUMMARY_TXT;
import static com.android.tools.idea.gradle.util.Projects.getBaseDirPath;
import static com.android.tools.idea.templates.TemplateUtils.openEditor;
import static org.jetbrains.android.sdk.AndroidSdkUtils.tryToChooseAndroidSdk;

/**
 * Importer which can import an ADT project as a Gradle project (it will first
 * run the Eclipse importer, which generates a Gradle project, and then it will
 * delegate to {@link org.jetbrains.plugins.gradle.service.project.wizard.GradleProjectImportBuilder}
 * to perform the IntelliJ model import.
 * */
public class AdtImportBuilder extends ProjectImportBuilder<String> {
  private File mySelectedProject;
  private GradleImport myImporter;
  private final boolean myCreateProject;

  public AdtImportBuilder(boolean createProject) {
    myCreateProject = createProject;
  }

  @NotNull
  @Override
  public String getName() {
    return "ADT (Eclipse Android)";
  }

  public void setSelectedProject(@NotNull File selectedProject) {
    mySelectedProject = selectedProject;
    List<File> projects = Collections.singletonList(mySelectedProject);
    myImporter = createImporter(projects);
  }

  protected GradleImport createImporter(@NotNull List<File> projects) {
    GradleImport importer = new GradleImport();
    importer.setImportIntoExisting(!myCreateProject);
    if (myCreateProject) {
      File templates = TemplateManager.getTemplateRootFolder();
      if (templates != null) {
        File wrapper = TemplateManager.getWrapperLocation(templates);
        if (wrapper.exists()) {
          importer.setGradleWrapperLocation(wrapper);
          AndroidSdkData sdkData = tryToChooseAndroidSdk();
          if (sdkData != null) {
            importer.setSdkLocation(sdkData.getLocation());
          }
        }
      }
    }
    try {
      importer.importProjects(projects);
    } catch (IOException ioe) {
      // pass: the errors are written into the import error list shown in the warnings panel
    }
    return importer;
  }

  @Nullable
  public GradleImport getImporter() {
    return myImporter;
  }

  @Override
  public Icon getIcon() {
    // TODO: Can we get the ADT bundle icon?
    return EclipseIcons.Eclipse;
  }

  @Override
  @Nullable
  public List<String> getList() {
    return null;
  }

  @Override
  public boolean isMarked(String element) {
    return false;
  }

  @Override
  public void setList(List<String> list) throws ConfigurationException {
  }

  @Override
  public void setOpenProjectSettingsAfter(boolean on) {
  }

  @Nullable
  @Override
  public List<Module> commit(final Project project,
                             @Nullable ModifiableModuleModel model,
                             ModulesProvider modulesProvider,
                             @Nullable ModifiableArtifactModel artifactModel) {
    File destDir = getBaseDirPath(project);
    try {
      if (!destDir.exists()) {
        boolean ok = destDir.mkdirs();
        if (!ok) {
          throw new IOException("Could not create destination directory");
        }
      }
      // Re-read the project here since one of the wizard steps can have modified the importer options,
      // and that affects the imported state (for example, if you enable/disable the replace-lib-with-dependency
      // options, the set of modules can change)
      readProjects();
      if (!myImporter.getErrors().isEmpty()) {
        return null;
      }
      myImporter.exportProject(destDir, true);
      project.getBaseDir().refresh(false, true);
    }
    catch (IOException e) {
      Logger.getInstance(AdtImportBuilder.class).error(e);
      return null;
    }

    try {
      final NewProjectImportGradleSyncListener callback = new NewProjectImportGradleSyncListener() {
        @Override
        public void syncSucceeded(@NotNull final Project project) {
          ApplicationManager.getApplication().invokeLater(new Runnable() {
            @Override
            public void run() {
              activateProjectView(project);
              openSummary(project);
            }
          });
        }

        @Override
        public void syncFailed(@NotNull final Project project, @NotNull String errorMessage) {
          ApplicationManager.getApplication().invokeLater(new Runnable() {
            @Override
            public void run() {
              createTopLevelProjectAndOpen(project);
              openSummary(project);
            }
          });
        }
      };
      final GradleProjectImporter importer = GradleProjectImporter.getInstance();
      if (myCreateProject) {
        importer.importProject(project.getName(), destDir, true, callback, project, null);
      } else {
        importer.requestProjectSync(project, true, callback);
      }
    }
    catch (ConfigurationException e) {
      Messages.showErrorDialog(project, e.getMessage(), e.getTitle());
    }
    catch (Throwable e) {
      Messages.showErrorDialog(project, e.getMessage(), "ADT Project Import");
    }

    return Collections.emptyList();
  }

  public void readProjects() {
    try {
      myImporter.importProjects(Collections.singletonList(mySelectedProject));
    }
    catch (IOException e) {
      // Ignore I/O warnings; they are also logged to the warnings panel we display
    }
  }

  @SuppressWarnings("ConstantConditions")
  @Override
  public boolean validate(@Nullable Project current, Project dest) {
    return super.validate(current, dest);
  }

  private static void openSummary(Project project) {
    VirtualFile summary = project.getBaseDir().findChild(IMPORT_SUMMARY_TXT);
    if (summary != null) {
      openEditor(project, summary);
    }
  }

  @Nullable
  public static AdtImportBuilder getBuilder(@Nullable WizardContext context) {
    if (context != null) {
      return (AdtImportBuilder)context.getProjectBuilder();
    }

    return null;
  }
}