constructor() {

// 常量定义

this.MAX_RETRY_ATTEMPTS = 3;

this.MAX_ERROR_COUNT = 10; // 最大错误次数，超过后自动停止

this.MAX_HEALTH_CHECK_ERROR_COUNT = 20; // 健康检查最大错误次数

this.HEALTH_CHECK_INTERVAL = 5 * 60 * 1000; // 5分钟

this.NOTIFICATION_THROTTLE = 60 * 1000; // 通知节流：1分钟

this.NOTIFICATION_CLEANUP_AGE = 24 * 60 * 60 * 1000; // 24小时

this.ERROR_BACKOFF_MULTIPLIER = 0.2; // 错误退避倍数

this.MAX_BACKOFF_MULTIPLIER = 5; // 最大退避倍数

this.TAB_LOAD_TIMEOUT = 5000; // 标签页加载超时：5秒

this.RESTORE_DELAY_MAX = 5000; // 恢复状态最大延迟：5秒

this.activeRefreshers = new Map(); // tabId -> refresher config

this.timers = new Map(); // tabId -> timer id

this.healthCheckInterval = null;

this.maxRetryAttempts = this.MAX_RETRY_ATTEMPTS;

this.isShuttingDown = false;

this.isEdge = this.detectEdge();

this.iconState = new Map(); // tabId -> icon state (normal/gray)

console.log(`🌐 检测到浏览器: ${this.isEdge ? 'Microsoft Edge' : 'Google Chrome'}`);

// Edge特定初始化

if (this.isEdge) {

this.initEdgeCompatibility();

}

// 初始化图标状态

this.initIconManagement();

// 监听消息

chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {

this.handleMessage(message, sender, sendResponse);

return true; // 保持消息通道开放

});

// 监听标签页更新和关闭

chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {

if (changeInfo.status === 'complete' && this.activeRefreshers.has(tabId)) {

this.handleTabUpdated(tabId, tab);

}

});

chrome.tabs.onRemoved.addListener((tabId) => {

this.stopRefresh(tabId);

});

// 监听扩展暂停/恢复

chrome.runtime.onSuspend.addListener(() => {

this.handleSuspend();

});

chrome.runtime.onStartup.addListener(() => {

this.handleStartup();

});

// 扩展启动时恢复状态

this.restoreState();

// 启动健康检查

this.startHealthCheck();

}

async handleMessage(message, sender, sendResponse) {

console.log('🔵 收到消息:', message);

try {

switch (message.action) {

case 'startRefresh':

console.log('🚀 开始启动刷新器 - TabId:', message.tabId, 'Settings:', message.settings);

await this.startRefresh(message.tabId, message.settings);

console.log('✅ 刷新器启动成功 - TabId:', message.tabId);

sendResponse({ success: true });

break;

case 'stopRefresh':

const tabIdToStop = message.tabId || sender.tab?.id;

console.log('🛑 停止刷新器 - TabId:', tabIdToStop);

await this.stopRefresh(tabIdToStop);

console.log('✅ 刷新器停止成功 - TabId:', tabIdToStop);

sendResponse({ success: true });

break;

case 'getStatus':

const tabIdForStatus = message.tabId || sender.tab?.id;

const status = this.getRefreshStatus(tabIdForStatus);

console.log('📊 获取状态 - TabId:', tabIdForStatus, 'Status:', status);

sendResponse({ success: true, data: status });

break;

case 'healthCheck':

console.log('❤️ 健康检查 - 活跃刷新器数量:', this.activeRefreshers.size);

sendResponse({ success: true, health: 'ok', activeCount: this.activeRefreshers.size });

break;

default:

console.log('❌ 未知操作:', message.action);

sendResponse({ success: false, error: 'Unknown action' });

}

} catch (error) {

console.error('💥 处理消息时出错:', error);

sendResponse({ success: false, error: error.message });

}

}

