FBro 浏览器开发文档

Appearance

🧩 FBro浏览器插件开发与管理完整指南 ​

深度集成Chrome扩展插件，实现浏览器功能的无限扩展

🚀 快速入门 ​

5分钟上手插件功能 ​

csharp
// 1. 启用VIP插件功能
FBroSharpVIPGlobalControl.EnableAdvancedExtension();

// 2. 初始化FBro（需要VIP授权码）
var initSet = new FBroSharpInitSet { /* 配置参数 */ };
FBroSharpInitControl.InitPro(initSet, new FBroInitEvent());

// 3. 加载插件
var requestContext = FBroSharpRequestContext.GetGlobalContext();
var extensionHandler = new ExtensionHandler();
requestContext.LoadExtension("插件目录路径", default, extensionHandler);

// 4. 获取插件状态
var extensionsList = requestContext.GetExtensionsList();
Console.WriteLine($"已加载 {extensionsList.Count} 个插件");

插件目录结构示例 ​

extensions/
├── ublock-origin/          # AdBlock广告拦截
│   ├── manifest.json       # manifest_version: 2
│   ├── background.js
│   └── ...
├── react-devtools/         # React开发工具
│   ├── manifest.json
│   └── ...
└── tampermonkey/           # 油猴脚本管理
    ├── manifest.json
    └── ...

📋 概述 ​

FBro浏览器提供了完整的Chrome扩展插件支持，通过VIP高级功能，开发者可以加载、管理和控制各种Chrome扩展插件。这个功能让FBro浏览器具备了与Chrome浏览器相同的插件生态系统支持能力，大大扩展了浏览器的功能边界。

📌 技术要求：插件功能需要VIP授权，仅支持manifest v2版本的Chrome扩展

🎯 主要功能 ​

  • 插件生命周期管理：支持插件的加载、卸载、启用和禁用
  • 多插件并行支持：可同时加载多个插件，互不干扰
  • 插件状态监控：实时监控插件的加载状态和运行情况
  • 插件信息获取：获取插件的详细信息，包括ID、路径、版本等
  • 背景脚本支持：完整支持Chrome扩展的background脚本
  • 标签页集成：插件可以与浏览器标签页进行交互
  • 资源访问控制：精细化控制插件对浏览器资源的访问权限
  • 事件驱动架构：基于事件的插件交互机制

📱 应用场景 ​

应用场景实现效果技术优势
网页增强使用AdBlock、油猴脚本等提升浏览体验支持manifest v2版本插件
开发工具集成集成Vue DevTools、React DevTools等无需重新开发调试工具
自动化扩展加载自定义自动化插件扩展FBro的自动化能力
内容处理集成翻译、截图、笔记等功能插件丰富的插件生态
安全增强使用密码管理、安全检测插件提升浏览安全性
电商助手集成价格监控、购物助手插件商业应用场景支持

🔧 核心实现架构 ​

插件加载流程图 ​

启用高级插件功能 → 初始化插件处理器 → 加载插件目录 → 插件生命周期管理
         ↓                    ↓               ↓              ↓
VIP功能激活        ExtensionHandler     LoadExtension    事件回调处理

关键组件说明 ​

  1. FBroSharpVIPGlobalControl：VIP全局控制器，用于启用高级插件功能
  2. FBroSharpRequestContext：请求上下文，管理插件的加载和卸载
  3. ExtensionHandler：插件事件处理器，处理插件生命周期事件
  4. IFBroSharpExtension：插件接口，提供插件操作方法
  5. Plugin Directory：插件目录结构，存储Chrome扩展文件

📖 完整实现指南 ​

1. 插件功能初始化 ​

VIP功能启用 ​

csharp
/// <summary>
/// 启用FBro高级插件功能
/// 必须在FBro初始化之前调用
/// </summary>
/// <returns>是否成功启用</returns>
public static bool EnablePluginSupport()
{
    try
    {
        // 启用高级扩展功能
        FBroSharpVIPGlobalControl.EnableAdvancedExtension();
        
        Console.WriteLine("✅ 高级插件功能已启用");
        return true;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"❌ 启用插件功能失败: {ex.Message}");
        return false;
    }
}

插件加载管理器 ​

csharp
/// <summary>
/// 插件加载管理器
/// 负责插件的批量加载和管理
/// </summary>
public class PluginLoadManager
{
    private readonly Dictionary<string, string> loadedPlugins;
    private readonly ExtensionHandler extensionHandler;
    private readonly IFBroSharpRequestContext requestContext;

    public PluginLoadManager()
    {
        loadedPlugins = new Dictionary<string, string>();
        extensionHandler = new ExtensionHandler();
        requestContext = FBroSharpRequestContext.GetGlobalContext();
        
        Console.WriteLine("🔧 插件加载管理器已初始化");
    }

    /// <summary>
    /// 批量加载插件目录
    /// </summary>
    /// <param name="extensionsBasePath">插件根目录</param>
    /// <returns>加载成功的插件数量</returns>
    public int LoadPluginsFromDirectory(string extensionsBasePath)
    {
        if (!Directory.Exists(extensionsBasePath))
        {
            Console.WriteLine($"⚠️ 插件目录不存在: {extensionsBasePath}");
            return 0;
        }

        int loadedCount = 0;
        var pluginDirectories = Directory.GetDirectories(extensionsBasePath);
        
        Console.WriteLine($"📂 发现 {pluginDirectories.Length} 个插件目录");

        foreach (string pluginPath in pluginDirectories)
        {
            try
            {
                if (LoadSinglePlugin(pluginPath))
                {
                    loadedCount++;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"❌ 加载插件失败 [{Path.GetFileName(pluginPath)}]: {ex.Message}");
            }
        }

        Console.WriteLine($"✅ 成功加载 {loadedCount}/{pluginDirectories.Length} 个插件");
        return loadedCount;
    }

