如何基于Python开发一个微信自动化工具

pip install pyqt5 psutil uiautomation

class WorkerThread(QThread):
    finished = pyqtSignal(str, bool)  # 信号参数：消息内容, 是否成功
    
    def run(self):
        try:
            result = self.func(*self.args, **self.kwargs)
            self.finished.emit(result or "操作成功", True)
        except Exception as e:
            self.finished.emit(f"错误: {str(e)}", False)

def wechat_active():
    # 超时设置优化
    uiautomation.uiautomation.TIME_OUT_SECOND = 2  
    if ifProcessRunning():
        try:
            # 快捷键激活方案
            desktop = uiautomation.PaneControl(Name='任务栏')
            desktop.SendKeys('{Ctrl}{Alt}w')
        except:
            # 异常后备方案
            os.system('taskkill /F /im "WeChat.exe"')
            wechat_start()
    else:
        wechat_start()
    
    # 恢复默认超时
    uiautomation.uiautomation.TIME_OUT_SECOND = 20  
    wechatWindow = uiautomation.WindowControl(
        searchDepth=1, 
        className='WeChatMainWndForPC', 
        Name='微信'
    )

def check_scheduled_tasks(self):
    now = datetime.now()
    for task in self.scheduled_tasks:
        if not task["completed"] and now >= task["send_time"]:
            success = self.send_message(
                recipient=task["recipient"],
                message=task["message"],
                file_path=task["file_path"]
            )
            
            if success and task["repeat"]:  # 重复任务处理
                task["send_time"] = now + timedelta(
                    minutes=task["interval"]
                )
                task["completed"] = False
            else:
                task["completed"] = True

# -*- coding:utf-8 -*-
import sys
import psutil
import uiautomation
import os
import time
from datetime import datetime, timedelta
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                            QTabWidget, QLabel, QLineEdit, QTextEdit, QPushButton, 
                            QFileDialog, QMessageBox, QStatusBar, QGroupBox,
                            QDateTimeEdit, QCheckBox, QSpinBox)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer
from PyQt5.QtGui import QIcon, QFont

class WorkerThread(QThread):
    finished = pyqtSignal(str, bool)  # message, success
    
    def __init__(self, func, *args, **kwargs):
        super().__init__()
        self.func = func
        self.args = args
        self.kwargs = kwargs
    
    def run(self):
        try:
            result = self.func(*self.args, **self.kwargs)
            self.finished.emit(result or "操作成功", True)
        except Exception as e:
            self.finished.emit(f"错误: {str(e)}", False)

class WeChatAutomationApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("微信自动化发送工具---BY 白泽")
        self.setGeometry(100, 100, 787, 639)
        self.setWindowIcon(QIcon("wechat.ico"))  # 替换为你的图标文件
        
        # 定时任务列表
        self.scheduled_tasks = []
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.check_scheduled_tasks)
        self.timer.start(1000)  # 每秒检查一次
        
        # 设置全局字体
        font = QFont("Microsoft YaHei", 10)
        QApplication.setFont(font)
        
        # 主控件
        self.main_widget = QWidget()
        self.setCentralWidget(self.main_widget)
        
        # 主布局
        self.main_layout = QVBoxLayout(self.main_widget)
        self.main_layout.setContentsMargins(15, 15, 15, 15)
        self.main_layout.setSpacing(15)
        
        # 创建标签页
        self.tabs = QTabWidget()
        self.main_layout.addWidget(self.tabs)
        
        # 创建各个标签页
        self.create_send_tab()
        self.create_schedule_tab()
        self.create_control_tab()
        
        # 状态栏
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.status_bar.showMessage("🟢 就绪")
        
        # 样式设置
        self.set_style()
    
    def set_style(self):
        self.setStyleSheet("""
            QMainWindow {
                background-color: #f5f5f5;
            }
            QTabWidget::pane {
                border: 1px solid #d3d3d3;
                border-radius: 5px;
                padding: 5px;
                background: white;
            }
            QTabBar::tab {
                padding: 8px 15px;
                border: 1px solid #d3d3d3;
                border-bottom: none;
                border-top-left-radius: 5px;
                border-top-right-radius: 5px;
                background: #e9e9e9;
                margin-right: 2px;
            }
            QTabBar::tab:selected {
                background: white;
                border-bottom: 1px solid white;
                margin-bottom: -1px;
            }
            QPushButton {
                background-color: #4CAF50;
                color: white;
                border: none;
                padding: 8px 15px;
                border-radius: 4px;
                min-width: 80px;
            }
            QPushButton:hover {
                background-color: #45a049;
            }
            QPushButton:pressed {
                background-color: #3d8b40;
            }
            QPushButton:disabled {
                background-color: #cccccc;
            }
            QLineEdit, QTextEdit {
                border: 1px solid #d3d3d3;
                border-radius: 4px;
                padding: 5px;
            }
            QLabel {
                color: #333333;
            }
            QStatusBar {
                background-color: #e9e9e9;
                color: #333333;
            }
            QGroupBox {
                border: 1px solid #d3d3d3;
                border-radius: 5px;
                margin-top: 10px;
                padding-top: 15px;
            }
            QGroupBox::title {
                subcontrol-origin: margin;
                left: 10px;
                padding: 0 3px;
            }
            QDateTimeEdit {
                padding: 5px;
            }
        """)
    
    def create_send_tab(self):
        """创建发送消息标签页"""
        self.send_tab = QWidget()
        self.tabs.addTab(self.send_tab, "📩 即时发送")
        
        layout = QVBoxLayout(self.send_tab)
        layout.setSpacing(15)
        
        # 收件人
        recipient_layout = QHBoxLayout()
        recipient_layout.addWidget(QLabel("👤 收件人:"))
        self.recipient_input = QLineEdit()
        self.recipient_input.setPlaceholderText("输入微信用户名或备注名")
        recipient_layout.addWidget(self.recipient_input)
        layout.addLayout(recipient_layout)
        
        # 消息内容
        layout.addWidget(QLabel("💬 消息内容:"))
        self.message_input = QTextEdit()
        self.message_input.setPlaceholderText("输入要发送的消息...")
        layout.addWidget(self.message_input)
        
        # 文件附件
        file_layout = QHBoxLayout()
        file_layout.addWidget(QLabel("📎 附件文件:"))
        self.file_input = QLineEdit()
        self.file_input.setReadOnly(True)
        file_layout.addWidget(self.file_input)
        
        self.browse_button = QPushButton("浏览...")
        self.browse_button.clicked.connect(self.browse_file)
        file_layout.addWidget(self.browse_button)
        layout.addLayout(file_layout)
        
        # 发送按钮
        self.send_button = QPushButton("🚀 发送消息")
        self.send_button.clicked.connect(lambda: self.send_message(immediate=True))
        layout.addWidget(self.send_button, alignment=Qt.AlignRight)
    
    def create_schedule_tab(self):
        """创建定时发送标签页"""
        self.schedule_tab = QWidget()
        self.tabs.addTab(self.schedule_tab, "⏰ 定时发送")
        
        layout = QVBoxLayout(self.schedule_tab)
        layout.setSpacing(15)
        
        # 定时任务设置组
        schedule_group = QGroupBox("新建定时任务")
        schedule_layout = QVBoxLayout()
        
        # 收件人
        recipient_layout = QHBoxLayout()
        recipient_layout.addWidget(QLabel("👤 收件人:"))
        self.schedule_recipient_input = QLineEdit()
        self.schedule_recipient_input.setPlaceholderText("输入微信用户名或备注名")
        recipient_layout.addWidget(self.schedule_recipient_input)
        schedule_layout.addLayout(recipient_layout)
        
        # 消息内容
        schedule_layout.addWidget(QLabel("💬 消息内容:"))
        self.schedule_message_input = QTextEdit()
        self.schedule_message_input.setPlaceholderText("输入要发送的消息...")
        schedule_layout.addWidget(self.schedule_message_input)
        
        # 文件附件
        file_layout = QHBoxLayout()
        file_layout.addWidget(QLabel("📎 附件文件:"))
        self.schedule_file_input = QLineEdit()
        self.schedule_file_input.setReadOnly(True)
        file_layout.addWidget(self.schedule_file_input)
        
        self.schedule_browse_button = QPushButton("浏览...")
        self.schedule_browse_button.clicked.connect(self.browse_schedule_file)
        file_layout.addWidget(self.schedule_browse_button)
        schedule_layout.addLayout(file_layout)
        
        # 定时设置
        time_layout = QHBoxLayout()
        time_layout.addWidget(QLabel("⏰ 发送时间:"))
        self.datetime_input = QDateTimeEdit()
        self.datetime_input.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
        self.datetime_input.setDateTime(datetime.now())
        time_layout.addWidget(self.datetime_input)
        
        self.repeat_checkbox = QCheckBox("重复发送")
        time_layout.addWidget(self.repeat_checkbox)
        
        self.repeat_interval = QSpinBox()
        self.repeat_interval.setRange(1, 1440)
        self.repeat_interval.setValue(60)
        self.repeat_interval.setSuffix("分钟")
        time_layout.addWidget(self.repeat_interval)
        schedule_layout.addLayout(time_layout)
        
        # 添加任务按钮
        self.add_task_button = QPushButton("➕ 添加定时任务")
        self.add_task_button.clicked.connect(self.add_scheduled_task)
        schedule_layout.addWidget(self.add_task_button)
        
        schedule_group.setLayout(schedule_layout)
        layout.addWidget(schedule_group)
        
        # 任务列表组
        tasks_group = QGroupBox("定时任务列表")
        tasks_layout = QVBoxLayout()
        
        self.tasks_list = QTextEdit()
        self.tasks_list.setReadOnly(True)
        tasks_layout.addWidget(self.tasks_list)
        
        self.clear_tasks_button = QPushButton("🗑️ 清除已完成任务")
        self.clear_tasks_button.clicked.connect(self.clear_completed_tasks)
        tasks_layout.addWidget(self.clear_tasks_button)
        
        tasks_group.setLayout(tasks_layout)
        layout.addWidget(tasks_group)
    
    def create_control_tab(self):
        """创建控制标签页"""
        self.control_tab = QWidget()
        self.tabs.addTab(self.control_tab, "⚙️ 微信控制")
        
        layout = QVBoxLayout(self.control_tab)
        layout.setSpacing(15)
        
        # 微信路径
        path_layout = QHBoxLayout()
        path_layout.addWidget(QLabel("📂 微信路径:"))
        self.wechat_path_input = QLineEdit(r'C:\Program Files (x86)\Tencent\WeChat\WeChat.exe')
        path_layout.addWidget(self.wechat_path_input)
        
        self.path_browse_button = QPushButton("浏览...")
        self.path_browse_button.clicked.connect(self.browse_wechat_path)
        path_layout.addWidget(self.path_browse_button)
        layout.addLayout(path_layout)
        
        # 控制按钮
        button_layout = QHBoxLayout()
        self.start_button = QPushButton("🚀 启动微信")
        self.start_button.clicked.connect(self.start_wechat)
        button_layout.addWidget(self.start_button)
        
        self.active_button = QPushButton("🔍 激活窗口")
        self.active_button.clicked.connect(self.active_wechat)
        button_layout.addWidget(self.active_button)
        
        self.quit_button = QPushButton("❌ 退出微信")
        self.quit_button.clicked.connect(self.quit_wechat)
        button_layout.addWidget(self.quit_button)
        layout.addLayout(button_layout)
        
        # 日志区域
        layout.addWidget(QLabel("📝 操作日志:"))
        self.log_output = QTextEdit()
        self.log_output.setReadOnly(True)
        layout.addWidget(self.log_output)
    
    def browse_file(self):
        file_path, _ = QFileDialog.getOpenFileName(self, "选择文件", "", "所有文件 (*.*)")
        if file_path:
            self.file_input.setText(file_path)
    
    def browse_schedule_file(self):
        file_path, _ = QFileDialog.getOpenFileName(self, "选择文件", "", "所有文件 (*.*)")
        if file_path:
            self.schedule_file_input.setText(file_path)
    
    def browse_wechat_path(self):
        file_path, _ = QFileDialog.getOpenFileName(
            self, "选择微信程序", "", "可执行文件 (*.exe)")
        if file_path:
            self.wechat_path_input.setText(file_path)
    
    def log_message(self, message):
        """添加日志消息"""
        self.log_output.append(f"[{datetime.now().strftime('%H:%M:%S')}] {message}")
    
    def update_status(self, message, is_success=True):
        """更新状态栏"""
        emoji = "🟢" if is_success else "🔴"
        self.status_bar.showMessage(f"{emoji} {message}")
    
    def send_message(self, recipient=None, message=None, file_path=None, immediate=False):
        """发送消息的核心方法"""
        if immediate:
            recipient = self.recipient_input.text().strip()
            message = self.message_input.toPlainText().strip()
            file_path = self.file_input.text().strip()
        
        if not recipient:
            QMessageBox.warning(self, "警告", "请输入收件人")
            return False
        
        if not message and not file_path:
            QMessageBox.warning(self, "警告", "请输入消息内容或选择文件")
            return False
        
        # 检查文件是否存在
        if file_path and not os.path.exists(file_path):
            QMessageBox.warning(self, "警告", f"文件不存在: {file_path}")
            return False
        
        if immediate:
            self.send_button.setEnabled(False)
            self.status_bar.showMessage("🟡 正在发送消息...")
        
        def send():
            try:
                if message:
                    wechat_send_msg(recipient, message)
                    self.log_message(f"文本消息已发送给: {recipient}")
                
                if file_path:
                    # 确保文件路径是绝对路径
                    abs_file_path = os.path.abspath(file_path)
                    if not os.path.exists(abs_file_path):
                        raise Exception(f"文件不存在: {abs_file_path}")
                    
                    msg = f"全路径文件名:{abs_file_path}"
                    wechat_send_msg(recipient, msg)
                    self.log_message(f"文件已发送: {abs_file_path}")
                
                return "消息发送成功"
            except Exception as e:
                raise Exception(f"发送失败: {str(e)}")
        
        if immediate:
            self.worker = WorkerThread(send)
            self.worker.finished.connect(lambda msg, success: self.on_operation_finished(msg, success, "send"))
            self.worker.start()
        else:
            try:
                send()
                return True
            except Exception as e:
                self.log_message(f"定时发送失败: {str(e)}")
                return False
    
    def add_scheduled_task(self):
        """添加定时任务"""
        recipient = self.schedule_recipient_input.text().strip()
        message = self.schedule_message_input.toPlainText().strip()
        file_path = self.schedule_file_input.text().strip()
        send_time = self.datetime_input.dateTime().toPyDateTime()
        repeat = self.repeat_checkbox.isChecked()
        interval = self.repeat_interval.value()
        
        if not recipient:
            QMessageBox.warning(self, "警告", "请输入收件人")
            return
        
        if not message and not file_path:
            QMessageBox.warning(self, "警告", "请输入消息内容或选择文件")
            return
        
        # 检查文件是否存在
        if file_path and not os.path.exists(file_path):
            QMessageBox.warning(self, "警告", f"文件不存在: {file_path}")
            return
        
        task = {
            "recipient": recipient,
            "message": message,
            "file_path": os.path.abspath(file_path) if file_path else "",
            "send_time": send_time,
            "repeat": repeat,
            "interval": interval,
            "completed": False
        }
        
        self.scheduled_tasks.append(task)
        self.update_tasks_list()
        QMessageBox.information(self, "成功", "定时任务已添加")
    
    def update_tasks_list(self):
        """更新任务列表显示"""
        self.tasks_list.clear()
        now = datetime.now()
        
        for i, task in enumerate(self.scheduled_tasks, 1):
            status = "✅ 已完成" if task["completed"] else "⏳ 等待中"
            time_left = (task["send_time"] - now).total_seconds()
            
            if time_left > 0:
                time_str = f"剩余: {int(time_left//3600)}小时{int((time_left%3600)//60)}分钟"
            else:
                time_str = "已到时间"
            
            repeat_str = f", 每{task['interval']}分钟重复" if task["repeat"] else ""
            
            self.tasks_list.append(
                f"{i}. {status} | {time_str}{repeat_str}\n"
                f"收件人: {task['recipient']}\n"
                f"内容: {task['message'][:30]}{'...' if len(task['message'])>30 else ''}\n"
                f"附件: {task['file_path'] if task['file_path'] else '无'}\n"
                f"发送时间: {task['send_time'].strftime('%Y-%m-%d %H:%M:%S')}\n"
                "─" * 50
            )
    
    def check_scheduled_tasks(self):
        """检查并执行定时任务"""
        now = datetime.now()
        any_task_executed = False
        
        for task in self.scheduled_tasks:
            if not task["completed"] and now >= task["send_time"]:
                # 执行任务
                success = self.send_message(
                    recipient=task["recipient"],
                    message=task["message"],
                    file_path=task["file_path"]
                )
                
                if success:
                    task["completed"] = True
                    self.log_message(f"定时任务执行成功: 发送给 {task['recipient']}")
                    
                    # 如果是重复任务，重新设置下次执行时间
                    if task["repeat"]:
                        task["send_time"] = now + timedelta(minutes=task["interval"])
                        task["completed"] = False
                
                any_task_executed = True
        
        if any_task_executed:
            self.update_tasks_list()
    
    def clear_completed_tasks(self):
        """清除已完成的任务"""
        self.scheduled_tasks = [task for task in self.scheduled_tasks if not task["completed"]]
        self.update_tasks_list()
        QMessageBox.information(self, "提示", "已清除所有已完成任务")
    
    def start_wechat(self):
        wechat_path = self.wechat_path_input.text().strip()
        
        if not os.path.exists(wechat_path):
            QMessageBox.warning(self, "警告", "微信路径无效，请重新选择")
            return
        
        self.start_button.setEnabled(False)
        self.status_bar.showMessage("🟡 正在启动微信...")
        
        def start():
            try:
                wechat_start(wechat_path)
                return "微信启动成功"
            except Exception as e:
                raise Exception(f"启动失败: {str(e)}")
        
        self.worker = WorkerThread(start)
        self.worker.finished.connect(lambda msg, success: self.on_operation_finished(msg, success, "start"))
        self.worker.start()
    
    def active_wechat(self):
        self.active_button.setEnabled(False)
        self.status_bar.showMessage("🟡 正在激活微信窗口...")
        
        def active():
            try:
                wechat_active()
                return "微信窗口已激活"
            except Exception as e:
                raise Exception(f"激活失败: {str(e)}")
        
        self.worker = WorkerThread(active)
        self.worker.finished.connect(lambda msg, success: self.on_operation_finished(msg, success, "active"))
        self.worker.start()
    
    def quit_wechat(self):
        self.quit_button.setEnabled(False)
        self.status_bar.showMessage("🟡 正在退出微信...")
        
        def quit():
            try:
                wechat_quit()
                return "微信已退出"
            except Exception as e:
                raise Exception(f"退出失败: {str(e)}")
        
        self.worker = WorkerThread(quit)
        self.worker.finished.connect(lambda msg, success: self.on_operation_finished(msg, success, "quit"))
        self.worker.start()
    
    def on_operation_finished(self, message, success, operation_type):
        """操作完成后的回调"""
        self.update_status(message, success)
        self.log_message(message)
        
        if not success:
            QMessageBox.critical(self, "错误", message)
        
        # 重新启用按钮
        if operation_type == "send":
            self.send_button.setEnabled(True)
        elif operation_type == "start":
            self.start_button.setEnabled(True)
        elif operation_type == "active":
            self.active_button.setEnabled(True)
        elif operation_type == "quit":
            self.quit_button.setEnabled(True)

