import sys
import os
import random
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
QHBoxLayout, QPushButton, QLabel, QSlider,
QFileDialog, QMessageBox, QStyle, QListWidget,
QListWidgetItem, QGroupBox, QMenu, QAction,
QComboBox, QProgressBar, QSplitter, QToolBar,
QStatusBar, QSystemTrayIcon)
from PyQt5.QtCore import Qt, QTimer, QTime, pyqtSignal, QSize, QEvent
from PyQt5.QtGui import QIcon, QFont, QPalette, QColor, QPixmap, QCursor
from player import AudioLibrary
import time
class ModernAudioPlayer(QMainWindow):
# 自定义信号
position_changed = pyqtSignal(float)
state_changed = pyqtSignal(str)
volume_changed = pyqtSignal(int)
# 播放模式常量
PLAY_MODE_SEQUENTIAL = 0 # 顺序播放
PLAY_MODE_SHUFFLE = 1 # 随机播放
PLAY_MODE_SINGLE = 2 # 单曲循环
PLAY_MODE_LOOP = 3 # 列表循环
def __init__(self):
super().__init__()
# 初始化音频库
try:
self.audio_lib = AudioLibrary()
print("音频库初始化成功")
except Exception as e:
QMessageBox.critical(self, "错误", f"音频库初始化失败: {e}")
self.audio_lib = None
return
# 初始化变量
self.current_aid = None
self.current_file = None
self.current_file_name = ""
self.playlist = []
self.current_index = -1
self.is_playing = False
self.is_paused = False
self.total_duration = 0
self.playback_start_time = 0
self.current_position = 0
self.volume = 80
self.is_muted = False
self.last_volume = 80
# 播放模式相关
self.play_mode = self.PLAY_MODE_SEQUENTIAL
self.shuffled_indices = [] # 随机播放时的播放顺序
self.is_shuffle_active = False
# 更新定时器
self.update_timer = QTimer()
# 初始化UI
self.init_ui()
# 连接信号和槽
self.setup_connections()
# 启动更新定时器
self.update_timer.start(100) # 100ms更新一次
# 初始化系统托盘
self.init_system_tray()
def init_ui(self):
"""初始化UI"""
self.setWindowTitle("Modern Audio Player - Advanced")
self.setGeometry(100, 100, 1000, 700)
# 设置应用程序图标
self.setWindowIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
# 设置深色主题
self.set_dark_theme()
# 创建中央部件
central_widget = QWidget()
self.setCentralWidget(central_widget)
# 主布局
main_layout = QVBoxLayout(central_widget)
main_layout.setContentsMargins(15, 15, 15, 15)
main_layout.setSpacing(10)
# 1. 顶部工具栏
self.create_toolbar()
# 2. 使用分割器创建左右布局
splitter = QSplitter(Qt.Horizontal)
# 左侧：播放控制和信息面板
left_widget = QWidget()
left_layout = QVBoxLayout(left_widget)
left_layout.setContentsMargins(0, 0, 0, 0)
# 当前播放信息
self.create_current_info_panel(left_layout)
# 播放进度控制
self.create_progress_panel(left_layout)
# 播放控制按钮
self.create_control_panel(left_layout)
# 音量控制
self.create_volume_panel(left_layout)
# 播放模式选择
self.create_playmode_panel(left_layout)
# 右侧：播放列表
right_widget = QWidget()
right_layout = QVBoxLayout(right_widget)
right_layout.setContentsMargins(0, 0, 0, 0)
right_layout.setSpacing(5)
# 播放列表标题和操作按钮
playlist_header = QWidget()
playlist_header_layout = QHBoxLayout(playlist_header)
playlist_header_layout.setContentsMargins(0, 0, 0, 0)
playlist_label = QLabel("🎵 播放列表")
playlist_label.setFont(QFont("Arial", 12, QFont.Bold))
playlist_label.setStyleSheet("color: #ecf0f1; padding: 5px;")
# 播放列表操作按钮
playlist_actions = QWidget()
playlist_actions_layout = QHBoxLayout(playlist_actions)
playlist_actions_layout.setContentsMargins(0, 0, 0, 0)
self.playlist_clear_button = QPushButton("清空")
self.playlist_remove_button = QPushButton("移除")
self.playlist_save_button = QPushButton("保存")
self.playlist_load_button = QPushButton("加载")
for btn in [self.playlist_clear_button, self.playlist_remove_button,
self.playlist_save_button, self.playlist_load_button]:
btn.setFixedSize(60, 25)
btn.setFont(QFont("Arial", 8))
playlist_actions_layout.addWidget(self.playlist_clear_button)
playlist_actions_layout.addWidget(self.playlist_remove_button)
playlist_actions_layout.addWidget(self.playlist_save_button)
playlist_actions_layout.addWidget(self.playlist_load_button)
playlist_actions_layout.addStretch()
playlist_header_layout.addWidget(playlist_label)
playlist_header_layout.addWidget(playlist_actions)
right_layout.addWidget(playlist_header)
# 播放列表
self.playlist_widget = QListWidget()
self.playlist_widget.setStyleSheet("""
QListWidget {
background-color: #2c3e50;
border: 2px solid #34495e;
border-radius: 8px;
padding: 5px;
color: #ecf0f1;
font-size: 11px;
}
QListWidget::item {
padding: 8px;
border-bottom: 1px solid #34495e;
border-radius: 4px;
margin: 2px;
}
QListWidget::item:selected {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 0,
stop: 0 #3498db, stop: 1 #2980b9
);
color: white;
border: 1px solid #2980b9;
}
QListWidget::item:hover {
background-color: #34495e;
border: 1px solid #7f8c8d;
}
QListWidget::item:alternate {
background-color: #2d3e50;
}
""")
self.playlist_widget.setAlternatingRowColors(True)
right_layout.addWidget(self.playlist_widget)
# 播放列表信息
self.playlist_info_label = QLabel("共 0 首歌曲 | 总时长: 00:00")
self.playlist_info_label.setFont(QFont("Arial", 9))
self.playlist_info_label.setStyleSheet("color: #7f8c8d; padding: 5px;")
self.playlist_info_label.setAlignment(Qt.AlignCenter)
right_layout.addWidget(self.playlist_info_label)
# 设置分割器
splitter.addWidget(left_widget)
splitter.addWidget(right_widget)
splitter.setSizes([400, 600])
main_layout.addWidget(splitter)
# 3. 底部状态栏
self.create_status_bar()
# 设置按钮样式
self.set_button_styles()
# 初始化菜单
self.create_context_menus()
def create_toolbar(self):
"""创建工具栏"""
toolbar = QToolBar()
toolbar.setIconSize(QSize(24, 24))
toolbar.setMovable(False)
self.addToolBar(toolbar)
# 文件操作
self.open_file_action = QAction(
self.style().standardIcon(QStyle.SP_DirOpenIcon),
"打开文件", self
)
self.open_folder_action = QAction(
self.style().standardIcon(QStyle.SP_DirIcon),
"打开文件夹", self
)
toolbar.addAction(self.open_file_action)
toolbar.addAction(self.open_folder_action)
toolbar.addSeparator()
# 播放控制
self.play_action = QAction(
self.style().standardIcon(QStyle.SP_MediaPlay),
"播放", self
)
self.pause_action = QAction(
self.style().standardIcon(QStyle.SP_MediaPause),
"暂停", self
)
self.stop_action = QAction(
self.style().standardIcon(QStyle.SP_MediaStop),
"停止", self
)
self.prev_action = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipBackward),
"上一首", self
)
self.next_action = QAction(
self.style().standardIcon(QStyle.SP_MediaSkipForward),
"下一首", self
)
toolbar.addAction(self.play_action)
toolbar.addAction(self.pause_action)
toolbar.addAction(self.stop_action)
toolbar.addAction(self.prev_action)
toolbar.addAction(self.next_action)
toolbar.addSeparator()
# 播放模式
self.playmode_combo = QComboBox()
self.playmode_combo.addItem("顺序播放", self.PLAY_MODE_SEQUENTIAL)
self.playmode_combo.addItem("随机播放", self.PLAY_MODE_SHUFFLE)
self.playmode_combo.addItem("单曲循环", self.PLAY_MODE_SINGLE)
self.playmode_combo.addItem("列表循环", self.PLAY_MODE_LOOP)
self.playmode_combo.setFixedWidth(120)
toolbar.addWidget(self.playmode_combo)
def create_current_info_panel(self, layout):
"""创建当前播放信息面板"""
info_group = QGroupBox("当前播放")
info_group.setStyleSheet("""
QGroupBox {
font-weight: bold;
border: 2px solid #3498db;
border-radius: 10px;
margin-top: 5px;
padding-top: 15px;
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 0,
stop: 0 #2c3e50, stop: 1 #34495e
);
}
QGroupBox::title {
subcontrol-origin: margin;
left: 15px;
padding: 0 10px 0 10px;
color: #3498db;
font-size: 12px;
}
""")
info_layout = QVBoxLayout()
info_layout.setSpacing(8)
# 专辑封面（占位符）
album_frame = QWidget()
album_frame.setFixedHeight(150)
album_frame.setStyleSheet("""
background-color: #2c3e50;
border: 2px dashed #3498db;
border-radius: 8px;
""")
album_layout = QVBoxLayout(album_frame)
album_layout.setAlignment(Qt.AlignCenter)
album_icon = QLabel("🎵")
album_icon.setFont(QFont("Arial", 48))
album_icon.setAlignment(Qt.AlignCenter)
album_layout.addWidget(album_icon)
info_layout.addWidget(album_frame)
# 歌曲信息
self.current_file_label = QLabel("未选择歌曲")
self.current_file_label.setFont(QFont("Arial", 11, QFont.Bold))
self.current_file_label.setStyleSheet("color: #ecf0f1; padding: 5px;")
self.current_file_label.setAlignment(Qt.AlignCenter)
self.current_file_label.setWordWrap(True)
self.song_info_label = QLabel("艺术家: 未知 | 专辑: 未知")
self.song_info_label.setFont(QFont("Arial", 9))
self.song_info_label.setStyleSheet("color: #bdc3c7; padding: 3px;")
self.song_info_label.setAlignment(Qt.AlignCenter)
info_layout.addWidget(self.current_file_label)
info_layout.addWidget(self.song_info_label)
info_group.setLayout(info_layout)
layout.addWidget(info_group)
def create_progress_panel(self, layout):
"""创建进度控制面板"""
progress_group = QGroupBox("播放进度")
progress_group.setStyleSheet("""
QGroupBox {
font-weight: bold;
border: 2px solid #2ecc71;
border-radius: 10px;
margin-top: 5px;
padding-top: 15px;
}
QGroupBox::title {
subcontrol-origin: margin;
left: 15px;
padding: 0 10px 0 10px;
color: #2ecc71;
font-size: 12px;
}
""")
progress_layout = QVBoxLayout()
progress_layout.setSpacing(8)
# 时间显示
time_layout = QHBoxLayout()
self.current_time_label = QLabel("00:00")
self.current_time_label.setFont(QFont("Arial", 11))
self.current_time_label.setStyleSheet("color: #ecf0f1;")
self.total_time_label = QLabel("00:00")
self.total_time_label.setFont(QFont("Arial", 11))
self.total_time_label.setStyleSheet("color: #ecf0f1;")
self.total_time_label.setAlignment(Qt.AlignRight)
time_layout.addWidget(self.current_time_label)
time_layout.addStretch()
time_layout.addWidget(self.total_time_label)
progress_layout.addLayout(time_layout)
# 进度条
self.position_slider = QSlider(Qt.Horizontal)
self.position_slider.setRange(0, 1000)
self.position_slider.setStyleSheet("""
QSlider::groove:horizontal {
border: 1px solid #27ae60;
background: #2c3e50;
height: 8px;
border-radius: 4px;
}
QSlider::sub-page:horizontal {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 0,
stop: 0 #2ecc71, stop: 1 #27ae60
);
border: 1px solid #27ae60;
height: 8px;
border-radius: 4px;
}
QSlider::add-page:horizontal {
background: #34495e;
border: 1px solid #27ae60;
height: 8px;
border-radius: 4px;
}
QSlider::handle:horizontal {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 1,
stop: 0 #ecf0f1, stop: 1 #bdc3c7
);
width: 18px;
height: 18px;
margin: -5px 0;
border-radius: 9px;
border: 1px solid #7f8c8d;
}
QSlider::handle:horizontal:hover {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 1,
stop: 0 #ffffff, stop: 1 #ecf0f1
);
border: 2px solid #2ecc71;
}
""")
progress_layout.addWidget(self.position_slider)
progress_group.setLayout(progress_layout)
layout.addWidget(progress_group)
def create_control_panel(self, layout):
"""创建控制按钮面板"""
control_group = QGroupBox("播放控制")
control_group.setStyleSheet("""
QGroupBox {
font-weight: bold;
border: 2px solid #e74c3c;
border-radius: 10px;
margin-top: 5px;
padding-top: 15px;
}
QGroupBox::title {
subcontrol-origin: margin;
left: 15px;
padding: 0 10px 0 10px;
color: #e74c3c;
font-size: 12px;
}
""")
control_layout = QHBoxLayout()
control_layout.setSpacing(15)
# 创建控制按钮
buttons = [
("⏮", "上一首", self.play_previous, 50, 50),
("⏪", "快退10秒", lambda: self.seek_relative(-10), 45, 45),
("▶", "播放", self.play_pause, 60, 60),
("⏩", "快进10秒", lambda: self.seek_relative(10), 45, 45),
("⏭", "下一首", self.play_next, 50, 50),
("⏹", "停止", self.stop, 45, 45),
]
for icon, tooltip, slot, w, h in buttons:
btn = QPushButton(icon)
btn.setFont(QFont("Arial", 14))
btn.setFixedSize(w, h)
btn.setToolTip(tooltip)
btn.clicked.connect(slot)
# 为播放按钮特殊处理
if icon == "▶":
self.play_button = btn
elif icon == "⏹":
self.stop_button = btn
control_layout.addWidget(btn)
control_layout.insertStretch(0, 1)
control_layout.addStretch(1)
control_group.setLayout(control_layout)
layout.addWidget(control_group)
def create_volume_panel(self, layout):
"""创建音量控制面板"""
volume_group = QGroupBox("音量控制")
volume_group.setStyleSheet("""
QGroupBox {
font-weight: bold;
border: 2px solid #9b59b6;
border-radius: 10px;
margin-top: 5px;
padding-top: 15px;
}
QGroupBox::title {
subcontrol-origin: margin;
left: 15px;
padding: 0 10px 0 10px;
color: #9b59b6;
font-size: 12px;
}
""")
volume_layout = QHBoxLayout()
volume_layout.setSpacing(10)
# 静音按钮
self.mute_button = QPushButton("🔊")
self.mute_button.setFont(QFont("Arial", 12))
self.mute_button.setFixedSize(40, 40)
self.mute_button.setToolTip("静音")
# 音量滑块
self.volume_slider = QSlider(Qt.Horizontal)
self.volume_slider.setRange(0, 128)
self.volume_slider.setValue(80)
self.volume_slider.setStyleSheet("""
QSlider::groove:horizontal {
border: 1px solid #8e44ad;
background: #2c3e50;
height: 8px;
border-radius: 4px;
}
QSlider::sub-page:horizontal {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 0,
stop: 0 #9b59b6, stop: 1 #8e44ad
);
border: 1px solid #8e44ad;
height: 8px;
border-radius: 4px;
}
QSlider::add-page:horizontal {
background: #34495e;
border: 1px solid #8e44ad;
height: 8px;
border-radius: 4px;
}
QSlider::handle:horizontal {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 1,
stop: 0 #ecf0f1, stop: 1 #bdc3c7
);
width: 18px;
height: 18px;
margin: -5px 0;
border-radius: 9px;
border: 1px solid #7f8c8d;
}
QSlider::handle:horizontal:hover {
background: qlineargradient(
x1: 0, y1: 0, x2: 1, y2: 1,
stop: 0 #ffffff, stop: 1 #ecf0f1
);
border: 2px solid #9b59b6;
}
""")
# 音量标签
self.volume_label = QLabel("80")
self.volume_label.setFont(QFont("Arial", 11))
self.volume_label.setFixedWidth(30)
self.volume_label.setStyleSheet("color: #ecf0f1;")
volume_layout.addWidget(self.mute_button)
volume_layout.addWidget(self.volume_slider)
volume_layout.addWidget(self.volume_label)
volume_group.setLayout(volume_layout)
layout.addWidget(volume_group)
def create_playmode_panel(self, layout):
"""创建播放模式面板"""
playmode_group = QGroupBox("播放模式")
playmode_group.setStyleSheet("""
QGroupBox {
font-weight: bold;
border: 2px solid #f39c12;
border-radius: 10px;
margin-top: 5px;
padding-top: 15px;
}
QGroupBox::title {
subcontrol-origin: margin;
left: 15px;
padding: 0 10px 0 10px;
color: #f39c12;
font-size: 12px;
}
""")
playmode_layout = QVBoxLayout()
playmode_layout.setSpacing(8)
# 播放模式描述
self.playmode_desc_label = QLabel("顺序播放: 按列表顺序播放，播放完停止")
self.playmode_desc_label.setFont(QFont("Arial", 9))
self.playmode_desc_label.setStyleSheet("color: #bdc3c7;")
self.playmode_desc_label.setWordWrap(True)
# 模式按钮组
mode_buttons_layout = QHBoxLayout()
self.mode_sequential = QPushButton("顺序")
self.mode_shuffle = QPushButton("随机")
self.mode_single = QPushButton("单曲")
self.mode_loop = QPushButton("列表")
for btn in [self.mode_sequential, self.mode_shuffle,
self.mode_single, self.mode_loop]:
btn.setFixedSize(60, 30)
btn.setCheckable(True)
# 设置顺序播放为默认选中
self.mode_sequential.setChecked(True)
mode_buttons_layout.addWidget(self.mode_sequential)
mode_buttons_layout.addWidget(self.mode_shuffle)
mode_buttons_layout.addWidget(self.mode_single)
mode_buttons_layout.addWidget(self.mode_loop)
mode_buttons_layout.addStretch()
playmode_layout.addWidget(self.playmode_desc_label)
playmode_layout.addLayout(mode_buttons_layout)
playmode_group.setLayout(playmode_layout)
layout.addWidget(playmode_group)
# 添加弹簧使布局更紧凑
layout.addStretch()
def create_status_bar(self):
"""创建状态栏"""
self.status_bar = QStatusBar()
self.setStatusBar(self.status_bar)
# 状态标签
self.status_label = QLabel("就绪")
self.status_label.setFont(QFont("Arial", 9))
self.status_label.setStyleSheet("color: #7f8c8d;")
# 播放状态
self.play_status_label = QLabel("已停止")
self.play_status_label.setFont(QFont("Arial", 9))
self.play_status_label.setStyleSheet("color: #3498db;")
# 时间显示
self.time_status_label = QLabel("00:00 / 00:00")
self.time_status_label.setFont(QFont("Arial", 9))
self.time_status_label.setStyleSheet("color: #2ecc71;")
self.status_bar.addWidget(self.status_label, 1)
self.status_bar.addPermanentWidget(self.play_status_label)
self.status_bar.addPermanentWidget(self.time_status_label)
def create_context_menus(self):
"""创建上下文菜单"""
# 播放列表右键菜单
self.playlist_widget.setContextMenuPolicy(Qt.CustomContextMenu)
self.playlist_widget.customContextMenuRequested.connect(self.show_playlist_context_menu)
def set_dark_theme(self):
"""设置深色主题"""
palette = QPalette()
palette.setColor(QPalette.Window, QColor(40, 44, 52))
palette.setColor(QPalette.WindowText, QColor(220, 220, 220))
palette.setColor(QPalette.Base, QColor(30, 33, 40))
palette.setColor(QPalette.AlternateBase, QColor(35, 38, 45))
palette.setColor(QPalette.ToolTipBase, QColor(220, 220, 220))
palette.setColor(QPalette.ToolTipText, QColor(220, 220, 220))
palette.setColor(QPalette.Text, QColor(220, 220, 220))
palette.setColor(QPalette.Button, QColor(50, 54, 63))
palette.setColor(QPalette.ButtonText, QColor(220, 220, 220))
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(66, 139, 202))
palette.setColor(QPalette.Highlight, QColor(66, 139, 202))
palette.setColor(QPalette.HighlightedText, Qt.black)
self.setPalette(palette)
def set_button_styles(self):
"""设置按钮样式"""
# 控制按钮样式
control_button_style = """
QPushButton {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #34495e, stop: 1 #2c3e50
);
color: #ecf0f1;
border: 2px solid #3498db;
border-radius: 25px;
font-weight: bold;
}
QPushButton:hover {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #3498db, stop: 1 #2980b9
);
border: 2px solid #2980b9;
color: white;
}
QPushButton:pressed {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #2980b9, stop: 1 #3498db
);
}
QPushButton:checked {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #2ecc71, stop: 1 #27ae60
);
border: 2px solid #27ae60;
color: white;
}
"""
# 播放按钮特殊样式
play_button_style = """
QPushButton {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #2ecc71, stop: 1 #27ae60
);
color: white;
border: 2px solid #27ae60;
border-radius: 30px;
font-weight: bold;
}
QPushButton:hover {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #27ae60, stop: 1 #2ecc71
);
border: 2px solid #2ecc71;
}
QPushButton:pressed {
background-color: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #229954, stop: 1 #27ae60
);
}
"""
# 设置播放按钮样式
self.play_button.setStyleSheet(play_button_style)
# 设置其他控制按钮样式
for btn in [self.stop_button, self.mute_button]:
btn.setStyleSheet(control_button_style)
# 模式按钮样式
mode_button_style = """
QPushButton {
background-color: #34495e;
color: #ecf0f1;
border: 1px solid #f39c12;
border-radius: 4px;
font-weight: bold;
}
QPushButton:hover {
background-color: #f39c12;
color: white;
}
QPushButton:checked {
background-color: #e67e22;
color: white;
border: 2px solid #d35400;
}
"""
for btn in [self.mode_sequential, self.mode_shuffle,
self.mode_single, self.mode_loop]:
btn.setStyleSheet(mode_button_style)
# 播放列表按钮样式
playlist_button_style = """
QPushButton {
background-color: #2c3e50;
color: #ecf0f1;
border: 1px solid #3498db;
border-radius: 3px;
font-weight: bold;
}
QPushButton:hover {
background-color: #3498db;
color: white;
}
"""
for btn in [self.playlist_clear_button, self.playlist_remove_button,
self.playlist_save_button, self.playlist_load_button]:
btn.setStyleSheet(playlist_button_style)
def setup_connections(self):
"""连接信号和槽"""
# 工具栏动作连接
self.open_file_action.triggered.connect(self.open_file)
self.open_folder_action.triggered.connect(self.open_folder)
self.play_action.triggered.connect(self.play_pause)
self.pause_action.triggered.connect(self.pause)
self.stop_action.triggered.connect(self.stop)
self.prev_action.triggered.connect(self.play_previous)
self.next_action.triggered.connect(self.play_next)
# 播放模式按钮连接
self.mode_sequential.clicked.connect(lambda: self.set_play_mode(self.PLAY_MODE_SEQUENTIAL))
self.mode_shuffle.clicked.connect(lambda: self.set_play_mode(self.PLAY_MODE_SHUFFLE))
self.mode_single.clicked.connect(lambda: self.set_play_mode(self.PLAY_MODE_SINGLE))
self.mode_loop.clicked.connect(lambda: self.set_play_mode(self.PLAY_MODE_LOOP))
# 播放模式组合框连接
self.playmode_combo.currentIndexChanged.connect(self.on_playmode_changed)
# 播放列表按钮连接
self.playlist_clear_button.clicked.connect(self.clear_playlist)
self.playlist_remove_button.clicked.connect(self.remove_selected_items)
self.playlist_save_button.clicked.connect(self.save_playlist)
self.playlist_load_button.clicked.connect(self.load_playlist)
# 滑块连接
self.position_slider.sliderMoved.connect(self.seek_position)
self.volume_slider.valueChanged.connect(self.set_volume)
# 播放列表连接
self.playlist_widget.itemDoubleClicked.connect(self.playlist_item_double_clicked)
# 静音按钮
self.mute_button.clicked.connect(self.toggle_mute)
# 定时器连接
self.update_timer.timeout.connect(self.update_ui)
def init_system_tray(self):
"""初始化系统托盘"""
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon(self)
self.tray_icon.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
# 创建托盘菜单
tray_menu = QMenu()
play_action = QAction("播放/暂停", self)
play_action.triggered.connect(self.play_pause)
stop_action = QAction("停止", self)
stop_action.triggered.connect(self.stop)
next_action = QAction("下一首", self)
next_action.triggered.connect(self.play_next)
show_action = QAction("显示窗口", self)
show_action.triggered.connect(self.show_normal)
quit_action = QAction("退出", self)
quit_action.triggered.connect(self.quit_application)
tray_menu.addAction(play_action)
tray_menu.addAction(stop_action)
tray_menu.addAction(next_action)
tray_menu.addSeparator()
tray_menu.addAction(show_action)
tray_menu.addSeparator()
tray_menu.addAction(quit_action)
self.tray_icon.setContextMenu(tray_menu)
self.tray_icon.show()
# 托盘图标点击事件
self.tray_icon.activated.connect(self.on_tray_icon_activated)
def show_playlist_context_menu(self, position):
"""显示播放列表右键菜单"""
menu = QMenu()
play_action = QAction("播放", self)
play_action.triggered.connect(lambda: self.play_selected_item())
remove_action = QAction("移除", self)
remove_action.triggered.connect(self.remove_selected_items)
clear_action = QAction("清空列表", self)
clear_action.triggered.connect(self.clear_playlist)
menu.addAction(play_action)
menu.addAction(remove_action)
menu.addSeparator()
menu.addAction(clear_action)
menu.exec_(self.playlist_widget.mapToGlobal(position))
def open_file(self):
"""打开单个文件"""
file_path, _ = QFileDialog.getOpenFileName(
self, "选择音频文件", "",
"音频文件 (*.mp3 *.wav *.ogg *.flac *.m4a *.aac);;所有文件 (*.*)"
)
if file_path:
self.add_to_playlist(file_path)
if len(self.playlist) == 1: # 如果是第一个文件，自动加载
self.load_file(file_path)
def open_folder(self):
"""打开文件夹并添加所有音频文件"""
folder_path = QFileDialog.getExistingDirectory(self, "选择文件夹")
if folder_path:
# 清空当前播放列表
self.playlist.clear()
self.playlist_widget.clear()
self.shuffled_indices.clear()
# 遍历文件夹中的音频文件
audio_extensions = ['.mp3', '.wav', '.ogg', '.flac', '.m4a', '.aac']
for root, dirs, files in os.walk(folder_path):
for file in files:
if any(file.lower().endswith(ext) for ext in audio_extensions):
file_path = os.path.join(root, file)
self.add_to_playlist(file_path)
if self.playlist:
self.status_label.setText(f"已添加 {len(self.playlist)} 个文件到播放列表")
self.update_playlist_info()
# 如果当前没有在播放，自动加载第一个文件
if not self.is_playing:
self.load_file(self.playlist[0])
def add_to_playlist(self, file_path):
"""添加文件到播放列表"""
if file_path not in self.playlist:
self.playlist.append(file_path)
file_name = os.path.basename(file_path)
# 获取文件信息
try:
duration_result = self.audio_lib.get_audio_duration(file_path, is_file=True)
if isinstance(duration_result, tuple):
duration = 0
else:
duration = int(duration_result) if duration_result else 0
duration_str = self.format_time(duration)
display_text = f"{file_name} ({duration_str})"
except:
display_text = file_name
item = QListWidgetItem(f"🎵 {display_text}")
item.setData(Qt.UserRole, file_path)
item.setToolTip(file_path)
self.playlist_widget.addItem(item)
# 设置高亮当前播放的项目
if self.current_file == file_path:
item.setSelected(True)
self.playlist_widget.scrollToItem(item)
# 更新播放列表信息
self.update_playlist_info()
def update_playlist_info(self):
"""更新播放列表信息"""
count = len(self.playlist)
# 计算总时长
total_seconds = 0
for file_path in self.playlist:
try:
duration_result = self.audio_lib.get_audio_duration(file_path, is_file=True)
if isinstance(duration_result, tuple):
continue
total_seconds += int(duration_result) if duration_result else 0
except:
continue
total_time = self.format_time(total_seconds)
self.playlist_info_label.setText(f"共 {count} 首歌曲 | 总时长: {total_time}")
def remove_selected_items(self):
"""移除选中的播放列表项"""
selected_items = self.playlist_widget.selectedItems()
if not selected_items:
return
reply = QMessageBox.question(
self, "确认", f"确定要移除选中的 {len(selected_items)} 个项目吗？",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No
)
if reply == QMessageBox.Yes:
for item in selected_items:
file_path = item.data(Qt.UserRole)
if file_path in self.playlist:
index = self.playlist.index(file_path)
self.playlist.pop(index)
# 如果移除的是当前播放的文件
if file_path == self.current_file:
self.stop()
self.current_file = None
self.current_index = -1
self.playlist_widget.takeItem(self.playlist_widget.row(item))
self.update_playlist_info()
def save_playlist(self):
"""保存播放列表到文件"""
if not self.playlist:
QMessageBox.warning(self, "警告", "播放列表为空，无法保存")
return
file_path, _ = QFileDialog.getSaveFileName(
self, "保存播放列表", "", "播放列表文件 (*.m3u);;文本文件 (*.txt)"
)
if file_path:
try:
with open(file_path, 'w', encoding='utf-8') as f:
for item_path in self.playlist:
f.write(item_path + '\n')
self.status_label.setText(f"播放列表已保存到: {file_path}")
QMessageBox.information(self, "成功", "播放列表保存成功！")
except Exception as e:
QMessageBox.critical(self, "错误", f"保存播放列表失败: {e}")
def load_playlist(self):
"""从文件加载播放列表"""
file_path, _ = QFileDialog.getOpenFileName(
self, "加载播放列表", "", "播放列表文件 (*.m3u *.txt);;所有文件 (*.*)"
)
if file_path:
try:
with open(file_path, 'r', encoding='utf-8') as f:
lines = f.readlines()
# 清空当前播放列表
self.playlist.clear()
self.playlist_widget.clear()
self.shuffled_indices.clear()
for line in lines:
line = line.strip()
if line and os.path.exists(line):
self.add_to_playlist(line)
if self.playlist:
self.status_label.setText(f"已加载 {len(self.playlist)} 个文件")
QMessageBox.information(self, "成功", "播放列表加载成功！")
else:
QMessageBox.warning(self, "警告", "播放列表文件为空或文件路径无效")
except Exception as e:
QMessageBox.critical(self, "错误", f"加载播放列表失败: {e}")
def clear_playlist(self):
"""清空播放列表"""
if not self.playlist:
return
reply = QMessageBox.question(
self, "确认", "确定要清空播放列表吗？",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No
)
if reply == QMessageBox.Yes:
self.playlist.clear()
self.playlist_widget.clear()
self.shuffled_indices.clear()
self.current_index = -1
self.current_file = None
self.current_file_label.setText("未选择歌曲")
self.song_info_label.setText("艺术家: 未知 | 专辑: 未知")
self.update_playlist_info()
# 停止当前播放
if self.is_playing and self.current_aid:
self.stop()
def load_file(self, file_path):
"""加载音频文件"""
try:
if not os.path.exists(file_path):
raise FileNotFoundError(f"文件不存在: {file_path}")
# 停止当前播放
if self.is_playing and self.current_aid:
try:
self.audio_lib.stop_audio(self.current_aid)
except:
pass
self.is_playing = False
self.is_paused = False
self.play_button.setText("▶")
# 设置当前文件
self.current_file = file_path
self.current_file_name = os.path.basename(file_path)
# 更新显示信息
self.current_file_label.setText(self.current_file_name)
# 尝试提取艺术家和专辑信息
file_dir = os.path.dirname(file_path)
folder_name = os.path.basename(file_dir)
self.song_info_label.setText(f"艺术家: 未知 | 专辑: {folder_name}")
# 更新当前索引
if file_path in self.playlist:
self.current_index = self.playlist.index(file_path)
# 如果是随机播放模式，更新随机索引
if self.play_mode == self.PLAY_MODE_SHUFFLE:
if not self.shuffled_indices:
self.generate_shuffle_indices()
# 高亮当前播放的项目
for i in range(self.playlist_widget.count()):
item = self.playlist_widget.item(i)
if item.data(Qt.UserRole) == file_path:
item.setSelected(True)
self.playlist_widget.scrollToItem(item)
# 更新项目文本，添加播放标志
current_text = item.text()
if not current_text.startswith("▶ "):
item.setText("▶ " + current_text.lstrip("🎵 ▶ "))
else:
item.setSelected(False)
# 移除其他项目的播放标志
text = item.text()
if text.startswith("▶ "):
item.setText("🎵 " + text[2:])
# 获取音频时长
try:
duration_result = self.audio_lib.get_audio_duration(file_path, is_file=True)
if isinstance(duration_result, tuple):
self.total_duration = 300 # 默认5分钟
else:
self.total_duration = float(duration_result) if duration_result else 300
except:
self.total_duration = 300
# 更新总时长显示
self.total_time_label.setText(self.format_time(self.total_duration))
# 加载音频到内存
try:
if self.current_aid:
try:
old_file = self.audio_lib._get_file_path_by_aid(self.current_aid)
if old_file in self.audio_lib._audio_cache:
self.audio_lib._audio_cache.pop(old_file, None)
elif old_file in self.audio_lib._music_cache:
self.audio_lib._music_cache.pop(old_file, None)
except:
pass
self.current_aid = self.audio_lib.new_aid(file_path)
print(f"加载音频成功，AID: {self.current_aid}")
# 设置音量和播放速度
self.audio_lib.set_volume(self.current_aid, self.volume)
self.status_label.setText(f"已加载: {self.current_file_name}")
self.play_status_label.setText("已加载")
except Exception as e:
raise Exception(f"加载音频失败: {e}")
except Exception as e:
QMessageBox.warning(self, "警告", f"加载文件失败: {e}")
self.status_label.setText(f"加载失败: {e}")
def play_selected_item(self):
"""播放选中的项目"""
selected_items = self.playlist_widget.selectedItems()
if selected_items:
item = selected_items[0]
file_path = item.data(Qt.UserRole)
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def playlist_item_double_clicked(self, item):
"""播放列表项双击事件"""
file_path = item.data(Qt.UserRole)
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def play_pause(self):
"""播放/暂停"""
if not self.current_file or not self.current_aid:
if self.playlist:
# 如果没有当前文件，但有播放列表，播放第一个
self.load_file(self.playlist[0])
if self.current_aid:
self.start_playback()
else:
self.status_label.setText("请先选择音频文件")
return
try:
if not self.is_playing:
self.start_playback()
else:
if self.is_paused:
self.resume_playback()
else:
self.pause_playback()
except Exception as e:
print(f"播放控制失败: {e}")
self.status_label.setText(f"播放失败: {e}")
def start_playback(self):
"""开始播放"""
print(f"开始播放，AID: {self.current_aid}")
try:
self.current_aid = self.audio_lib.play_from_memory(self.current_file)
except Exception as e:
print(f"从内存播放失败，尝试从文件播放: {e}")
self.current_aid = self.audio_lib.play_from_file(self.current_file)
self.is_playing = True
self.is_paused = False
self.play_button.setText("⏸")
self.playback_start_time = time.time()
self.current_position = 0
# 设置音量和播放速度
self.audio_lib.set_volume(self.current_aid, self.volume)
self.status_label.setText(f"正在播放: {self.current_file_name}")
self.play_status_label.setText("播放中")
self.state_changed.emit("playing")
def pause_playback(self):
"""暂停播放"""
print("暂停播放")
self.audio_lib.pause_audio(self.current_aid)
self.is_paused = True
self.play_button.setText("▶")
self.current_position = time.time() - self.playback_start_time
self.status_label.setText(f"已暂停: {self.current_file_name}")
self.play_status_label.setText("已暂停")
self.state_changed.emit("paused")
def resume_playback(self):
"""恢复播放"""
print("恢复播放")
self.audio_lib.play_audio(self.current_aid)
self.is_paused = False
self.play_button.setText("⏸")
self.playback_start_time = time.time() - self.current_position
self.status_label.setText(f"正在播放: {self.current_file_name}")
self.play_status_label.setText("播放中")
self.state_changed.emit("playing")
def pause(self):
"""暂停播放（工具栏专用）"""
if self.is_playing and not self.is_paused:
self.pause_playback()
def stop(self):
"""停止播放"""
if self.is_playing and self.current_aid:
try:
print("停止播放")
played_time = self.audio_lib.stop_audio(self.current_aid)
print(f"已停止播放，播放时长: {played_time:.2f}秒")
self.is_playing = False
self.is_paused = False
self.play_button.setText("▶")
self.position_slider.setValue(0)
self.current_position = 0
self.current_time_label.setText("00:00")
self.status_label.setText(f"已停止: {self.current_file_name}")
self.play_status_label.setText("已停止")
self.state_changed.emit("stopped")
except Exception as e:
print(f"停止播放失败: {e}")
self.status_label.setText(f"停止失败: {e}")
def play_previous(self):
"""播放上一首"""
if not self.playlist:
return
if self.current_index >= 0:
if self.play_mode == self.PLAY_MODE_SHUFFLE:
self.play_previous_shuffle()
else:
if self.current_index > 0:
self.current_index -= 1
elif self.play_mode == self.PLAY_MODE_LOOP:
self.current_index = len(self.playlist) - 1
else:
return
file_path = self.playlist[self.current_index]
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def play_previous_shuffle(self):
"""随机播放模式下的上一首"""
if not self.shuffled_indices:
self.generate_shuffle_indices()
current_shuffle_index = self.get_current_shuffle_index()
if current_shuffle_index > 0:
new_index = self.shuffled_indices[current_shuffle_index - 1]
self.current_index = new_index
file_path = self.playlist[self.current_index]
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def play_next(self):
"""播放下一首"""
if not self.playlist:
return
if self.play_mode == self.PLAY_MODE_SINGLE:
# 单曲循环，重新播放当前歌曲
if self.current_file:
self.load_file(self.current_file)
if not self.is_playing:
self.play_pause()
return
if self.current_index >= 0:
if self.play_mode == self.PLAY_MODE_SHUFFLE:
self.play_next_shuffle()
else:
if self.current_index < len(self.playlist) - 1:
self.current_index += 1
elif self.play_mode == self.PLAY_MODE_LOOP:
self.current_index = 0
else:
# 顺序播放到最后一首，停止播放
self.stop()
return
file_path = self.playlist[self.current_index]
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def play_next_shuffle(self):
"""随机播放模式下的下一首"""
if not self.shuffled_indices:
self.generate_shuffle_indices()
current_shuffle_index = self.get_current_shuffle_index()
if current_shuffle_index < len(self.shuffled_indices) - 1:
new_index = self.shuffled_indices[current_shuffle_index + 1]
self.current_index = new_index
file_path = self.playlist[self.current_index]
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
else:
# 随机播放列表结束，重新生成或停止
if self.play_mode == self.PLAY_MODE_SHUFFLE:
self.generate_shuffle_indices()
if self.shuffled_indices:
self.current_index = self.shuffled_indices[0]
file_path = self.playlist[self.current_index]
self.load_file(file_path)
if not self.is_playing:
self.play_pause()
def generate_shuffle_indices(self):
"""生成随机播放的索引列表"""
if not self.playlist:
return
indices = list(range(len(self.playlist)))
random.shuffle(indices)
# 确保当前播放的歌曲不在第一个位置（如果可能）
if self.current_index in indices and indices[0] == self.current_index and len(indices) > 1:
indices[0], indices[1] = indices[1], indices[0]
self.shuffled_indices = indices
def get_current_shuffle_index(self):
"""获取当前歌曲在随机播放列表中的位置"""
if self.current_index in self.shuffled_indices:
return self.shuffled_indices.index(self.current_index)
return -1
def set_play_mode(self, mode):
"""设置播放模式"""
self.play_mode = mode
# 更新按钮状态
self.mode_sequential.setChecked(mode == self.PLAY_MODE_SEQUENTIAL)
self.mode_shuffle.setChecked(mode == self.PLAY_MODE_SHUFFLE)
self.mode_single.setChecked(mode == self.PLAY_MODE_SINGLE)
self.mode_loop.setChecked(mode == self.PLAY_MODE_LOOP)
# 更新组合框
self.playmode_combo.setCurrentIndex(mode)
# 更新模式描述
descriptions = [
"顺序播放: 按列表顺序播放，播放完停止",
"随机播放: 随机播放列表中的歌曲",
"单曲循环: 重复播放当前歌曲",
"列表循环: 按列表顺序循环播放"
]
self.playmode_desc_label.setText(descriptions[mode])
# 如果是随机播放模式，生成随机索引
if mode == self.PLAY_MODE_SHUFFLE:
self.generate_shuffle_indices()
self.status_label.setText(f"播放模式已切换: {self.playmode_combo.currentText()}")
def on_playmode_changed(self, index):
"""播放模式组合框变化"""
mode = self.playmode_combo.currentData()
self.set_play_mode(mode)
def toggle_mute(self):
"""切换静音"""
if not self.is_muted:
self.last_volume = self.volume_slider.value()
self.volume_slider.setValue(0)
self.mute_button.setText("🔇")
self.is_muted = True
else:
self.volume_slider.setValue(self.last_volume)
self.mute_button.setText("🔊")
self.is_muted = False
def set_volume(self, value):
"""设置音量"""
self.volume = value
self.volume_label.setText(str(value))
if self.current_aid and self.is_playing:
try:
self.audio_lib.set_volume(self.current_aid, value)
except Exception as e:
print(f"设置音量失败: {e}")
# 更新静音状态
if value == 0:
self.is_muted = True
self.mute_button.setText("🔇")
else:
self.is_muted = False
self.mute_button.setText("🔊")
self.volume_changed.emit(value)
def on_speed_changed(self, index):
"""播放速度变化"""
pass
def seek_position(self, value):
"""跳转到指定位置"""
if self.total_duration > 0:
position = (value / 1000.0) * self.total_duration
if self.is_playing and self.current_aid:
try:
self.audio_lib.seek_audio(self.current_aid, position)
self.playback_start_time = time.time() - position
self.current_position = position
except Exception as e:
print(f"跳转失败: {e}")
def seek_relative(self, seconds):
"""相对跳转（快进/快退）"""
if self.is_playing and self.current_aid and self.total_duration > 0:
current_time = time.time() - self.playback_start_time
new_position = max(0, min(self.total_duration, current_time + seconds))
try:
self.audio_lib.seek_audio(self.current_aid, new_position)
self.playback_start_time = time.time() - new_position
self.current_position = new_position
except Exception as e:
print(f"跳转失败: {e}")
def update_ui(self):
"""更新UI"""
try:
if self.is_playing and not self.is_paused and self.current_aid:
if self.playback_start_time > 0:
current_time = time.time() - self.playback_start_time
self.current_position = current_time
# 防止超出总时长
if self.total_duration > 0 and current_time >= self.total_duration:
current_time = self.total_duration
# 歌曲播放结束，根据播放模式处理
self.on_track_end()
if not self.is_playing:
return
# 更新时间显示
self.current_time_label.setText(self.format_time(current_time))
self.time_status_label.setText(
f"{self.format_time(current_time)} / {self.format_time(self.total_duration)}"
)
# 更新进度条
if self.total_duration > 0:
progress_value = int((current_time / self.total_duration) * 1000)
self.position_slider.setValue(progress_value)
except Exception as e:
print(f"更新UI时出错: {e}")
def on_track_end(self):
"""处理歌曲播放结束"""
if self.play_mode == self.PLAY_MODE_SINGLE:
# 单曲循环，重新播放
self.load_file(self.current_file)
self.start_playback()
else:
# 其他模式，播放下一首
self.play_next()
def format_time(self, seconds):
"""格式化时间显示"""
if not seconds:
seconds = 0
minutes = int(seconds // 60)
secs = int(seconds % 60)
return f"{minutes:02d}:{secs:02d}"
def show_normal(self):
"""显示窗口"""
self.show()
self.activateWindow()
self.raise_()
def on_tray_icon_activated(self, reason):
"""托盘图标激活"""
if reason == QSystemTrayIcon.DoubleClick:
self.show_normal()
def quit_application(self):
"""退出应用程序"""
self.cleanup()
QApplication.quit()
def closeEvent(self, event):
"""关闭窗口事件"""
if hasattr(self, 'tray_icon') and self.tray_icon.isVisible():
# 如果有托盘图标，最小化到托盘
self.hide()
event.ignore()
self.tray_icon.showMessage(
"Modern Audio Player",
"程序已最小化到系统托盘",
QSystemTrayIcon.Information,
2000
)
else:
# 否则正常退出
self.cleanup()
event.accept()
def cleanup(self):
"""清理资源"""
try:
if self.audio_lib:
print("清理音频库资源...")
if self.current_aid and self.is_playing:
try:
self.audio_lib.stop_audio(self.current_aid)
except:
pass
self.audio_lib.clear_memory_cache()
except Exception as e:
print(f"清理资源时出错: {e}")
def main():
app = QApplication(sys.argv)
app.setApplicationName("Modern Audio Player")
app.setApplicationDisplayName("Modern Audio Player")
# 设置应用程序样式
app.setStyle('Fusion')
# 设置应用程序图标
app.setWindowIcon(QIcon(":icons/media-play"))
player = ModernAudioPlayer()
player.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()