android多余资源自动清理工具arc发布到google code

1. 我已经将arc(android resource cleaner)的3.0 beta版本的源代码发布到google code,项目目前还很粗鄙,需要进一步的完善,里面也可能还有不少bug,需要解决,感兴趣的朋友可以联系我,里面有我的qq号码(286505491).

2. 项目所在地址: https://android-resource-cleaner.googlecode.com/svn/trunk/

3.项目里面两个主要的类:

ARC.java   主要负责UI和事件处理

package xiaogang.src;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.SwingUtilities;

class ARC extends JFrame {
    private static final String VERSION_STR = "3.0 beta";
    private static final long serialVersionUID = -1600532762007579488L;

    private JMenu mFileMenu;
    private JMenu mActionMenu;
    private JMenu mHelpMenu;

    private JMenuItem mOpenFileMenuItem;
    private JMenuItem mDeleteMenuItem;
    private JMenuItem mDeleteAllMenuItem;
    private JMenuItem mExitMenuItem;
    private JMenuItem mHelpMenuItem;

    private JButton mJButton;
    private JMenuBar mJMenuBar1;
    private JList mUnusedResList;
    private JSeparator mJSeparator1, mJSeparator2;

    private ResProbe mCleanRes;

    private String mSPath;

    private boolean running = false;

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                ARC inst = new ARC();
                inst.setLocationRelativeTo(null);
                inst.setVisible(true);
            }
        });
    }

    public ARC() {
        super();
        setupGUI();
    }

    private void setupGUI() {
        try {
            BorderLayout thisLayout = new BorderLayout();
            getContentPane().setLayout(thisLayout);

            mUnusedResList = new JList();
            mUnusedResList.setListData(new String[] {
                    "请打开Android工程根目录"
            });
            mUnusedResList.setLayoutOrientation(JList.VERTICAL);
            JScrollPane listScroller = new JScrollPane(mUnusedResList);
            getContentPane().add(listScroller, BorderLayout.CENTER);

            mJButton = new JButton("开始");
            mJButton.addActionListener(new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent arg0) {
                    if (running) {
                        mCleanRes.setbCancel(true);
                        mJButton.setText("开始");
                        running = false;
                        return;
                    }
                    if (mSPath == null && mSPath.length() <= 0) {
                        JOptionPane.showMessageDialog(ARC.this, "选择目录", "Error",
                                JOptionPane.ERROR_MESSAGE);
                    }

                    running = true;
                    mJButton.setText("取消");

                    new Thread() {

                        @Override
                        public void run() {
                            mCleanRes.run(ARC.this);
                        }
                    }.start();
                }
            });
            getContentPane().add(mJButton, BorderLayout.SOUTH);

            setSize(400, 300);
            {
                mJMenuBar1 = new JMenuBar();
                setJMenuBar(mJMenuBar1);
                {
                    mFileMenu = new JMenu();
                    mJMenuBar1.add(mFileMenu);
                    mFileMenu.setText("文件");
                    {
                        mOpenFileMenuItem = new JMenuItem();
                        mFileMenu.add(mOpenFileMenuItem);
                        mOpenFileMenuItem.setText("打开");
                        mOpenFileMenuItem.addActionListener(new ActionListener() {

                            @Override
                            public void actionPerformed(ActionEvent e) {
                                if (e.getActionCommand().equals("打开")) {
                                    JFileChooser jFileChooser = new JFileChooser();
                                    jFileChooser
                                    .setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
                                    int returnVal = jFileChooser.showOpenDialog(ARC.this);
                                    if (returnVal == JFileChooser.APPROVE_OPTION) {
                                        mSPath = jFileChooser.getSelectedFile().getAbsolutePath();
                                        mCleanRes = new ResProbe(mSPath);
                                        mUnusedResList.setListData(new String[] {
                                                "工程目录: "+mSPath
                                        });
                                        mUnusedResList.invalidate();
                                    }
                                }
                            }
                        });
                    }
                    {
                        mJSeparator1 = new JSeparator();
                        mFileMenu.add(mJSeparator1);
                    }
                    {
                        mExitMenuItem = new JMenuItem();
                        mFileMenu.add(mExitMenuItem);
                        mExitMenuItem.setText("退出");
                        mExitMenuItem.addActionListener(new ActionListener() {

                            @Override
                            public void actionPerformed(ActionEvent arg0) {
                                ARC.this.dispose();
                            }
                        });
                    }
                }

                mActionMenu = new JMenu();
                mJMenuBar1.add(mActionMenu);
                mActionMenu.setText("操作");

                mDeleteMenuItem = new JMenuItem();
                mActionMenu.add(mDeleteMenuItem);
                mDeleteMenuItem.setText("删除");
                mDeleteMenuItem.addActionListener(new ActionListener() {

                    @Override
                    public void actionPerformed(ActionEvent arg0) {
                        mCleanRes.delete(mUnusedResList.getSelectedIndices());
                        mUnusedResList.setListData(mCleanRes.getResult());
                        mUnusedResList.invalidate();
                    }

                });
                mJSeparator2 = new JSeparator();
                mActionMenu.add(mJSeparator2);
                mDeleteAllMenuItem = new JMenuItem();
                mActionMenu.add(mDeleteAllMenuItem);
                mDeleteAllMenuItem.setText("删除所有");
                mDeleteAllMenuItem.addActionListener(new ActionListener() {

                    @Override
                    public void actionPerformed(ActionEvent arg0) {
                        mCleanRes.deleteAll();
                        mUnusedResList.setListData(mCleanRes.getResult());
                        mUnusedResList.invalidate();
                    }
                });

                mHelpMenu = new JMenu();
                mJMenuBar1.add(mHelpMenu);
                mHelpMenu.setText("帮助");

                mHelpMenuItem = new JMenuItem();
                mHelpMenu.add(mHelpMenuItem);
                mHelpMenuItem.setText("帮助");
                mHelpMenuItem.addActionListener(new ActionListener() {

                    @Override
                    public void actionPerformed(ActionEvent arg0) {
                        JOptionPane.showMessageDialog(ARC.this, "Version v" + VERSION_STR
                                + "\n赵小刚,  QQ: 286505491", "ARC",
                                JOptionPane.INFORMATION_MESSAGE);
                    }
                });
            }
            this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void setResult(List<ResSet> list) {
        running = false;
        mJButton.setText("开始");
        String[] fileList = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            fileList[i] = list.get(i).toString();
        }
        if (fileList.length == 0) {
            fileList = new String[1];
            fileList[0] = "No result";
        }
        mUnusedResList.setListData(fileList);
        mUnusedResList.invalidate();
    }

    public void setProgress(File file) {
        String[] pathList = new String[3];
        pathList[0] = "正在处理... : " + mSPath;
        pathList[1] = file.getParent().replace(mSPath, "");
        pathList[2] = file.getName();
        mUnusedResList.setListData(pathList);
        mUnusedResList.invalidate();
    }
}

