/*
* 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.android.tools.idea.templates.TemplateUtils;
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.android.sdk.AndroidSdkUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* 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 = Arrays.asList(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 = AndroidSdkUtils.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 = new File(project.getBasePath());
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(Arrays.asList(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(GradleImport.IMPORT_SUMMARY_TXT);
if (summary != null) {
TemplateUtils.openEditor(project, summary);
}
}
@Nullable
public static AdtImportBuilder getBuilder(@Nullable WizardContext context) {
if (context != null) {
return (AdtImportBuilder)context.getProjectBuilder();
}
return null;
}
}