async startRefresh(tabId, settings) {

// 停止已存在的刷新器

this.stopRefresh(tabId);

// 验证设置

if (!this.validateSettings(settings)) {

throw new Error('无效的设置参数');

}

// 创建新的刷新器配置

const refresher = {

tabId,

settings,

refreshCount: 0,

errorCount: 0,

lastErrorTime: null,

startTime: Date.now(),

nextRefreshTime: null,

isActive: true,

retryAttempts: 0

};

this.activeRefreshers.set(tabId, refresher);

// 保存到存储（立即保存）

await this.saveRefresherState(tabId, refresher, true);

// 更新图标显示运行状态

await this.updateIconForTab(tabId).catch((err) => {

console.warn(`启动刷新时更新图标失败 (TabId: ${tabId}):`, err.message);

});

// 调度下次刷新

this.scheduleNextRefresh(tabId);

console.log(`开始刷新标签页 ${tabId}`, settings);

}

validateSettings(settings) {

if (!settings || typeof settings !== 'object') return false;

if (!['fixed', 'random'].includes(settings.mode)) return false;

// 验证时间单位

if (!['seconds', 'minutes'].includes(settings.minTimeUnit)) return false;

// 验证最小时间

if (!Number.isInteger(settings.minTime) || settings.minTime < 1) return false;

const minMaxValue = settings.minTimeUnit === 'seconds' ? 3600 : 60;

if (settings.minTime > minMaxValue) return false;

// 验证随机模式的最大时间

if (settings.mode === 'random') {

if (!['seconds', 'minutes'].includes(settings.maxTimeUnit)) return false;

if (!Number.isInteger(settings.maxTime) || settings.maxTime < 1) return false;

const maxMaxValue = settings.maxTimeUnit === 'seconds' ? 3600 : 60;

if (settings.maxTime > maxMaxValue) return false;

// 转换为秒进行比较

const minTimeInSeconds = settings.minTimeUnit === 'seconds' ? settings.minTime : settings.minTime * 60;

const maxTimeInSeconds = settings.maxTimeUnit === 'seconds' ? settings.maxTime : settings.maxTime * 60;

if (maxTimeInSeconds < minTimeInSeconds) return false;

}

return true;

}

async stopRefresh(tabId) {

if (!tabId) return;

try {

// 清除定时器

if (this.timers.has(tabId)) {

clearTimeout(this.timers.get(tabId));

this.timers.delete(tabId);

}

// 移除刷新器

this.activeRefreshers.delete(tabId);

// 清除图标状态

this.iconState.delete(tabId);

// 清除防抖定时器

if (this.saveTimers && this.saveTimers.has(tabId)) {

clearTimeout(this.saveTimers.get(tabId));

this.saveTimers.delete(tabId);

}

// 清除存储

await this.clearRefresherState(tabId);

// 更新图标，移除运行状态badge

await this.updateIconForTab(tabId).catch((err) => {

// 标签页可能已关闭，这是正常情况

console.log(`停止刷新时更新图标失败 (TabId: ${tabId}):`, err.message);

});

console.log(`停止刷新标签页 ${tabId}`);

} catch (error) {

console.error(`停止刷新时出错:`, error);

}

}

scheduleNextRefresh(tabId) {

const refresher = this.activeRefreshers.get(tabId);

if (!refresher || !refresher.isActive || this.isShuttingDown) return;

const { settings } = refresher;

let delay = this.calculateDelay(settings);

// 如果有错误历史，增加延迟（错误退避算法）

if (refresher.errorCount > 0) {

const backoffMultiplier = Math.min(refresher.errorCount, this.MAX_BACKOFF_MULTIPLIER);

delay *= (1 + backoffMultiplier * this.ERROR_BACKOFF_MULTIPLIER);

}

// Edge兼容性：增加额外的缓冲时间

if (this.isEdge && this.edgeTimerBuffer) {

delay += this.edgeTimerBuffer;

console.log(`🔧 Edge模式：添加 ${this.edgeTimerBuffer}ms 缓冲时间`);

}

refresher.nextRefreshTime = Date.now() + delay;

// 发送状态更新到popup

this.notifyPopup(tabId, {

nextRefreshTime: refresher.nextRefreshTime,

refreshCount: refresher.refreshCount,

errorCount: refresher.errorCount,

startTime: refresher.startTime

});

// 设置定时器

const timerId = setTimeout(() => {

this.performRefresh(tabId);

}, delay);

this.timers.set(tabId, timerId);

console.log(`⏰ 已调度标签页 ${tabId} 在 ${Math.round(delay/1000)}秒 后刷新 (${new Date(refresher.nextRefreshTime).toLocaleTimeString()})`);

console.log(`📋 当前活跃定时器数量: ${this.timers.size}, 活跃刷新器数量: ${this.activeRefreshers.size}`);

}