ResProbe.java  负责扫描各种资源文件，源代码，r文件，清单文件，然后经过对比，找出冗余资源的核心类

package xiaogang.src;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class ResProbe {
    private volatile boolean isCanceled = false;
    private String mPackageName;
    private ARC mCallback;

    private File mBaseDirectory;
    private File mSrcDirectory;
    private File mResDirectory;
    private File mGenDirectory;
    private File mManifestFile;
    private File mRJavaFile;

    private List<ResSet> mResList = new ArrayList<ResSet>();
    private final Set<ResSet> mResources = new HashSet<ResSet>();
    private final Set<ResSet> mUsedResources = new HashSet<ResSet>();

    private static final Pattern sResourceTypePattern = Pattern
            .compile("^\\s*public static final class (\\w+)\\s*\\{$");
    private static final Pattern sResourceNamePattern = Pattern
            .compile("^\\s*public static( final)? int(\\[\\])? (\\w+)\\s*=\\s*(\\{|(0x)?[0-9A-Fa-f]+;)\\s*$");
    private static final FileType sJavaFileType = new FileType("java", "R." + FileType.USAGE_TYPE
            + "." + FileType.USAGE_NAME + "[^\\w_]");
    private static final FileType sXmlFileType = new FileType("xml", "[\" >]@"
            + FileType.USAGE_TYPE + "/" + FileType.USAGE_NAME + "[\" <]");

    private static final Map<String, ResType> sResourceTypes = new HashMap<String, ResType>();

    static {
        // anim
        sResourceTypes.put("anim", new ResType("anim") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals(getType())) {
                    return false;
                }

                final String name = fileName.split("\\.")[0];
                final Pattern pattern = Pattern.compile("^" + resourceName + "$");
                return pattern.matcher(name).find();
            }
        });

        // array
        sResourceTypes.put("array", new ResType("array") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<([a-z]+\\-)?array.*?name\\s*=\\s*\""
                        + resourceName + "\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // attr
        sResourceTypes.put("attr", new ResType("attr") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<attr.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }

            @Override
            public boolean doesFileUseResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (parent != null) {
                    if (!parent.isDirectory()) {
                        return false;
                    }

                    final String directoryType = parent.getName().split("-")[0];
                    if (!directoryType.equals("layout") && !directoryType.equals("values")) {
                        return false;
                    }
                }

                final Pattern pattern = Pattern.compile("<.+?:" + resourceName
                        + "\\s*=\\s*\".*?\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                final Pattern itemPattern = Pattern.compile("<item.+?name\\s*=\\s*\""
                        + resourceName + "\".*?>");
                final Matcher itemMatcher = itemPattern.matcher(fileContents);

                if (itemMatcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // bool
        sResourceTypes.put("bool", new ResType("bool") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<bool.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // color
        sResourceTypes.put("color", new ResType("color") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<color.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // dimen
        sResourceTypes.put("dimen", new ResType("dimen") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<dimen.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // drawable
        sResourceTypes.put("drawable", new ResType("drawable") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (directoryType.equals(getType())) {

                    final String name = fileName.split("\\.")[0];
                    final Pattern pattern = Pattern.compile("^" + resourceName + "$");
                    return pattern.matcher(name).find();
                }

                if (directoryType.equals("values")) {
                    final Pattern pattern = Pattern.compile("<drawable.*?name\\s*=\\s*\""
                            + resourceName + "\".*?/?>");
                    final Matcher matcher = pattern.matcher(fileContents);
                    if (matcher.find()) {
                        return true;
                    }
                }

                return false;
            }
        });

        // id
        sResourceTypes.put("id", new ResType("id") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values") && !directoryType.equals("layout")) {
                    return false;
                }

                final Pattern valuesPattern0 = Pattern
                        .compile("<item.*?type\\s*=\\s*\"id\".*?name\\s*=\\s*\"" + resourceName
                                + "\".*?/?>");
                final Pattern valuesPattern1 = Pattern.compile("<item.*?name\\s*=\\s*\""
                        + resourceName + "\".*?type\\s*=\\s*\"id\".*?/?>");
                final Pattern layoutPattern = Pattern.compile(":id\\s*=\\s*\"@\\+id/"
                        + resourceName + "\"");
                Matcher matcher = valuesPattern0.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                matcher = valuesPattern1.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                matcher = layoutPattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // integer
        sResourceTypes.put("integer", new ResType("integer") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<integer.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");
                final Matcher matcher = pattern.matcher(fileContents);
                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // layout
        sResourceTypes.put("layout", new ResType("layout") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals(getType())) {
                    return false;
                }

                final String name = fileName.split("\\.")[0];

                final Pattern pattern = Pattern.compile("^" + resourceName + "$");

                return pattern.matcher(name).find();
            }
        });

        // menu
        sResourceTypes.put("menu", new ResType("menu") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals(getType())) {
                    return false;
                }

                final String name = fileName.split("\\.")[0];
                final Pattern pattern = Pattern.compile("^" + resourceName + "$");
                return pattern.matcher(name).find();
            }
        });

        // plurals
        sResourceTypes.put("plurals", new ResType("plurals") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<plurals.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");
                final Matcher matcher = pattern.matcher(fileContents);
                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // raw
        sResourceTypes.put("raw", new ResType("raw") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals(getType())) {
                    return false;
                }

                final String name = fileName.split("\\.")[0];
                final Pattern pattern = Pattern.compile("^" + resourceName + "$");
                return pattern.matcher(name).find();
            }
        });

        // string
        sResourceTypes.put("string", new ResType("string") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<string.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");
                final Matcher matcher = pattern.matcher(fileContents);
                if (matcher.find()) {
                    return true;
                }

                return false;
            }
        });

        // style
        sResourceTypes.put("style", new ResType("style") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final Pattern pattern = Pattern.compile("<style.*?name\\s*=\\s*\"" + resourceName
                        + "\".*?/?>");
                final Matcher matcher = pattern.matcher(fileContents);
                if (matcher.find()) {
                    return true;
                }
                return false;
            }

            @Override
            public boolean doesFileUseResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (parent != null) {
                    if (!parent.isDirectory()) {
                        return false;
                    }

                    final String directoryType = parent.getName().split("-")[0];
                    if (!directoryType.equals("values")) {
                        return false;
                    }
                }

                // (name="Parent.Child")
                final Pattern pattern = Pattern.compile("<style.*?name\\s*=\\s*\"" + resourceName
                        + "\\.\\w+\".*?/?>");

                final Matcher matcher = pattern.matcher(fileContents);

                if (matcher.find()) {
                    return true;
                }

                // (parent="Parent")
                final Pattern pattern1 = Pattern.compile("<style.*?parent\\s*=\\s*\""
                        + resourceName + "\".*?/?>");
                final Matcher matcher1 = pattern1.matcher(fileContents);
                if (matcher1.find()) {
                    return true;
                }
                return false;
            }
        });

        // styleable
        sResourceTypes.put("styleable", new ResType("styleable") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals("values")) {
                    return false;
                }

                final String[] styleableAttr = resourceName.split("\\[_\\\\.\\]");

                if (styleableAttr.length == 1) {

                    final Pattern pattern = Pattern.compile("<declare-styleable.*?name\\s*=\\s*\""
                            + styleableAttr[0] + "\".*?/?>");
                    final Matcher matcher = pattern.matcher(fileContents);

                    if (matcher.find()) {
                        return true;
                    }

                    return false;
                }

                final Pattern blockPattern = Pattern.compile("<declare-styleable.*?name\\s*=\\s*\""
                        + styleableAttr[0] + "\".*?>(.*?)</declare-styleable\\s*>");
                final Matcher blockMatcher = blockPattern.matcher(fileContents);

                if (blockMatcher.find()) {
                    final String styleableAttributes = blockMatcher.group(1);

                    final Pattern attributePattern = Pattern.compile("<attr.*?name\\s*=\\s*\""
                            + styleableAttr[1] + "\".*?/?>");
                    final Matcher attributeMatcher = attributePattern.matcher(styleableAttributes);
                    if (attributeMatcher.find()) {
                        return true;
                    }
                    return false;
                }

                return false;
            }
        });

        // xml
        sResourceTypes.put("xml", new ResType("xml") {
            @Override
            public boolean doesFileDeclareResource(final File parent, final String fileName,
                    final String fileContents, final String resourceName) {
                if (!parent.isDirectory()) {
                    return false;
                }

                final String directoryType = parent.getName().split("-")[0];
                if (!directoryType.equals(getType())) {
                    return false;
                }

                final String name = fileName.split("\\.")[0];
                final Pattern pattern = Pattern.compile("^" + resourceName + "$");
                return pattern.matcher(name).find();
            }
        });
    }

    public ResProbe() {
        super();
        final String baseDirectory = System.getProperty("user.dir");
        mBaseDirectory = new File(baseDirectory);
    }

    protected ResProbe(final String baseDirectory) {
        super();
        mBaseDirectory = new File(baseDirectory);
    }

    public void delete(int[] list) {
        LinkedList<ResSet> remove = new LinkedList<ResSet>();
        for (int i : list) {
            ResSet result = mResList.get(i);
            final String type = result.getType();
            System.out.println("type: "+type);
            if (type.equals("anim") || type.equals("drawable") || type.equals("layout")) {
                final String path = result.getPath();
                System.out.println("path: "+path);
                if (!isEmpty(path)) {
                    File file = new File(path);
                    file.delete();
                    remove.add(result);
                }
            }
        }
        mResList.removeAll(remove);
    }

    public String[] getResult() {
        String[] result = new String[mResList.size()];
        for (int i = 0; i < mResList.size(); i++) {
            result[i] = mResList.get(i).toString();
        }
        return result;
    }

    public void deleteAll() {
        LinkedList<ResSet> remove = new LinkedList<ResSet>();
        for (ResSet resource : mResList) {
            final String type = resource.getType();
            if (type.equals("anim") || type.equals("drawable") || type.equals("layout") ||type.equals("menu")) {
                final String path = resource.getPath();
                if (!isEmpty(path)) {
                    File file = new File(path);
                    file.delete();
                    remove.add(resource);
                }
            }
        }
        mResList.removeAll(remove);
    }

    private boolean isEmpty(CharSequence str) {
        if (str == null || str.length() == 0)
            return true;
        else
            return false;
    }

    public void showResult() {
        if (mCallback != null) {
            mCallback.setResult(mResList);
        }
    }

    @Override
    protected void finalize() throws Throwable {
        if (mResList != null) {
            mResList.clear();
        }
        super.finalize();
    }

    public void run(ARC callback) {

        isCanceled = false;

        if (callback != null) {
            this.mCallback = callback;
        }

        System.out.println("Running in: " + mBaseDirectory.getAbsolutePath());

        findPaths();

        if (mSrcDirectory == null || mResDirectory == null || mManifestFile == null) {
            System.err.println("The current directory is not a valid Android project root.");
            return;
        }

        mPackageName = findPackageName(mManifestFile);

        if (mPackageName == null || mPackageName.trim().length() == 0) {
            return;
        }

        if (mGenDirectory == null) {
            System.err.println("You must first build your project to generate R.java");
            return;
        }

        mRJavaFile = findRJavaFile(mGenDirectory, mPackageName);

        if (mRJavaFile == null) {
            System.err.println("You must first build your project to generate R.java");
            return;
        }

        mResources.clear();

        try {
            mResources.addAll(getResourceList(mRJavaFile));//查找R文件
        } catch (final IOException e) {
            System.err.println("The R.java found could not be opened.");
            e.printStackTrace();
        }

        if (isCanceled) {
            return;
        }

        System.out.println(mResources.size() + " resources found");
        System.out.println();

        mUsedResources.clear();

        searchFiles(null, mSrcDirectory, sJavaFileType);
        if (isCanceled) {
            return;
        }
        searchFiles(null, mResDirectory, sXmlFileType);
        if (isCanceled) {
            return;
        }
        searchFiles(null, mManifestFile, sXmlFileType);
        if (isCanceled) {
            return;
        }

        /*
         * Because attr and styleable are so closely linked, we need to do some
         * matching now to ensure we don't say an attr is unused if its
         * corresponding styleable is used.
         */
        final Set<ResSet> extraUsedResources = new HashSet<ResSet>();

        for (final ResSet resource : mResources) {
            if (resource.getType().equals("styleable")) {
                final String[] styleableAttr = resource.getName().split("_");

                if (styleableAttr.length > 1) {
                    final String attrName = styleableAttr[1];

                    final ResSet attrResourceTest = new ResSet("attr", attrName);

                    if (mUsedResources.contains(attrResourceTest)) {
                        extraUsedResources.add(resource);
                    }
                }
            } else if (resource.getType().equals("attr")) {
                for (final ResSet usedResource : mUsedResources) {
                    if (usedResource.getType().equals("styleable")) {
                        final String[] styleableAttr = usedResource.getName().split("_");

                        if (styleableAttr.length > 1 && styleableAttr[1].equals(resource.getName())) {
                            extraUsedResources.add(resource);
                        }
                    }
                }
            }
        }

        for (final ResSet resource : extraUsedResources) {
            mResources.remove(resource);
            mUsedResources.add(resource);
        }

        final SortedMap<String, SortedMap<String, ResSet>> unusedResources = new TreeMap<String, SortedMap<String, ResSet>>();

        for (final ResSet resource : mResources) {
            final String type = resource.getType();
            SortedMap<String, ResSet> typeMap = unusedResources.get(type);

            if (typeMap == null) {
                typeMap = new TreeMap<String, ResSet>();
                unusedResources.put(type, typeMap);
            }

            typeMap.put(resource.getName(), resource);
        }

        final Map<String, ResType> unusedResourceTypes = new HashMap<String, ResType>(
                unusedResources.size());

        for (final String type : unusedResources.keySet()) {
            final ResType resourceType = sResourceTypes.get(type);
            if (resourceType != null) {
                unusedResourceTypes.put(type, resourceType);
            }
        }

        findDeclaredPaths(null, mResDirectory, unusedResourceTypes, unusedResources);

        /*
         * Find the paths where the used resources are declared.
         */
        final SortedMap<String, SortedMap<String, ResSet>> usedResources = new TreeMap<String, SortedMap<String, ResSet>>();

        for (final ResSet resource : mUsedResources) {
            final String type = resource.getType();
            SortedMap<String, ResSet> typeMap = usedResources.get(type);

            if (typeMap == null) {
                typeMap = new TreeMap<String, ResSet>();
                usedResources.put(type, typeMap);
            }

            typeMap.put(resource.getName(), resource);
        }

        if (isCanceled) {
            return;
        }

        final Map<String, ResType> usedResourceTypes = new HashMap<String, ResType>(
                usedResources.size());

        for (final String type : usedResources.keySet()) {
            final ResType resourceType = sResourceTypes.get(type);
            if (resourceType != null) {
                usedResourceTypes.put(type, resourceType);
            }
        }

        if (isCanceled) {
            return;
        }

        findDeclaredPaths(null, mResDirectory, usedResourceTypes, usedResources);

        final Set<ResSet> libraryProjectResources = getLibraryProjectResources();

        for (final ResSet libraryResource : libraryProjectResources) {
            final SortedMap<String, ResSet> typedResources = unusedResources.get(libraryResource
                    .getType());

            if (typedResources != null) {
                final ResSet appResource = typedResources.get(libraryResource.getName());

                if (appResource != null && appResource.hasNoDeclaredPaths()) {
                    typedResources.remove(libraryResource.getName());
                    mResources.remove(appResource);
                }
            }
        }

        if (isCanceled) {
            return;
        }

        final int unusedResourceCount = mResources.size();

        if (unusedResourceCount > 0) {
            System.out.println(unusedResourceCount + " unused resources were found:");

            final SortedSet<ResSet> sortedResources = new TreeSet<ResSet>(mResources);

            for (final ResSet resource : sortedResources) {
                System.out.println(resource);
            }
            mResList.addAll(sortedResources);
        }

        showResult();
    }

    private void findPaths() {
        final File[] children = mBaseDirectory.listFiles();

        if (children == null) {
            return;
        }

        for (final File file : children) {
            if (file.isDirectory()) {
                if (file.getName().equals("src")) {
                    mSrcDirectory = file;
                } else if (file.getName().equals("res")) {
                    mResDirectory = file;
                } else if (file.getName().equals("gen")) {
                    mGenDirectory = file;
                }
            } else if (file.getName().equals("AndroidManifest.xml")) {
                mManifestFile = file;
            }
        }
    }

    private static String findPackageName(final File androidManifestFile) {
        String manifest = "";

        try {
            manifest = FileUtils.getFileContents(androidManifestFile);
        } catch (final IOException e) {
            e.printStackTrace();
        }

        final Pattern pattern = Pattern
                .compile("<manifest\\s+.*?package\\s*=\\s*\"([A-Za-z0-9_\\.]+)\".*?>");
        final Matcher matcher = pattern.matcher(manifest);

        if (matcher.find()) {
            return matcher.group(1);
        }

        return null;
    }

    private static File findRJavaFile(final File baseDirectory, final String packageName) {
        final File rJava = new File(baseDirectory, packageName.replace('.', '/') + "/R.java");

        if (rJava.exists()) {
            return rJava;
        }

        return null;
    }

    public void setbCancel(boolean bCancel) {
        this.isCanceled = bCancel;
    }

    /**
     * Removes all resources declared in library projects.
     */
    private Set<ResSet> getLibraryProjectResources() {
        final Set<ResSet> resources = new HashSet<ResSet>();

        final File projectPropertiesFile = new File(mBaseDirectory, "project.properties");

        if (!projectPropertiesFile.exists()) {
            return resources;
        }

        List<String> fileLines = new ArrayList<String>();
        try {
            fileLines = FileUtils.getFileLines(projectPropertiesFile);
        } catch (final IOException e) {
            e.printStackTrace();
        }

        final Pattern libraryProjectPattern = Pattern.compile(
                "^android\\.library\\.reference\\.\\d+=(.*)$", Pattern.CASE_INSENSITIVE);

        final List<String> libraryProjectPaths = new ArrayList<String>();

        for (final String line : fileLines) {
            final Matcher libraryProjectMatcher = libraryProjectPattern.matcher(line);

            if (libraryProjectMatcher.find()) {
                libraryProjectPaths.add(libraryProjectMatcher.group(1));
            }
        }

        for (final String libraryProjectPath : libraryProjectPaths) {
            final File libraryProjectDirectory = new File(mBaseDirectory, libraryProjectPath);

            if (libraryProjectDirectory.exists() && libraryProjectDirectory.isDirectory()) {
                final String libraryProjectPackageName = findPackageName(new File(
                        libraryProjectDirectory, "AndroidManifest.xml"));
                final File libraryProjectRJavaFile = findRJavaFile(new File(
                        libraryProjectDirectory, "gen"), libraryProjectPackageName);

                if (libraryProjectRJavaFile != null) {
                    try {
                        resources.addAll(getResourceList(libraryProjectRJavaFile));
                    } catch (final IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        return resources;
    }

    private static Set<ResSet> getResourceList(final File rJavaFile) throws IOException {
        final InputStream inputStream = new FileInputStream(rJavaFile);
        final BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

        boolean done = false;

        final Set<ResSet> resources = new HashSet<ResSet>();

        String type = "";

        while (!done) {
            final String line = reader.readLine();
            done = (line == null);

            if (line != null) {
                final Matcher typeMatcher = sResourceTypePattern.matcher(line);
                final Matcher nameMatcher = sResourceNamePattern.matcher(line);

                if (nameMatcher.find()) {
                    resources.add(new ResSet(type, nameMatcher.group(3)));
                } else if (typeMatcher.find()) {
                    type = typeMatcher.group(1);
                }
            }
        }

        reader.close();
        inputStream.close();

        return resources;
    }

    private void searchFiles(final File parent, final File file, final FileType fileType) {
        if (isCanceled) {
            return;
        }
        if (file.isDirectory()) {
            for (final File child : file.listFiles()) {
                if (isCanceled) {
                    return;
                }
                searchFiles(file, child, fileType);
            }
        } else if (file.getName().endsWith(fileType.getExtension())) {
            try {
                if (isCanceled) {
                    return;
                }
                searchFile(parent, file, fileType);
                if (mCallback != null) {
                    mCallback.setProgress(file);
                }
            } catch (final IOException e) {
                System.err.println("There was a problem reading " + file.getAbsolutePath());
                e.printStackTrace();
            }
        }
    }

    private void searchFile(final File parent, final File file, final FileType fileType)
            throws IOException {
        final Set<ResSet> foundResources = new HashSet<ResSet>();

        final String fileContents = FileUtils.getFileContents(file);

        for (final ResSet resource : mResources) {
            if (isCanceled) {
                return;
            }
            final Matcher matcher = fileType.getPattern(resource.getType(),
                    resource.getName().replace("_", "[_\\.]")).matcher(fileContents);

            if (matcher.find()) {
                foundResources.add(resource);
            } else {
                final ResType type = sResourceTypes.get(resource.getType());

                if (type != null
                        && type.doesFileUseResource(parent, file.getName(), fileContents, resource
                                .getName().replace("_", "[_\\.]"))) {
                    foundResources.add(resource);
                }
            }
        }

        for (final ResSet resource : foundResources) {
            if (isCanceled) {
                return;
            }
            mUsedResources.add(resource);
            mResources.remove(resource);
        }
    }

    private void findDeclaredPaths(final File parent, final File file,
            final Map<String, ResType> resourceTypes,
            final Map<String, SortedMap<String, ResSet>> resources) {
        if (file.isDirectory()) {
            for (final File child : file.listFiles()) {
                if (isCanceled) {
                    return;
                }
                if (!child.isHidden()) {
                    findDeclaredPaths(file, child, resourceTypes, resources);
                }
            }
        } else {
            if (!file.isHidden()) {
                final String fileName = file.getName();

                String fileContents = "";
                try {
                    fileContents = FileUtils.getFileContents(file);
                } catch (final IOException e) {
                    e.printStackTrace();
                }

                for (final ResType resourceType : resourceTypes.values()) {
                    if (isCanceled) {
                        return;
                    }
                    final Map<String, ResSet> typeMap = resources.get(resourceType.getType());

                    if (typeMap != null) {
                        for (final ResSet resource : typeMap.values()) {
                            if (isCanceled) {
                                return;
                            }
                            if (resourceType.doesFileDeclareResource(parent, fileName,
                                    fileContents, resource.getName().replace("_", "[_\\.]"))) {
                                resource.addDeclaredPath(file.getAbsolutePath());

                                final String configuration = parent.getName();
                                resource.addConfiguration(configuration);
                            }
                        }
                    }
                }
            }
        }
    }
}

4.感兴趣的朋友可以联系我，加入到维护和后续版本的开发中去。