为豆子域名管家实现Windows开机自启动功能的技术实践

// auto_start_windows.go
// +build windows

package main

import (
    "errors"
    "os"
    "path/filepath"
    "strings"

    "golang.org/x/sys/windows/registry"
)

// AutoStartManager Windows自启动管理器
type AutoStartManager struct {
    appName string
    exePath string
    regPath string
}

// NewAutoStartManager 创建自启动管理器实例
func NewAutoStartManager(appName string) (*AutoStartManager, error) {
    exePath, err := os.Executable()
    if err != nil {
        return nil, errors.New("获取可执行文件路径失败")
    }
    
    // 转换为绝对路径并处理空格
    absPath, _ := filepath.Abs(exePath)
    if strings.Contains(absPath, " ") {
        absPath = `"` + absPath + `"`
    }
    
    return &AutoStartManager{
        appName: appName,
        exePath: absPath,
        regPath: `Software\Microsoft\Windows\CurrentVersion\Run`,
    }, nil
}

// IsAutoStartEnabled 检查是否已启用开机自启动
func (m *AutoStartManager) IsAutoStartEnabled() (bool, error) {
    key, err := registry.OpenKey(registry.CURRENT_USER, m.regPath, registry.QUERY_VALUE)
    if err != nil {
        return false, err
    }
    defer key.Close()
    
    value, _, err := key.GetStringValue(m.appName)
    if err != nil {
        if err == registry.ErrNotExist {
            return false, nil
        }
        return false, err
    }
    
    // 对比路径，处理可能的引号差异
    current := strings.Trim(m.exePath, `"`)
    stored := strings.Trim(value, `"`)
    return strings.EqualFold(filepath.Clean(current), filepath.Clean(stored)), nil
}

// SetAutoStart 设置或取消开机自启动
func (m *AutoStartManager) SetAutoStart(enable bool) error {
    key, err := registry.OpenKey(registry.CURRENT_USER, m.regPath, 
        registry.QUERY_VALUE|registry.SET_VALUE)
    if err != nil {
        return err
    }
    defer key.Close()
    
    if enable {
        return key.SetStringValue(m.appName, m.exePath)
    } else {
        err = key.DeleteValue(m.appName)
        if err == registry.ErrNotExist {
            return nil // 键不存在不算错误
        }
        return err
    }
}

// settings.js - 前端设置界面
class AutoStartManager {
    constructor() {
        this.switchElement = document.getElementById('autoStartSwitch');
        this.saveButton = document.getElementById('saveSettingsBtn');
        this.init();
    }
    
    async init() {
        // 初始化时读取当前状态
        await this.loadCurrentState();
        
        // 绑定开关事件
        this.switchElement.addEventListener('change', (e) => {
            this.onSwitchChange(e.target.checked);
        });
        
        // 绑定保存按钮事件
        this.saveButton.addEventListener('click', () => {
            this.saveSettings();
        });
    }
    
    async loadCurrentState() {
        try {
            const isEnabled = await window.go.main.App.IsAutoStartEnabled();
            this.switchElement.checked = isEnabled;
            this.updateStatusText(isEnabled);
        } catch (error) {
            console.error('读取自启动状态失败:', error);
            this.showError('无法读取当前设置，请重试');
        }
    }
    
    async onSwitchChange(enabled) {
        const oldState = !enabled;
        
        try {
            const success = await window.go.main.App.SetAutoStart(enabled);
            
            if (success) {
                this.updateStatusText(enabled);
                this.showSuccess(enabled ? '已开启开机自启动' : '已关闭开机自启动');
            } else {
                // 操作失败，恢复原状态
                this.switchElement.checked = oldState;
                this.showError('设置失败，请检查权限或重试');
            }
        } catch (error) {
            console.error('设置自启动失败:', error);
            this.switchElement.checked = oldState;
            this.showError('操作失败: ' + error.message);
        }
    }
    
    updateStatusText(enabled) {
        const statusElement = document.getElementById('autoStartStatus');
        if (statusElement) {
            statusElement.textContent = enabled ? '已开启' : '已关闭';
            statusElement.className = enabled ? 'status-enabled' : 'status-disabled';
        }
    }
    
    showSuccess(message) {
        // 显示成功提示
        this.showNotification(message, 'success');
    }
    
    showError(message) {
        // 显示错误提示
        this.showNotification(message, 'error');
    }
    
    showNotification(message, type) {
        // 实现通知显示逻辑
        const notification = document.createElement('div');
        notification.className = `notification notification-${type}`;
        notification.textContent = message;
        document.body.appendChild(notification);
        
        setTimeout(() => {
            notification.remove();
        }, 3000);
    }
    
    async saveSettings() {
        // 可在此处添加批量保存逻辑
        this.showSuccess('设置已保存');
    }
}

// backend.go - 后端接口
package main

import (
    "context"
)

type App struct {
    ctx context.Context
    autoStartManager *AutoStartManager
}

func NewApp() *App {
    manager, err := NewAutoStartManager("BeanDomainManager")
    if err != nil {
        // 记录日志，但不阻止应用启动
        log.Printf("初始化自启动管理器失败: %v", err)
    }
    
    return &App{
        autoStartManager: manager,
    }
}

func (a *App) IsAutoStartEnabled() (bool, error) {
    if a.autoStartManager == nil {
        return false, errors.New("自启动功能不可用")
    }
    return a.autoStartManager.IsAutoStartEnabled()
}

func (a *App) SetAutoStart(enable bool) (bool, error) {
    if a.autoStartManager == nil {
        return false, errors.New("自启动功能不可用")
    }
    
    err := a.autoStartManager.SetAutoStart(enable)
    if err != nil {
        return false, err
    }
    return true, nil
}