calculateDelay(settings) {

if (settings.mode === 'fixed') {

// 根据时间单位转换为毫秒

const multiplier = settings.minTimeUnit === 'seconds' ? 1000 : 60 * 1000;

return settings.minTime * multiplier;

} else {

// 随机模式 - 转换为毫秒

const minMultiplier = settings.minTimeUnit === 'seconds' ? 1000 : 60 * 1000;

const maxMultiplier = settings.maxTimeUnit === 'seconds' ? 1000 : 60 * 1000;

const minMs = settings.minTime * minMultiplier;

const maxMs = settings.maxTime * maxMultiplier;

return Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;

}

}

async performRefresh(tabId) {

console.log(`🔄 开始执行刷新 - TabId: ${tabId}`);

const refresher = this.activeRefreshers.get(tabId);

if (!refresher || !refresher.isActive || this.isShuttingDown) {

console.log(`⚠️ 刷新器不存在或已停止 - TabId: ${tabId}, refresher:`, refresher ? 'exists' : 'not found', 'isActive:', refresher?.isActive, 'isShuttingDown:', this.isShuttingDown);

return;

}

let success = false;

let retryCount = 0;

const maxRetries = 3;

while (!success && retryCount < maxRetries) {

try {

console.log(`🔍 检查标签页 - TabId: ${tabId} (尝试 ${retryCount + 1}/${maxRetries})`);

// 检查标签页是否仍然存在和可访问

const tab = await this.getTabWithRetry(tabId, 2);

if (!tab || !this.isValidTab(tab)) {

console.log(`❌ 标签页 ${tabId} 不存在或无效，停止刷新`, tab ? `URL: ${tab.url}` : '标签页为空');

this.stopRefresh(tabId);

return;

}

console.log(`🔄 执行刷新 - TabId: ${tabId}, URL: ${tab.url}`);

// 执行刷新 - Edge兼容模式

if (this.isEdge) {

const edgeSuccess = await this.performRefreshEdgeCompatible(tabId);

if (!edgeSuccess) {

throw new Error('Edge兼容模式刷新失败');

}

} else {

await chrome.tabs.reload(tabId);

}

console.log(`⏳ 等待页面加载完成 - TabId: ${tabId}`);

// 等待页面加载完成（可选，避免刷新过于频繁）

await this.waitForTabLoad(tabId, 5000);

// 更新计数

refresher.refreshCount++;

refresher.errorCount = Math.max(0, refresher.errorCount - 1); // 成功后减少错误计数

refresher.retryAttempts = 0;

// 使用防抖保存，避免频繁写入

await this.saveRefresherState(tabId, refresher, false);

// 发送通知 - Edge兼容模式

if (refresher.settings.notificationEnabled) {

if (this.isEdge) {

await this.showNotificationEdgeCompatible(tabId, refresher.refreshCount);

} else {

await this.showNotification(tabId, refresher.refreshCount);

}

}

// 发送状态更新到popup

this.notifyPopup(tabId, {

refreshCount: refresher.refreshCount,

errorCount: refresher.errorCount,

startTime: refresher.startTime

});

// 自动刷新不再播放提示音（浏览器限制）

// 提示音功能仅在手动立即刷新时可用

console.log(`✅ 已刷新标签页 ${tabId}，第 ${refresher.refreshCount} 次`);

success = true;

} catch (error) {

retryCount++;

refresher.errorCount++;

refresher.lastErrorTime = Date.now();

console.error(`💥 刷新标签页 ${tabId} 时出错 (尝试 ${retryCount}/${maxRetries}):`, error);

if (retryCount < maxRetries) {

console.log(`⏳ 等待 ${retryCount} 秒后重试...`);

// 等待后重试

await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));

}

}

}

if (!success) {

console.error(`标签页 ${tabId} 刷新失败，达到最大重试次数`);

// 设置错误图标

await this.setErrorIcon();

// 检查是否应该停止（连续失败过多）

if (refresher.errorCount >= this.MAX_ERROR_COUNT) {

console.log(`标签页 ${tabId} 错误次数达到上限(${this.MAX_ERROR_COUNT})，自动停止刷新`);

this.stopRefresh(tabId);

return;

}

} else {

// 刷新成功，确保图标状态正确

await this.updateIconForTab(tabId).catch((err) => {

console.log(`刷新成功后更新图标失败 (TabId: ${tabId}):`, err.message);

});

}

// 调度下次刷新（无论成功还是失败都继续）

if (refresher.isActive) {

this.scheduleNextRefresh(tabId);

}

}

async getTabWithRetry(tabId, maxRetries = 3) {

for (let i = 0; i < maxRetries; i++) {

try {

const tab = await chrome.tabs.get(tabId);

return tab;

} catch (error) {

if (i === maxRetries - 1) {

console.error(`获取标签页 ${tabId} 失败，已重试 ${maxRetries} 次:`, error);

throw error;

}

// 指数退避

await new Promise(resolve => setTimeout(resolve, 500 * (i + 1)));

}

}

}

isValidTab(tab) {

if (!tab) return false;

if (tab.url.startsWith('chrome://') || tab.url.startsWith('edge://') || tab.url.startsWith('moz-extension://')) return false;

return true;

}

async waitForTabLoad(tabId, timeout = 5000) {

return new Promise((resolve) => {

let listener = null;

const cleanup = () => {

if (listener) {

chrome.tabs.onUpdated.removeListener(listener);

listener = null;

}

};

const timeoutId = setTimeout(() => {

cleanup();

resolve();

}, timeout);

listener = (updatedTabId, changeInfo) => {

if (updatedTabId === tabId && changeInfo.status === 'complete') {

clearTimeout(timeoutId);

cleanup();

resolve();

}

};

chrome.tabs.onUpdated.addListener(listener);

});

}

async showNotification(tabId, refreshCount) {

try {

const tab = await chrome.tabs.get(tabId);

const title = tab.title || '未知页面';

// 限制通知频率，避免过多通知

const lastNotificationKey = `lastNotification_${tabId}`;

const lastNotificationTime = await chrome.storage.local.get(lastNotificationKey);

const now = Date.now();

// 通知节流：避免过于频繁的通知

if (lastNotificationTime[lastNotificationKey] &&

now - lastNotificationTime[lastNotificationKey] < this.NOTIFICATION_THROTTLE) {

return;

}

await chrome.storage.local.set({ [lastNotificationKey]: now });

chrome.notifications.create(`refresh_${tabId}_${now}`, {

type: 'basic',

iconUrl: 'icons/icon48.png',

title: '页面已刷新',

message: `${title}\n刷新次数: ${refreshCount}`,

priority: 0 // 低优先级，避免打扰用户

});

} catch (error) {

console.error('显示通知时出错:', error);

// 通知失败不影响刷新功能

}

}

notifyPopup(tabId, data) {

// 向popup发送状态更新

chrome.runtime.sendMessage({

action: 'updateStatus',

tabId,

data

}).catch(() => {

// popup可能未打开，忽略错误

});

}

getRefreshStatus(tabId) {

const refresher = this.activeRefreshers.get(tabId);

if (!refresher) {

return { isActive: false };

}

return {

isActive: refresher.isActive,

refreshCount: refresher.refreshCount,

errorCount: refresher.errorCount,

startTime: refresher.startTime,

nextRefreshTime: refresher.nextRefreshTime,

settings: refresher.settings

};

}

async saveRefresherState(tabId, refresher, immediate = false) {

try {

const key = `refresher_${tabId}`;

const stateData = {

settings: refresher.settings,

refreshCount: refresher.refreshCount,

errorCount: refresher.errorCount || 0,

startTime: refresher.startTime,

isActive: refresher.isActive

};

// 使用防抖机制，避免频繁写入storage

if (!immediate) {

if (this.saveTimers) {

clearTimeout(this.saveTimers.get(tabId));

} else {

this.saveTimers = new Map();

}

this.saveTimers.set(tabId, setTimeout(async () => {

await chrome.storage.local.set({ [key]: stateData });

this.saveTimers.delete(tabId);

}, 1000)); // 1秒后保存

} else {

// 立即保存（用于启动和停止时）

await chrome.storage.local.set({ [key]: stateData });

}

} catch (error) {

console.error('保存状态时出错:', error);

}

}

async clearRefresherState(tabId) {

try {

const key = `refresher_${tabId}`;

await chrome.storage.local.remove([key, `lastNotification_${tabId}`]);

} catch (error) {

console.error('清除状态时出错:', error);

}

}

async restoreState() {

try {

// 获取所有存储的刷新器状态

const storage = await chrome.storage.local.get();

const refresherKeys = Object.keys(storage).filter(key => key.startsWith('refresher_'));

console.log(`恢复 ${refresherKeys.length} 个刷新器状态`);

for (const key of refresherKeys) {

const tabId = parseInt(key.replace('refresher_', ''));

const savedState = storage[key];

// 检查标签页是否仍然存在

try {

const tab = await chrome.tabs.get(tabId);

if (tab && savedState.isActive && this.isValidTab(tab)) {

// 恢复刷新器

const refresher = {

tabId,

settings: savedState.settings,

refreshCount: savedState.refreshCount || 0,

errorCount: savedState.errorCount || 0,

lastErrorTime: null,

startTime: savedState.startTime,

nextRefreshTime: null,

isActive: true,

retryAttempts: 0

};

this.activeRefreshers.set(tabId, refresher);

// 延迟启动，避免同时启动过多定时器

setTimeout(() => {

this.scheduleNextRefresh(tabId);

}, Math.random() * this.RESTORE_DELAY_MAX);

console.log(`恢复标签页 ${tabId} 的刷新状态`);

} else {

// 清除无效状态

await this.clearRefresherState(tabId);

}

} catch (error) {

// 标签页不存在，清除状态

await this.clearRefresherState(tabId);

}

}

} catch (error) {

console.error('恢复状态时出错:', error);

}

}

handleTabUpdated(tabId, tab) {

const refresher = this.activeRefreshers.get(tabId);

if (refresher && tab.status === 'complete') {

// 标签页加载完成，可能需要更新UI状态

this.notifyPopup(tabId, {

refreshCount: refresher.refreshCount,

errorCount: refresher.errorCount,

nextRefreshTime: refresher.nextRefreshTime,

startTime: refresher.startTime

});

}

}

// 健康检查机制

startHealthCheck() {

// 定期进行健康检查

this.healthCheckInterval = setInterval(() => {

this.performHealthCheck();

}, this.HEALTH_CHECK_INTERVAL);

}

async performHealthCheck() {

try {

console.log(`健康检查: 活跃刷新器数量 ${this.activeRefreshers.size}`);

// 检查每个活跃的刷新器

for (const [tabId, refresher] of this.activeRefreshers.entries()) {

try {

const tab = await chrome.tabs.get(tabId);

if (!tab || !this.isValidTab(tab)) {

console.log(`健康检查: 清理无效标签页 ${tabId}`);

this.stopRefresh(tabId);

continue;

}

// 检查是否有定时器

if (!this.timers.has(tabId)) {

console.log(`健康检查: 重新调度标签页 ${tabId}`);

this.scheduleNextRefresh(tabId);

}

// 检查错误率

if (refresher.errorCount > this.MAX_HEALTH_CHECK_ERROR_COUNT) {

console.log(`健康检查: 标签页 ${tabId} 错误次数超过${this.MAX_HEALTH_CHECK_ERROR_COUNT}，停止刷新`);

this.stopRefresh(tabId);

}

} catch (error) {

console.log(`健康检查: 标签页 ${tabId} 不存在，停止刷新`);

this.stopRefresh(tabId);

}

}

// 清理过期的存储数据

await this.cleanupStorage();

} catch (error) {

console.error('健康检查时出错:', error);

}

}

async cleanupStorage() {

try {

const storage = await chrome.storage.local.get();

const keysToRemove = [];

// 清理过期的通知时间戳

const now = Date.now();

for (const [key, value] of Object.entries(storage)) {

if (key.startsWith('lastNotification_') && typeof value === 'number') {

if (now - value > this.NOTIFICATION_CLEANUP_AGE) {

keysToRemove.push(key);

}

}

}

if (keysToRemove.length > 0) {

await chrome.storage.local.remove(keysToRemove);

console.log(`清理了 ${keysToRemove.length} 个过期存储项`);

}

} catch (error) {

console.error('清理存储时出错:', error);

}

}