def ifProcessRunning(process_name='WeChat.exe'):
    pl = psutil.pids()
    result = "PROCESS_IS_NOT_RUNNING"
    for pid in pl:
        try:
            if psutil.Process(pid).name() == process_name:
                if isinstance(pid, int):
                    result = "PROCESS_IS_RUNNING"
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    return result

def wechat_start(wechat_path):
    os.startfile(wechat_path)
    loginwin = uiautomation.PaneControl(searchDepth=1, ClassName='WeChatLoginWndForPC', Name='微信')
    try:
        loginwin.ButtonControl(Name='进入微信').Click()
    except:
        loginwin.ButtonControl(Name='登录').Click()

def wechat_active():
    uiautomation.uiautomation.TIME_OUT_SECOND = 2
    if ifProcessRunning() == "PROCESS_IS_RUNNING":
        try:
            desktop = uiautomation.PaneControl(Name='任务栏')
            desktop.SendKeys('{Ctrl}{Alt}w')
        except:
            os.system('taskkill /F /im "WeChat.exe" >nul')
            wechat_start(r'C:\Program Files (x86)\Tencent\WeChat\WeChat.exe')
    else:
        wechat_start(r'C:\Program Files (x86)\Tencent\WeChat\WeChat.exe')
    uiautomation.uiautomation.TIME_OUT_SECOND = 20
    wechatWindow = uiautomation.WindowControl(searchDepth=1, className='WeChatMainWndForPC', Name='微信')
    try:
        wechatWindow.Restore()
        wechatWindow.MoveToCenter()
        wechatWindow.SetTopmost(True)
    except:
        print('未能成功激活微信窗口')

def wechat_send_msg(send_to='微信用户名', msg='要发送的消息'):
    wechat_active()
    wechatWindow = uiautomation.WindowControl(searchDepth=1, className='WeChatMainWndForPC', Name='微信')
    
    # 搜索联系人
    search_edit = wechatWindow.EditControl(Name="搜索")
    search_edit.Click()
    search_edit.SendKeys(send_to, 0.5)
    time.sleep(1)  # 等待搜索结果
    
    # 按回车键选择联系人
    search_edit.SendKeys('{enter}')
    time.sleep(2)  # 增加等待时间确保聊天窗口加载
    
    if msg[:7] != '全路径文件名:':
        # 查找消息输入框 - 使用更可靠的方法
        chat_input = None
        for _ in range(5):  # 增加重试次数
            try:
                # 尝试多种方式查找输入框
                chat_input = wechatWindow.EditControl(Name="输入")
                if not chat_input.Exists():
                    chat_input = wechatWindow.EditControl(automationId="editArea")
                if not chat_input.Exists():
                    chat_input = wechatWindow.EditControl(ClassName="Edit")
                
                if chat_input and chat_input.Exists():
                    break
            except Exception as e:
                print(f"查找输入框时出错: {str(e)}")
            time.sleep(1)
        
        if not chat_input or not chat_input.Exists():
            raise Exception("找不到消息输入框，请确保已打开正确的聊天窗口")
        
        chat_input.SendKeys(msg, 0.03)
        
        # 查找发送按钮 - 使用更可靠的方法
        send_button = None
        for _ in range(5):  # 增加重试次数
            try:
                send_button = wechatWindow.ButtonControl(Name="发送(S)")
                if not send_button.Exists():
                    send_button = wechatWindow.ButtonControl(automationId="sendBtn")
                if not send_button.Exists():
                    send_button = wechatWindow.ButtonControl(ClassName="Button", foundIndex=1)
                
                if send_button and send_button.Exists():
                    break
            except Exception as e:
                print(f"查找发送按钮时出错: {str(e)}")
            time.sleep(1)
        
        if not send_button or not send_button.Exists():
            raise Exception("找不到发送按钮")
        
        send_button.Click()
    else:
        file_path = msg[7:]
        if not os.path.exists(file_path):
            raise Exception(f"文件不存在: {file_path}")
            
        # 查找文件发送按钮 - 使用更可靠的方法
        file_button = None
        for _ in range(5):  # 增加重试次数
            try:
                file_button = wechatWindow.ButtonControl(Name="发送文件")
                if not file_button.Exists():
                    file_button = wechatWindow.ButtonControl(automationId="fileBtn")
                
                if file_button and file_button.Exists():
                    break
            except Exception as e:
                print(f"查找文件发送按钮时出错: {str(e)}")
            time.sleep(1)
        
        if not file_button or not file_button.Exists():
            raise Exception("找不到文件发送按钮")
        
        file_button.Click()
        
        # 等待文件选择对话框出现
        time.sleep(2)
        file_dialog = uiautomation.WindowControl(Name="打开")
        if not file_dialog.Exists():
            raise Exception("文件选择对话框未出现")
            
        # 输入文件路径
        filename_edit = file_dialog.EditControl(Name="文件名(N):")
        filename_edit.SendKeys(file_path)
        time.sleep(0.5)
        filename_edit.SendKeys('{enter}')
        
        # 等待文件上传
        time.sleep(3)
        
        # 查找最终发送按钮 - 使用更可靠的方法
        final_send_button = None
        for _ in range(5):  # 增加重试次数
            try:
                final_send_button = wechatWindow.ButtonControl(Name="发送（1）")
                if not final_send_button.Exists():
                    final_send_button = wechatWindow.ButtonControl(automationId="sendBtn")
                
                if final_send_button and final_send_button.Exists():
                    break
            except Exception as e:
                print(f"查找最终发送按钮时出错: {str(e)}")
            time.sleep(1)
        
        if not final_send_button or not final_send_button.Exists():
            raise Exception("找不到最终发送按钮")
        
        final_send_button.Click()
    
    wechatWindow.SetTopmost(False)
    wechatWindow.Minimize()

def wechat_quit():
    if ifProcessRunning() == "PROCESS_IS_RUNNING":
        os.system('taskkill /F /im "WeChat.exe" >nul')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = WeChatAutomationApp()
    window.show()
    sys.exit(app.exec_())

# 多重定位策略
chat_input = None
for control_type in [("Name","输入"), ("automationId","editArea"), ("ClassName","Edit")]:
    chat_input = wechatWindow.EditControl(**{control_type[0]: control_type[1]})
    if chat_input.Exists():
        break