Flash缓存一键清理工具

成品下载：可在下载区进行下载
代码演示：

import os
import shutil
import tkinter as tk
from tkinter import ttk, messagebox, filedialog
import threading
import psutil
from datetime import datetime

class FlashCacheCleaner:
    def __init__(self, root):
        self.root = root
        self.root.title("Flash缓存清理工具 v2.1")
        self.root.geometry("800x650")  # 增加高度确保所有元素可见
        self.root.resizable(True, True)
        self.root.configure(bg="#f0f0f0")

        # 创建主框架
        self.main_frame = ttk.Frame(root)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)

        # 标题
        title_label = ttk.Label(
            self.main_frame,
            text="Flash缓存清理工具",
            font=("Arial", 24, "bold"),
            foreground="#2c3e50"
        )
        title_label.pack(pady=(0, 15))

        # 说明标签
        desc_label = ttk.Label(
            self.main_frame,
            text="此工具可以清理各种模式下的Flash Player缓存，包括普通模式、调试模式和独立调试播放器模式",
            wraplength=700,
            font=("Arial", 10),
            foreground="#7f8c8d"
        )
        desc_label.pack(pady=(0, 20))

        # 缓存类型选择框架
        cache_frame = ttk.LabelFrame(self.main_frame, text="选择要清理的缓存类型", padding=15)
        cache_frame.pack(fill=tk.X, pady=10)

        # 缓存类型复选框
        self.var_normal = tk.BooleanVar(value=True)
        self.var_debug = tk.BooleanVar(value=True)
        self.var_sa_debug = tk.BooleanVar(value=True)

        normal_check = ttk.Checkbutton(
            cache_frame,
            text="普通Flash缓存",
            variable=self.var_normal
        )
        normal_check.grid(row=0, column=0, padx=10, pady=5, sticky=tk.W)

        debug_check = ttk.Checkbutton(
            cache_frame,
            text="调试模式缓存",
            variable=self.var_debug
        )
        debug_check.grid(row=0, column=1, padx=10, pady=5, sticky=tk.W)

        sa_debug_check = ttk.Checkbutton(
            cache_frame,
            text="独立调试播放器缓存",
            variable=self.var_sa_debug
        )
        sa_debug_check.grid(row=0, column=2, padx=10, pady=5, sticky=tk.W)

        # 自定义路径框架
        custom_frame = ttk.LabelFrame(self.main_frame, text="自定义缓存路径 (可选)", padding=15)
        custom_frame.pack(fill=tk.X, pady=10)

        self.custom_path = tk.StringVar()
        custom_entry = ttk.Entry(custom_frame, textvariable=self.custom_path, width=50)
        custom_entry.grid(row=0, column=0, padx=(0, 10), sticky=tk.EW)

        browse_btn = ttk.Button(custom_frame, text="浏览...", command=self.browse_folder)
        browse_btn.grid(row=0, column=1, padx=(0, 10))

        # 进度条
        self.progress = ttk.Progressbar(self.main_frame, orient=tk.HORIZONTAL, length=700, mode='determinate')
        self.progress.pack(pady=15)

        # 日志区域框架 - 使用Frame包装以确保正确布局
        log_frame = ttk.LabelFrame(self.main_frame, text="操作日志", padding=10)
        log_frame.pack(fill=tk.BOTH, expand=True, pady=10)

        # 添加滚动条
        log_container = ttk.Frame(log_frame)
        log_container.pack(fill=tk.BOTH, expand=True)

        scrollbar = ttk.Scrollbar(log_container)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

        self.log_text = tk.Text(
            log_container,
            height=8,
            bg="white",
            fg="#2c3e50",
            wrap=tk.WORD,
            yscrollcommand=scrollbar.set
        )
        self.log_text.pack(fill=tk.BOTH, expand=True)
        scrollbar.config(command=self.log_text.yview)

        # 配置日志标签
        self.log_text.tag_config("info", foreground="blue")
        self.log_text.tag_config("success", foreground="green")
        self.log_text.tag_config("warning", foreground="orange")
        self.log_text.tag_config("error", foreground="red")

        # 按钮框架 - 放在日志区域下方
        button_frame = ttk.Frame(self.main_frame)
        button_frame.pack(pady=15, fill=tk.X)

        # 使用grid布局按钮确保居中
        self.clean_btn = ttk.Button(
            button_frame,
            text="开始清理缓存",
            command=self.start_cleaning,
            width=15
        )
        self.clean_btn.grid(row=0, column=0, padx=5)

        info_btn = ttk.Button(
            button_frame,
            text="关于此工具",
            command=self.show_info,
            width=15
        )
        info_btn.grid(row=0, column=1, padx=5)

        exit_btn = ttk.Button(
            button_frame,
            text="退出",
            command=root.destroy,
            width=15
        )
        exit_btn.grid(row=0, column=2, padx=5)

        # 使按钮居中
        button_frame.columnconfigure((0, 1, 2), weight=1)

        # 状态栏
        self.status_var = tk.StringVar()
        self.status_var.set("就绪")
        status_bar = ttk.Label(root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)

        # 初始化缓存路径
        self.cache_paths = {
            "normal": self.get_normal_cache_paths(),
            "debug": self.get_debug_cache_paths(),
            "sa_debug": self.get_sa_debug_cache_paths()
        }

        # 添加演示缓存
        self.create_demo_cache()

        # 初始日志
        self.log("工具已启动，请选择要清理的缓存类型", "info")

    def get_normal_cache_paths(self):
        """获取普通Flash缓存路径"""
        paths = []
        appdata = os.environ.get('APPDATA', '')
        localappdata = os.environ.get('LOCALAPPDATA', '')

        if appdata:
            paths.extend([
                os.path.join(appdata, 'Adobe', 'Flash Player'),
                os.path.join(appdata, 'Macromedia', 'Flash Player')
            ])

        if localappdata:
            paths.extend([
                os.path.join(localappdata, 'Adobe', 'Flash Player'),
                os.path.join(localappdata, 'Macromedia', 'Flash Player')
            ])

        return paths

    def get_debug_cache_paths(self):
        """获取调试模式缓存路径"""
        paths = []
        appdata = os.environ.get('APPDATA', '')

        if appdata:
            paths.extend([
                os.path.join(appdata, 'Macromedia', 'Flash Player', 'Logs'),
                os.path.join(appdata, 'Macromedia', 'Flash Player', '#SharedObjects'),
                os.path.join(appdata, 'Macromedia', 'Flash Player', 'macromedia.com')
            ])

        return paths

    def get_sa_debug_cache_paths(self):
        """获取独立调试播放器缓存路径"""
        paths = []
        userprofile = os.environ.get('USERPROFILE', '')

        if userprofile:
            paths.extend([
                os.path.join(userprofile, 'AppData', 'Roaming', 'Macromedia', 'Flash Player'),
                os.path.join(userprofile, 'AppData', 'Local', 'Macromedia', 'Flash Player')
            ])

        return paths

    def create_demo_cache(self):
        """创建演示用的缓存文件"""
        demo_dirs = [
            os.path.join(os.environ['TEMP'], 'FlashCacheCleanerDemo', 'NormalCache'),
            os.path.join(os.environ['TEMP'], 'FlashCacheCleanerDemo', 'DebugCache'),
            os.path.join(os.environ['TEMP'], 'FlashCacheCleanerDemo', 'SADebugCache'),
        ]

        for demo_dir in demo_dirs:
            os.makedirs(demo_dir, exist_ok=True)

            # 创建一些模拟文件
            for i in range(3):
                with open(os.path.join(demo_dir, f'cache_file_{i}.bin'), 'wb') as f:
                    f.write(os.urandom(1024))

            # 添加到缓存路径
            if "Normal" in demo_dir:
                self.cache_paths["normal"].append(demo_dir)
            elif "Debug" in demo_dir:
                self.cache_paths["debug"].append(demo_dir)
            elif "SADebug" in demo_dir:
                self.cache_paths["sa_debug"].append(demo_dir)

    def browse_folder(self):
        """浏览文件夹"""
        folder = filedialog.askdirectory(title="选择缓存文件夹")
        if folder:
            self.custom_path.set(folder)
            # 在日志中显示添加的路径
            self.log(f"添加自定义缓存路径: {folder}", "info")

    def log(self, message, tag="info"):
        """添加日志消息"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.log_text.insert(tk.END, f"[{timestamp}] {message}\n", tag)
        self.log_text.see(tk.END)
        self.status_var.set(message)
        # 确保日志更新
        self.log_text.update_idletasks()

    def start_cleaning(self):
        """开始清理缓存"""
        # 检查是否选择了任何缓存类型
        if not (self.var_normal.get() or self.var_debug.get() or self.var_sa_debug.get()):
            if not self.custom_path.get():
                messagebox.showwarning("警告", "请选择至少一种缓存类型进行清理！")
                return

        # 确认清理
        if not messagebox.askyesno("确认", "确定要清理Flash缓存吗？此操作不可撤销！"):
            return

        # 禁用清理按钮
        self.clean_btn.config(state=tk.DISABLED)

        # 启动清理线程
        threading.Thread(target=self.clean_cache, daemon=True).start()

    def clean_cache(self):
        """执行缓存清理"""
        self.log("开始清理Flash缓存...", "info")
        total_paths = []

        # 收集要清理的路径
        if self.var_normal.get():
            total_paths.extend(self.cache_paths["normal"])
            self.log("已选择清理普通Flash缓存", "info")

        if self.var_debug.get():
            total_paths.extend(self.cache_paths["debug"])
            self.log("已选择清理调试模式缓存", "info")

        if self.var_sa_debug.get():
            total_paths.extend(self.cache_paths["sa_debug"])
            self.log("已选择清理独立调试播放器缓存", "info")

        # 添加自定义路径
        custom_path = self.custom_path.get()
        if custom_path:
            total_paths.append(custom_path)
            self.log(f"已选择清理自定义缓存路径: {custom_path}", "info")

        # 去重
        total_paths = list(set(total_paths))
        total = len(total_paths)

        # 检查Flash Player进程是否正在运行
        flash_processes = self.check_flash_processes()
        if flash_processes:
            self.log(f"检测到 {len(flash_processes)} 个Flash Player进程正在运行", "warning")
            self.log("清理前建议关闭所有Flash Player进程", "warning")

        # 更新进度条
        self.progress["value"] = 0
        self.progress["maximum"] = total if total > 0 else 1

        # 清理每个路径
        cleaned_count = 0
        cleaned_size = 0

        for i, path in enumerate(total_paths):
            self.progress["value"] = i + 1
            self.root.update()

            if os.path.exists(path):
                try:
                    # 计算文件夹大小
                    size = self.get_folder_size(path)

                    # 删除文件夹
                    if os.path.isdir(path):
                        shutil.rmtree(path)
                    else:
                        os.remove(path)

                    self.log(f"已清理: {path} ({self.format_size(size)})", "success")
                    cleaned_count += 1
                    cleaned_size += size

                    # 重新创建目录（防止应用程序出错）
                    if "Logs" not in path and "SharedObjects" not in path:
                        os.makedirs(path, exist_ok=True)
                except Exception as e:
                    self.log(f"清理失败: {path} - {str(e)}", "error")
            else:
                self.log(f"路径不存在: {path}", "warning")

        # 显示清理结果
        if cleaned_count > 0:
            self.log(f"清理完成! 共清理 {cleaned_count}/{total} 个目录, 释放空间: {self.format_size(cleaned_size)}",
                     "success")
        else:
            self.log("没有找到可清理的缓存", "info")

        self.clean_btn.config(state=tk.NORMAL)

        # 进度条重置
        self.root.after(5000, lambda: self.progress.config(value=0))

    def check_flash_processes(self):
        """检查正在运行的Flash Player进程"""
        flash_processes = []
        for proc in psutil.process_iter(['name']):
            name = proc.info.get('name', '').lower()
            if name and "flash" in name:
                flash_processes.append(proc.info['name'])
        return flash_processes

    def get_folder_size(self, folder):
        """计算文件夹大小（字节）"""
        total_size = 0
        for dirpath, dirnames, filenames in os.walk(folder):
            for f in filenames:
                fp = os.path.join(dirpath, f)
                if os.path.exists(fp):
                    try:
                        total_size += os.path.getsize(fp)
                    except OSError:
                        continue
        return total_size

    def format_size(self, size):
        """格式化文件大小"""
        if size == 0:
            return "0 B"

        units = ['B', 'KB', 'MB', 'GB']
        unit_index = 0

        while size >= 1024 and unit_index < len(units) - 1:
            size /= 1024.0
            unit_index += 1

        return f"{size:.1f} {units[unit_index]}"

    def show_info(self):
        """显示关于信息"""
        info_text = """Flash缓存清理工具 v2.1

功能:
- 清理普通Flash Player缓存
- 清理调试模式Flash缓存
- 清理独立调试播放器(flashplayer_sa_debug.exe)缓存
- 支持自定义缓存路径
- 显示详细清理日志

重要提示:
1. 清理前请关闭所有使用Flash的应用程序
2. 清理后可能需要重启浏览器才能生效
3. 此工具会保留必要的目录结构

系统要求:
- Windows 7/10/11
- Python 3.6+

发布日期: 2023-08-20
        """
        messagebox.showinfo("关于此工具", info_text)

if __name__ == "__main__":
    root = tk.Tk()
    app = FlashCacheCleaner(root)
    root.mainloop()