handleSuspend() {

console.log('扩展即将暂停，保存状态');

this.isShuttingDown = true;

// 立即保存所有待保存的状态

if (this.saveTimers) {

for (const [tabId, timerId] of this.saveTimers.entries()) {

clearTimeout(timerId);

const refresher = this.activeRefreshers.get(tabId);

if (refresher) {

this.saveRefresherState(tabId, refresher, true);

}

}

this.saveTimers.clear();

}

// 清理定时器

if (this.healthCheckInterval) {

clearInterval(this.healthCheckInterval);

}

// 暂停所有刷新器，但保留状态

for (const [tabId, timerId] of this.timers.entries()) {

clearTimeout(timerId);

}

this.timers.clear();

}

handleStartup() {

console.log('扩展启动，恢复状态');

this.isShuttingDown = false;

this.restoreState();

this.startHealthCheck();

// 更新图标状态

this.updateIconOnExtensionStart();

}

detectEdge() {

try {

// 检测Edge特征

const userAgent = navigator.userAgent;

const isEdge = userAgent.includes('Edg/') || userAgent.includes('Edge/');

// 检测Edge特有的API

const hasEdgeFeatures = typeof chrome.runtime.getContexts !== 'undefined' ||

chrome.runtime.getURL('').includes('-extension://');

console.log('🔍 浏览器检测:', { userAgent, isEdge, hasEdgeFeatures });

return isEdge || hasEdgeFeatures;

} catch (error) {

console.error('💥 浏览器检测失败:', error);

return false;

}

}

initEdgeCompatibility() {

console.log('🔧 初始化Edge兼容性设置...');

// Edge的定时器可能不太稳定，增加缓冲时间

this.edgeTimerBuffer = 1000; // 1秒缓冲

// Edge可能需要更多的权限检查

this.needsExtraPermissionChecks = true;

// Edge的通知API可能不同

this.edgeNotificationFallback = true;

}

async performRefreshEdgeCompatible(tabId) {

console.log(`🔄 Edge兼容模式刷新 - TabId: ${tabId}`);

try {

// Edge特定的权限检查

if (this.needsExtraPermissionChecks) {

const permissions = await chrome.permissions.contains({

permissions: ['tabs'],

origins: ['<all_urls>']

});

if (!permissions) {

console.log('⚠️ Edge权限不足，尝试请求权限');

// 在Edge中不能直接请求权限，需要用户手动授权

throw new Error('Edge权限不足，请重新安装扩展');

}

}

// 使用更稳定的标签页获取方法

const tab = await this.getTabForEdge(tabId);

if (!tab || !this.isValidTab(tab)) {

throw new Error('标签页无效或不存在');

}

// Edge中使用更安全的刷新方法

await chrome.tabs.reload(tabId, { bypassCache: false });

console.log(`✅ Edge兼容模式刷新成功 - TabId: ${tabId}`);

return true;

} catch (error) {

console.error(`💥 Edge兼容模式刷新失败 - TabId: ${tabId}:`, error);

return false;

}

}

async getTabForEdge(tabId) {

// Edge使用相同的重试逻辑，但可能需要更多次数

try {

return await this.getTabWithRetry(tabId, this.isEdge ? 3 : 2);

} catch (error) {

console.error('💥 Edge标签页获取失败:', error);

return null;

}

}

async showNotificationEdgeCompatible(tabId, refreshCount) {

if (!this.edgeNotificationFallback) {

return this.showNotification(tabId, refreshCount);

}

try {

// Edge中使用更简单的通知方式

const tab = await this.getTabForEdge(tabId);

const title = tab?.title || '未知页面';

// 检查通知权限

const permission = await chrome.permissions.contains({ permissions: ['notifications'] });

if (!permission) {

console.log('⚠️ Edge通知权限不足');

return;

}

chrome.notifications.create(`refresh_${tabId}_${Date.now()}`, {