Question

系统：4.19.49-1-MANJARO

备份android项目时，排除构建文件夹更快。我注意到有两种排除方法：

Android Studio->构建->清理项目
手动删除文件夹

当我们有多个项目和所有相关引用（也是Android项目）时，问题就来了。不方便打开项目->清理或手动删除所有文件夹。我的简单解决方案是：

在android studio出口上执行clean命令
创建shell脚本以检查模式ex。如果存在build.gradle文件名，则删除“ build”文件夹。然后从当前文件夹退出并重复模式检查另一个文件夹

问题：

如何解决方案1和2？
还有其他便捷的方法可以同时清理多个项目吗？如果是，怎么办？

Answer 1

对于解决方案1和2，清理操作相同，如果gradlew clean存在并且具有Android Studio项目根目录的可执行权限，则调用gradlew。让gradle进行清理。

对于解决方案1 ，您需要创建一个简单的intellij插件，以jar形式发布，并通过Install plugin from Disk...从本地在Android Studio中安装此插件。

该插件的目标和任务非常简单，注册一些回调并仅监听应用程序和项目事件。收到应用程序或项目关闭事件后，请执行清理操作。

由于清理是基于项目的，因此对于解决方案1，建议您注册一个项目事件侦听器并对项目关闭回调执行清理操作。

对于解决方案1的实现，如果您具有intellij插件开发背景，那是完美的。如果没有，请看一下documentation来实现一个简单的实现。

这是解决方案1的实现。创建一个虚拟动作，然后在动作的构造函数中注册侦听器。

plugin.xml

<!-- ... -->
<actions>
<!-- Add your actions here -->
<action id="ExitHooker.DummyAction" class="com.exithooker.DummyAction" text="DummyAction"
        description="This is just a dummy action">
  <add-to-group group-id="ToolsMenu" anchor="last"/>
</action>

DummyAction.java

package com.exithooker;

import com.intellij.openapi.actionSystem.AnAction;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.application.ApplicationAdapter;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.project.VetoableProjectManagerListener;
import com.intellij.openapi.project.ex.ProjectManagerEx;
import com.intellij.openapi.vfs.VirtualFile;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;

public class DummyAction extends AnAction {

    public DummyAction() {
        super();
        Logger.getInstance(getClass()).info("DummyAction Loaded");
        ApplicationManager.getApplication().addApplicationListener(new ApplicationAdapter() {
            @Override
            public void applicationExiting() {
                super.applicationExiting();
                Logger.getInstance(DummyAction.this.getClass()).info("applicationExisting");
            }
        });

        ProjectManagerEx.getInstance().addProjectManagerListener(new VetoableProjectManagerListener() {
            @Override
            public boolean canClose(@NotNull Project project) {
                return true;
            }

            @Override
            public void projectClosingBeforeSave(@NotNull Project project) {
                Logger.getInstance(DummyAction.class).info("DummyAction.projectClosingBeforeSave");
                final VirtualFile gradlewVirtualFile = project.getBaseDir().findChild("gradlew");
                if (gradlewVirtualFile != null && gradlewVirtualFile.exists() && new File(gradlewVirtualFile.getCanonicalPath()).canExecute()) {
                    Logger.getInstance(DummyAction.class).info(gradlewVirtualFile.getCanonicalPath());

                    ProgressManager.getInstance().runProcessWithProgressSynchronously(new Runnable() {
                        @Override
                        public void run() {
                            try {
                                ProgressManager.getGlobalProgressIndicator().setIndeterminate(true);

                                final int wait = Runtime.getRuntime().exec(new String[]{
                                        gradlewVirtualFile.getCanonicalPath(), "clean"
                                }, null, new File(gradlewVirtualFile.getCanonicalFile().getParent().getCanonicalPath()))
                                        .waitFor();

                                ProgressManager.getGlobalProgressIndicator().stop();
                                Logger.getInstance(DummyAction.class).info("gradlew clean return = " + wait);
                            } catch (IOException | InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }, "RUN GRADLEW CLEAN", false, project);
                }
            }

            @Override
            public void projectClosed(Project project) {
                Logger.getInstance(DummyAction.class).info("DummyAction.projectClosed");
            }

            @Override
            public void projectClosing(Project project) {
                Logger.getInstance(DummyAction.class).info("DummyAction.projectClosing");
            }
        });
    }

    @Override
    public void actionPerformed(AnActionEvent e) {
        Logger.getInstance(getClass()).info("actionPerformed");
    }
}

对于解决方案2 ，其实现非常简单，只需保存您的所有项目路径，然后更改为要在脚本中执行gradlew clean任务的每个路径即可。

#!/bin/bash
projects=(/path/to/project1 /path/to/project2 /path/to/projectn)
for p in ${projects[@]}
do
    if [ -d $p ];then
        pushd .
        cd $p && [ -x $p/gradlew ] && $p/gradlew clean
        popd
    else
        printf "\e[31merror: $p not exists\e[0m\n"
    fi
done

最后，我个人更喜欢解决方案2。解决方案2只需几分钟即可编写脚本，并且调试脚本非常容易。解决方案1需要编写代码，调试插件和安装插件，有经验的插件开发人员可能要花几个小时，初学者甚至要花几天时间。

如何同时清理多个android项目？

1 个答案: