#1137

Committed 23 Aug 2025 02:52AM UTC coverage: 2.94% (-0.01%) from 2.954%

Build # #1137

Build Type

push

Committed by

Commit Message

bugfix: cannot cancel immediately

Run Details

0 of 47 new or added lines in 3 files covered. (0.0%)

2 existing lines in 2 files now uncovered.

236 of 8026 relevant lines covered (2.94%)

0.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/edu/jiangxin/apktoolbox/file/duplicate/DuplicateSearchPanel.java

package edu.jiangxin.apktoolbox.file.duplicate;

import edu.jiangxin.apktoolbox.utils.DateUtils;
import edu.jiangxin.apktoolbox.swing.extend.FileListPanel;
import edu.jiangxin.apktoolbox.swing.extend.EasyPanel;
import edu.jiangxin.apktoolbox.utils.Constants;
import edu.jiangxin.apktoolbox.utils.FileUtils;
import edu.jiangxin.apktoolbox.utils.RevealFileUtils;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.*;
import java.util.List;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

public class DuplicateSearchPanel extends EasyPanel {

    @Serial
    private static final long serialVersionUID = 1L;

    private JTabbedPane tabbedPane;

    private JPanel optionPanel;

    private FileListPanel fileListPanel;

    private JCheckBox isFileNameChecked;
    private JCheckBox isMD5Checked;
    private JCheckBox isModifiedTimeChecked;

    private JCheckBox isHiddenFileSearched;
    private JCheckBox isRecursiveSearched;
    private JTextField suffixTextField;

    private JPanel resultPanel;

    private JTable resultTable;

    private DefaultTableModel resultTableModel;

    private JButton searchButton;
    private JButton cancelButton;

    private JProgressBar progressBar;

    private JMenuItem openDirMenuItem;
    private JMenuItem deleteFileMenuItem;
    private JMenuItem deleteFilesInSameDirMenuItem;
    private JMenuItem deleteFilesInSameDirRecursiveMenuItem;

    private SearchThread searchThread;

    final private Map<String, List<File>> duplicateFileGroupMap = new HashMap<>();


    @Override
    public void initUI() {
        tabbedPane = new JTabbedPane();
        add(tabbedPane);

        createOptionPanel();
        tabbedPane.addTab("Option", null, optionPanel, "Show Search Options");

        createResultPanel();
        tabbedPane.addTab("Result", null, resultPanel, "Show Search Result");
    }