    /// <summary>
    /// 加载单个插件
    /// </summary>
    /// <param name="pluginPath">插件目录路径</param>
    /// <returns>是否加载成功</returns>
    public bool LoadSinglePlugin(string pluginPath)
    {
        try
        {
            // 验证插件目录结构
            if (!ValidatePluginStructure(pluginPath))
            {
                Console.WriteLine($"❌ 插件目录结构无效: {pluginPath}");
                return false;
            }

            string pluginName = Path.GetFileName(pluginPath);
            Console.WriteLine($"📦 正在加载插件: {pluginName}");

            // 加载插件
            requestContext.LoadExtension(pluginPath, default, extensionHandler);
            
            // 记录已加载的插件
            loadedPlugins[pluginName] = pluginPath;
            
            Console.WriteLine($"✅ 插件加载成功: {pluginName}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 插件加载异常: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 验证插件目录结构
    /// </summary>
    /// <param name="pluginPath">插件路径</param>
    /// <returns>是否有效</returns>
    private bool ValidatePluginStructure(string pluginPath)
    {
        // 检查manifest.json文件
        string manifestPath = Path.Combine(pluginPath, "manifest.json");
        if (!File.Exists(manifestPath))
        {
            Console.WriteLine($"⚠️ 缺少manifest.json文件: {pluginPath}");
            return false;
        }

        try
        {
            // 验证manifest.json格式
            string manifestContent = File.ReadAllText(manifestPath);
            var manifest = Newtonsoft.Json.JsonConvert.DeserializeObject(manifestContent);
            
            if (manifest == null)
            {
                Console.WriteLine($"⚠️ manifest.json格式无效: {pluginPath}");
                return false;
            }

            Console.WriteLine($"✅ 插件结构验证通过: {Path.GetFileName(pluginPath)}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ manifest.json解析失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 获取已加载插件列表
    /// </summary>
    /// <returns>插件名称和路径的字典</returns>
    public Dictionary<string, string> GetLoadedPlugins()
    {
        return new Dictionary<string, string>(loadedPlugins);
    }

    /// <summary>
    /// 卸载所有插件
    /// </summary>
    public void UnloadAllPlugins()
    {
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            foreach (string extensionId in extensionsList)
            {
                var extension = requestContext.GetExtension(extensionId);
                if (extension != null)
                {
                    extension.Unload();
                    Console.WriteLine($"🗑️ 已卸载插件: {extensionId}");
                }
            }
            
            loadedPlugins.Clear();
            Console.WriteLine("✅ 所有插件已卸载");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 卸载插件时发生错误: {ex.Message}");
        }
    }
}

2. 完整的初始化示例 ​

csharp
/// <summary>
/// FBro浏览器完整初始化，包含插件支持
/// </summary>
public class FBroInitializer
{
    private PluginLoadManager pluginManager;
    private string baseDirectory;
    private string cacheBaseDirectory;

    public FBroInitializer()
    {
        baseDirectory = Application.StartupPath;
        cacheBaseDirectory = Path.Combine(baseDirectory, "Cache");
    }

    /// <summary>
    /// 执行完整初始化流程
    /// </summary>
    /// <param name="args">启动参数</param>
    /// <returns>是否初始化成功</returns>
    public bool Initialize(string[] args)
    {
        try
        {
            // 1. 设置授权码
            if (!SetAuthorizationCode())
            {
                return false;
            }

            // 2. 解析浏览器参数
            var browserArgs = ParseBrowserArgs(args);

            // 3. 创建目录结构
            CreateDirectoryStructure(browserArgs.id);

            // 4. 注册JS交互
            RegisterJavaScriptInteractions();

            // 5. 初始化FBro设置
            var initSet = CreateInitializationSettings(browserArgs.id);

            // 6. 执行FBro初始化
            if (!InitializeFBro(initSet))
            {
                return false;
            }

            // 7. 启用插件功能
            if (!EnablePluginSupport())
            {
                return false;
            }

            // 8. 加载插件
            LoadPlugins();

            Console.WriteLine("🎉 FBro浏览器初始化完成，插件功能已启用");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 初始化失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 设置VIP授权码
    /// </summary>
    /// <returns>是否设置成功</returns>
    private bool SetAuthorizationCode()
    {
        try
        {
            string authCode = "XXDGFDGDSRGDRFGDFGFDSGDFSGDFSGHDSFHGDSF"; //这里替换为你自己的VIP授权码
            
            if (!FBroSharpVIPGlobalControl.SetAuthorizationCode(authCode))
            {
                Console.WriteLine("❌ FBroSharp授权码设置失败");
                return false;
            }

            Console.WriteLine("✅ VIP授权码设置成功");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 授权码设置异常: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 解析浏览器启动参数
    /// </summary>
    /// <param name="args">命令行参数</param>
    /// <returns>浏览器参数</returns>
    private BrowserArgs ParseBrowserArgs(string[] args)
    {
        BrowserArgs browserArgs = null;

        if (args.Length > 0)
        {
            try
            {
                browserArgs = JsonConvert.DeserializeObject<BrowserArgs>(args[0]);
                Console.WriteLine($"📋 参数解析成功: ID={browserArgs?.id}, URL={browserArgs?.url}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"⚠️ 参数解析失败，使用默认值: {ex.Message}");
            }
        }

        // 使用默认参数
        if (browserArgs == null)
        {
            browserArgs = new BrowserArgs
            {
                url = "about:blank",
                name = "新建窗口",
                id = 0
            };
            Console.WriteLine("📋 使用默认浏览器参数");
        }

        return browserArgs;
    }

    /// <summary>
    /// 创建必要的目录结构
    /// </summary>
    /// <param name="browserId">浏览器ID</param>
    private void CreateDirectoryStructure(int browserId)
    {
        try
        {
            // 创建基础缓存目录
            Directory.CreateDirectory(cacheBaseDirectory);
            Directory.CreateDirectory(Path.Combine(cacheBaseDirectory, "UserPath"));
            
            // 创建特定浏览器的缓存目录
            string specificCacheDir = Path.Combine(cacheBaseDirectory, browserId.ToString());
            Directory.CreateDirectory(specificCacheDir);
            
            Console.WriteLine($"📁 目录结构创建完成: {specificCacheDir}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 目录创建失败: {ex.Message}");
            throw;
        }
    }

    /// <summary>
    /// 注册JavaScript交互接口
    /// </summary>
    private void RegisterJavaScriptInteractions()
    {
        try
        {
            // 注册主要的JS交互通道
            FBroSharpInitControl.QueryFunctions("cefQuery", "cefQueryCancel", 
                new FBroQueryHandlerDis(0));
            
            // 注册测试JS交互通道
            FBroSharpInitControl.QueryFunctions("cefQuerytest", "cefQueryCanceltest", 
                new FBroQueryHandlerDis(1));
            
            Console.WriteLine("✅ JavaScript交互接口注册成功");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ JS交互注册失败: {ex.Message}");
            throw;
        }
    }

    /// <summary>
    /// 创建FBro初始化设置
    /// </summary>
    /// <param name="browserId">浏览器ID</param>
    /// <returns>初始化设置对象</returns>
    private FBroSharpInitSet CreateInitializationSettings(int browserId)
    {
        string subprocessPath = Path.Combine(baseDirectory, "FBroSubprocess.exe");
        
        // 检查子进程文件
        if (!File.Exists(subprocessPath))
        {
            throw new FileNotFoundException($"找不到必要的子进程文件: {subprocessPath}");
        }

        var initSet = new FBroSharpInitSet
        {
            cache_path = Path.Combine(cacheBaseDirectory, browserId.ToString()) + "\\",
            user_data_path = Path.Combine(cacheBaseDirectory, "UserPath"),
            root_cache_path = cacheBaseDirectory + "\\",
            multi_threaded_message_loop = true,
            browser_subprocess_path = subprocessPath,
            locale = "zh-CN",
            log_severity = FBroSharpLogSeverity.ERROR,
            no_sandbox = true
        };

        Console.WriteLine("⚙️ FBro初始化设置创建完成");
        return initSet;
    }

    /// <summary>
    /// 执行FBro框架初始化
    /// </summary>
    /// <param name="initSet">初始化设置</param>
    /// <returns>是否初始化成功</returns>
    private bool InitializeFBro(FBroSharpInitSet initSet)
    {
        try
        {
            var initEvent = new FBroInitEvent();
            
            if (!FBroSharpInitControl.InitPro(initSet, initEvent))
            {
                Console.WriteLine("❌ FBroSharp框架初始化失败");
                return false;
            }

            Console.WriteLine("✅ FBroSharp框架初始化成功");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ FBro初始化异常: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 加载浏览器插件
    /// </summary>
    private void LoadPlugins()
    {
        try
        {
            // 创建插件管理器
            pluginManager = new PluginLoadManager();
            
            // 插件目录路径
            string extensionsPath = Path.Combine(baseDirectory, "extensions");
            
            if (!Directory.Exists(extensionsPath))
            {
                Console.WriteLine($"⚠️ 插件目录不存在，跳过插件加载: {extensionsPath}");
                return;
            }

            // 批量加载插件
            int loadedCount = pluginManager.LoadPluginsFromDirectory(extensionsPath);
            Console.WriteLine($"🧩 插件加载完成，成功加载 {loadedCount} 个插件");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 插件加载过程中发生错误: {ex.Message}");
        }
    }

    /// <summary>
    /// 清理资源
    /// </summary>
    public void Cleanup()
    {
        try
        {
            pluginManager?.UnloadAllPlugins();
            FBroSharpInitControl.Shutdown(false);
            Console.WriteLine("🧹 资源清理完成");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 资源清理失败: {ex.Message}");
        }
    }
}

/// <summary>
/// 浏览器启动参数
/// </summary>
public class BrowserArgs
{
    public string url { get; set; } = "about:blank";
    public string name { get; set; } = "新建窗口";
    public int id { get; set; } = 0;
}

3. 插件管理功能实现 ​

插件状态查询 ​

csharp
/// <summary>
/// 插件状态管理器
/// 提供插件状态查询和控制功能
/// </summary>
public class PluginStatusManager
{
    private readonly IFBroSharpBrowser browser;
    private readonly IFBroSharpRequestContext requestContext;

    public PluginStatusManager(IFBroSharpBrowser browser)
    {
        this.browser = browser ?? throw new ArgumentNullException(nameof(browser));
        this.requestContext = browser.GetRequestContext();
    }

    /// <summary>
    /// 获取插件数量
    /// </summary>
    /// <returns>已加载的插件数量</returns>
    public int GetPluginCount()
    {
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            int count = extensionsList?.Count ?? 0;
            
            Console.WriteLine($"📊 当前已加载插件数量: {count}");
            return count;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 获取插件数量失败: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 获取插件清单
    /// </summary>
    /// <returns>插件ID列表</returns>
    public List<string> GetPluginList()
    {
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            
            if (extensionsList != null && extensionsList.Count > 0)
            {
                Console.WriteLine("📋 插件清单:");
                for (int i = 0; i < extensionsList.Count; i++)
                {
                    Console.WriteLine($"  {i + 1}. {extensionsList[i]}");
                }
            }
            else
            {
                Console.WriteLine("📋 暂无已加载的插件");
            }

            return extensionsList ?? new List<string>();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 获取插件清单失败: {ex.Message}");
            return new List<string>();
        }
    }

    /// <summary>
    /// 检查插件加载状态
    /// </summary>
    /// <returns>插件加载状态字典</returns>
    public Dictionary<string, bool> GetPluginLoadStatus()
    {
        var loadStatus = new Dictionary<string, bool>();
        
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            
            if (extensionsList != null)
            {
                Console.WriteLine("🔍 检查插件加载状态:");
                
                foreach (string extensionId in extensionsList)
                {
                    bool isLoaded = requestContext.DidLoadExtension(extensionId);
                    loadStatus[extensionId] = isLoaded;
                    
                    string status = isLoaded ? "✅ 已加载" : "❌ 未加载";
                    Console.WriteLine($"  {extensionId}: {status}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 检查插件状态失败: {ex.Message}");
        }

        return loadStatus;
    }

    /// <summary>
    /// 检查插件访问状态
    /// </summary>
    /// <returns>插件访问状态字典</returns>
    public Dictionary<string, bool> GetPluginAccessStatus()
    {
        var accessStatus = new Dictionary<string, bool>();
        
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            
            if (extensionsList != null)
            {
                Console.WriteLine("🔑 检查插件访问状态:");
                
                foreach (string extensionId in extensionsList)
                {
                    bool hasAccess = requestContext.HasExtension(extensionId);
                    accessStatus[extensionId] = hasAccess;
                    
                    string status = hasAccess ? "✅ 可访问" : "❌ 无访问权限";
                    Console.WriteLine($"  {extensionId}: {status}");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 检查插件访问状态失败: {ex.Message}");
        }

        return accessStatus;
    }

    /// <summary>
    /// 获取插件详细信息
    /// </summary>
    /// <returns>插件详细信息列表</returns>
    public List<PluginInfo> GetPluginDetails()
    {
        var pluginInfos = new List<PluginInfo>();
        
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            
            if (extensionsList != null)
            {
                Console.WriteLine("📖 获取插件详细信息:");
                
                foreach (string extensionId in extensionsList)
                {
                    try
                    {
                        var extension = requestContext.GetExtension(extensionId);
                        if (extension != null)
                        {
                            var pluginInfo = new PluginInfo
                            {
                                Id = extension.GetIdentifier(),
                                Path = extension.GetPath(),
                                IsLoaded = requestContext.DidLoadExtension(extensionId),
                                HasAccess = requestContext.HasExtension(extensionId)
                            };
                            
                            pluginInfos.Add(pluginInfo);
                            
                            Console.WriteLine($"  📦 {pluginInfo.Id}");
                            Console.WriteLine($"    路径: {pluginInfo.Path}");
                            Console.WriteLine($"    状态: {(pluginInfo.IsLoaded ? "已加载" : "未加载")}");
                            Console.WriteLine($"    权限: {(pluginInfo.HasAccess ? "可访问" : "无权限")}");
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"❌ 获取插件 {extensionId} 详情失败: {ex.Message}");
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 获取插件详细信息失败: {ex.Message}");
        }

        return pluginInfos;
    }

    /// <summary>
    /// 卸载指定插件
    /// </summary>
    /// <param name="extensionId">插件ID</param>
    /// <returns>是否卸载成功</returns>
    public bool UnloadPlugin(string extensionId)
    {
        try
        {
            var extension = requestContext.GetExtension(extensionId);
            if (extension != null)
            {
                extension.Unload();
                Console.WriteLine($"🗑️ 插件已卸载: {extensionId}");
                return true;
            }
            else
            {
                Console.WriteLine($"⚠️ 未找到插件: {extensionId}");
                return false;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 卸载插件失败 [{extensionId}]: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 批量卸载所有插件
    /// </summary>
    /// <returns>成功卸载的插件数量</returns>
    public int UnloadAllPlugins()
    {
        int unloadedCount = 0;
        
        try
        {
            var extensionsList = requestContext.GetExtensionsList();
            
            if (extensionsList != null)
            {
                Console.WriteLine($"🗑️ 开始卸载 {extensionsList.Count} 个插件...");
                
                foreach (string extensionId in extensionsList)
                {
                    if (UnloadPlugin(extensionId))
                    {
                        unloadedCount++;
                    }
                }
                
                Console.WriteLine($"✅ 成功卸载 {unloadedCount}/{extensionsList.Count} 个插件");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 批量卸载插件失败: {ex.Message}");
        }

        return unloadedCount;
    }
}

/// <summary>
/// 插件信息数据类
/// </summary>
public class PluginInfo
{
    public string Id { get; set; }
    public string Path { get; set; }
    public bool IsLoaded { get; set; }
    public bool HasAccess { get; set; }
    public DateTime LoadTime { get; set; } = DateTime.Now;
    public string Version { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
}

UI集成示例 ​

csharp
/// <summary>
/// 插件管理UI集成示例
/// 演示如何在Windows Forms中集成插件管理功能
/// </summary>
public partial class PluginManagerForm : Form
{
    private PluginStatusManager pluginManager;
    private Timer statusUpdateTimer;

    public PluginManagerForm(IFBroSharpBrowser browser)
    {
        InitializeComponent();
        pluginManager = new PluginStatusManager(browser);
        InitializePluginManager();
    }

    /// <summary>
    /// 初始化插件管理器
    /// </summary>
    private void InitializePluginManager()
    {
        // 设置定时刷新
        statusUpdateTimer = new Timer();
        statusUpdateTimer.Interval = 5000; // 5秒刷新一次
        statusUpdateTimer.Tick += (s, e) => RefreshPluginStatus();
        statusUpdateTimer.Start();

        // 初始加载
        RefreshPluginStatus();
    }

    /// <summary>
    /// 刷新插件状态显示
    /// </summary>
    private void RefreshPluginStatus()
    {
        try
        {
            // 更新插件数量
            int pluginCount = pluginManager.GetPluginCount();
            lblPluginCount.Text = $"已加载插件: {pluginCount} 个";

            // 更新插件列表
            var pluginDetails = pluginManager.GetPluginDetails();
            UpdatePluginListView(pluginDetails);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"刷新插件状态失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 更新插件列表视图
    /// </summary>
    /// <param name="plugins">插件信息列表</param>
    private void UpdatePluginListView(List<PluginInfo> plugins)
    {
        lvPlugins.Items.Clear();

        foreach (var plugin in plugins)
        {
            var item = new ListViewItem(plugin.Id);
            item.SubItems.Add(Path.GetFileName(plugin.Path));
            item.SubItems.Add(plugin.IsLoaded ? "已加载" : "未加载");
            item.SubItems.Add(plugin.HasAccess ? "可访问" : "无权限");
            item.SubItems.Add(plugin.LoadTime.ToString("HH:mm:ss"));
            item.Tag = plugin;

            // 设置状态图标
            item.ImageIndex = plugin.IsLoaded ? 0 : 1;

            lvPlugins.Items.Add(item);
        }
    }

    /// <summary>
    /// 获取插件数量按钮点击事件
    /// </summary>
    private void btnGetPluginCount_Click(object sender, EventArgs e)
    {
        try
        {
            int count = pluginManager.GetPluginCount();
            MessageBox.Show($"当前已加载 {count} 个插件", "插件数量", 
                MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"操作失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 获取插件清单按钮点击事件
    /// </summary>
    private void btnGetPluginList_Click(object sender, EventArgs e)
    {
        try
        {
            var plugins = pluginManager.GetPluginList();
            string pluginListText = plugins.Count > 0 
                ? string.Join("\n", plugins.Select((p, i) => $"{i + 1}. {p}"))
                : "暂无已加载的插件";

            MessageBox.Show(pluginListText, "插件清单", 
                MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"操作失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 检查加载状态按钮点击事件
    /// </summary>
    private void btnCheckLoadStatus_Click(object sender, EventArgs e)
    {
        try
        {
            var loadStatus = pluginManager.GetPluginLoadStatus();
            
            if (loadStatus.Count > 0)
            {
                var statusText = string.Join("\n", 
                    loadStatus.Select(kvp => $"{kvp.Key}: {(kvp.Value ? "已加载" : "未加载")}"));
                
                MessageBox.Show(statusText, "插件加载状态", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            else
            {
                MessageBox.Show("暂无插件加载状态信息", "插件加载状态", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"操作失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 卸载选中插件按钮点击事件
    /// </summary>
    private void btnUnloadSelected_Click(object sender, EventArgs e)
    {
        if (lvPlugins.SelectedItems.Count == 0)
        {
            MessageBox.Show("请先选择要卸载的插件", "提示", 
                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            return;
        }

        try
        {
            var selectedPlugin = lvPlugins.SelectedItems[0].Tag as PluginInfo;
            if (selectedPlugin != null)
            {
                var result = MessageBox.Show(
                    $"确定要卸载插件 '{selectedPlugin.Id}' 吗？", 
                    "确认卸载", 
                    MessageBoxButtons.YesNo, 
                    MessageBoxIcon.Question);

                if (result == DialogResult.Yes)
                {
                    bool success = pluginManager.UnloadPlugin(selectedPlugin.Id);
                    if (success)
                    {
                        MessageBox.Show("插件卸载成功", "成功", 
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
                        RefreshPluginStatus(); // 刷新状态
                    }
                    else
                    {
                        MessageBox.Show("插件卸载失败", "失败", 
                            MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"卸载插件失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 卸载所有插件按钮点击事件
    /// </summary>
    private void btnUnloadAll_Click(object sender, EventArgs e)
    {
        try
        {
            var result = MessageBox.Show(
                "确定要卸载所有插件吗？此操作不可撤销。", 
                "确认卸载", 
                MessageBoxButtons.YesNo, 
                MessageBoxIcon.Warning);

            if (result == DialogResult.Yes)
            {
                int unloadedCount = pluginManager.UnloadAllPlugins();
                MessageBox.Show($"成功卸载 {unloadedCount} 个插件", "卸载完成", 
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
                RefreshPluginStatus(); // 刷新状态
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"批量卸载失败: {ex.Message}", "错误", 
                MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 窗口关闭时清理资源
    /// </summary>
    protected override void OnFormClosed(FormClosedEventArgs e)
    {
        statusUpdateTimer?.Stop();
        statusUpdateTimer?.Dispose();
        base.OnFormClosed(e);
    }
}

4. 高级扩展事件处理器 ​

完整的ExtensionHandler实现 ​

csharp
/// <summary>
/// 高级扩展事件处理器
/// 提供完整的插件生命周期事件处理和管理功能
/// </summary>
public class AdvancedExtensionHandler : FBroSharpExtensionHandler
{
    private readonly Dictionary<string, PluginInfo> pluginRegistry;
    private readonly Dictionary<int, int> pluginBrowserMapping;
    private readonly ILogger logger;

    public AdvancedExtensionHandler(ILogger logger = null)
    {
        this.logger = logger ?? new ConsoleLogger();
        pluginRegistry = new Dictionary<string, PluginInfo>();
        pluginBrowserMapping = new Dictionary<int, int>();
        
        this.logger.Log("🔧 高级扩展处理器已初始化");
    }

    #region 插件加载相关事件

    /// <summary>
    /// 插件加载成功事件
    /// </summary>
    /// <param name="extension">加载成功的插件</param>
    public override void OnExtensionLoaded(IFBroSharpExtension extension)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            string extensionPath = extension.GetPath();
            
            // 创建插件信息
            var pluginInfo = new PluginInfo
            {
                Id = extensionId,
                Path = extensionPath,
                IsLoaded = true,
                HasAccess = true,
                LoadTime = DateTime.Now,
                Name = GetPluginNameFromPath(extensionPath)
            };

            // 尝试从manifest.json获取详细信息
            LoadPluginManifestInfo(pluginInfo);

            // 注册插件
            pluginRegistry[extensionId] = pluginInfo;

            // 触发插件特定的初始化逻辑
            InitializePluginByType(pluginInfo);

            logger.Log($"✅ 插件加载成功: {pluginInfo.Name} (ID: {extensionId})");
            logger.Log($"   路径: {extensionPath}");
            logger.Log($"   版本: {pluginInfo.Version ?? "未知"}");
            logger.Log($"   描述: {pluginInfo.Description ?? "无描述"}");

            // 触发自定义事件
            OnPluginLoadedEvent?.Invoke(pluginInfo);
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 处理插件加载事件时发生错误: {ex.Message}");
        }
    }

    /// <summary>
    /// 插件加载失败事件
    /// </summary>
    /// <param name="result">错误代码</param>
    public override void OnExtensionLoadFailed(int result)
    {
        string errorMessage = GetErrorMessage(result);
        logger.LogError($"❌ 插件加载失败 - 错误代码: {result}, 描述: {errorMessage}");
        
        // 触发自定义事件
        OnPluginLoadFailedEvent?.Invoke(result, errorMessage);
    }

    /// <summary>
    /// 插件加载失败消息事件
    /// </summary>
    /// <param name="error">错误消息</param>
    /// <param name="path">插件路径</param>
    public override void OnExtensionLoadFailedMessage(string error, string path)
    {
        logger.LogError($"❌ 插件加载失败详情:");
        logger.LogError($"   路径: {path}");
        logger.LogError($"   错误: {error}");
        
        // 触发自定义事件
        OnPluginLoadFailedMessageEvent?.Invoke(error, path);
    }

    /// <summary>
    /// 插件卸载事件
    /// </summary>
    /// <param name="extension">被卸载的插件</param>
    public override void OnExtensionUnloaded(IFBroSharpExtension extension)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            string extensionPath = extension.GetPath();

            // 从注册表中移除
            if (pluginRegistry.TryGetValue(extensionId, out var pluginInfo))
            {
                pluginRegistry.Remove(extensionId);
                logger.Log($"🗑️ 插件已卸载: {pluginInfo.Name} (ID: {extensionId})");
                
                // 触发自定义事件
                OnPluginUnloadedEvent?.Invoke(pluginInfo);
            }
            else
            {
                logger.Log($"🗑️ 插件已卸载: {extensionId} (路径: {extensionPath})");
            }

            // 清理相关的浏览器映射
            CleanupPluginBrowserMapping(extensionId);
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 处理插件卸载事件时发生错误: {ex.Message}");
        }
    }

    #endregion

    #region 浏览器相关事件

    /// <summary>
    /// 即将创建Background浏览器事件
    /// </summary>
    public override bool OnBeforeBackgroundBrowser(IFBroSharpExtension extension, string url, 
        IFBroSharpUseExtraData user_settings, ref FBroSharpBrowserSetting settings)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            logger.Log($"🔄 插件请求创建Background浏览器:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   URL: {url}");

            // 可以在这里自定义Background浏览器的设置
            ConfigureBackgroundBrowserSettings(ref settings, extensionId);

            // 触发自定义事件
            OnBackgroundBrowserCreatingEvent?.Invoke(extensionId, url);

            return false; // 允许创建
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 处理Background浏览器创建事件时发生错误: {ex.Message}");
            return true; // 取消创建
        }
    }

    /// <summary>
    /// 即将创建插件浏览器事件
    /// </summary>
    public override bool OnBeforeBrowser(IFBroSharpExtension extension, IFBroSharpBrowser browser, 
        IFBroSharpBrowser active_browser, int index, string url, bool active, 
        out FBroSharpWindowsInfo windowInfo, IFBroSharpUseExtraData user_settings, 
        ref FBroSharpBrowserSetting settings)
    {
        windowInfo = default(FBroSharpWindowsInfo);

        try
        {
            string extensionId = extension.GetIdentifier();
            int browserId = browser?.GetIdentifier() ?? -1;

            logger.Log($"🌐 插件请求创建浏览器:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   浏览器ID: {browserId}");
            logger.Log($"   URL: {url}");
            logger.Log($"   索引: {index}");
            logger.Log($"   是否激活: {active}");

            // 记录浏览器映射关系
            if (browserId != -1 && active_browser != null)
            {
                pluginBrowserMapping[browserId] = active_browser.GetIdentifier();
            }

            // 可以在这里自定义浏览器窗口信息和设置
            ConfigureBrowserSettings(ref settings, ref windowInfo, extensionId);

            // 触发自定义事件
            OnPluginBrowserCreatingEvent?.Invoke(extensionId, url, active);

            return false; // 允许创建
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 处理插件浏览器创建事件时发生错误: {ex.Message}");
            return true; // 取消创建
        }
    }

    /// <summary>
    /// 获取活动浏览器事件
    /// </summary>
    public override IFBroSharpBrowser GetActiveBrowser(IFBroSharpExtension extension, 
        IFBroSharpBrowser browser, bool include_incognito)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            int browserId = browser?.GetIdentifier() ?? -1;

            logger.Log($"🎯 插件请求获取活动浏览器:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   当前浏览器ID: {browserId}");
            logger.Log($"   包含隐身模式: {include_incognito}");

            // 查找关联的主浏览器
            var activeBrowser = FindAssociatedMainBrowser(browserId);
            
            if (activeBrowser != null)
            {
                logger.Log($"✅ 找到关联的主浏览器: {activeBrowser.GetIdentifier()}");
            }
            else
            {
                logger.Log("⚠️ 未找到关联的主浏览器，使用当前浏览器");
            }

            return activeBrowser;
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 获取活动浏览器时发生错误: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// 获取默认标签页浏览器事件
    /// 自定义事件，用于兼容Chrome扩展的tab概念
    /// </summary>
    public override IFBroSharpBrowser GetDefaultTabBrowser(IFBroSharpExtension extension, 
        IFBroSharpBrowser browser)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            int pluginBrowserId = browser?.GetIdentifier() ?? -1;

            logger.Log($"📑 插件请求获取默认标签页浏览器:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   插件浏览器ID: {pluginBrowserId}");

            // 查找关联的主浏览器
            var defaultBrowser = FindAssociatedMainBrowser(pluginBrowserId);

            if (defaultBrowser != null)
            {
                logger.Log($"✅ 返回默认标签页浏览器: {defaultBrowser.GetIdentifier()}");
                return defaultBrowser;
            }
            else
            {
                logger.Log("⚠️ 未找到关联的主浏览器");
                return null;
            }
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 获取默认标签页浏览器时发生错误: {ex.Message}");
            return null;
        }
    }

    #endregion

    #region 资源访问控制

    /// <summary>
    /// 浏览器访问权限控制事件
    /// </summary>
    public override bool CanAccessBrowser(IFBroSharpExtension extension, IFBroSharpBrowser browser, 
        bool include_incognito, IFBroSharpBrowser target_browser)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            int browserId = browser?.GetIdentifier() ?? -1;
            int targetBrowserId = target_browser?.GetIdentifier() ?? -1;

            logger.Log($"🔐 插件请求浏览器访问权限:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   源浏览器ID: {browserId}");
            logger.Log($"   目标浏览器ID: {targetBrowserId}");
            logger.Log($"   包含隐身模式: {include_incognito}");

            // 根据插件类型和安全策略决定是否允许访问
            bool canAccess = DetermineAccessPermission(extensionId, browserId, targetBrowserId, include_incognito);

            logger.Log($"   访问权限: {(canAccess ? "✅ 允许" : "❌ 拒绝")}");
            return canAccess;
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 检查浏览器访问权限时发生错误: {ex.Message}");
            return false; // 默认拒绝访问
        }
    }

    /// <summary>
    /// 扩展资源获取事件
    /// </summary>
    public override bool GetExtensionResource(IFBroSharpExtension extension, 
        IFBroSharpBrowser browser, string file)
    {
        try
        {
            string extensionId = extension.GetIdentifier();
            int browserId = browser?.GetIdentifier() ?? -1;

            logger.Log($"📁 插件请求获取扩展资源:");
            logger.Log($"   插件ID: {extensionId}");
            logger.Log($"   浏览器ID: {browserId}");
            logger.Log($"   文件: {file}");

            // 可以在这里实现自定义资源处理逻辑
            bool handled = HandleCustomExtensionResource(extensionId, file);

            logger.Log($"   处理结果: {(handled ? "✅ 自定义处理" : "⏭️ 使用默认处理")}");
            return handled;
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 获取扩展资源时发生错误: {ex.Message}");
            return false; // 使用默认处理
        }
    }

    #endregion

    #region 辅助方法和自定义事件

    /// <summary>
    /// 从路径获取插件名称
    /// </summary>
    /// <param name="path">插件路径</param>
    /// <returns>插件名称</returns>
    private string GetPluginNameFromPath(string path)
    {
        try
        {
            return Path.GetFileName(path) ?? "未知插件";
        }
        catch
        {
            return "未知插件";
        }
    }

    /// <summary>
    /// 从manifest.json加载插件信息
    /// </summary>
    /// <param name="pluginInfo">插件信息对象</param>
    private void LoadPluginManifestInfo(PluginInfo pluginInfo)
    {
        try
        {
            string manifestPath = Path.Combine(pluginInfo.Path, "manifest.json");
            if (File.Exists(manifestPath))
            {
                string manifestContent = File.ReadAllText(manifestPath);
                dynamic manifest = Newtonsoft.Json.JsonConvert.DeserializeObject(manifestContent);
                
                if (manifest != null)
                {
                    pluginInfo.Name = manifest.name ?? pluginInfo.Name;
                    pluginInfo.Version = manifest.version ?? "未知";
                    pluginInfo.Description = manifest.description ?? "无描述";
                }
            }
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 加载插件manifest信息失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 根据插件类型初始化特定逻辑
    /// </summary>
    /// <param name="pluginInfo">插件信息</param>
    private void InitializePluginByType(PluginInfo pluginInfo)
    {
        try
        {
            string lowerPath = pluginInfo.Path.ToLower();
            
            // 抖音插件特殊处理
            if (lowerPath.Contains("douyin"))
            {
                logger.Log($"🎵 检测到抖音插件，执行特殊初始化逻辑");
                // 可以在这里添加抖音插件特定的初始化代码
            }
            // 小红书插件特殊处理
            else if (lowerPath.Contains("xhs"))
            {
                logger.Log($"📷 检测到小红书插件，执行特殊初始化逻辑");
                // 可以在这里添加小红书插件特定的初始化代码
            }
            // 开发者工具插件
            else if (lowerPath.Contains("devtools") || lowerPath.Contains("developer"))
            {
                logger.Log($"🔧 检测到开发者工具插件，启用调试功能");
                // 开发者工具特定配置
            }
            // 广告拦截插件
            else if (lowerPath.Contains("adblock") || lowerPath.Contains("ublock"))
            {
                logger.Log($"🛡️ 检测到广告拦截插件，优化性能配置");
                // 广告拦截插件特定配置
            }
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 插件特殊初始化失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 配置Background浏览器设置
    /// </summary>
    /// <param name="settings">浏览器设置</param>
    /// <param name="extensionId">插件ID</param>
    private void ConfigureBackgroundBrowserSettings(ref FBroSharpBrowserSetting settings, string extensionId)
    {
        try
        {
            // Background浏览器通常不需要显示界面，优化性能
            // settings.off_screen_rendering_enabled = true;
            // settings.windowless_rendering_enabled = true;
            
            logger.Log($"⚙️ Background浏览器设置已配置 [{extensionId}]");
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 配置Background浏览器设置失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 配置插件浏览器设置
    /// </summary>
    /// <param name="settings">浏览器设置</param>
    /// <param name="windowInfo">窗口信息</param>
    /// <param name="extensionId">插件ID</param>
    private void ConfigureBrowserSettings(ref FBroSharpBrowserSetting settings, 
        ref FBroSharpWindowsInfo windowInfo, string extensionId)
    {
        try
        {
            // 根据插件类型配置不同的浏览器设置
            if (pluginRegistry.TryGetValue(extensionId, out var pluginInfo))
            {
                // 开发者工具类插件可能需要更大的窗口
                if (pluginInfo.Name.ToLower().Contains("devtools"))
                {
                    // windowInfo.width = 1200;
                    // windowInfo.height = 800;
                }
            }
            
            logger.Log($"⚙️ 插件浏览器设置已配置 [{extensionId}]");
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 配置插件浏览器设置失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 查找关联的主浏览器
    /// </summary>
    /// <param name="pluginBrowserId">插件浏览器ID</param>
    /// <returns>关联的主浏览器</returns>
    private IFBroSharpBrowser FindAssociatedMainBrowser(int pluginBrowserId)
    {
        try
        {
            // 尝试从映射表中查找
            if (pluginBrowserMapping.TryGetValue(pluginBrowserId, out int mainBrowserId))
            {
                // 这里需要实现根据ID查找浏览器的逻辑
                // 具体实现取决于您的浏览器管理架构
                return FindBrowserById(mainBrowserId);
            }
            
            return null;
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 查找关联主浏览器失败: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// 根据ID查找浏览器实例
    /// </summary>
    /// <param name="browserId">浏览器ID</param>
    /// <returns>浏览器实例</returns>
    private IFBroSharpBrowser FindBrowserById(int browserId)
    {
        // 这里需要根据您的具体实现来查找浏览器
        // 例如从全局浏览器列表中查找
        return null; // 占位符实现
    }

    /// <summary>
    /// 清理插件浏览器映射
    /// </summary>
    /// <param name="extensionId">插件ID</param>
    private void CleanupPluginBrowserMapping(string extensionId)
    {
        try
        {
            var keysToRemove = new List<int>();
            
            foreach (var kvp in pluginBrowserMapping)
            {
                // 这里可以添加更复杂的清理逻辑
                // 例如根据插件ID清理相关的映射
            }
            
            foreach (int key in keysToRemove)
            {
                pluginBrowserMapping.Remove(key);
            }
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 清理插件浏览器映射失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 确定访问权限
    /// </summary>
    /// <param name="extensionId">插件ID</param>
    /// <param name="sourceBrowserId">源浏览器ID</param>
    /// <param name="targetBrowserId">目标浏览器ID</param>
    /// <param name="includeIncognito">是否包含隐身模式</param>
    /// <returns>是否允许访问</returns>
    private bool DetermineAccessPermission(string extensionId, int sourceBrowserId, 
        int targetBrowserId, bool includeIncognito)
    {
        try
        {
            // 实现访问权限策略
            // 例如：某些插件只能访问特定的浏览器
            
            if (pluginRegistry.TryGetValue(extensionId, out var pluginInfo))
            {
                // 根据插件类型和安全级别决定权限
                if (pluginInfo.Name.ToLower().Contains("safe") || 
                    pluginInfo.Name.ToLower().Contains("trusted"))
                {
                    return true; // 受信任的插件允许访问
                }
            }
            
            // 默认安全策略：限制跨浏览器访问
            return sourceBrowserId == targetBrowserId;
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 确定访问权限失败: {ex.Message}");
            return false; // 默认拒绝
        }
    }

    /// <summary>
    /// 处理自定义扩展资源
    /// </summary>
    /// <param name="extensionId">插件ID</param>
    /// <param name="file">请求的文件</param>
    /// <returns>是否自定义处理</returns>
    private bool HandleCustomExtensionResource(string extensionId, string file)
    {
        try
        {
            // 可以在这里实现自定义资源处理逻辑
            // 例如：动态生成配置文件、替换资源内容等
            
            if (file.EndsWith(".json"))
            {
                // 处理JSON配置文件
                logger.Log($"📄 处理JSON配置文件: {file}");
                return false; // 使用默认处理
            }
            
            if (file.EndsWith(".js"))
            {
                // 处理JavaScript文件
                logger.Log($"📜 处理JavaScript文件: {file}");
                return false; // 使用默认处理
            }
            
            return false; // 默认使用标准处理
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 处理自定义扩展资源失败: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 获取错误消息描述
    /// </summary>
    /// <param name="errorCode">错误代码</param>
    /// <returns>错误描述</returns>
    private string GetErrorMessage(int errorCode)
    {
        // 映射常见的CEF错误代码
        return errorCode switch
        {
            -2 => "文件未找到",
            -3 => "文件无法读取",
            -4 => "文件格式错误",
            -5 => "网络错误",
            -6 => "访问被拒绝",
            -7 => "内存不足",
            -8 => "操作超时",
            _ => $"未知错误 (代码: {errorCode})"
        };
    }

    #endregion

    #region 自定义事件定义

    /// <summary>
    /// 插件加载成功事件
    /// </summary>
    public event Action<PluginInfo> OnPluginLoadedEvent;

    /// <summary>
    /// 插件加载失败事件
    /// </summary>
    public event Action<int, string> OnPluginLoadFailedEvent;

    /// <summary>
    /// 插件加载失败消息事件
    /// </summary>
    public event Action<string, string> OnPluginLoadFailedMessageEvent;

    /// <summary>
    /// 插件卸载事件
    /// </summary>
    public event Action<PluginInfo> OnPluginUnloadedEvent;

    /// <summary>
    /// Background浏览器创建事件
    /// </summary>
    public event Action<string, string> OnBackgroundBrowserCreatingEvent;

    /// <summary>
    /// 插件浏览器创建事件
    /// </summary>
    public event Action<string, string, bool> OnPluginBrowserCreatingEvent;

    #endregion

    #region 公共属性和方法

    /// <summary>
    /// 获取已注册的插件信息
    /// </summary>
    /// <returns>插件信息字典</returns>
    public Dictionary<string, PluginInfo> GetRegisteredPlugins()
    {
        return new Dictionary<string, PluginInfo>(pluginRegistry);
    }

    /// <summary>
    /// 获取插件浏览器映射
    /// </summary>
    /// <returns>浏览器映射字典</returns>
    public Dictionary<int, int> GetPluginBrowserMapping()
    {
        return new Dictionary<int, int>(pluginBrowserMapping);
    }

    /// <summary>
    /// 手动注册浏览器映射关系
    /// </summary>
    /// <param name="pluginBrowserId">插件浏览器ID</param>
    /// <param name="mainBrowserId">主浏览器ID</param>
    public void RegisterBrowserMapping(int pluginBrowserId, int mainBrowserId)
    {
        try
        {
            pluginBrowserMapping[pluginBrowserId] = mainBrowserId;
            logger.Log($"🔗 已注册浏览器映射: 插件浏览器[{pluginBrowserId}] -> 主浏览器[{mainBrowserId}]");
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 注册浏览器映射失败: {ex.Message}");
        }
    }

    /// <summary>
    /// 移除浏览器映射关系
    /// </summary>
    /// <param name="pluginBrowserId">插件浏览器ID</param>
    public void UnregisterBrowserMapping(int pluginBrowserId)
    {
        try
        {
            if (pluginBrowserMapping.Remove(pluginBrowserId))
            {
                logger.Log($"🗑️ 已移除浏览器映射: 插件浏览器[{pluginBrowserId}]");
            }
        }
        catch (Exception ex)
        {
            logger.LogError($"❌ 移除浏览器映射失败: {ex.Message}");
        }
    }

    #endregion
}

/// <summary>
/// 简单日志接口
/// </summary>
public interface ILogger
{
    void Log(string message);
    void LogError(string message);
}

/// <summary>
/// 控制台日志实现
/// </summary>
public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {message}");
    }

    public void LogError(string message)
    {
        var originalColor = Console.ForegroundColor;
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] {message}");
        Console.ForegroundColor = originalColor;
    }
}

🎯 应用场景详解 ​

1. 网页增强和自动化 ​

场景：广告拦截和页面净化 ​

csharp
/// <summary>
/// 广告拦截插件集成示例
/// </summary>
public class AdBlockIntegration
{
    private AdvancedExtensionHandler extensionHandler;
    private PluginLoadManager pluginManager;

    public async Task<bool> SetupAdBlockPlugin()
    {
        try
        {
            // 加载uBlock Origin插件
            string uBlockPath = Path.Combine(Application.StartupPath, "extensions", "ublock-origin");
            
            if (Directory.Exists(uBlockPath))
            {
                bool loaded = pluginManager.LoadSinglePlugin(uBlockPath);
                if (loaded)
                {
                    Console.WriteLine("✅ 广告拦截插件加载成功");
                    
                    // 等待插件初始化完成
                    await Task.Delay(2000);
                    
                    return true;
                }
            }
            
            Console.WriteLine("❌ 广告拦截插件加载失败");
            return false;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 设置广告拦截插件失败: {ex.Message}");
            return false;
        }
    }
}

2. 性能优化和最佳实践 ​

插件加载策略优化 ​

csharp
/// <summary>
/// 智能插件加载管理器
/// </summary>
public class SmartPluginLoader
{
    /// <summary>
    /// 根据使用频率智能加载插件
    /// </summary>
    public async Task LoadPluginsByUsage()
    {
        try
        {
            // 按使用频率排序的插件列表
            var pluginsByUsage = new[]
            {
                new { Name = "ublock-origin", Usage = 95, Priority = 1 },
                new { Name = "react-devtools", Usage = 70, Priority = 2 },
                new { Name = "douyin-helper", Usage = 45, Priority = 3 },
                new { Name = "xhs-assistant", Usage = 30, Priority = 4 }
            }.OrderByDescending(p => p.Usage);

            foreach (var plugin in pluginsByUsage)
            {
                if (plugin.Usage > 50) // 高频使用插件立即加载
                {
                    await LoadPluginImmediately(plugin.Name);
                }
                else // 低频使用插件延迟加载
                {
                    _ = Task.Run(() => LoadPluginDelayed(plugin.Name, plugin.Priority * 1000));
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"❌ 智能插件加载失败: {ex.Message}");
        }
    }

    private async Task LoadPluginImmediately(string pluginName)
    {
        Console.WriteLine($"🚀 立即加载高频插件: {pluginName}");
        // 实现立即加载逻辑
    }

    private async Task LoadPluginDelayed(string pluginName, int delayMs)
    {
        await Task.Delay(delayMs);
        Console.WriteLine($"⏰ 延迟加载低频插件: {pluginName}");
        // 实现延迟加载逻辑
    }
}

📋 常见问题和解决方案 ​

Q1: 如何选择兼容的Chrome插件？ ​

解决方案：

  1. 确保插件的manifest.json中"manifest_version": 2
  2. 避免使用标注为manifest v3的新版插件
  3. 可使用插件的旧版本或寻找v2兼容版本
  4. 推荐插件：uBlock Origin、Tampermonkey、React DevTools等经典插件

Q2: 插件加载失败，提示权限不足 ​

解决方案：

  1. 确保以管理员权限运行程序
  2. 检查插件目录的读取权限
  3. 验证VIP授权码是否正确设置

Q3: 多个插件冲突，导致功能异常 ​

解决方案：

  1. 实现插件隔离机制
  2. 设置插件加载优先级
  3. 检查插件间的依赖关系

Q4: 插件内存占用过高，影响性能 ​

解决方案：

  1. 定期卸载不使用的插件
  2. 实现插件生命周期管理
  3. 监控插件资源使用情况

🏆 技术优势总结 ​

1. 完整的生态支持 ​

  • Chrome插件兼容：支持manifest v2版本Chrome扩展插件
  • 丰富的插件资源：可使用Chrome Web Store中兼容的插件
  • 标准API支持：完全兼容Chrome扩展manifest v2 API标准
  • VIP增强功能：通过VIP授权获得完整插件管理能力

2. 企业级管理能力 ​

  • 批量部署：支持插件的批量安装和配置
  • 权限控制：精细化的插件权限管理机制
  • 监控告警：完善的插件状态监控和异常处理

3. 高性能优化 ​

  • 智能加载：按需加载和延迟加载策略
  • 资源隔离：插件间资源隔离，避免相互影响
  • 内存优化：智能内存管理和垃圾回收机制

4. 开发友好 ​

  • 完整API：提供完整的插件管理API接口
  • 事件驱动：基于事件的插件交互机制
  • 调试支持：完善的调试和日志记录功能

🎉 总结 ​

通过本完整指南，您已经掌握了FBro浏览器插件开发与管理的全部核心技术：

✅ 完整的插件生命周期管理
✅ 企业级安全和权限控制
✅ 高性能插件加载策略
✅ 丰富的应用场景实现
✅ 专业的调试和维护工具

这套解决方案不仅适用于个人开发者的小型项目，更能满足企业级应用的复杂需求。通过合理运用这些技术，您可以构建出功能强大、性能卓越、安全可靠的浏览器应用系统。

下一步建议：

  1. 根据实际需求选择合适的插件管理策略
  2. 建立完善的插件测试和验证流程
  3. 持续监控和优化插件性能表现
  4. 建立用户反馈和问题解决机制

让FBro浏览器的插件生态为您的项目带来无限可能！🚀

如果文档对您有帮助，欢迎 请喝咖啡 ☕ | 软件发布 | 源码购买

总访问量: -- 访客数: --

Copyright © 2024 FBro文档. 由莫生编写 | QQ: 1098901025 | 微信: zhx_ms