android/src/com/android/tools/idea/gradle/project/GradleBuildFileUpdater.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.project;

import com.android.SdkConstants;
import com.android.tools.idea.gradle.GradleSyncState;
import com.android.tools.idea.gradle.facet.AndroidGradleFacet;
import com.android.tools.idea.gradle.parser.GradleSettingsFile;
import com.android.tools.idea.gradle.util.GradleUtil;
import com.google.common.base.Joiner;
import com.intellij.openapi.application.Result;
import com.intellij.openapi.command.WriteCommandAction;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.module.ModuleUtilCore;
import com.intellij.openapi.project.ModuleAdapter;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.newvfs.BulkFileListener;
import com.intellij.openapi.vfs.newvfs.events.VFileEvent;
import com.intellij.openapi.vfs.newvfs.events.VFilePropertyChangeEvent;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;

import java.util.List;

/**
 * GradleBuildFileUpdater listens for module-level events and updates the settings.gradle and build.gradle files to reflect any changes it
 * sees.
 */
public class GradleBuildFileUpdater extends ModuleAdapter implements BulkFileListener {
  private final Project myProject;

  public GradleBuildFileUpdater(@NotNull Project project) {
    myProject = project;
  }

  @Override
  public void moduleAdded(@NotNull final Project project, @NotNull final Module module) {
    // Don't do anything if we are in the middle of a project sync.
    if (GradleSyncState.getInstance(project).isSyncInProgress()) {
      return;
    }
    final GradleSettingsFile settingsFile = GradleSettingsFile.get(project);
    if (settingsFile != null) {
      // if settings.gradle does not have a module, we are in the middle of setting up a project.
      final PsiFile psiFile = settingsFile.getPsiFile();
      Module found = ModuleUtilCore.findModuleForPsiElement(psiFile);
      if (found != null) {
        new WriteCommandAction<Void>(project, "Update settings.gradle", psiFile) {
          @Override
          protected void run(@NotNull Result<Void> result) throws Throwable {
            settingsFile.addModule(module);
          }
        }.execute();
      }
    }
  }

  @Override
  public void moduleRemoved(@NotNull Project project, @NotNull final Module module) {
    // Don't do anything if we are in the middle of a project sync.
    if (GradleSyncState.getInstance(project).isSyncInProgress()) {
      return;
    }
    final GradleSettingsFile settingsFile = GradleSettingsFile.get(project);
    if (settingsFile != null) {
      new WriteCommandAction<Void>(project, "Update settings.gradle", settingsFile.getPsiFile()) {
        @Override
        protected void run(@NotNull Result<Void> result) throws Throwable {
          settingsFile.removeModule(module);
        }
      }.execute();
    }
  }

  @Override
  public void before(@NotNull List<? extends VFileEvent> events) {
  }

  /**
   * This gets called on all file system changes, but we're interested in changes to module root directories. When we see them, we'll update
   * the settings.gradle file. Note that users can also refactor modules by renaming them, which just changes their display name and not
   * the filesystem directory -- when that happens, this class gets a
   * {@link ModuleAdapter#modulesRenamed(com.intellij.openapi.project.Project, java.util.List)} callback. However, it's not appropriate to
   * update settings.gradle in that case since Gradle doesn't case about IJ's display name of the module.
   */
  @Override
  public void after(@NotNull List<? extends VFileEvent> events) {
    for (VFileEvent event : events) {
      if (!(event instanceof VFilePropertyChangeEvent)) {
        continue;
      }
      VFilePropertyChangeEvent propChangeEvent = (VFilePropertyChangeEvent)event;
      if (!(VirtualFile.PROP_NAME.equals(propChangeEvent.getPropertyName()))) {
        continue;
      }

      VirtualFile eventFile = propChangeEvent.getFile();
      if (!eventFile.isDirectory()) {
        continue;
      }

      // Dig through our modules and find the one that matches the change event's path (the module will already have its path updated by
      // now).
      Module module = null;
      Module[] modules = ModuleManager.getInstance(myProject).getModules();
      for (Module m : modules) {
        VirtualFile file = GradleUtil.getGradleBuildFile(m);
        if (file != null) {
          VirtualFile moduleDir = file.getParent();
          if (moduleDir != null && FileUtil.pathsEqual(eventFile.getPath(), moduleDir.getPath())) {
            module = m;
            break;
          }
        }
      }

      // If we found the module, then remove the old reference from the settings.gradle file and put in a new one.
      if (module != null) {
        AndroidGradleFacet androidGradleFacet = AndroidGradleFacet.getInstance(module);
        if (androidGradleFacet == null) {
          continue;
        }
        String oldPath = androidGradleFacet.getConfiguration().GRADLE_PROJECT_PATH;
        String newPath = updateProjectNameInGradlePath(androidGradleFacet, eventFile);

        if (oldPath.equals(newPath)) {
          continue;
        }

        GradleSettingsFile settingsFile = GradleSettingsFile.get(myProject);
        if (settingsFile != null) {
          settingsFile.removeModule(oldPath);
          settingsFile.addModule(newPath, VfsUtilCore.virtualToIoFile(eventFile));
        }
      }
    }
  }

  @NotNull
  private static String updateProjectNameInGradlePath(@NotNull AndroidGradleFacet androidGradleFacet, @NotNull VirtualFile moduleDir) {
    String gradlePath = androidGradleFacet.getConfiguration().GRADLE_PROJECT_PATH;
    if (gradlePath.equals(SdkConstants.GRADLE_PATH_SEPARATOR)) {
      // This is root project, renaming folder does not affect it since the path is just ":".
      return gradlePath;
    }
    List<String> pathSegments = GradleUtil.getPathSegments(gradlePath);
    pathSegments.remove(pathSegments.size() - 1);
    pathSegments.add(moduleDir.getName());

    String newPath = Joiner.on(SdkConstants.GRADLE_PATH_SEPARATOR).join(pathSegments);
    androidGradleFacet.getConfiguration().GRADLE_PROJECT_PATH = newPath;
    return newPath;
  }
}