    private void createOptionPanel() {
        optionPanel = new JPanel();
        optionPanel.setLayout(new BoxLayout(optionPanel, BoxLayout.Y_AXIS));

        fileListPanel = new FileListPanel();

        JPanel checkOptionPanel = new JPanel();
        checkOptionPanel.setLayout(new BoxLayout(checkOptionPanel, BoxLayout.X_AXIS));
        checkOptionPanel.setBorder(BorderFactory.createTitledBorder("Check Options"));

        JCheckBox isSizeChecked = new JCheckBox("Size");
        isSizeChecked.setSelected(true);
        isSizeChecked.setEnabled(false);
        isFileNameChecked = new JCheckBox("Filename");
        isMD5Checked = new JCheckBox("MD5");
        isModifiedTimeChecked = new JCheckBox("Last Modified Time");
        checkOptionPanel.add(isSizeChecked);
        checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        checkOptionPanel.add(isFileNameChecked);
        checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        checkOptionPanel.add(isMD5Checked);
        checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        checkOptionPanel.add(isModifiedTimeChecked);
        checkOptionPanel.add(Box.createHorizontalGlue());

        JPanel searchOptionPanel = new JPanel();
        searchOptionPanel.setLayout(new BoxLayout(searchOptionPanel, BoxLayout.X_AXIS));
        searchOptionPanel.setBorder(BorderFactory.createTitledBorder("Search Options"));

        isHiddenFileSearched = new JCheckBox("Hidden Files");
        isRecursiveSearched = new JCheckBox("Recursive");
        isRecursiveSearched.setSelected(true);
        JLabel suffixLabel = new JLabel("Suffix: ");
        suffixTextField = new JTextField();
        suffixTextField.setToolTipText("an array of extensions, ex. {\"java\",\"xml\"}. If this parameter is empty, all files are returned.");
        searchOptionPanel.add(isHiddenFileSearched);
        searchOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        searchOptionPanel.add(isRecursiveSearched);
        searchOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        searchOptionPanel.add(suffixLabel);
        searchOptionPanel.add(suffixTextField);
        searchOptionPanel.add(Box.createHorizontalGlue());

        JPanel operationPanel = new JPanel();
        operationPanel.setLayout(new BoxLayout(operationPanel, BoxLayout.X_AXIS));
        operationPanel.setBorder(BorderFactory.createTitledBorder("Operations"));

        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));

        searchButton = new JButton("Search");
        cancelButton = new JButton("Cancel");
        cancelButton.setEnabled(false);
        searchButton.addActionListener(new OperationButtonActionListener());
        cancelButton.addActionListener(new OperationButtonActionListener());
        operationPanel.add(searchButton);
        operationPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        operationPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));
        operationPanel.add(cancelButton);
        operationPanel.add(Box.createHorizontalGlue());

        progressBar = new JProgressBar();
        progressBar.setStringPainted(true);
        progressBar.setString("Ready");

        optionPanel.add(fileListPanel);
        optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));
        optionPanel.add(checkOptionPanel);
        optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));
        optionPanel.add(searchOptionPanel);
        optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));
        optionPanel.add(operationPanel);
                optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));
        optionPanel.add(progressBar);
    }

    private void createResultPanel() {
        resultPanel = new JPanel();
        resultPanel.setLayout(new BoxLayout(resultPanel, BoxLayout.Y_AXIS));

        resultTableModel = new DuplicateFilesTableModel(new Vector<>(), DuplicateFilesConstants.COLUMN_NAMES);
        resultTable = new JTable(resultTableModel);

        resultTable.setDefaultRenderer(Vector.class, new DuplicateFilesTableCellRenderer());

        for (int i = 0; i < resultTable.getColumnCount(); i++) {
            resultTable.getColumn(resultTable.getColumnName(i)).setCellRenderer(new DuplicateFilesTableCellRenderer());
        }

        resultTable.addMouseListener(new MyMouseListener());

        resultTable.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);

        JScrollPane scrollPane = new JScrollPane(resultTable);
        resultPanel.add(scrollPane);
    }

    private String getComparedKey(File file) {
        StringBuilder sb = new StringBuilder();
        sb.append("[Size][");
        sb.append(DigestUtils.md5Hex(String.valueOf(file.length())));
        sb.append("]");
        
        if (isFileNameChecked.isSelected()) {
            sb.append("[Filename][");
            sb.append(DigestUtils.md5Hex(file.getName()));
            sb.append("]");
        }
        if (isMD5Checked.isSelected()) {
            sb.append("[MD5][");
            try (InputStream is = new FileInputStream(file)) {
                sb.append(DigestUtils.md5Hex(is));
            } catch (FileNotFoundException e) {
                logger.error("getComparedKey FileNotFoundException");
            } catch (IOException e) {
                logger.error("getComparedKey IOException");
            }
            sb.append("]");
        }
        if (isModifiedTimeChecked.isSelected()) {
            sb.append("[ModifiedTime][");
            sb.append(DigestUtils.md5Hex(String.valueOf(file.lastModified())));
            sb.append("]");
        }
        logger.info("path: " + file.getAbsolutePath() + ", key: " + sb);
        return sb.toString();
    }

    class MyMouseListener extends MouseAdapter {
        @Override
        public void mouseReleased(MouseEvent e) {
            super.mouseReleased(e);
            int r = resultTable.rowAtPoint(e.getPoint());
            if (r >= 0 && r < resultTable.getRowCount()) {
                resultTable.setRowSelectionInterval(r, r);
            } else {
                resultTable.clearSelection();
            }
            int rowIndex = resultTable.getSelectedRow();
            if (rowIndex < 0) {
                return;
            }
            if (e.isPopupTrigger() && e.getComponent() instanceof JTable) {
                JPopupMenu popupmenu = new JPopupMenu();
                MyMenuActionListener menuActionListener = new MyMenuActionListener();

                openDirMenuItem = new JMenuItem("Open parent folder of this file");
                openDirMenuItem.addActionListener(menuActionListener);
                popupmenu.add(openDirMenuItem);

                deleteFileMenuItem = new JMenuItem("Delete this duplicate file");
                deleteFileMenuItem.addActionListener(menuActionListener);
                popupmenu.add(deleteFileMenuItem);

                deleteFilesInSameDirMenuItem = new JMenuItem("Delete these duplicate files in the same directory");
                deleteFilesInSameDirMenuItem.addActionListener(menuActionListener);
                popupmenu.add(deleteFilesInSameDirMenuItem);

                deleteFilesInSameDirRecursiveMenuItem = new JMenuItem("Delete these duplicate files in the same directory(Recursive)");
                deleteFilesInSameDirRecursiveMenuItem.addActionListener(menuActionListener);
                popupmenu.add(deleteFilesInSameDirRecursiveMenuItem);

                popupmenu.show(e.getComponent(), e.getX(), e.getY());
            }
        }
    }

    class MyMenuActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent actionEvent) {
            Object source = actionEvent.getSource();
            if (source.equals(openDirMenuItem)) {
                onOpenDir();
            } else if (source.equals(deleteFileMenuItem)) {
                onDeleteFile();
            } else if (source.equals(deleteFilesInSameDirMenuItem)) {
                onDeleteFilesInSameDir();
            } else if (source.equals(deleteFilesInSameDirRecursiveMenuItem)) {
                onDeleteFilesInSameDirRecursive();
            } else {
                logger.error("invalid source");
            }
        }

        private void onOpenDir() {
            int rowIndex = resultTable.getSelectedRow();
            String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();
            File parent = new File(parentPath);
            RevealFileUtils.revealDirectory(parent);
        }

        private void onDeleteFile() {
            int rowIndex = resultTable.getSelectedRow();
            String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();
            String name = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_NAME).getModelIndex()).toString();
            File selectedFile = new File(parentPath, name);
            String key = getComparedKey(selectedFile);
            List<File> files = duplicateFileGroupMap.get(key);
            for (File file : files) {
                if (!selectedFile.equals(file)) {
                    continue;
                }
                files.remove(file);
                boolean isSuccessful = file.delete();
                logger.info("delete file: " + file.getAbsolutePath() + ", result: " + isSuccessful);
                break;
            }
            resultTableModel.setRowCount(0);
            showResult();
        }

        private void onDeleteFilesInSameDir() {
            int rowIndex = resultTable.getSelectedRow();
            String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();
            for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {
                List<File> duplicateFileGroup = entry.getValue();
                for (File duplicateFile : duplicateFileGroup) {
                    String parentPathTmp = duplicateFile.getParent();
                    if (Objects.equals(parentPath, parentPathTmp)) {
                        duplicateFileGroup.remove(duplicateFile);
                        boolean isSuccessful = duplicateFile.delete();
                        logger.info("delete file: " + duplicateFile.getAbsolutePath() + ", result: " + isSuccessful);
                        break;
                    }
                }
            }
            resultTableModel.setRowCount(0);
            showResult();
        }

        private void onDeleteFilesInSameDirRecursive() {
            int rowIndex = resultTable.getSelectedRow();
            String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();
            for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {
                List<File> duplicateFileGroup = entry.getValue();
                for (File duplicateFile : duplicateFileGroup) {
                    String parentPathTmp = duplicateFile.getParent();
                    if (Objects.equals(parentPath, parentPathTmp) || FilenameUtils.directoryContains(parentPath, parentPathTmp)) {
                        duplicateFileGroup.remove(duplicateFile);
                        boolean isSuccessful = duplicateFile.delete();
                        logger.info("delete file: " + duplicateFile.getAbsolutePath() + ", result: " + isSuccessful);
                        break;
                    }
                }
            }
            resultTableModel.setRowCount(0);
            showResult();
        }
    }

    class OperationButtonActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            Object source = e.getSource();
            if (source.equals(searchButton)) {
                searchButton.setEnabled(false);
                cancelButton.setEnabled(true);
                String[] extensions = null;
                if (StringUtils.isNotEmpty(suffixTextField.getText())) {
                    extensions = suffixTextField.getText().split(",");
                }
                searchThread = new SearchThread(extensions, isRecursiveSearched.isSelected(), isHiddenFileSearched.isSelected(), duplicateFileGroupMap);
                searchThread.start();
            } else if (source.equals(cancelButton)) {
                searchButton.setEnabled(true);
                cancelButton.setEnabled(false);
                if (searchThread.isAlive()) {
                    searchThread.interrupt();
                    searchThread.executorService.shutdownNow();
                }
            }

        }
    }

    private void showResult() {
        SwingUtilities.invokeLater(() -> {
            int groupIndex = 0;
            for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {
                List<File> duplicateFileGroup = entry.getValue();
                if (duplicateFileGroup.size() < 2) {
                    continue;
                }
                groupIndex++;
                for (File duplicateFile : duplicateFileGroup) {
                    Vector<Object> rowData = getRowVector(groupIndex, duplicateFile);
                    resultTableModel.addRow(rowData);
                }
            }
            tabbedPane.setSelectedIndex(1);
        });
    }

    private Vector<Object> getRowVector(int groupIndex, File file) {
        Vector<Object> rowData = new Vector<>();
        rowData.add(groupIndex);
        rowData.add(file.getParent());
        rowData.add(file.getName());
        rowData.add(FilenameUtils.getExtension(file.getName()));
        rowData.add(FileUtils.sizeOfInHumanFormat(file));
        rowData.add(DateUtils.millisecondToHumanFormat(file.lastModified()));
        return rowData;
    }

    class SearchThread extends Thread {
        private final ExecutorService executorService;
        private final AtomicInteger processedFiles = new AtomicInteger(0);
        private int totalFiles = 0;
        private final String[] extensions;
        private final boolean isRecursiveSearched;
        private final boolean isHiddenFileSearched;
        private final Map<String, List<File>> duplicateFileGroupMap;

        public SearchThread(String[] extensions, boolean isRecursiveSearched, boolean isHiddenFileSearched, Map<String, List<File>> duplicateFileGroupMap) {
            super();
            this.extensions = extensions;
            this.isRecursiveSearched = isRecursiveSearched;
            this.isHiddenFileSearched = isHiddenFileSearched;
            this.duplicateFileGroupMap = duplicateFileGroupMap;
            this.executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

            SwingUtilities.invokeLater(() -> {
                progressBar.setValue(0);
                progressBar.setString("Starting search...");
            });
        }

        @Override
        public void run() {
            try {
                duplicateFileGroupMap.clear();
                SwingUtilities.invokeLater(() -> resultTableModel.setRowCount(0));

                List<File> fileList = fileListPanel.getFileList();
                Set<File> fileSet = new TreeSet<>(fileList);
                for (File file : fileList) {
                    fileSet.addAll(org.apache.commons.io.FileUtils.listFiles(file, extensions, isRecursiveSearched));
                }

                // 1. Group files by size first
                Map<Long, List<File>> sizeGroups = new HashMap<>();
                for (File file : fileSet) {
                    if (Thread.currentThread().isInterrupted()) {
                        return;
                    }
                    if (file.isHidden() && !isHiddenFileSearched) {
                        continue;
                    }
                    sizeGroups.computeIfAbsent(file.length(), k -> new ArrayList<>()).add(file);
                }

                // 2. Only process groups with duplicate sizes
                List<Future<?>> futures = new ArrayList<>();
                totalFiles = fileSet.size();
                updateProgress();

                for (Map.Entry<Long, List<File>> entry : sizeGroups.entrySet()) {
                    if (entry.getValue().size() > 1) { // Only process groups with duplicates
                        futures.add(executorService.submit(() -> {
                            processFileGroup(entry.getValue());
                            return null;
                        }));
                    } else {
                        // Count single files directly
                        incrementProcessedFiles();
                    }
                }

                // Wait for all tasks to complete
                for (Future<?> future : futures) {
                    try {
                        future.get();
                    } catch (InterruptedException e) {
                        logger.error("Search interrupted", e);
                        Thread.currentThread().interrupt(); // Restore interrupted status
                        return;
                    }
                }

                showResult();
            } catch (Exception e) {
                logger.error("Search failed", e);
                SwingUtilities.invokeLater(() -> progressBar.setString("Search failed"));
            } finally {
                executorService.shutdown();
                SwingUtilities.invokeLater(() -> {
                    searchButton.setEnabled(true);
                    cancelButton.setEnabled(false);
                });
            }
        }

        private void processFileGroup(List<File> files) {
            Map<String, List<File>> groupMap = new HashMap<>();
            for (File file : files) {
                if (Thread.currentThread().isInterrupted()) {
                    return;
                }
                String key = getComparedKey(file);
                groupMap.computeIfAbsent(key, k -> new ArrayList<>()).add(file);
                incrementProcessedFiles();
            }

            // Merge results to main map
            synchronized (duplicateFileGroupMap) {
                for (Map.Entry<String, List<File>> entry : groupMap.entrySet()) {
                    if (entry.getValue().size() > 1) {
                        duplicateFileGroupMap.put(entry.getKey(), entry.getValue());
                    }
                }
            }
        }

        private void incrementProcessedFiles() {
            processedFiles.incrementAndGet();
            updateProgress();
        }

        private void updateProgress() {
            if (totalFiles > 0) {
                SwingUtilities.invokeLater(() -> {
                    int processed = processedFiles.get();
                    int percentage = (int) ((processed * 100.0) / totalFiles);
                    progressBar.setValue(percentage);
                    progressBar.setString(String.format("Processing: %d/%d files (%d%%)", 
                        processed, totalFiles, percentage));
                });
            }
        }
    }
}

1	package edu.jiangxin.apktoolbox.file.duplicate;
2
3	import edu.jiangxin.apktoolbox.utils.DateUtils;
4	import edu.jiangxin.apktoolbox.swing.extend.FileListPanel;
5	import edu.jiangxin.apktoolbox.swing.extend.EasyPanel;
6	import edu.jiangxin.apktoolbox.utils.Constants;
7	import edu.jiangxin.apktoolbox.utils.FileUtils;
8	import edu.jiangxin.apktoolbox.utils.RevealFileUtils;
9	import org.apache.commons.codec.digest.DigestUtils;
10	import org.apache.commons.io.FilenameUtils;
11	import org.apache.commons.lang3.StringUtils;
12
13	import javax.swing.*;
14	import javax.swing.table.DefaultTableModel;
15	import java.awt.*;
16	import java.awt.event.ActionEvent;
17	import java.awt.event.ActionListener;
18	import java.awt.event.MouseAdapter;
19	import java.awt.event.MouseEvent;
20	import java.io.*;
21	import java.util.List;
22	import java.util.*;
23	import java.util.concurrent.ExecutorService;
24	import java.util.concurrent.Executors;
25	import java.util.concurrent.Future;
26	import java.util.concurrent.atomic.AtomicInteger;
27
28	public class DuplicateSearchPanel extends EasyPanel {	×
29
30	@Serial
31	private static final long serialVersionUID = 1L;
32
33	private JTabbedPane tabbedPane;
34
35	private JPanel optionPanel;
36
37	private FileListPanel fileListPanel;
38
39	private JCheckBox isFileNameChecked;
40	private JCheckBox isMD5Checked;
41	private JCheckBox isModifiedTimeChecked;
42
43	private JCheckBox isHiddenFileSearched;
44	private JCheckBox isRecursiveSearched;
45	private JTextField suffixTextField;
46
47	private JPanel resultPanel;
48
49	private JTable resultTable;
50
51	private DefaultTableModel resultTableModel;
52
53	private JButton searchButton;
54	private JButton cancelButton;
55
56	private JProgressBar progressBar;
57
58	private JMenuItem openDirMenuItem;
59	private JMenuItem deleteFileMenuItem;
60	private JMenuItem deleteFilesInSameDirMenuItem;
61	private JMenuItem deleteFilesInSameDirRecursiveMenuItem;
62
63	private SearchThread searchThread;
64
65	final private Map<String, List<File>> duplicateFileGroupMap = new HashMap<>();	×
66
67
68	@Override
69	public void initUI() {
70	tabbedPane = new JTabbedPane();	×
71	add(tabbedPane);	×
72
73	createOptionPanel();	×
74	tabbedPane.addTab("Option", null, optionPanel, "Show Search Options");	×
75
76	createResultPanel();	×
77	tabbedPane.addTab("Result", null, resultPanel, "Show Search Result");	×
78	}	×
79
80	private void createOptionPanel() {
81	optionPanel = new JPanel();	×
82	optionPanel.setLayout(new BoxLayout(optionPanel, BoxLayout.Y_AXIS));	×
83
84	fileListPanel = new FileListPanel();	×
85
86	JPanel checkOptionPanel = new JPanel();	×
87	checkOptionPanel.setLayout(new BoxLayout(checkOptionPanel, BoxLayout.X_AXIS));	×
88	checkOptionPanel.setBorder(BorderFactory.createTitledBorder("Check Options"));	×
89
90	JCheckBox isSizeChecked = new JCheckBox("Size");	×
91	isSizeChecked.setSelected(true);	×
92	isSizeChecked.setEnabled(false);	×
93	isFileNameChecked = new JCheckBox("Filename");	×
94	isMD5Checked = new JCheckBox("MD5");	×
95	isModifiedTimeChecked = new JCheckBox("Last Modified Time");	×
96	checkOptionPanel.add(isSizeChecked);	×
97	checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
98	checkOptionPanel.add(isFileNameChecked);	×
99	checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
100	checkOptionPanel.add(isMD5Checked);	×
101	checkOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
102	checkOptionPanel.add(isModifiedTimeChecked);	×
103	checkOptionPanel.add(Box.createHorizontalGlue());	×
104
105	JPanel searchOptionPanel = new JPanel();	×
106	searchOptionPanel.setLayout(new BoxLayout(searchOptionPanel, BoxLayout.X_AXIS));	×
107	searchOptionPanel.setBorder(BorderFactory.createTitledBorder("Search Options"));	×
108
109	isHiddenFileSearched = new JCheckBox("Hidden Files");	×
110	isRecursiveSearched = new JCheckBox("Recursive");	×
111	isRecursiveSearched.setSelected(true);	×
112	JLabel suffixLabel = new JLabel("Suffix: ");	×
113	suffixTextField = new JTextField();	×
114	suffixTextField.setToolTipText("an array of extensions, ex. {\"java\",\"xml\"}. If this parameter is empty, all files are returned.");	×
115	searchOptionPanel.add(isHiddenFileSearched);	×
116	searchOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
117	searchOptionPanel.add(isRecursiveSearched);	×
118	searchOptionPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
119	searchOptionPanel.add(suffixLabel);	×
120	searchOptionPanel.add(suffixTextField);	×
121	searchOptionPanel.add(Box.createHorizontalGlue());	×
122
123	JPanel operationPanel = new JPanel();	×
124	operationPanel.setLayout(new BoxLayout(operationPanel, BoxLayout.X_AXIS));	×
125	operationPanel.setBorder(BorderFactory.createTitledBorder("Operations"));	×
126
127	JPanel buttonPanel = new JPanel();	×
128	buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));	×
129
130	searchButton = new JButton("Search");	×
131	cancelButton = new JButton("Cancel");	×
NEW 132	cancelButton.setEnabled(false);	×
133	searchButton.addActionListener(new OperationButtonActionListener());	×
134	cancelButton.addActionListener(new OperationButtonActionListener());	×
135	operationPanel.add(searchButton);	×
136	operationPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
137	operationPanel.add(Box.createHorizontalStrut(Constants.DEFAULT_X_BORDER));	×
138	operationPanel.add(cancelButton);	×
139	operationPanel.add(Box.createHorizontalGlue());	×
140
141	progressBar = new JProgressBar();	×
142	progressBar.setStringPainted(true);	×
143	progressBar.setString("Ready");	×
144
145	optionPanel.add(fileListPanel);	×
146	optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));	×
147	optionPanel.add(checkOptionPanel);	×
148	optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));	×
149	optionPanel.add(searchOptionPanel);	×
150	optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));	×
151	optionPanel.add(operationPanel);	×
152	optionPanel.add(Box.createVerticalStrut(Constants.DEFAULT_Y_BORDER));	×
153	optionPanel.add(progressBar);	×
154	}	×
155
156	private void createResultPanel() {
157	resultPanel = new JPanel();	×
158	resultPanel.setLayout(new BoxLayout(resultPanel, BoxLayout.Y_AXIS));	×
159
160	resultTableModel = new DuplicateFilesTableModel(new Vector<>(), DuplicateFilesConstants.COLUMN_NAMES);	×
161	resultTable = new JTable(resultTableModel);	×
162
163	resultTable.setDefaultRenderer(Vector.class, new DuplicateFilesTableCellRenderer());	×
164
165	for (int i = 0; i < resultTable.getColumnCount(); i++) {	×
166	resultTable.getColumn(resultTable.getColumnName(i)).setCellRenderer(new DuplicateFilesTableCellRenderer());	×
167	}
168
169	resultTable.addMouseListener(new MyMouseListener());	×
170
171	resultTable.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);	×
172
173	JScrollPane scrollPane = new JScrollPane(resultTable);	×
174	resultPanel.add(scrollPane);	×
175	}	×
176
177	private String getComparedKey(File file) {
178	StringBuilder sb = new StringBuilder();	×
179	sb.append("[Size][");	×
180	sb.append(DigestUtils.md5Hex(String.valueOf(file.length())));	×
181	sb.append("]");	×
182
183	if (isFileNameChecked.isSelected()) {	×
184	sb.append("[Filename][");	×
185	sb.append(DigestUtils.md5Hex(file.getName()));	×
186	sb.append("]");	×
187	}
188	if (isMD5Checked.isSelected()) {	×
189	sb.append("[MD5][");	×
190	try (InputStream is = new FileInputStream(file)) {	×
191	sb.append(DigestUtils.md5Hex(is));	×
192	} catch (FileNotFoundException e) {	×
193	logger.error("getComparedKey FileNotFoundException");	×
194	} catch (IOException e) {	×
195	logger.error("getComparedKey IOException");	×
196	}	×
197	sb.append("]");	×
198	}
199	if (isModifiedTimeChecked.isSelected()) {	×
200	sb.append("[ModifiedTime][");	×
201	sb.append(DigestUtils.md5Hex(String.valueOf(file.lastModified())));	×
202	sb.append("]");	×
203	}
204	logger.info("path: " + file.getAbsolutePath() + ", key: " + sb);	×
205	return sb.toString();	×
206	}
207
208	class MyMouseListener extends MouseAdapter {	×
209	@Override
210	public void mouseReleased(MouseEvent e) {
211	super.mouseReleased(e);	×
212	int r = resultTable.rowAtPoint(e.getPoint());	×
213	if (r >= 0 && r < resultTable.getRowCount()) {	×
214	resultTable.setRowSelectionInterval(r, r);	×
215	} else {
216	resultTable.clearSelection();	×
217	}
218	int rowIndex = resultTable.getSelectedRow();	×
219	if (rowIndex < 0) {	×
220	return;	×
221	}
222	if (e.isPopupTrigger() && e.getComponent() instanceof JTable) {	×
223	JPopupMenu popupmenu = new JPopupMenu();	×
224	MyMenuActionListener menuActionListener = new MyMenuActionListener();	×
225
226	openDirMenuItem = new JMenuItem("Open parent folder of this file");	×
227	openDirMenuItem.addActionListener(menuActionListener);	×
228	popupmenu.add(openDirMenuItem);	×
229
230	deleteFileMenuItem = new JMenuItem("Delete this duplicate file");	×
231	deleteFileMenuItem.addActionListener(menuActionListener);	×
232	popupmenu.add(deleteFileMenuItem);	×
233
234	deleteFilesInSameDirMenuItem = new JMenuItem("Delete these duplicate files in the same directory");	×
235	deleteFilesInSameDirMenuItem.addActionListener(menuActionListener);	×
236	popupmenu.add(deleteFilesInSameDirMenuItem);	×
237
238	deleteFilesInSameDirRecursiveMenuItem = new JMenuItem("Delete these duplicate files in the same directory(Recursive)");	×
239	deleteFilesInSameDirRecursiveMenuItem.addActionListener(menuActionListener);	×
240	popupmenu.add(deleteFilesInSameDirRecursiveMenuItem);	×
241
242	popupmenu.show(e.getComponent(), e.getX(), e.getY());	×
243	}
244	}	×
245	}
246
247	class MyMenuActionListener implements ActionListener {	×
248	@Override
249	public void actionPerformed(ActionEvent actionEvent) {
250	Object source = actionEvent.getSource();	×
251	if (source.equals(openDirMenuItem)) {	×
252	onOpenDir();	×
253	} else if (source.equals(deleteFileMenuItem)) {	×
254	onDeleteFile();	×
255	} else if (source.equals(deleteFilesInSameDirMenuItem)) {	×
256	onDeleteFilesInSameDir();	×
257	} else if (source.equals(deleteFilesInSameDirRecursiveMenuItem)) {	×
258	onDeleteFilesInSameDirRecursive();	×
259	} else {
260	logger.error("invalid source");	×
261	}
262	}	×
263
264	private void onOpenDir() {
265	int rowIndex = resultTable.getSelectedRow();	×
266	String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();	×
267	File parent = new File(parentPath);	×
NEW 268	RevealFileUtils.revealDirectory(parent);	×
UNCOV 269	}	×
270
271	private void onDeleteFile() {
272	int rowIndex = resultTable.getSelectedRow();	×
273	String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();	×
274	String name = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_NAME).getModelIndex()).toString();	×
275	File selectedFile = new File(parentPath, name);	×
276	String key = getComparedKey(selectedFile);	×
277	List<File> files = duplicateFileGroupMap.get(key);	×
278	for (File file : files) {	×
279	if (!selectedFile.equals(file)) {	×
280	continue;	×
281	}
282	files.remove(file);	×
283	boolean isSuccessful = file.delete();	×
284	logger.info("delete file: " + file.getAbsolutePath() + ", result: " + isSuccessful);	×
285	break;	×
286	}
287	resultTableModel.setRowCount(0);	×
288	showResult();	×
289	}	×
290
291	private void onDeleteFilesInSameDir() {
292	int rowIndex = resultTable.getSelectedRow();	×
293	String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();	×
294	for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {	×
295	List<File> duplicateFileGroup = entry.getValue();	×
296	for (File duplicateFile : duplicateFileGroup) {	×
297	String parentPathTmp = duplicateFile.getParent();	×
298	if (Objects.equals(parentPath, parentPathTmp)) {	×
299	duplicateFileGroup.remove(duplicateFile);	×
300	boolean isSuccessful = duplicateFile.delete();	×
301	logger.info("delete file: " + duplicateFile.getAbsolutePath() + ", result: " + isSuccessful);	×
302	break;	×
303	}
304	}	×
305	}	×
306	resultTableModel.setRowCount(0);	×
307	showResult();	×
308	}	×
309
310	private void onDeleteFilesInSameDirRecursive() {
311	int rowIndex = resultTable.getSelectedRow();	×
312	String parentPath = resultTableModel.getValueAt(rowIndex, resultTable.getColumn(DuplicateFilesConstants.COLUMN_NAME_FILE_PARENT).getModelIndex()).toString();	×
313	for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {	×
314	List<File> duplicateFileGroup = entry.getValue();	×
315	for (File duplicateFile : duplicateFileGroup) {	×
316	String parentPathTmp = duplicateFile.getParent();	×
317	if (Objects.equals(parentPath, parentPathTmp) \|\| FilenameUtils.directoryContains(parentPath, parentPathTmp)) {	×
318	duplicateFileGroup.remove(duplicateFile);	×
319	boolean isSuccessful = duplicateFile.delete();	×
320	logger.info("delete file: " + duplicateFile.getAbsolutePath() + ", result: " + isSuccessful);	×
321	break;	×
322	}
323	}	×
324	}	×
325	resultTableModel.setRowCount(0);	×
326	showResult();	×
327	}	×
328	}
329
330	class OperationButtonActionListener implements ActionListener {	×
331	@Override
332	public void actionPerformed(ActionEvent e) {
333	Object source = e.getSource();	×
334	if (source.equals(searchButton)) {	×
NEW 335	searchButton.setEnabled(false);	×
NEW 336	cancelButton.setEnabled(true);	×
337	String[] extensions = null;	×
338	if (StringUtils.isNotEmpty(suffixTextField.getText())) {	×
339	extensions = suffixTextField.getText().split(",");	×
340	}
341	searchThread = new SearchThread(extensions, isRecursiveSearched.isSelected(), isHiddenFileSearched.isSelected(), duplicateFileGroupMap);	×
342	searchThread.start();	×
343	} else if (source.equals(cancelButton)) {	×
NEW 344	searchButton.setEnabled(true);	×
NEW 345	cancelButton.setEnabled(false);	×
346	if (searchThread.isAlive()) {	×
347	searchThread.interrupt();	×
NEW 348	searchThread.executorService.shutdownNow();	×
349	}
350	}
351
352	}	×
353	}
354
355	private void showResult() {
356	SwingUtilities.invokeLater(() -> {	×
357	int groupIndex = 0;	×
358	for (Map.Entry<String, List<File>> entry : duplicateFileGroupMap.entrySet()) {	×
359	List<File> duplicateFileGroup = entry.getValue();	×
360	if (duplicateFileGroup.size() < 2) {	×
361	continue;	×
362	}
363	groupIndex++;	×
364	for (File duplicateFile : duplicateFileGroup) {	×
365	Vector<Object> rowData = getRowVector(groupIndex, duplicateFile);	×
366	resultTableModel.addRow(rowData);	×
367	}	×
368	}	×
369	tabbedPane.setSelectedIndex(1);	×
370	});	×
371	}	×
372
373	private Vector<Object> getRowVector(int groupIndex, File file) {
374	Vector<Object> rowData = new Vector<>();	×
375	rowData.add(groupIndex);	×
376	rowData.add(file.getParent());	×
377	rowData.add(file.getName());	×
378	rowData.add(FilenameUtils.getExtension(file.getName()));	×
379	rowData.add(FileUtils.sizeOfInHumanFormat(file));	×
380	rowData.add(DateUtils.millisecondToHumanFormat(file.lastModified()));	×
381	return rowData;	×
382	}
383
384	class SearchThread extends Thread {
385	private final ExecutorService executorService;
386	private final AtomicInteger processedFiles = new AtomicInteger(0);	×
387	private int totalFiles = 0;	×
388	private final String[] extensions;
389	private final boolean isRecursiveSearched;
390	private final boolean isHiddenFileSearched;
391	private final Map<String, List<File>> duplicateFileGroupMap;
392
393	public SearchThread(String[] extensions, boolean isRecursiveSearched, boolean isHiddenFileSearched, Map<String, List<File>> duplicateFileGroupMap) {	×
394	super();	×
395	this.extensions = extensions;	×
396	this.isRecursiveSearched = isRecursiveSearched;	×
397	this.isHiddenFileSearched = isHiddenFileSearched;	×
398	this.duplicateFileGroupMap = duplicateFileGroupMap;	×
399	this.executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());	×
400
401	SwingUtilities.invokeLater(() -> {	×
402	progressBar.setValue(0);	×
403	progressBar.setString("Starting search...");	×
404	});	×
405	}	×
406
407	@Override
408	public void run() {
409	try {
410	duplicateFileGroupMap.clear();	×
411	SwingUtilities.invokeLater(() -> resultTableModel.setRowCount(0));	×
412
413	List<File> fileList = fileListPanel.getFileList();	×
414	Set<File> fileSet = new TreeSet<>(fileList);	×
415	for (File file : fileList) {	×
416	fileSet.addAll(org.apache.commons.io.FileUtils.listFiles(file, extensions, isRecursiveSearched));	×
417	}	×
418
419	// 1. Group files by size first
420	Map<Long, List<File>> sizeGroups = new HashMap<>();	×
421	for (File file : fileSet) {	×
422	if (Thread.currentThread().isInterrupted()) {	×
423	return;	×
424	}
425	if (file.isHidden() && !isHiddenFileSearched) {	×
426	continue;	×
427	}
428	sizeGroups.computeIfAbsent(file.length(), k -> new ArrayList<>()).add(file);	×
429	}	×
430
431	// 2. Only process groups with duplicate sizes
432	List<Future<?>> futures = new ArrayList<>();	×
433	totalFiles = fileSet.size();	×
434	updateProgress();	×
435
436	for (Map.Entry<Long, List<File>> entry : sizeGroups.entrySet()) {	×
437	if (entry.getValue().size() > 1) { // Only process groups with duplicates	×
438	futures.add(executorService.submit(() -> {	×
439	processFileGroup(entry.getValue());	×
440	return null;	×
441	}));
442	} else {
443	// Count single files directly
444	incrementProcessedFiles();	×
445	}
446	}	×
447
448	// Wait for all tasks to complete
449	for (Future<?> future : futures) {	×
450	try {
451	future.get();	×
452	} catch (InterruptedException e) {	×
453	logger.error("Search interrupted", e);	×
454	Thread.currentThread().interrupt(); // Restore interrupted status	×
455	return;	×
456	}	×
457	}	×
458
459	showResult();	×
460	} catch (Exception e) {	×
461	logger.error("Search failed", e);	×
462	SwingUtilities.invokeLater(() -> progressBar.setString("Search failed"));	×
463	} finally {
464	executorService.shutdown();	×
NEW 465	SwingUtilities.invokeLater(() -> {	×
NEW 466	searchButton.setEnabled(true);	×
NEW 467	cancelButton.setEnabled(false);	×
NEW 468	});	×
469	}
470	}	×
471
472	private void processFileGroup(List<File> files) {
473	Map<String, List<File>> groupMap = new HashMap<>();	×
474	for (File file : files) {	×
475	if (Thread.currentThread().isInterrupted()) {	×
476	return;	×
477	}
478	String key = getComparedKey(file);	×
479	groupMap.computeIfAbsent(key, k -> new ArrayList<>()).add(file);	×
480	incrementProcessedFiles();	×
481	}	×
482
483	// Merge results to main map
484	synchronized (duplicateFileGroupMap) {	×
485	for (Map.Entry<String, List<File>> entry : groupMap.entrySet()) {	×
486	if (entry.getValue().size() > 1) {	×
487	duplicateFileGroupMap.put(entry.getKey(), entry.getValue());	×
488	}
489	}	×
490	}	×
491	}	×
492
493	private void incrementProcessedFiles() {
494	processedFiles.incrementAndGet();	×
495	updateProgress();	×
496	}	×
497
498	private void updateProgress() {
499	if (totalFiles > 0) {	×
500	SwingUtilities.invokeLater(() -> {	×
501	int processed = processedFiles.get();	×
502	int percentage = (int) ((processed * 100.0) / totalFiles);	×
503	progressBar.setValue(percentage);	×
504	progressBar.setString(String.format("Processing: %d/%d files (%d%%)",	×
505	processed, totalFiles, percentage));	×
506	});	×
507	}
508	}	×
509	}
510	}

jiangxincode / ApkToolBoxGUI / #1137

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous